[llvm] [VPlan] Make VPRegionValue a subclass of VPSymbolicValue. (NFC) (PR #196753)
via llvm-commits
llvm-commits at lists.llvm.org
Sat May 9 13:49:20 PDT 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-vectorizers
Author: Florian Hahn (fhahn)
<details>
<summary>Changes</summary>
Turn VPRegionValue into a subclass of VPSymbolicValue, ensuring we also guard against premature RAUW of region values.
---
Full diff: https://github.com/llvm/llvm-project/pull/196753.diff
7 Files Affected:
- (modified) llvm/lib/Transforms/Vectorize/VPlan.cpp (+9-3)
- (modified) llvm/lib/Transforms/Vectorize/VPlanAnalysis.cpp (+3-3)
- (modified) llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp (+4-2)
- (modified) llvm/lib/Transforms/Vectorize/VPlanUnroll.cpp (+1-1)
- (modified) llvm/lib/Transforms/Vectorize/VPlanUtils.cpp (+9-9)
- (modified) llvm/lib/Transforms/Vectorize/VPlanValue.h (+33-28)
- (modified) llvm/unittests/Transforms/Vectorize/VPlanTest.cpp (+26)
``````````diff
diff --git a/llvm/lib/Transforms/Vectorize/VPlan.cpp b/llvm/lib/Transforms/Vectorize/VPlan.cpp
index 3c8f3362ae93a..fb86073fb55e9 100644
--- a/llvm/lib/Transforms/Vectorize/VPlan.cpp
+++ b/llvm/lib/Transforms/Vectorize/VPlan.cpp
@@ -887,7 +887,8 @@ VPlan::~VPlan() {
R.setOperand(I, &DummyValue);
}
} else if (auto *CanIV = cast<VPRegionBlock>(VPB)->getCanonicalIV()) {
- CanIV->replaceAllUsesWith(&DummyValue);
+ if (!CanIV->isMaterialized())
+ CanIV->replaceAllUsesWith(&DummyValue);
}
delete VPB;
@@ -1252,10 +1253,15 @@ VPlan *VPlan::duplicate() {
assert(OldCanIV && NewCanIV &&
"Loop regions of both plans must have canonical IVs.");
Old2NewVPValues[OldCanIV] = NewCanIV;
+ if (OldCanIV->isMaterialized())
+ NewCanIV->markMaterialized();
}
- assert(none_of(Old2NewVPValues.keys(), IsaPred<VPSymbolicValue>) &&
- "All VPSymbolicValues must be handled below");
+ assert(none_of(Old2NewVPValues.keys(),
+ [](const VPValue *V) {
+ return V->getVPValueID() == VPValue::VPVSymbolicSC;
+ }) &&
+ "All plain VPSymbolicValues must be handled below");
if (BackedgeTakenCount)
NewPlan->BackedgeTakenCount = new VPSymbolicValue();
diff --git a/llvm/lib/Transforms/Vectorize/VPlanAnalysis.cpp b/llvm/lib/Transforms/Vectorize/VPlanAnalysis.cpp
index a42b631cd3304..ec8c37f1b7b04 100644
--- a/llvm/lib/Transforms/Vectorize/VPlanAnalysis.cpp
+++ b/llvm/lib/Transforms/Vectorize/VPlanAnalysis.cpp
@@ -286,15 +286,15 @@ Type *VPTypeAnalysis::inferScalarType(const VPValue *V) {
if (auto *IRV = dyn_cast<VPIRValue>(V))
return IRV->getType();
+ if (auto *RegionV = dyn_cast<VPRegionValue>(V))
+ return RegionV->getType();
+
if (isa<VPSymbolicValue>(V)) {
// All VPValues without any underlying IR value (like the vector trip count
// or the backedge-taken count) have the same type as the canonical IV.
return CanonicalIVTy;
}
- if (auto *RegionV = dyn_cast<VPRegionValue>(V))
- return RegionV->getType();
-
Type *ResultTy =
TypeSwitch<const VPRecipeBase *, Type *>(V->getDefiningRecipe())
.Case<VPActiveLaneMaskPHIRecipe, VPFirstOrderRecurrencePHIRecipe,
diff --git a/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp b/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp
index 32d89a34105a4..ce0bd54b16312 100644
--- a/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp
+++ b/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp
@@ -3224,8 +3224,10 @@ void VPlanTransforms::addExplicitVectorLength(
// Replace all uses of the canonical IV with VPCurrentIterationPHIRecipe
// except for the canonical IV increment.
- CanonicalIV->replaceAllUsesWith(CurrentIteration);
- CanonicalIVIncrement->setOperand(0, CanonicalIV);
+ CanonicalIV->replaceUsesWithIf(CurrentIteration,
+ [CanonicalIVIncrement](VPUser &U, unsigned) {
+ return &U != CanonicalIVIncrement;
+ });
// TODO: support unroll factor > 1.
Plan.setUF(1);
}
diff --git a/llvm/lib/Transforms/Vectorize/VPlanUnroll.cpp b/llvm/lib/Transforms/Vectorize/VPlanUnroll.cpp
index f1b9efae08377..f6f280e72fb6e 100644
--- a/llvm/lib/Transforms/Vectorize/VPlanUnroll.cpp
+++ b/llvm/lib/Transforms/Vectorize/VPlanUnroll.cpp
@@ -80,7 +80,7 @@ class UnrollState {
void unrollBlock(VPBlockBase *VPB);
VPValue *getValueForPart(VPValue *V, unsigned Part) {
- if (Part == 0 || isa<VPIRValue, VPSymbolicValue, VPRegionValue>(V))
+ if (Part == 0 || isa<VPIRValue, VPSymbolicValue>(V))
return V;
assert((VPV2Parts.contains(V) && VPV2Parts[V].size() >= Part) &&
"accessed value does not exist");
diff --git a/llvm/lib/Transforms/Vectorize/VPlanUtils.cpp b/llvm/lib/Transforms/Vectorize/VPlanUtils.cpp
index 5b80fa15a5535..91b3b747a6d09 100644
--- a/llvm/lib/Transforms/Vectorize/VPlanUtils.cpp
+++ b/llvm/lib/Transforms/Vectorize/VPlanUtils.cpp
@@ -162,13 +162,6 @@ const SCEV *vputils::getSCEVExprForVPValue(const VPValue *V,
PredicatedScalarEvolution &PSE,
const Loop *L) {
ScalarEvolution &SE = *PSE.getSE();
- if (isa<VPIRValue, VPSymbolicValue>(V)) {
- Value *LiveIn = V->getUnderlyingValue();
- if (LiveIn && SE.isSCEVable(LiveIn->getType()))
- return SE.getSCEV(LiveIn);
- return SE.getCouldNotCompute();
- }
-
if (auto *RV = dyn_cast<VPRegionValue>(V)) {
assert(RV == RV->getDefiningRegion()->getCanonicalIV() &&
"RegionValue must be canonical IV");
@@ -178,6 +171,13 @@ const SCEV *vputils::getSCEVExprForVPValue(const VPValue *V,
L, SCEV::FlagAnyWrap);
}
+ if (isa<VPIRValue, VPSymbolicValue>(V)) {
+ Value *LiveIn = V->getUnderlyingValue();
+ if (LiveIn && SE.isSCEVable(LiveIn->getType()))
+ return SE.getSCEV(LiveIn);
+ return SE.getCouldNotCompute();
+ }
+
// Helper to create SCEVs for binary and unary operations.
auto CreateSCEV = [&](ArrayRef<VPValue *> Ops,
function_ref<const SCEV *(ArrayRef<SCEVUse>)> CreateFn)
@@ -381,7 +381,7 @@ static bool preservesUniformity(unsigned Opcode) {
bool vputils::isSingleScalar(const VPValue *VPV) {
// Live-in, symbolic and region-values represent single-scalar values.
- if (isa<VPIRValue, VPSymbolicValue, VPRegionValue>(VPV))
+ if (isa<VPIRValue, VPSymbolicValue>(VPV))
return true;
if (auto *Rep = dyn_cast<VPReplicateRecipe>(VPV)) {
@@ -418,7 +418,7 @@ bool vputils::isSingleScalar(const VPValue *VPV) {
bool vputils::isUniformAcrossVFsAndUFs(const VPValue *V) {
// Live-ins and region values are uniform.
- if (isa<VPIRValue, VPSymbolicValue, VPRegionValue>(V))
+ if (isa<VPIRValue, VPSymbolicValue>(V))
return true;
const VPRecipeBase *R = V->getDefiningRecipe();
diff --git a/llvm/lib/Transforms/Vectorize/VPlanValue.h b/llvm/lib/Transforms/Vectorize/VPlanValue.h
index 8f9806adf774e..5c14a3397eb02 100644
--- a/llvm/lib/Transforms/Vectorize/VPlanValue.h
+++ b/llvm/lib/Transforms/Vectorize/VPlanValue.h
@@ -48,7 +48,7 @@ class VPRegionBlock;
/// coming from the input IR, symbolic values and values defined by recipes.
class LLVM_ABI_FOR_TEST VPValue {
friend struct VPIRValue;
- friend struct VPSymbolicValue;
+ friend class VPSymbolicValue;
friend class VPRecipeValue;
friend class VPRegionValue;
@@ -205,16 +205,45 @@ class LLVM_ABI_FOR_TEST VPValue {
}
};
+/// A symbolic live-in VPValue, used for values like vector trip count, VF, and
+/// VFxUF. Serves as base class for VPValues that hold a materialization state
+/// (currently VPRegionValue).
+class VPSymbolicValue : public VPValue {
+ /// Track whether this value has been materialized (replaced). After
+ /// materialization, accessing users should trigger an assertion.
+ bool Materialized = false;
+
+protected:
+ VPSymbolicValue(unsigned char SC) : VPValue(SC, nullptr) {}
+
+public:
+ VPSymbolicValue() : VPSymbolicValue(VPVSymbolicSC) {}
+
+ /// Returns true if this value has been materialized.
+ bool isMaterialized() const { return Materialized; }
+
+ /// Mark this value as materialized.
+ void markMaterialized() {
+ assert(!Materialized && "VPSymbolicValue already materialized");
+ Materialized = true;
+ }
+
+ static bool classof(const VPValue *V) {
+ return V->getVPValueID() == VPVSymbolicSC ||
+ V->getVPValueID() == VPRegionValueSC;
+ }
+};
+
/// VPValues defined by a VPRegionBlock, like the canonical IV.
-class VPRegionValue : public VPValue {
+class VPRegionValue : public VPSymbolicValue {
VPRegionBlock *DefiningRegion;
Type *Ty;
DebugLoc DL;
public:
VPRegionValue(Type *Ty, DebugLoc DL, VPRegionBlock *Region)
- : VPValue(VPValue::VPRegionValueSC), DefiningRegion(Region), Ty(Ty),
- DL(DL) {}
+ : VPSymbolicValue(VPValue::VPRegionValueSC), DefiningRegion(Region),
+ Ty(Ty), DL(DL) {}
~VPRegionValue() override = default;
@@ -275,30 +304,6 @@ struct VPConstantInt : public VPIRValue {
uint64_t getZExtValue() const { return getAPInt().getZExtValue(); }
};
-/// A symbolic live-in VPValue, used for values like vector trip count, VF, and
-/// VFxUF.
-struct VPSymbolicValue : public VPValue {
- VPSymbolicValue() : VPValue(VPVSymbolicSC, nullptr) {}
-
- static bool classof(const VPValue *V) {
- return V->getVPValueID() == VPVSymbolicSC;
- }
-
- /// Returns true if this symbolic value has been materialized.
- bool isMaterialized() const { return Materialized; }
-
- /// Mark this symbolic value as materialized.
- void markMaterialized() {
- assert(!Materialized && "VPSymbolicValue already materialized");
- Materialized = true;
- }
-
-private:
- /// Track whether this symbolic value has been materialized (replaced).
- /// After materialization, accessing users should trigger an assertion.
- bool Materialized = false;
-};
-
/// A VPValue defined by a recipe that produces one or more values.
class VPRecipeValue : public VPValue {
friend class VPValue;
diff --git a/llvm/unittests/Transforms/Vectorize/VPlanTest.cpp b/llvm/unittests/Transforms/Vectorize/VPlanTest.cpp
index a1ddda7eda969..ad2a32dbf70b1 100644
--- a/llvm/unittests/Transforms/Vectorize/VPlanTest.cpp
+++ b/llvm/unittests/Transforms/Vectorize/VPlanTest.cpp
@@ -1787,6 +1787,32 @@ TEST_F(VPInstructionTest, VPSymbolicValueMaterialization) {
EXPECT_TRUE(Plan.getVF().isMaterialized());
}
+TEST_F(VPBasicBlockTest, VPRegionValueClonePropagatesMaterialized) {
+ VPlan &Plan = getPlan();
+ VPBasicBlock *Preheader = Plan.getEntry();
+ VPBasicBlock *Header = Plan.createVPBasicBlock("header");
+ VPBasicBlock *Latch = Plan.createVPBasicBlock("latch");
+ VPRegionBlock *Region = Plan.createLoopRegion(Type::getInt32Ty(C), DebugLoc(),
+ "loop", Header, Latch);
+ VPBlockUtils::connectBlocks(Header, Latch);
+ VPBlockUtils::connectBlocks(Preheader, Region);
+ VPBlockUtils::connectBlocks(Region, Plan.getScalarHeader());
+
+ VPRegionValue *CanIV = Region->getCanonicalIV();
+ EXPECT_TRUE(isa<VPSymbolicValue>(CanIV));
+ EXPECT_FALSE(CanIV->isMaterialized());
+
+ // Materialize the canonical IV by replacing all uses, then verify clone
+ // propagates the materialized state.
+ CanIV->replaceAllUsesWith(Plan.getConstantInt(32, 0));
+ EXPECT_TRUE(CanIV->isMaterialized());
+
+ std::unique_ptr<VPlan> Clone(Plan.duplicate());
+ VPRegionValue *ClonedCanIV = Clone->getVectorLoopRegion()->getCanonicalIV();
+ EXPECT_NE(CanIV, ClonedCanIV);
+ EXPECT_TRUE(ClonedCanIV->isMaterialized());
+}
+
#if defined(GTEST_HAS_DEATH_TEST) && !defined(NDEBUG)
TEST_F(VPInstructionTest, VPSymbolicValueAddUserAfterMaterialization) {
VPlan &Plan = getPlan();
``````````
</details>
https://github.com/llvm/llvm-project/pull/196753
More information about the llvm-commits
mailing list