[llvm] [VPlan] Use WideInfo to improve select-cond-query (PR #216445)
via llvm-commits
llvm-commits at lists.llvm.org
Fri Aug 14 19:24:02 PDT 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-backend-risc-v
Author: Ramkumar Ramachandra (artagnon)
<details>
<summary>Changes</summary>
The WideInfo abstraction is useful in improving the accuracy of the scalar nature of a select condition, and it is much cheaper than vputils::isSingleScalar.
-- 8< --
Based on https://github.com/llvm/llvm-project/pull/208910.
---
Patch is 27.41 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/216445.diff
8 Files Affected:
- (modified) llvm/lib/Transforms/Vectorize/VPlan.h (-27)
- (modified) llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp (+10-2)
- (modified) llvm/lib/Transforms/Vectorize/VPlanUtils.cpp (+137-76)
- (modified) llvm/lib/Transforms/Vectorize/VPlanUtils.h (+38)
- (modified) llvm/lib/Transforms/Vectorize/VPlanValue.h (+2-7)
- (modified) llvm/test/Transforms/LoopVectorize/AArch64/masked-call-scalarize.ll (+2-4)
- (modified) llvm/test/Transforms/LoopVectorize/RISCV/divrem.ll (+4-8)
- (modified) llvm/test/Transforms/LoopVectorize/X86/invariant-load-gather.ll (+3-5)
``````````diff
diff --git a/llvm/lib/Transforms/Vectorize/VPlan.h b/llvm/lib/Transforms/Vectorize/VPlan.h
index b2e87a8f4f52d..bb53559e7f8e5 100644
--- a/llvm/lib/Transforms/Vectorize/VPlan.h
+++ b/llvm/lib/Transforms/Vectorize/VPlan.h
@@ -1598,13 +1598,6 @@ class VPInstructionWithType : public VPInstruction {
Type *getResultType() const { return getScalarType(); }
- /// Cast recipes always use scalars of their operand.
- bool usesScalars(const VPValue *Op) const override {
- if (Instruction::isCast(getOpcode()))
- return true;
- return VPInstruction::usesScalars(Op);
- }
-
protected:
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
/// Print the recipe.
@@ -1762,12 +1755,6 @@ class VPIRInstruction : public VPRecipeBase {
Instruction &getInstruction() const { return I; }
- bool usesScalars(const VPValue *Op) const override {
- assert(is_contained(operands(), Op) &&
- "Op must be an operand of the recipe");
- return true;
- }
-
bool usesFirstPartOnly(const VPValue *Op) const override {
assert(is_contained(operands(), Op) &&
"Op must be an operand of the recipe");
@@ -3467,13 +3454,6 @@ class LLVM_ABI_FOR_TEST VPReplicateRecipe : public VPRecipeWithIRFlags,
return isSingleScalar();
}
- /// Returns true if the recipe uses scalars of operand \p Op.
- bool usesScalars(const VPValue *Op) const override {
- assert(is_contained(operands(), Op) &&
- "Op must be an operand of the recipe");
- return true;
- }
-
/// Return the mask of a predicated VPReplicateRecipe.
VPValue *getMask() {
assert(isPredicated() && "Trying to get the mask of a unpredicated recipe");
@@ -3529,13 +3509,6 @@ class LLVM_ABI_FOR_TEST VPBranchOnMaskRecipe : public VPRecipeBase {
printOperands(O, SlotTracker);
}
#endif
-
- /// Returns true if the recipe uses scalars of operand \p Op.
- bool usesScalars(const VPValue *Op) const override {
- assert(is_contained(operands(), Op) &&
- "Op must be an operand of the recipe");
- return true;
- }
};
/// A recipe to combine multiple recipes into a single 'expression' recipe,
diff --git a/llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp b/llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp
index 53ab77fbd28b1..0f32349fab022 100644
--- a/llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp
+++ b/llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp
@@ -56,6 +56,12 @@ static cl::opt<bool> VPlanPrintMetadata(
cl::desc("Controls the printing of recipe metadata when debugging."));
#endif
+bool VPUser::usesScalars(const VPValue *Op) const {
+ assert(is_contained(operands(), Op) && "Op must be an operand of the recipe");
+ VPWideningInfo WideInfo = vputils::getWideningInfo(*cast<VPRecipeBase>(this));
+ return WideInfo.usesScalarOperands() || usesFirstLaneOnly(Op);
+}
+
bool VPRecipeBase::mayWriteToMemory() const {
switch (getVPRecipeID()) {
case VPExpressionSC:
@@ -790,7 +796,8 @@ Value *VPInstruction::generate(VPTransformState &State) {
bool OnlyFirstLaneUsed = vputils::onlyFirstLaneUsed(this);
Value *Cond =
State.get(getOperand(0),
- OnlyFirstLaneUsed || vputils::isSingleScalar(getOperand(0)));
+ OnlyFirstLaneUsed || vputils::getWideningInfo(getOperand(0))
+ .producesSingleScalarResult());
Value *Op1 = State.get(getOperand(1), OnlyFirstLaneUsed);
Value *Op2 = State.get(getOperand(2), OnlyFirstLaneUsed);
return Builder.CreateSelectFMF(Cond, Op1, Op2, getFastMathFlagsOrNone(),
@@ -2876,7 +2883,8 @@ void VPWidenRecipe::execute(VPTransformState &State) {
}
case Instruction::Select: {
VPValue *CondOp = getOperand(0);
- Value *Cond = State.get(CondOp, vputils::isSingleScalar(CondOp));
+ Value *Cond = State.get(
+ CondOp, vputils::getWideningInfo(CondOp).producesSingleScalarResult());
Value *Op0 = State.get(getOperand(1));
Value *Op1 = State.get(getOperand(2));
Value *Sel = State.Builder.CreateSelect(Cond, Op0, Op1);
diff --git a/llvm/lib/Transforms/Vectorize/VPlanUtils.cpp b/llvm/lib/Transforms/Vectorize/VPlanUtils.cpp
index daf8114d482d0..db5ef8a77d8c2 100644
--- a/llvm/lib/Transforms/Vectorize/VPlanUtils.cpp
+++ b/llvm/lib/Transforms/Vectorize/VPlanUtils.cpp
@@ -380,11 +380,10 @@ vputils::getOpcodeOrIntrinsicID(const VPValue *V) {
return {};
}
-/// Returns true if \p Opcode preserves uniformity, i.e., if all operands are
-/// uniform, the result will also be uniform.
-static bool preservesUniformity(unsigned Opcode) {
+static VPWideningInfo getNarrowableWideningInfo(unsigned Opcode,
+ VPWideningInfo WideOrRep) {
if (Instruction::isBinaryOp(Opcode) || Instruction::isCast(Opcode))
- return true;
+ return WideOrRep | VPWideningInfo::SingleScalar;
switch (Opcode) {
case Instruction::Freeze:
case Instruction::GetElementPtr:
@@ -392,13 +391,107 @@ static bool preservesUniformity(unsigned Opcode) {
case Instruction::FCmp:
case Instruction::Select:
case VPInstruction::Not:
- case VPInstruction::Broadcast:
case VPInstruction::MaskedCond:
case VPInstruction::PtrAdd:
- return true;
+ return WideOrRep | VPWideningInfo::SingleScalar;
default:
- return false;
+ return WideOrRep;
+ }
+}
+
+VPWideningInfo vputils::getWideningInfo(const VPRecipeBase &R) {
+ switch (R.getVPRecipeID()) {
+ case VPRecipeBase::VPVectorPointerSC:
+ case VPRecipeBase::VPVectorEndPointerSC:
+ case VPRecipeBase::VPDerivedIVSC:
+ case VPRecipeBase::VPExpandSCEVSC:
+ case VPRecipeBase::VPIRInstructionSC:
+ case VPRecipeBase::VPBranchOnMaskSC:
+ return VPWideningInfo::SingleScalar;
+ case VPRecipeBase::VPScalarIVStepsSC:
+ return VPWideningInfo::GenPerAllLanes;
+ case VPRecipeBase::VPWidenCastSC:
+ case VPRecipeBase::VPWidenGEPSC:
+ case VPRecipeBase::VPPredInstPHISC:
+ case VPRecipeBase::VPBlendSC:
+ return VPWideningInfo::Wide | VPWideningInfo::SingleScalar;
+ case VPRecipeBase::VPInstructionSC: {
+ auto *VPI = cast<VPInstruction>(&R);
+ // Broadcast is a special case of a vector-to-scalar.
+ if (VPI->isVectorToScalar() || VPI->getOpcode() == VPInstruction::Broadcast)
+ return VPWideningInfo::SingleScalar | VPWideningInfo::Agnostic;
+ // These opcodes take multiple scalars are produce a vector.
+ if (is_contained({VPInstruction::BuildStructVector,
+ VPInstruction::BuildVector,
+ VPInstruction::ActiveLaneMask},
+ VPI->getOpcode()))
+ return VPWideningInfo::Wide | VPWideningInfo::Agnostic;
+ if (VPI->isSingleScalar())
+ return VPWideningInfo::SingleScalar;
+ if (VPI->doesGeneratePerAllLanes())
+ return VPWideningInfo::GenPerAllLanes;
+ return getNarrowableWideningInfo(VPI->getOpcode(), VPWideningInfo::Wide);
+ }
+ case VPRecipeBase::VPExpressionSC: {
+ auto *Expr = cast<VPExpressionRecipe>(&R);
+ return Expr->isVectorToScalar()
+ ? (VPWideningInfo::SingleScalar | VPWideningInfo::Agnostic)
+ : VPWideningInfo::Wide;
+ }
+ case VPRecipeBase::VPReductionSC:
+ case VPRecipeBase::VPReductionEVLSC: {
+ auto *Red = cast<VPReductionRecipe>(&R);
+ return Red->isPartialReduction()
+ ? VPWideningInfo::Wide
+ : (VPWideningInfo::SingleScalar | VPWideningInfo::Agnostic);
}
+ case VPRecipeBase::VPReplicateSC: {
+ auto *Rep = cast<VPReplicateRecipe>(&R);
+ if (Rep->isSingleScalar())
+ return VPWideningInfo::SingleScalar;
+ return getNarrowableWideningInfo(Rep->getOpcode(),
+ VPWideningInfo::GenPerAllLanes);
+ }
+ case VPRecipeBase::VPWidenSC: {
+ auto *Wide = cast<VPWidenRecipe>(&R);
+ return getNarrowableWideningInfo(Wide->getOpcode(), VPWideningInfo::Wide);
+ }
+ case VPRecipeBase::VPWidenCanonicalIVSC:
+ case VPRecipeBase::VPWidenPHISC:
+ case VPRecipeBase::VPWidenCallSC:
+ case VPRecipeBase::VPWidenIntrinsicSC:
+ case VPRecipeBase::VPWidenMemIntrinsicSC:
+ case VPRecipeBase::VPWidenLoadSC:
+ case VPRecipeBase::VPWidenLoadEVLSC:
+ case VPRecipeBase::VPWidenStoreSC:
+ case VPRecipeBase::VPWidenStoreEVLSC:
+ case VPRecipeBase::VPInterleaveSC:
+ case VPRecipeBase::VPInterleaveEVLSC:
+ case VPRecipeBase::VPHistogramSC:
+ case VPRecipeBase::VPCurrentIterationPHISC:
+ case VPRecipeBase::VPActiveLaneMaskPHISC:
+ case VPRecipeBase::VPFirstOrderRecurrencePHISC:
+ case VPRecipeBase::VPWidenIntOrFpInductionSC:
+ case VPRecipeBase::VPWidenPointerInductionSC:
+ case VPRecipeBase::VPReductionPHISC:
+ return VPWideningInfo::Wide;
+ }
+ llvm_unreachable("Fell off end of switch: unknown recipe class");
+}
+
+VPWideningInfo vputils::getWideningInfo(const VPValue *VPV) {
+ if (!VPV->hasDefiningRecipe()) {
+ // Only a CanonicalIV region value is single scalar.
+ if (auto *RV = dyn_cast<VPRegionValue>(VPV))
+ return RV == RV->getDefiningRegion()->getCanonicalIV()
+ ? VPWideningInfo::SingleScalar
+ : VPWideningInfo::Wide;
+ // A non-constant live-in may be introduce a Broadcast.
+ return isa<VPConstant>(VPV)
+ ? VPWideningInfo::SingleScalar
+ : VPWideningInfo::SingleScalar | VPWideningInfo::Agnostic;
+ }
+ return getWideningInfo(*VPV->getDefiningRecipe());
}
bool vputils::isElementwise(const VPValue *V) {
@@ -410,12 +503,6 @@ bool vputils::isElementwise(const VPValue *V) {
}
bool vputils::isSingleScalar(const VPValue *VPV) {
- // Live-in, symbolic and canonical-IV region values are single-scalar.
- if (auto *RV = dyn_cast<VPRegionValue>(VPV))
- return RV == RV->getDefiningRegion()->getCanonicalIV();
- if (isa<VPIRValue, VPSymbolicValue>(VPV))
- return true;
-
if (auto *Rep = dyn_cast<VPReplicateRecipe>(VPV)) {
const VPRegionBlock *RegionOfR = Rep->getRegion();
// Don't consider recipes in replicate regions as uniform yet; their first
@@ -423,29 +510,13 @@ bool vputils::isSingleScalar(const VPValue *VPV) {
// lanes.
if (RegionOfR && RegionOfR->isReplicator())
return false;
- return Rep->isSingleScalar() || (preservesUniformity(Rep->getOpcode()) &&
- all_of(Rep->operands(), isSingleScalar));
- }
- if (isa<VPWidenGEPRecipe, VPBlendRecipe>(VPV))
- return all_of(VPV->getDefiningRecipe()->operands(), isSingleScalar);
- if (auto *WidenR = dyn_cast<VPWidenRecipe>(VPV)) {
- return preservesUniformity(WidenR->getOpcode()) &&
- all_of(WidenR->operands(), isSingleScalar);
}
- if (auto *VPI = dyn_cast<VPInstruction>(VPV))
- return VPI->isSingleScalar() || VPI->isVectorToScalar() ||
- (preservesUniformity(VPI->getOpcode()) &&
- all_of(VPI->operands(), isSingleScalar));
- if (auto *RR = dyn_cast<VPReductionRecipe>(VPV))
- return !RR->isPartialReduction();
- if (isa<VPVectorPointerRecipe, VPVectorEndPointerRecipe, VPDerivedIVRecipe>(
- VPV))
- return true;
- if (auto *Expr = dyn_cast<VPExpressionRecipe>(VPV))
- return Expr->isVectorToScalar();
-
- // VPExpandSCEVRecipes must be placed in the entry and are always uniform.
- return isa<VPExpandSCEVRecipe>(VPV);
+ // FIXME: Marking WidenCast as a single-scalar leads to regressions.
+ VPWideningInfo Info = getWideningInfo(VPV);
+ return Info.producesSingleScalarResult() ||
+ (!isa<VPWidenCastRecipe>(VPV) &&
+ Info.couldProduceSingleScalarResult() &&
+ all_of(VPV->getDefiningRecipe()->operands(), isSingleScalar));
}
bool vputils::isUniformAcrossVFsAndUFs(const VPValue *V) {
@@ -455,50 +526,40 @@ bool vputils::isUniformAcrossVFsAndUFs(const VPValue *V) {
if (isa<VPIRValue, VPSymbolicValue>(V))
return true;
- const VPRecipeBase *R = V->getDefiningRecipe();
- const VPBasicBlock *VPBB = R ? R->getParent() : nullptr;
- const VPlan *Plan = VPBB ? VPBB->getPlan() : nullptr;
- if (VPBB &&
- (VPBB == Plan->getVectorPreheader() || VPBB == Plan->getEntry())) {
- if (match(R,
+ // Bail out on VPPhi, as we can end up in infinite cycles.
+ if (isa<VPPhi>(V))
+ return false;
+
+ if (const VPRecipeBase *R = V->getDefiningRecipe()) {
+ const VPBasicBlock *VPBB = R->getParent();
+ const VPlan *Plan = VPBB->getPlan();
+ if (VPBB == Plan->getVectorPreheader() || VPBB == Plan->getEntry()) {
+ if (match(
+ R,
m_VPInstruction<VPInstruction::CanonicalIVIncrementForPart>()) ||
- match(R, m_ExtractVectorForPart(m_VPValue(), m_VPValue())))
- return false;
- return all_of(R->operands(), isUniformAcrossVFsAndUFs);
+ match(R, m_ExtractVectorForPart(m_VPValue(), m_VPValue())))
+ return false;
+ return all_of(R->operands(), isUniformAcrossVFsAndUFs);
+ }
+ if (auto *RepR = dyn_cast<VPReplicateRecipe>(R)) {
+ // Be conservative about side-effects, except for the
+ // known-side-effecting assumes and stores, which we know will be
+ // uniform.
+ return RepR->isSingleScalar() &&
+ (!RepR->mayHaveSideEffects() ||
+ isa<AssumeInst, StoreInst>(RepR->getUnderlyingInstr())) &&
+ all_of(RepR->operands(), isUniformAcrossVFsAndUFs);
+ }
}
- return TypeSwitch<const VPRecipeBase *, bool>(R)
- .Case([](const VPDerivedIVRecipe *R) { return true; })
- .Case([](const VPReplicateRecipe *R) {
- // Be conservative about side-effects, except for the
- // known-side-effecting assumes and stores, which we know will be
- // uniform.
- return R->isSingleScalar() &&
- (!R->mayHaveSideEffects() ||
- isa<AssumeInst, StoreInst>(R->getUnderlyingInstr())) &&
- all_of(R->operands(), isUniformAcrossVFsAndUFs);
- })
- .Case([](const VPWidenRecipe *R) {
- return preservesUniformity(R->getOpcode()) &&
- all_of(R->operands(), isUniformAcrossVFsAndUFs);
- })
- .Case([](const VPPhi *) {
- // Bail out on VPPhi, as we can end up in infinite cycles.
- return false;
- })
- .Case([](const VPInstruction *VPI) {
- return (VPI->isSingleScalar() || VPI->isVectorToScalar() ||
- preservesUniformity(VPI->getOpcode())) &&
- all_of(VPI->operands(), isUniformAcrossVFsAndUFs);
- })
- .Case([](const VPWidenCastRecipe *R) {
- // A cast is uniform according to its operand.
- return isUniformAcrossVFsAndUFs(R->getOperand(0));
- })
- .Default([](const VPRecipeBase *) { // A value is considered non-uniform
- // unless proven otherwise.
- return false;
- });
+ // TODO: Match more recipes.
+ if (!isa<VPDerivedIVRecipe, VPWidenRecipe, VPWidenCastRecipe, VPInstruction>(
+ V))
+ return false;
+
+ VPWideningInfo Info = getWideningInfo(V);
+ return Info.couldProduceSingleScalarResult() &&
+ all_of(V->getDefiningRecipe()->operands(), isUniformAcrossVFsAndUFs);
}
bool vputils::doesGeneratePerAllLanes(const VPRecipeBase *R) {
diff --git a/llvm/lib/Transforms/Vectorize/VPlanUtils.h b/llvm/lib/Transforms/Vectorize/VPlanUtils.h
index 0c556dbab1eab..cd6862c90b625 100644
--- a/llvm/lib/Transforms/Vectorize/VPlanUtils.h
+++ b/llvm/lib/Transforms/Vectorize/VPlanUtils.h
@@ -22,6 +22,38 @@ class VPBuilder;
} // namespace llvm
namespace llvm {
+/// A class keeping track of widening information of various recipes.
+/// A recipe necessarily produces a single scalar value if only the SingleScalar
+/// bit is set, a wide value if only the Wide bit is set, and scalar values for
+/// all VF lanes only the GenPerAllLanes bit is set. The SingleScalar bit can be
+/// set on Wide or GenPerAllLanes recipes, which indicates that the recipe could
+/// be narrowed to single-scalar if legal and profitable. For instructions not
+/// producing values, like an assume or store, the bits talk about the
+/// appropriate operands. Finally, there is a class of instructions that
+/// necessarily take vector operands and produce a scalar result termed
+/// VectorToScalar, or necessarily take a scalar values and produce a vector,
+/// termed ScalarToVector. These are marked with the Agnostic bit.
+class VPWideningInfo {
+ unsigned char Info : 4;
+
+public:
+ using VPWideningTy = enum {
+ SingleScalar = 1 << 0,
+ Wide = 1 << 1,
+ GenPerAllLanes = 1 << 2,
+ Agnostic = 1 << 3
+ };
+
+ VPWideningInfo(unsigned char Info) : Info(Info) {}
+ operator unsigned char() const { return Info; }
+ bool producesSingleScalarResult() const {
+ return Info == SingleScalar || Info == (SingleScalar | Agnostic);
+ }
+ bool couldProduceSingleScalarResult() const { return Info & SingleScalar; }
+ bool usesScalarOperands() const {
+ return !(Info & (Agnostic | Wide)) || Info == (Wide | Agnostic);
+ }
+};
namespace vputils {
/// Returns true if only the first lane of \p Def is used.
@@ -62,6 +94,12 @@ bool isSingleScalar(const VPValue *VPV);
/// VPDerivedIV or the canonical IV).
bool isUniformAcrossVFsAndUFs(const VPValue *V);
+/// Get the WideningInfo for \p R.
+VPWideningInfo getWideningInfo(const VPRecipeBase &R);
+
+/// Get the WideningInfo for \p VPV.
+VPWideningInfo getWideningInfo(const VPValue *VPV);
+
/// Return true if \p V is elementwise, i.e. none of the lanes are permuted.
bool isElementwise(const VPValue *V);
diff --git a/llvm/lib/Transforms/Vectorize/VPlanValue.h b/llvm/lib/Transforms/Vectorize/VPlanValue.h
index b318c38c796a3..48f768b4523ac 100644
--- a/llvm/lib/Transforms/Vectorize/VPlanValue.h
+++ b/llvm/lib/Transforms/Vectorize/VPlanValue.h
@@ -476,13 +476,8 @@ class LLVM_ABI_FOR_TEST VPUser {
return const_operand_range(op_begin(), op_end());
}
- /// Returns true if the VPUser uses scalars of operand \p Op. Conservatively
- /// returns if only first (scalar) lane is used, as default.
- virtual bool usesScalars(const VPValue *Op) const {
- assert(is_contained(operands(), Op) &&
- "Op must be an operand of the recipe");
- return usesFirstLaneOnly(Op);
- }
+ /// Returns true if the VPUser uses scalars of operand \p Op.
+ bool usesScalars(const VPValue *Op) const;
/// Returns true if the VPUser only uses the first lane of operand \p Op.
/// Conservatively returns false.
diff --git a/llvm/test/Transforms/LoopVectorize/AArch64/masked-call-scalarize.ll b/llvm/test/Transforms/LoopVectorize/AArch64/masked-call-scalarize.ll
index 8aa223c0f927c..6dc3ed281d683 100644
--- a/llvm/test/Transforms/LoopVectorize/AArch64/masked-call-scalarize.ll
+++ b/llvm/test/Transforms/LoopVectorize/AArch64/masked-call-scalarize.ll
@@ -69,8 +69,7 @@ define void @test_widen_exp_v2(ptr noalias %p2, ptr noalias %p, i64 %n) #5 {
; TFCOMMON-NEXT: [[BROADCAST_SPLATINSERT:%.*]] = insertelement <2 x double> poison, double [[TMP2]], i64 0
; TFCOMMON-NEXT: [[BROADCAST_SPLAT:%.*]] = shufflevector <2 x double> [[BROADCAST_SPLATINSERT]], <2 x double> poison, <2 x i32> zeroinitializer
; TFCOMMON-NEXT: [[TMP3:%.*]] = fcmp ogt <2 x double> [[BROADCAST_SPLAT]], zeroinitializer
-; TFCOMMON-NEXT: [[TMP4:%.*]] = extractelement <2 x i1> [[TMP3]], i64 0
-; TFCOMMON-NEXT: [[PREDPHI:%.*]] = select i1 [[TMP4]], <2 x double> zeroinitializer, <2 x double> splat (double 1.000000e+00)
+; TFCOMMON-NEXT: [[PREDPHI:%.*]] = select <2 x i1> [[TMP3]], <2 x double> zeroinitializer, <2 x double> splat (double 1.000000e+00)
; TFCOMMON-NEXT: [[TMP5:%.*]] = extractelement <2 x i1> [[ACTIVE_LANE_MASK]], i64 0
; TFCOMMON-NEXT: br i1 [[TMP5]], label %[[PRED_STORE_IF:.*]], label %[[PRED_STORE_CONTINUE:.*]]
; TFCOMMON: [[PRED_STORE_IF]]:
@@ -114,8 +113,7 @@ define void @test_widen_exp_v2(ptr noalias %p2, ptr noalias %p, i64 %n) #5 {
; TFA_INTERLEAVE-NEXT: [[BROADCAST_SPLATINSERT:%.*]] = insertelement <2 x double> poison, double [[TMP2]], i64 0
; TFA_INTERLEAVE-NEXT: [[BROADCAST_SPLAT:%.*]] = shufflevector <2 x double> [[BROADCAST_SPLATINSERT]], <2 x double> poison, <2 x i32> zeroinitializer
; TFA_INTERLEAVE-NEXT: [[TMP3:%.*]] = fcmp ogt <2 x double> [[BROADCAST_SPLAT]], zeroinitializer
-; TFA_INTERLEAVE-NEXT: [[TMP4:%.*]] = extractelement <2 x i1> [[TMP3]], i64 0
-; TFA_INTERLEAVE-NEXT: [[PREDPHI:%.*]] = select i1 [[TMP4]], <2 x double> zeroinitializer, <2 x double> splat (double 1.000000e+00)
+; TFA_INTERLEAVE-NEXT: [[PREDPHI:%.*]] = selec...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/216445
More information about the llvm-commits
mailing list