[llvm] 8cd86ff - [VPlan] Propagate FastMathFlags from phis to blends (#180226)
via llvm-commits
llvm-commits at lists.llvm.org
Mon Feb 9 03:39:03 PST 2026
Author: Luke Lau
Date: 2026-02-09T19:38:58+08:00
New Revision: 8cd86ff284c3aa1b47c00500a5dc7889b1c9bade
URL: https://github.com/llvm/llvm-project/commit/8cd86ff284c3aa1b47c00500a5dc7889b1c9bade
DIFF: https://github.com/llvm/llvm-project/commit/8cd86ff284c3aa1b47c00500a5dc7889b1c9bade.diff
LOG: [VPlan] Propagate FastMathFlags from phis to blends (#180226)
If a phi has fast math flags, we can propagate it to the widened select.
To do this, this patch makes VPPhi and VPBlendRecipe subclasses of
VPRecipeWithIRFlags, and propagates it through PlainCFGBuilder and
VPPredicator.
Alive2 proofs for some of the FMFs (it looks like it can't reason about
the full "fast" set yet)
nnan: https://alive2.llvm.org/ce/z/f0bRd4
nsz: https://alive2.llvm.org/ce/z/u9P96T
The actual motivation for this to eventually be able to move the special
casing for tail folding in
LoopVectorizationPlanner::addReductionResultComputation into the CFG in
#176143, which requires passing through FMFs.
Added:
llvm/test/Transforms/LoopVectorize/phi-with-fastflags-vplan.ll
llvm/test/Transforms/LoopVectorize/phi-with-fastflags.ll
Modified:
llvm/lib/Transforms/Vectorize/LoopVectorizationPlanner.h
llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
llvm/lib/Transforms/Vectorize/VPlan.h
llvm/lib/Transforms/Vectorize/VPlanConstruction.cpp
llvm/lib/Transforms/Vectorize/VPlanPredicator.cpp
llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp
llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp
llvm/unittests/Transforms/Vectorize/VPlanTest.cpp
llvm/unittests/Transforms/Vectorize/VPlanVerifierTest.cpp
Removed:
################################################################################
diff --git a/llvm/lib/Transforms/Vectorize/LoopVectorizationPlanner.h b/llvm/lib/Transforms/Vectorize/LoopVectorizationPlanner.h
index 38ede9fff3650..0b8796f646ae3 100644
--- a/llvm/lib/Transforms/Vectorize/LoopVectorizationPlanner.h
+++ b/llvm/lib/Transforms/Vectorize/LoopVectorizationPlanner.h
@@ -233,15 +233,13 @@ class VPBuilder {
return createNaryOp(VPInstruction::LogicalAnd, {LHS, RHS}, DL, Name);
}
- VPInstruction *
- createSelect(VPValue *Cond, VPValue *TrueVal, VPValue *FalseVal,
- DebugLoc DL = DebugLoc::getUnknown(), const Twine &Name = "",
- std::optional<FastMathFlags> FMFs = std::nullopt) {
- if (!FMFs)
- return createNaryOp(Instruction::Select, {Cond, TrueVal, FalseVal}, DL,
- Name);
+ VPInstruction *createSelect(VPValue *Cond, VPValue *TrueVal,
+ VPValue *FalseVal,
+ DebugLoc DL = DebugLoc::getUnknown(),
+ const Twine &Name = "",
+ const VPIRFlags &Flags = {}) {
return tryInsertInstruction(new VPInstruction(
- Instruction::Select, {Cond, TrueVal, FalseVal}, *FMFs, {}, DL, Name));
+ Instruction::Select, {Cond, TrueVal, FalseVal}, Flags, {}, DL, Name));
}
/// Create a new ICmp VPInstruction with predicate \p Pred and operands \p A
@@ -291,9 +289,10 @@ class VPBuilder {
GEPNoWrapFlags::none(), {}, DL, Name));
}
- VPPhi *createScalarPhi(ArrayRef<VPValue *> IncomingValues, DebugLoc DL,
- const Twine &Name = "") {
- return tryInsertInstruction(new VPPhi(IncomingValues, DL, Name));
+ VPPhi *createScalarPhi(ArrayRef<VPValue *> IncomingValues,
+ DebugLoc DL = DebugLoc::getUnknown(),
+ const Twine &Name = "", const VPIRFlags &Flags = {}) {
+ return tryInsertInstruction(new VPPhi(IncomingValues, Flags, DL, Name));
}
VPValue *createElementCount(Type *Ty, ElementCount EC) {
diff --git a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
index 46882ebf7f4a7..36a728d861048 100644
--- a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
+++ b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
@@ -8472,12 +8472,11 @@ void LoopVectorizationPlanner::addReductionResultComputation(
if (!PhiR->isInLoop() && CM.foldTailByMasking() &&
(!RR || !RR->isPartialReduction())) {
VPValue *Cond = vputils::findHeaderMask(*Plan);
- std::optional<FastMathFlags> FMFs =
- PhiTy->isFloatingPointTy()
- ? std::make_optional(RdxDesc.getFastMathFlags())
- : std::nullopt;
+ VPIRFlags Flags = PhiTy->isFloatingPointTy()
+ ? VPIRFlags(RdxDesc.getFastMathFlags())
+ : VPIRFlags();
NewExitingVPV =
- Builder.createSelect(Cond, OrigExitingVPV, PhiR, {}, "", FMFs);
+ Builder.createSelect(Cond, OrigExitingVPV, PhiR, {}, "", Flags);
OrigExitingVPV->replaceUsesWithIf(NewExitingVPV, [](VPUser &U, unsigned) {
using namespace VPlanPatternMatch;
return match(
diff --git a/llvm/lib/Transforms/Vectorize/VPlan.h b/llvm/lib/Transforms/Vectorize/VPlan.h
index 8b82f24c1cad5..eac5b58841e80 100644
--- a/llvm/lib/Transforms/Vectorize/VPlan.h
+++ b/llvm/lib/Transforms/Vectorize/VPlan.h
@@ -1046,7 +1046,8 @@ struct VPRecipeWithIRFlags : public VPSingleDefRecipe, public VPIRFlags {
: VPSingleDefRecipe(SC, Operands, DL), VPIRFlags(Flags) {}
static inline bool classof(const VPRecipeBase *R) {
- return R->getVPRecipeID() == VPRecipeBase::VPInstructionSC ||
+ return R->getVPRecipeID() == VPRecipeBase::VPBlendSC ||
+ R->getVPRecipeID() == VPRecipeBase::VPInstructionSC ||
R->getVPRecipeID() == VPRecipeBase::VPWidenSC ||
R->getVPRecipeID() == VPRecipeBase::VPWidenGEPSC ||
R->getVPRecipeID() == VPRecipeBase::VPWidenCallSC ||
@@ -1560,8 +1561,9 @@ class VPPhiAccessors {
};
struct LLVM_ABI_FOR_TEST VPPhi : public VPInstruction, public VPPhiAccessors {
- VPPhi(ArrayRef<VPValue *> Operands, DebugLoc DL, const Twine &Name = "")
- : VPInstruction(Instruction::PHI, Operands, {}, {}, DL, Name) {}
+ VPPhi(ArrayRef<VPValue *> Operands, const VPIRFlags &Flags, DebugLoc DL,
+ const Twine &Name = "")
+ : VPInstruction(Instruction::PHI, Operands, Flags, {}, DL, Name) {}
static inline bool classof(const VPUser *U) {
auto *VPI = dyn_cast<VPInstruction>(U);
@@ -1579,7 +1581,7 @@ struct LLVM_ABI_FOR_TEST VPPhi : public VPInstruction, public VPPhiAccessors {
}
VPPhi *clone() override {
- auto *PhiR = new VPPhi(operands(), getDebugLoc(), getName());
+ auto *PhiR = new VPPhi(operands(), *this, getDebugLoc(), getName());
PhiR->setUnderlyingValue(getUnderlyingValue());
return PhiR;
}
@@ -2690,20 +2692,22 @@ class VPReductionPHIRecipe : public VPHeaderPHIRecipe,
/// A recipe for vectorizing a phi-node as a sequence of mask-based select
/// instructions.
-class LLVM_ABI_FOR_TEST VPBlendRecipe : public VPSingleDefRecipe {
+class LLVM_ABI_FOR_TEST VPBlendRecipe : public VPRecipeWithIRFlags {
public:
/// The blend operation is a User of the incoming values and of their
/// respective masks, ordered [I0, M0, I1, M1, I2, M2, ...]. Note that M0 can
/// be omitted (implied by passing an odd number of operands) in which case
/// all other incoming values are merged into it.
- VPBlendRecipe(PHINode *Phi, ArrayRef<VPValue *> Operands, DebugLoc DL)
- : VPSingleDefRecipe(VPRecipeBase::VPBlendSC, Operands, Phi, DL) {
+ VPBlendRecipe(PHINode *Phi, ArrayRef<VPValue *> Operands,
+ const VPIRFlags &Flags, DebugLoc DL)
+ : VPRecipeWithIRFlags(VPRecipeBase::VPBlendSC, Operands, Flags, DL) {
assert(Operands.size() >= 2 && "Expected at least two operands!");
+ setUnderlyingValue(Phi);
}
VPBlendRecipe *clone() override {
return new VPBlendRecipe(cast_or_null<PHINode>(getUnderlyingValue()),
- operands(), getDebugLoc());
+ operands(), *this, getDebugLoc());
}
VP_CLASSOF_IMPL(VPRecipeBase::VPBlendSC)
diff --git a/llvm/lib/Transforms/Vectorize/VPlanConstruction.cpp b/llvm/lib/Transforms/Vectorize/VPlanConstruction.cpp
index d22e8c100529e..91d73671cf26a 100644
--- a/llvm/lib/Transforms/Vectorize/VPlanConstruction.cpp
+++ b/llvm/lib/Transforms/Vectorize/VPlanConstruction.cpp
@@ -221,7 +221,8 @@ void PlainCFGBuilder::createVPInstructionsForVPBB(VPBasicBlock *VPBB,
// Phi node's operands may not have been visited at this point. We create
// an empty VPInstruction that we will fix once the whole plain CFG has
// been built.
- NewR = VPIRBuilder.createScalarPhi({}, Phi->getDebugLoc(), "vec.phi");
+ NewR =
+ VPIRBuilder.createScalarPhi({}, Phi->getDebugLoc(), "vec.phi", *Phi);
NewR->setUnderlyingValue(Phi);
if (isHeaderBB(Phi->getParent(), LI->getLoopFor(Phi->getParent()))) {
// Header phis need to be fixed after the VPBB for the latch has been
diff --git a/llvm/lib/Transforms/Vectorize/VPlanPredicator.cpp b/llvm/lib/Transforms/Vectorize/VPlanPredicator.cpp
index f91bf986bda9e..216efaf4b2fe9 100644
--- a/llvm/lib/Transforms/Vectorize/VPlanPredicator.cpp
+++ b/llvm/lib/Transforms/Vectorize/VPlanPredicator.cpp
@@ -256,7 +256,7 @@ void VPPredicator::convertPhisToBlends(VPBasicBlock *VPBB) {
}
PHINode *IRPhi = cast_or_null<PHINode>(PhiR->getUnderlyingValue());
auto *Blend =
- new VPBlendRecipe(IRPhi, OperandsWithMask, PhiR->getDebugLoc());
+ new VPBlendRecipe(IRPhi, OperandsWithMask, *PhiR, PhiR->getDebugLoc());
Builder.insert(Blend);
PhiR->replaceAllUsesWith(Blend);
PhiR->eraseFromParent();
diff --git a/llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp b/llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp
index 4a5145b092d6c..6a95804c1c5f0 100644
--- a/llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp
+++ b/llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp
@@ -583,7 +583,9 @@ Value *VPInstruction::generate(VPTransformState &State) {
OnlyFirstLaneUsed || vputils::isSingleScalar(getOperand(0)));
Value *Op1 = State.get(getOperand(1), OnlyFirstLaneUsed);
Value *Op2 = State.get(getOperand(2), OnlyFirstLaneUsed);
- return Builder.CreateSelect(Cond, Op1, Op2, Name);
+ FastMathFlags FMFs =
+ hasFastMathFlags() ? getFastMathFlags() : FastMathFlags();
+ return Builder.CreateSelectFMF(Cond, Op1, Op2, FMFs, Name);
}
case VPInstruction::ActiveLaneMask: {
// Get first lane of vector induction variable.
@@ -1619,7 +1621,8 @@ void VPPhi::printRecipe(raw_ostream &O, const Twine &Indent,
VPSlotTracker &SlotTracker) const {
O << Indent << "EMIT" << (isSingleScalar() ? "-SCALAR" : "") << " ";
printAsOperand(O, SlotTracker);
- O << " = phi ";
+ O << " = phi";
+ printFlags(O);
printPhiOperands(O, SlotTracker);
}
#endif
@@ -2128,7 +2131,8 @@ bool VPIRFlags::flagsValidForOpcode(unsigned Opcode) const {
Opcode == Instruction::FMul || Opcode == Instruction::FSub ||
Opcode == Instruction::FNeg || Opcode == Instruction::FDiv ||
Opcode == Instruction::FRem || Opcode == Instruction::FPExt ||
- Opcode == Instruction::FPTrunc || Opcode == Instruction::Select ||
+ Opcode == Instruction::FPTrunc || Opcode == Instruction::PHI ||
+ Opcode == Instruction::Select ||
Opcode == VPInstruction::WideIVStep ||
Opcode == VPInstruction::ReductionStartVector;
case OperationType::FCmp:
@@ -2739,14 +2743,15 @@ void VPBlendRecipe::printRecipe(raw_ostream &O, const Twine &Indent,
O << Indent << "BLEND ";
printAsOperand(O, SlotTracker);
O << " =";
+ printFlags(O);
if (getNumIncomingValues() == 1) {
// Not a User of any mask: not really blending, this is a
// single-predecessor phi.
- O << " ";
getIncomingValue(0)->printAsOperand(O, SlotTracker);
} else {
for (unsigned I = 0, E = getNumIncomingValues(); I < E; ++I) {
- O << " ";
+ if (I != 0)
+ O << " ";
getIncomingValue(I)->printAsOperand(O, SlotTracker);
if (I == 0)
continue;
diff --git a/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp b/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp
index cdddb183c02b0..839b4cdf4219c 100644
--- a/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp
+++ b/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp
@@ -1796,7 +1796,7 @@ static void simplifyBlends(VPlan &Plan) {
auto *NewBlend =
new VPBlendRecipe(cast_or_null<PHINode>(Blend->getUnderlyingValue()),
- OperandsWithMask, Blend->getDebugLoc());
+ OperandsWithMask, *Blend, Blend->getDebugLoc());
NewBlend->insertBefore(&R);
VPValue *DeadMask = Blend->getMask(StartIndex);
@@ -3898,7 +3898,7 @@ void VPlanTransforms::convertToConcreteRecipes(VPlan &Plan) {
for (unsigned I = 1; I != Blend->getNumIncomingValues(); ++I)
Select = Builder.createSelect(Blend->getMask(I),
Blend->getIncomingValue(I), Select,
- R.getDebugLoc(), "predphi");
+ R.getDebugLoc(), "predphi", *Blend);
Blend->replaceAllUsesWith(Select);
ToRemove.push_back(Blend);
}
diff --git a/llvm/test/Transforms/LoopVectorize/phi-with-fastflags-vplan.ll b/llvm/test/Transforms/LoopVectorize/phi-with-fastflags-vplan.ll
new file mode 100644
index 0000000000000..f685bf806929c
--- /dev/null
+++ b/llvm/test/Transforms/LoopVectorize/phi-with-fastflags-vplan.ll
@@ -0,0 +1,74 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 6
+; RUN: opt -p loop-vectorize -force-vector-width=4 -debug-only=loop-vectorize -disable-output -S %s 2>&1 | FileCheck %s
+
+define void @f(ptr noalias %p, i1 %c) {
+; CHECK-LABEL: 'f'
+; CHECK: VPlan 'Initial VPlan for VF={4},UF>=1' {
+; CHECK-NEXT: Live-in vp<[[VP0:%[0-9]+]]> = VF
+; CHECK-NEXT: Live-in vp<[[VP1:%[0-9]+]]> = VF * UF
+; CHECK-NEXT: Live-in vp<[[VP2:%[0-9]+]]> = vector-trip-count
+; CHECK-NEXT: Live-in ir<1024> = original trip-count
+; CHECK-EMPTY:
+; CHECK-NEXT: ir-bb<entry>:
+; CHECK-NEXT: Successor(s): scalar.ph, vector.ph
+; CHECK-EMPTY:
+; CHECK-NEXT: vector.ph:
+; CHECK-NEXT: Successor(s): vector loop
+; CHECK-EMPTY:
+; CHECK-NEXT: <x1> vector loop: {
+; CHECK-NEXT: vector.body:
+; CHECK-NEXT: EMIT vp<[[VP3:%[0-9]+]]> = CANONICAL-INDUCTION ir<0>, vp<%index.next>
+; CHECK-NEXT: vp<[[VP4:%[0-9]+]]> = SCALAR-STEPS vp<[[VP3]]>, ir<1>, vp<[[VP0]]>
+; CHECK-NEXT: CLONE ir<%gep> = getelementptr ir<%p>, vp<[[VP4]]>
+; CHECK-NEXT: vp<[[VP5:%[0-9]+]]> = vector-pointer ir<%gep>
+; CHECK-NEXT: WIDEN ir<%x> = load vp<[[VP5]]>
+; CHECK-NEXT: BLEND ir<%phi> = fast ir<%x> ir<0.000000e+00>/ir<%c>
+; CHECK-NEXT: vp<[[VP6:%[0-9]+]]> = vector-pointer ir<%gep>
+; CHECK-NEXT: WIDEN store vp<[[VP6]]>, ir<%phi>
+; CHECK-NEXT: EMIT vp<%index.next> = add nuw vp<[[VP3]]>, vp<[[VP1]]>
+; CHECK-NEXT: EMIT branch-on-count vp<%index.next>, vp<[[VP2]]>
+; CHECK-NEXT: No successors
+; CHECK-NEXT: }
+; CHECK-NEXT: Successor(s): middle.block
+; CHECK-EMPTY:
+; CHECK-NEXT: middle.block:
+; CHECK-NEXT: EMIT vp<%cmp.n> = icmp eq ir<1024>, vp<[[VP2]]>
+; CHECK-NEXT: EMIT branch-on-cond vp<%cmp.n>
+; CHECK-NEXT: Successor(s): ir-bb<exit>, scalar.ph
+; CHECK-EMPTY:
+; CHECK-NEXT: ir-bb<exit>:
+; CHECK-NEXT: No successors
+; CHECK-EMPTY:
+; CHECK-NEXT: scalar.ph:
+; CHECK-NEXT: EMIT-SCALAR vp<%bc.resume.val> = phi [ vp<[[VP2]]>, middle.block ], [ ir<0>, ir-bb<entry> ]
+; CHECK-NEXT: Successor(s): ir-bb<loop>
+; CHECK-EMPTY:
+; CHECK-NEXT: ir-bb<loop>:
+; CHECK-NEXT: IR %iv = phi i32 [ 0, %entry ], [ %iv.next, %latch ] (extra operand: vp<%bc.resume.val> from scalar.ph)
+; CHECK-NEXT: IR %gep = getelementptr float, ptr %p, i32 %iv
+; CHECK-NEXT: IR %x = load float, ptr %gep, align 4
+; CHECK-NEXT: No successors
+; CHECK-NEXT: }
+;
+entry:
+ br label %loop
+
+loop:
+ %iv = phi i32 [ 0, %entry ], [ %iv.next, %latch ]
+ %gep = getelementptr float, ptr %p, i32 %iv
+ %x = load float, ptr %gep
+ br i1 %c, label %then, label %latch
+
+then:
+ br label %latch
+
+latch:
+ %phi = phi fast float [ %x, %loop ], [ 0.0, %then ]
+ store float %phi, ptr %gep
+ %iv.next = add i32 %iv, 1
+ %done = icmp eq i32 %iv.next, 1024
+ br i1 %done, label %exit, label %loop
+
+exit:
+ ret void
+}
diff --git a/llvm/test/Transforms/LoopVectorize/phi-with-fastflags.ll b/llvm/test/Transforms/LoopVectorize/phi-with-fastflags.ll
new file mode 100644
index 0000000000000..2ce2c932de2cb
--- /dev/null
+++ b/llvm/test/Transforms/LoopVectorize/phi-with-fastflags.ll
@@ -0,0 +1,46 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-globals none --version 6
+; RUN: opt -p loop-vectorize -force-vector-width=4 -S < %s | FileCheck %s
+
+define void @f(ptr noalias %p, i1 %c) {
+; CHECK-LABEL: define void @f(
+; CHECK-SAME: ptr noalias [[P:%.*]], i1 [[C:%.*]]) {
+; CHECK-NEXT: [[ENTRY:.*:]]
+; CHECK-NEXT: br label %[[VECTOR_PH:.*]]
+; CHECK: [[VECTOR_PH]]:
+; CHECK-NEXT: br label %[[VECTOR_BODY:.*]]
+; CHECK: [[VECTOR_BODY]]:
+; CHECK-NEXT: [[INDEX:%.*]] = phi i32 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], %[[VECTOR_BODY]] ]
+; CHECK-NEXT: [[TMP0:%.*]] = getelementptr float, ptr [[P]], i32 [[INDEX]]
+; CHECK-NEXT: [[WIDE_LOAD:%.*]] = load <4 x float>, ptr [[TMP0]], align 4
+; CHECK-NEXT: [[PREDPHI:%.*]] = select fast i1 [[C]], <4 x float> zeroinitializer, <4 x float> [[WIDE_LOAD]]
+; CHECK-NEXT: store <4 x float> [[PREDPHI]], ptr [[TMP0]], align 4
+; CHECK-NEXT: [[INDEX_NEXT]] = add nuw i32 [[INDEX]], 4
+; CHECK-NEXT: [[TMP1:%.*]] = icmp eq i32 [[INDEX_NEXT]], 1024
+; CHECK-NEXT: br i1 [[TMP1]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP0:![0-9]+]]
+; CHECK: [[MIDDLE_BLOCK]]:
+; CHECK-NEXT: br label %[[EXIT:.*]]
+; CHECK: [[EXIT]]:
+; CHECK-NEXT: ret void
+;
+entry:
+ br label %loop
+
+loop:
+ %iv = phi i32 [ 0, %entry ], [ %iv.next, %latch ]
+ %gep = getelementptr float, ptr %p, i32 %iv
+ %x = load float, ptr %gep
+ br i1 %c, label %then, label %latch
+
+then:
+ br label %latch
+
+latch:
+ %phi = phi fast float [ %x, %loop ], [ 0.0, %then ]
+ store float %phi, ptr %gep
+ %iv.next = add i32 %iv, 1
+ %done = icmp eq i32 %iv.next, 1024
+ br i1 %done, label %exit, label %loop
+
+exit:
+ ret void
+}
diff --git a/llvm/unittests/Transforms/Vectorize/VPlanTest.cpp b/llvm/unittests/Transforms/Vectorize/VPlanTest.cpp
index 52634abcfb670..5f33f0593e05f 100644
--- a/llvm/unittests/Transforms/Vectorize/VPlanTest.cpp
+++ b/llvm/unittests/Transforms/Vectorize/VPlanTest.cpp
@@ -1147,7 +1147,7 @@ TEST_F(VPRecipeTest, CastVPBlendRecipeToVPUser) {
Args.push_back(I1);
Args.push_back(I2);
Args.push_back(M2);
- VPBlendRecipe Recipe(Phi, Args, {});
+ VPBlendRecipe Recipe(Phi, Args, {}, {});
checkVPRecipeCastImpl<VPBlendRecipe, VPUser>(&Recipe);
diff --git a/llvm/unittests/Transforms/Vectorize/VPlanVerifierTest.cpp b/llvm/unittests/Transforms/Vectorize/VPlanVerifierTest.cpp
index eeae72920854b..f07ee94105ff8 100644
--- a/llvm/unittests/Transforms/Vectorize/VPlanVerifierTest.cpp
+++ b/llvm/unittests/Transforms/Vectorize/VPlanVerifierTest.cpp
@@ -113,7 +113,7 @@ TEST_F(VPVerifierTest, VPBlendUseBeforeDefDifferentBB) {
auto *CanIV = new VPCanonicalIVPHIRecipe(Zero, {});
VPInstruction *BranchOnCond =
new VPInstruction(VPInstruction::BranchOnCond, {CanIV});
- auto *Blend = new VPBlendRecipe(Phi, {DefI, Plan.getTrue()}, {});
+ auto *Blend = new VPBlendRecipe(Phi, {DefI, Plan.getTrue()}, {}, {});
VPBasicBlock *VPBB1 = Plan.getEntry();
VPBasicBlock *VPBB2 = Plan.createVPBasicBlock("");
@@ -166,7 +166,7 @@ TEST_F(VPVerifierTest, VPPhiIncomingValueDoesntDominateIncomingBlock) {
VPInstruction *DefI =
new VPInstruction(Instruction::Add, {Zero, Zero},
VPIRFlags::getDefaultFlags(Instruction::Add));
- VPPhi *Phi = new VPPhi({DefI}, {});
+ VPPhi *Phi = new VPPhi({DefI}, {}, {});
VPBB2->appendRecipe(Phi);
VPBB2->appendRecipe(DefI);
auto *CanIV = new VPCanonicalIVPHIRecipe(Zero, {});
More information about the llvm-commits
mailing list