[llvm] [VPlan] Replace PhiR operand of ComputeFindIVResult with VPIRFlags. #174026 (PR #175461)
via llvm-commits
llvm-commits at lists.llvm.org
Sun Jan 11 13:21:04 PST 2026
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-backend-risc-v
Author: Florian Hahn (fhahn)
<details>
<summary>Changes</summary>
Replace the Phi recipe operand of ComputeFindIVResult with VPIRFlags, building on top of https://github.com/llvm/llvm-project/pull/174026.
---
Patch is 37.69 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/175461.diff
9 Files Affected:
- (modified) llvm/lib/Transforms/Vectorize/LoopVectorize.cpp (+16-12)
- (modified) llvm/lib/Transforms/Vectorize/VPlan.h (+51-4)
- (modified) llvm/lib/Transforms/Vectorize/VPlanConstruction.cpp (+31-24)
- (modified) llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp (+63-33)
- (modified) llvm/lib/Transforms/Vectorize/VPlanUnroll.cpp (+2-2)
- (modified) llvm/test/Transforms/LoopVectorize/AArch64/vplan-printing.ll (+4-4)
- (modified) llvm/test/Transforms/LoopVectorize/RISCV/vplan-vp-intrinsics-reduction.ll (+4-4)
- (modified) llvm/test/Transforms/LoopVectorize/first-order-recurrence-sink-replicate-region.ll (+1-1)
- (modified) llvm/test/Transforms/LoopVectorize/vplan-printing-reductions.ll (+14-14)
``````````diff
diff --git a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
index cdc6ecfa21bcb..9fad6c188deca 100644
--- a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
+++ b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
@@ -7302,7 +7302,7 @@ static Value *getStartValueFromReductionResult(VPInstruction *RdxResult) {
using namespace VPlanPatternMatch;
assert(RdxResult->getOpcode() == VPInstruction::ComputeFindIVResult &&
"RdxResult must be ComputeFindIVResult");
- VPValue *StartVPV = RdxResult->getOperand(1);
+ VPValue *StartVPV = RdxResult->getOperand(0);
match(StartVPV, m_Freeze(m_VPValue(StartVPV)));
return StartVPV->getLiveInIRValue();
}
@@ -7360,7 +7360,7 @@ static void fixReductionScalarResumeWhenVectorizingEpilog(
MainResumeValue = Cmp->getOperand(0);
} else if (RecurrenceDescriptor::isFindIVRecurrenceKind(Kind)) {
Value *StartV = getStartValueFromReductionResult(EpiRedResult);
- Value *SentinelV = EpiRedResult->getOperand(2)->getLiveInIRValue();
+ Value *SentinelV = EpiRedResult->getOperand(1)->getLiveInIRValue();
using namespace llvm::PatternMatch;
Value *Cmp, *OrigResumeV, *CmpOp;
[[maybe_unused]] bool IsExpectedPattern =
@@ -8746,22 +8746,26 @@ void LoopVectorizationPlanner::addReductionResultComputation(
if (RecurrenceDescriptor::isFindIVRecurrenceKind(RecurrenceKind)) {
VPValue *Start = PhiR->getStartValue();
VPValue *Sentinel = Plan->getOrAddLiveIn(RdxDesc.getSentinelValue());
+ VPIRFlags Flags(RecurrenceKind, /*IsOrdered=*/false, /*IsInLoop=*/false,
+ FastMathFlags());
FinalReductionResult =
Builder.createNaryOp(VPInstruction::ComputeFindIVResult,
- {PhiR, Start, Sentinel, NewExitingVPV}, ExitDL);
+ {Start, Sentinel, NewExitingVPV}, Flags, ExitDL);
} else if (RecurrenceDescriptor::isAnyOfRecurrenceKind(RecurrenceKind)) {
VPValue *Start = PhiR->getStartValue();
FinalReductionResult =
Builder.createNaryOp(VPInstruction::ComputeAnyOfResult,
{PhiR, Start, NewExitingVPV}, ExitDL);
} else {
- VPIRFlags Flags =
+ FastMathFlags FMFs =
RecurrenceDescriptor::isFloatingPointRecurrenceKind(RecurrenceKind)
- ? VPIRFlags(RdxDesc.getFastMathFlags())
- : VPIRFlags();
+ ? RdxDesc.getFastMathFlags()
+ : FastMathFlags();
+ VPIRFlags Flags(RecurrenceKind, PhiR->isOrdered(), PhiR->isInLoop(),
+ FMFs);
FinalReductionResult =
Builder.createNaryOp(VPInstruction::ComputeReductionResult,
- {PhiR, NewExitingVPV}, Flags, ExitDL);
+ {NewExitingVPV}, Flags, ExitDL);
}
// If the vector reduction can be performed in a smaller type, we truncate
// then extend the loop exit value to enable InstCombine to evaluate the
@@ -8789,8 +8793,8 @@ void LoopVectorizationPlanner::addReductionResultComputation(
PhiR->setOperand(1, Extnd->getVPSingleValue());
// Update ComputeReductionResult with the truncated exiting value and
- // extend its result.
- FinalReductionResult->setOperand(1, Trunc);
+ // extend its result. Operand 0 is the first reduction part.
+ FinalReductionResult->setOperand(0, Trunc);
FinalReductionResult =
Builder.createScalarCast(ExtendOpc, FinalReductionResult, PhiTy, {});
}
@@ -9292,12 +9296,12 @@ static void preparePlanForMainVectorLoop(VPlan &MainPlan, VPlan &EpiPlan) {
auto *VPI = dyn_cast<VPInstruction>(&R);
if (!VPI || VPI->getOpcode() != VPInstruction::ComputeFindIVResult)
continue;
- VPValue *OrigStart = VPI->getOperand(1);
+ VPValue *OrigStart = VPI->getOperand(0);
if (isGuaranteedNotToBeUndefOrPoison(OrigStart->getLiveInIRValue()))
continue;
VPInstruction *Freeze =
Builder.createNaryOp(Instruction::Freeze, {OrigStart}, {}, "fr");
- VPI->setOperand(1, Freeze);
+ VPI->setOperand(0, Freeze);
if (UpdateResumePhis)
OrigStart->replaceUsesWithIf(Freeze, [Freeze](VPUser &U, unsigned) {
return Freeze != &U && isa<VPPhi>(&U);
@@ -9454,7 +9458,7 @@ static SmallVector<Instruction *> preparePlanForEpilogueVectorLoop(
Value *Cmp = Builder.CreateICmpEQ(ResumeV, ToFrozen[StartV]);
if (auto *I = dyn_cast<Instruction>(Cmp))
InstsToMove.push_back(I);
- Value *Sentinel = RdxResult->getOperand(2)->getLiveInIRValue();
+ Value *Sentinel = RdxResult->getOperand(1)->getLiveInIRValue();
ResumeV = Builder.CreateSelect(Cmp, Sentinel, ResumeV);
if (auto *I = dyn_cast<Instruction>(ResumeV))
InstsToMove.push_back(I);
diff --git a/llvm/lib/Transforms/Vectorize/VPlan.h b/llvm/lib/Transforms/Vectorize/VPlan.h
index 83fe45bfd0bbf..234a2e30ca9ff 100644
--- a/llvm/lib/Transforms/Vectorize/VPlan.h
+++ b/llvm/lib/Transforms/Vectorize/VPlan.h
@@ -616,6 +616,7 @@ class VPIRFlags {
GEPOp,
FPMathOp,
NonNegOp,
+ ReductionOp,
Other
};
@@ -665,6 +666,18 @@ class VPIRFlags {
CmpInst::Predicate Pred;
FastMathFlagsTy FMFs;
};
+ /// Holds reduction-specific flags: RecurKind, IsOrdered, IsInLoop, and FMFs.
+ struct ReductionFlagsTy {
+ unsigned char Kind : 6; // RecurKind has ~26 values, needs 5 bits
+ unsigned char IsOrdered : 1;
+ unsigned char IsInLoop : 1;
+ FastMathFlagsTy FMFs;
+
+ ReductionFlagsTy(RecurKind Kind, bool IsOrdered, bool IsInLoop,
+ FastMathFlags FMFs)
+ : Kind(static_cast<unsigned char>(Kind)), IsOrdered(IsOrdered),
+ IsInLoop(IsInLoop), FMFs(FMFs) {}
+ };
OperationType OpType;
@@ -678,6 +691,7 @@ class VPIRFlags {
NonNegFlagsTy NonNegFlags;
FastMathFlagsTy FMFs;
FCmpFlagsTy FCmpFlags;
+ ReductionFlagsTy ReductionFlags;
unsigned AllFlags;
};
@@ -745,6 +759,10 @@ class VPIRFlags {
VPIRFlags(GEPNoWrapFlags GEPFlags)
: OpType(OperationType::GEPOp), GEPFlags(GEPFlags) {}
+ VPIRFlags(RecurKind Kind, bool IsOrdered, bool IsInLoop, FastMathFlags FMFs)
+ : OpType(OperationType::ReductionOp),
+ ReductionFlags(Kind, IsOrdered, IsInLoop, FMFs) {}
+
void transferFlags(VPIRFlags &Other) {
OpType = Other.OpType;
AllFlags = Other.AllFlags;
@@ -785,6 +803,7 @@ class VPIRFlags {
NonNegFlags.NonNeg = false;
break;
case OperationType::Cmp:
+ case OperationType::ReductionOp:
case OperationType::Other:
break;
}
@@ -826,6 +845,7 @@ class VPIRFlags {
I.setNonNeg(NonNegFlags.NonNeg);
break;
case OperationType::Cmp:
+ case OperationType::ReductionOp:
case OperationType::Other:
break;
}
@@ -855,7 +875,8 @@ class VPIRFlags {
/// Returns true if the recipe has fast-math flags.
bool hasFastMathFlags() const {
- return OpType == OperationType::FPMathOp || OpType == OperationType::FCmp;
+ return OpType == OperationType::FPMathOp || OpType == OperationType::FCmp ||
+ OpType == OperationType::ReductionOp;
}
LLVM_ABI_FOR_TEST FastMathFlags getFastMathFlags() const;
@@ -897,13 +918,39 @@ class VPIRFlags {
return DisjointFlags.IsDisjoint;
}
+ RecurKind getRecurKind() const {
+ assert(OpType == OperationType::ReductionOp &&
+ "recipe doesn't have reduction flags");
+ return static_cast<RecurKind>(ReductionFlags.Kind);
+ }
+
+ bool isReductionOrdered() const {
+ assert(OpType == OperationType::ReductionOp &&
+ "recipe doesn't have reduction flags");
+ return ReductionFlags.IsOrdered;
+ }
+
+ bool isReductionInLoop() const {
+ assert(OpType == OperationType::ReductionOp &&
+ "recipe doesn't have reduction flags");
+ return ReductionFlags.IsInLoop;
+ }
+
private:
- /// Get a reference to the fast-math flags for FPMathOp or FCmp.
+ /// Get a reference to the fast-math flags for FPMathOp, FCmp or ReductionOp.
FastMathFlagsTy &getFMFsRef() {
- return OpType == OperationType::FCmp ? FCmpFlags.FMFs : FMFs;
+ if (OpType == OperationType::FCmp)
+ return FCmpFlags.FMFs;
+ if (OpType == OperationType::ReductionOp)
+ return ReductionFlags.FMFs;
+ return FMFs;
}
const FastMathFlagsTy &getFMFsRef() const {
- return OpType == OperationType::FCmp ? FCmpFlags.FMFs : FMFs;
+ if (OpType == OperationType::FCmp)
+ return FCmpFlags.FMFs;
+ if (OpType == OperationType::ReductionOp)
+ return ReductionFlags.FMFs;
+ return FMFs;
}
public:
diff --git a/llvm/lib/Transforms/Vectorize/VPlanConstruction.cpp b/llvm/lib/Transforms/Vectorize/VPlanConstruction.cpp
index 33355f9dcd88c..0ed9d845ebf0d 100644
--- a/llvm/lib/Transforms/Vectorize/VPlanConstruction.cpp
+++ b/llvm/lib/Transforms/Vectorize/VPlanConstruction.cpp
@@ -1228,12 +1228,22 @@ bool VPlanTransforms::handleMaxMinNumReductions(VPlan &Plan) {
// If we exit early due to NaNs, compute the final reduction result based on
// the reduction phi at the beginning of the last vector iteration.
+ VPValue *BackedgeVal = RedPhiR->getBackedgeValue();
auto *RdxResult =
- findUserOf<VPInstruction::ComputeReductionResult>(RedPhiR);
+ findUserOf<VPInstruction::ComputeReductionResult>(BackedgeVal);
+
+ // Look through selects inserted for tail folding.
+ if (!RdxResult) {
+ auto *SelR = cast<VPSingleDefRecipe>(
+ *find_if(BackedgeVal->users(),
+ [PhiR = RedPhiR](VPUser *U) { return U != PhiR; }));
+ RdxResult = findUserOf<VPInstruction::ComputeReductionResult>(SelR);
+ assert(RdxResult && "must find a ComputeReductionResult");
+ }
auto *NewSel = MiddleBuilder.createSelect(AnyNaNLane, RedPhiR,
- RdxResult->getOperand(1));
- RdxResult->setOperand(1, NewSel);
+ RdxResult->getOperand(0));
+ RdxResult->setOperand(0, NewSel);
assert(!RdxResults.contains(RdxResult) && "RdxResult already used");
RdxResults.insert(RdxResult);
}
@@ -1299,10 +1309,10 @@ bool VPlanTransforms::handleMultiUseReductions(VPlan &Plan) {
// MinMaxPhiR has users outside the reduction cycle in the loop. Check if
// the only other user is a FindLastIV reduction. MinMaxPhiR must have
- // exactly 3 users: 1) the min/max operation, the compare of a FindLastIV
- // reduction and ComputeReductionResult. The comparisom must compare
- // MinMaxPhiR against the min/max operand used for the min/max reduction
- // and only be used by the select of the FindLastIV reduction.
+ // exactly 2 users: 1) the min/max operation and the compare of a FindLastIV
+ // reduction. The comparison must compare MinMaxPhiR against the min/max
+ // operand used for the min/max reduction and only be used by the select of
+ // the FindLastIV reduction.
RecurKind RdxKind = MinMaxPhiR->getRecurrenceKind();
assert(
RecurrenceDescriptor::isIntMinMaxRecurrenceKind(RdxKind) &&
@@ -1319,8 +1329,7 @@ bool VPlanTransforms::handleMultiUseReductions(VPlan &Plan) {
if (!match(MinMaxOp, m_Intrinsic(ExpectedIntrinsicID)))
return false;
- // MinMaxOp must have 2 users: 1) MinMaxPhiR and 2) ComputeReductionResult
- // (asserted below).
+ // MinMaxOp must have 2 users: 1) MinMaxPhiR and 2) ComputeReductionResult.
assert(MinMaxOp->getNumUsers() == 2 &&
"MinMaxOp must have exactly 2 users");
VPValue *MinMaxOpValue = MinMaxOp->getOperand(0);
@@ -1339,20 +1348,17 @@ bool VPlanTransforms::handleMultiUseReductions(VPlan &Plan) {
if (MinMaxOpValue != CmpOpB)
Pred = CmpInst::getSwappedPredicate(Pred);
- // MinMaxPhiR must have exactly 3 users:
+ // MinMaxPhiR must have exactly 2 users:
// * MinMaxOp,
- // * Cmp (that's part of a FindLastIV chain),
- // * ComputeReductionResult.
- if (MinMaxPhiR->getNumUsers() != 3)
+ // * Cmp (that's part of a FindLastIV chain).
+ if (MinMaxPhiR->getNumUsers() != 2)
return false;
VPInstruction *MinMaxResult =
- findUserOf<VPInstruction::ComputeReductionResult>(MinMaxPhiR);
+ findUserOf<VPInstruction::ComputeReductionResult>(MinMaxOp);
assert(is_contained(MinMaxPhiR->users(), MinMaxOp) &&
"one user must be MinMaxOp");
- assert(MinMaxResult && "MinMaxResult must be a user of MinMaxPhiR");
- assert(is_contained(MinMaxOp->users(), MinMaxResult) &&
- "MinMaxResult must be a user of MinMaxOp (and of MinMaxPhiR");
+ assert(MinMaxResult && "MinMaxResult must be a user of MinMaxOp");
// Cmp must be used by the select of a FindLastIV chain.
VPValue *Sel = dyn_cast<VPSingleDefRecipe>(Cmp->getSingleUser());
@@ -1411,7 +1417,7 @@ bool VPlanTransforms::handleMultiUseReductions(VPlan &Plan) {
// For example, this transforms
// vp<%min.result> = compute-reduction-result ir<%min.val>,
// ir<%min.val.next>
- // vp<%find.iv.result = compute-find-iv-result ir<%min.idx>, ir<0>,
+ // vp<%find.iv.result = compute-find-iv-result ir<0>,
// SENTINEL, vp<%min.idx.next>
//
// into:
@@ -1419,24 +1425,25 @@ bool VPlanTransforms::handleMultiUseReductions(VPlan &Plan) {
// vp<min.result> = compute-reduction-result ir<%min.val>, ir<%min.val.next>
// vp<%final.min.cmp> = icmp eq ir<%min.val.next>, vp<min.result>
// vp<%final.iv> = select vp<%final.min.cmp>, ir<%min.idx.next>, SENTINEL
- // vp<%find.iv.result> = compute-find-iv-result ir<%min.idx>, ir<0>,
+ // vp<%find.iv.result> = compute-find-iv-result ir<0>,
// SENTINEL, vp<%final.iv>
VPInstruction *FindIVResult =
- findUserOf<VPInstruction::ComputeFindIVResult>(FindIVPhiR);
+ findUserOf<VPInstruction::ComputeFindIVResult>(
+ FindIVPhiR->getBackedgeValue());
assert(FindIVResult->getParent() == MinMaxResult->getParent() &&
"both results must be computed in the same block");
MinMaxResult->moveBefore(*FindIVResult->getParent(),
FindIVResult->getIterator());
VPBuilder B(FindIVResult);
- VPValue *MinMaxExiting = MinMaxResult->getOperand(1);
+ VPValue *MinMaxExiting = MinMaxResult->getOperand(0);
auto *FinalMinMaxCmp =
B.createICmp(CmpInst::ICMP_EQ, MinMaxExiting, MinMaxResult);
- VPValue *Sentinel = FindIVResult->getOperand(2);
- VPValue *LastIVExiting = FindIVResult->getOperand(3);
+ VPValue *Sentinel = FindIVResult->getOperand(1);
+ VPValue *LastIVExiting = FindIVResult->getOperand(2);
auto *FinalIVSelect =
B.createSelect(FinalMinMaxCmp, LastIVExiting, Sentinel);
- FindIVResult->setOperand(3, FinalIVSelect);
+ FindIVResult->setOperand(2, FinalIVSelect);
}
return true;
}
diff --git a/llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp b/llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp
index 2c0772320c3cf..51b8ea1445d1e 100644
--- a/llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp
+++ b/llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp
@@ -345,6 +345,16 @@ void VPIRFlags::intersectFlags(const VPIRFlags &Other) {
case OperationType::Cmp:
assert(CmpPredicate == Other.CmpPredicate && "Cannot drop CmpPredicate");
break;
+ case OperationType::ReductionOp:
+ assert(ReductionFlags.Kind == Other.ReductionFlags.Kind &&
+ "Cannot change RecurKind");
+ assert(ReductionFlags.IsOrdered == Other.ReductionFlags.IsOrdered &&
+ "Cannot change IsOrdered");
+ assert(ReductionFlags.IsInLoop == Other.ReductionFlags.IsInLoop &&
+ "Cannot change IsInLoop");
+ getFMFsRef().NoNaNs &= Other.getFMFsRef().NoNaNs;
+ getFMFsRef().NoInfs &= Other.getFMFsRef().NoInfs;
+ break;
case OperationType::Other:
assert(AllFlags == Other.AllFlags && "Cannot drop other flags");
break;
@@ -352,7 +362,8 @@ void VPIRFlags::intersectFlags(const VPIRFlags &Other) {
}
FastMathFlags VPIRFlags::getFastMathFlags() const {
- assert((OpType == OperationType::FPMathOp || OpType == OperationType::FCmp) &&
+ assert((OpType == OperationType::FPMathOp || OpType == OperationType::FCmp ||
+ OpType == OperationType::ReductionOp) &&
"recipe doesn't have fast math flags");
const FastMathFlagsTy &F = getFMFsRef();
FastMathFlags Res;
@@ -437,6 +448,7 @@ unsigned VPInstruction::getNumOperandsForOpcode(unsigned Opcode) {
case VPInstruction::BuildVector:
case VPInstruction::CalculateTripCountMinusVF:
case VPInstruction::CanonicalIVIncrementForPart:
+ case VPInstruction::ComputeReductionResult:
case VPInstruction::ExplicitVectorLength:
case VPInstruction::ExtractLastLane:
case VPInstruction::ExtractLastPart:
@@ -452,7 +464,6 @@ unsigned VPInstruction::getNumOperandsForOpcode(unsigned Opcode) {
case Instruction::Store:
case VPInstruction::BranchOnCount:
case VPInstruction::BranchOnTwoConds:
- case VPInstruction::ComputeReductionResult:
case VPInstruction::ExtractLane:
case VPInstruction::FirstOrderRecurrenceSplice:
case VPInstruction::LogicalAnd:
@@ -463,10 +474,9 @@ unsigned VPInstruction::getNumOperandsForOpcode(unsigned Opcode) {
case Instruction::Select:
case VPInstruction::ActiveLaneMask:
case VPInstruction::ComputeAnyOfResult:
+ case VPInstruction::ComputeFindIVResult:
case VPInstruction::ReductionStartVector:
return 3;
- case VPInstruction::ComputeFindIVResult:
- return 4;
case Instruction::Call:
case Instruction::GetElementPtr:
case Instruction::PHI:
@@ -715,20 +725,14 @@ Value *VPInstruction::generate(VPTransformState &State) {
State.get(getOperand(1), VPLane(0)), OrigPhi);
}
case VPInstruction::ComputeFindIVResult: {
- // FIXME: The cross-recipe dependency on VPReductionPHIRecipe is temporary
- // and will be removed by breaking up the recipe further.
- auto *PhiR = cast<VPReductionPHIRecipe>(getOperand(0));
- // Get its reduction variable descriptor.
- RecurKind RK = PhiR->getRecurrenceKind();
+ RecurKind RK = getRecurKind();
assert(RecurrenceDescriptor::isFindIVRecurrenceKind(RK) &&
"Unexpected reduction kind");
- assert(!PhiR->isInLoop() &&
- "In-loop FindLastIV reduction is not supported yet");
- // The recipe's operands are the reduction phi, the start value, the
- // sentinel value, followed by one operand for each part of the reduction.
- unsigned UF = getNumOperands() - 3;
- Value *ReducedPartRdx = State.get(getOperand(3));
+ // The recipe's operands are the start value, the sentinel value, followed
+ // by one operand for each part of the reduction.
+ unsigned UF = getNumOperands() - 2;
+ Value *ReducedPartRdx = State.get(getOperand(2));
RecurKind MinMaxKind;
bool IsSigned = RecurrenceDescriptor::isSignedRecurrenceKind(RK);
if (RecurrenceDescriptor::isFindLastIVRecurrenceKind(RK))
@@ -737,10 +741,10 @@ Value *VPInstruction::generate(VPTransformState &State) {
MinMaxKind = IsSigned ? RecurKind::SMin : RecurKind::UMin;
for (unsigned Part = 1; Part < UF; ++Part)
ReducedPartRdx = createMinMaxOp(Builder, MinMaxKind, ReducedPartRdx,
- State.get(getOperand(3 + Part)));
+ State.get(getOperand(2 + Part)));
- Value *Start = State.get(getOperand(1), true);
- Value *Sentinel = getOperand(2)->getLiveInIRValue();
+ Value *Start = State.get(getOperand(0), true);
+ Value *Sentinel = getOperand(1)->getLiveInIRValue();
// Reduce the vector to a scalar.
bool IsFindLast = RecurrenceDescriptor::isFindLastIVRecurrenceKind(RK);
@@ -756,21 +760,16 @@ Value *VPInstruction::generate(VPTransformState &State) {
return Builder.CreateSelect(Cmp, ReducedIV, Start, "rdx.select");
}
case VPInstruction::ComputeReductionResult: {
- // FIXME: The cross-recipe dependency on VPReductionPHIRecipe is temporary
- // and will be removed by breaking up the recipe further.
- auto *PhiR = cast<VPReductionPHIRecipe>(getOperand(0));
- // Get its reduction variable descriptor.
-
- RecurKind RK = PhiR->getRecurrenc...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/175461
More information about the llvm-commits
mailing list