[llvm-branch-commits] [llvm] InstCombine: Support basic phis in SimplifyDemandedFPClass (PR #184124)
Matt Arsenault via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Tue Mar 10 08:49:30 PDT 2026
https://github.com/arsenm updated https://github.com/llvm/llvm-project/pull/184124
>From ab8dca7e5cc4b5a18eda23826e327a780ff2e4f6 Mon Sep 17 00:00:00 2001
From: Matt Arsenault <Matthew.Arsenault at amd.com>
Date: Mon, 2 Mar 2026 14:35:13 +0100
Subject: [PATCH] InstCombine: Support basic phis in SimplifyDemandedFPClass
Some complex function edge case epilogs are only handled under
some control flow paths (e.g. lgamma and erfcinv).
---
.../InstCombine/InstCombineInternal.h | 2 +-
.../InstCombineSimplifyDemanded.cpp | 150 ++++++++++++------
.../InstCombine/InstructionCombining.cpp | 3 +-
.../simplify-demanded-fpclass-phi.ll | 57 +++----
.../InstCombine/simplify-demanded-fpclass.ll | 8 +-
5 files changed, 131 insertions(+), 89 deletions(-)
diff --git a/llvm/lib/Transforms/InstCombine/InstCombineInternal.h b/llvm/lib/Transforms/InstCombine/InstCombineInternal.h
index 053a3a2b85b36..fd9f0675a3239 100644
--- a/llvm/lib/Transforms/InstCombine/InstCombineInternal.h
+++ b/llvm/lib/Transforms/InstCombine/InstCombineInternal.h
@@ -606,7 +606,7 @@ class LLVM_LIBRARY_VISIBILITY InstCombinerImpl final
bool SimplifyDemandedFPClass(Instruction *I, unsigned Op,
FPClassTest DemandedMask, KnownFPClass &Known,
- unsigned Depth = 0);
+ const SimplifyQuery &Q, unsigned Depth = 0);
bool SimplifyDemandedInstructionFPClass(Instruction &Inst);
diff --git a/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp b/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp
index e04c75a1536d3..e1b10657bb862 100644
--- a/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp
@@ -2281,7 +2281,8 @@ simplifyDemandedFPClassMinMax(KnownFPClass &Known, Intrinsic::ID IID,
static Value *
simplifyDemandedUseFPClassFPTrunc(InstCombinerImpl &IC, Instruction &I,
FastMathFlags FMF, FPClassTest DemandedMask,
- KnownFPClass &Known, unsigned Depth) {
+ KnownFPClass &Known, const SimplifyQuery &SQ,
+ unsigned Depth) {
FPClassTest SrcDemandedMask = DemandedMask;
if (DemandedMask & fcNan)
@@ -2305,7 +2306,8 @@ simplifyDemandedUseFPClassFPTrunc(InstCombinerImpl &IC, Instruction &I,
SrcDemandedMask |= fcNegNormal;
KnownFPClass KnownSrc;
- if (IC.SimplifyDemandedFPClass(&I, 0, SrcDemandedMask, KnownSrc, Depth + 1))
+ if (IC.SimplifyDemandedFPClass(&I, 0, SrcDemandedMask, KnownSrc, SQ,
+ Depth + 1))
return &I;
Known = KnownFPClass::fptrunc(KnownSrc);
@@ -2341,7 +2343,7 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I,
KnownFPClass KnownSrc;
if (SimplifyDemandedFPClass(cast<Instruction>(FNegSrc), 0,
llvm::unknown_sign(DemandedMask), KnownSrc,
- Depth + 1))
+ SQ, Depth + 1))
return I;
FastMathFlags FabsFMF = cast<FPMathOperator>(FNegSrc)->getFastMathFlags();
@@ -2370,7 +2372,7 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I,
break;
}
- if (SimplifyDemandedFPClass(I, 0, llvm::fneg(DemandedMask), Known,
+ if (SimplifyDemandedFPClass(I, 0, llvm::fneg(DemandedMask), Known, SQ,
Depth + 1))
return I;
Known.fneg();
@@ -2418,7 +2420,8 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I,
if (DemandedMask & fcNegInf)
SrcDemandedMask |= fcNegNormal;
- if (SimplifyDemandedFPClass(I, 0, SrcDemandedMask, KnownLHS, Depth + 1))
+ if (SimplifyDemandedFPClass(I, 0, SrcDemandedMask, KnownLHS, SQ,
+ Depth + 1))
return I;
Known = KnownFPClass::fadd_self(KnownLHS, Mode);
@@ -2433,8 +2436,10 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I,
if (DemandedMask & fcInf)
SrcDemandedMask |= fcInf;
- if (SimplifyDemandedFPClass(I, 1, SrcDemandedMask, KnownRHS, Depth + 1) ||
- SimplifyDemandedFPClass(I, 0, SrcDemandedMask, KnownLHS, Depth + 1))
+ if (SimplifyDemandedFPClass(I, 1, SrcDemandedMask, KnownRHS, SQ,
+ Depth + 1) ||
+ SimplifyDemandedFPClass(I, 0, SrcDemandedMask, KnownLHS, SQ,
+ Depth + 1))
return I;
Type *EltTy = VTy->getScalarType();
@@ -2508,7 +2513,8 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I,
if (X == Y &&
isGuaranteedNotToBeUndef(X, SQ.AC, SQ.CxtI, SQ.DT, Depth + 1)) {
- if (SimplifyDemandedFPClass(I, 0, SrcDemandedMask, KnownLHS, Depth + 1))
+ if (SimplifyDemandedFPClass(I, 0, SrcDemandedMask, KnownLHS, SQ,
+ Depth + 1))
return I;
Type *EltTy = VTy->getScalarType();
@@ -2538,8 +2544,9 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I,
return nullptr;
}
- if (SimplifyDemandedFPClass(I, 1, SrcDemandedMask, KnownRHS, Depth + 1) ||
- SimplifyDemandedFPClass(I, 0, SrcDemandedMask, KnownLHS, Depth + 1))
+ if (SimplifyDemandedFPClass(I, 1, SrcDemandedMask, KnownRHS, SQ,
+ Depth + 1) ||
+ SimplifyDemandedFPClass(I, 0, SrcDemandedMask, KnownLHS, SQ, Depth + 1))
return I;
if (FMF.noInfs()) {
@@ -2721,8 +2728,9 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I,
}
KnownFPClass KnownLHS, KnownRHS;
- if (SimplifyDemandedFPClass(I, 0, LHSDemandedMask, KnownLHS, Depth + 1) ||
- SimplifyDemandedFPClass(I, 1, RHSDemandedMask, KnownRHS, Depth + 1))
+ if (SimplifyDemandedFPClass(I, 0, LHSDemandedMask, KnownLHS, SQ,
+ Depth + 1) ||
+ SimplifyDemandedFPClass(I, 1, RHSDemandedMask, KnownRHS, SQ, Depth + 1))
return I;
// nsz [+-]0 / x -> 0
@@ -2782,7 +2790,7 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I,
}
case Instruction::FPTrunc:
return simplifyDemandedUseFPClassFPTrunc(*this, *I, FMF, DemandedMask,
- Known, Depth);
+ Known, SQ, Depth);
case Instruction::FPExt: {
FPClassTest SrcDemandedMask = DemandedMask;
if (DemandedMask & fcNan)
@@ -2795,7 +2803,7 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I,
SrcDemandedMask |= fcPosSubnormal;
KnownFPClass KnownSrc;
- if (SimplifyDemandedFPClass(I, 0, SrcDemandedMask, KnownSrc, Depth + 1))
+ if (SimplifyDemandedFPClass(I, 0, SrcDemandedMask, KnownSrc, SQ, Depth + 1))
return I;
const fltSemantics &DstTy = VTy->getScalarType()->getFltSemantics();
@@ -2815,7 +2823,7 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I,
case Intrinsic::fabs: {
KnownFPClass KnownSrc;
if (SimplifyDemandedFPClass(I, 0, llvm::inverse_fabs(DemandedMask),
- KnownSrc, Depth + 1))
+ KnownSrc, SQ, Depth + 1))
return I;
if (Value *Simplified = simplifyDemandedFPClassFabs(
@@ -2825,14 +2833,14 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I,
break;
}
case Intrinsic::arithmetic_fence:
- if (SimplifyDemandedFPClass(I, 0, DemandedMask, Known, Depth + 1))
+ if (SimplifyDemandedFPClass(I, 0, DemandedMask, Known, SQ, Depth + 1))
return I;
break;
case Intrinsic::copysign: {
// Flip on more potentially demanded classes
const FPClassTest DemandedMaskAnySign = llvm::unknown_sign(DemandedMask);
KnownFPClass KnownMag;
- if (SimplifyDemandedFPClass(CI, 0, DemandedMaskAnySign, KnownMag,
+ if (SimplifyDemandedFPClass(CI, 0, DemandedMaskAnySign, KnownMag, SQ,
Depth + 1))
return I;
@@ -2894,9 +2902,9 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I,
if (CI->getArgOperand(0) == CI->getArgOperand(1) &&
isGuaranteedNotToBeUndef(CI->getArgOperand(0), SQ.AC, SQ.CxtI, SQ.DT,
Depth + 1)) {
- if (SimplifyDemandedFPClass(CI, 0, SrcDemandedMask, KnownSrc[0],
+ if (SimplifyDemandedFPClass(CI, 0, SrcDemandedMask, KnownSrc[0], SQ,
Depth + 1) ||
- SimplifyDemandedFPClass(CI, 2, SrcDemandedMask, KnownSrc[2],
+ SimplifyDemandedFPClass(CI, 2, SrcDemandedMask, KnownSrc[2], SQ,
Depth + 1))
return I;
@@ -2906,7 +2914,7 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I,
} else {
for (int OpIdx = 0; OpIdx != 3; ++OpIdx) {
if (SimplifyDemandedFPClass(CI, OpIdx, SrcDemandedMask,
- KnownSrc[OpIdx], Depth + 1))
+ KnownSrc[OpIdx], SQ, Depth + 1))
return CI;
}
@@ -2935,9 +2943,10 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I,
: fcAllFlags;
KnownFPClass KnownLHS, KnownRHS;
- if (SimplifyDemandedFPClass(CI, 1, SrcDemandedMask, KnownRHS,
+ if (SimplifyDemandedFPClass(CI, 1, SrcDemandedMask, KnownRHS, SQ,
Depth + 1) ||
- SimplifyDemandedFPClass(CI, 0, SrcDemandedMask, KnownLHS, Depth + 1))
+ SimplifyDemandedFPClass(CI, 0, SrcDemandedMask, KnownLHS, SQ,
+ Depth + 1))
return I;
Value *Simplified =
@@ -3036,7 +3045,8 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I,
// TODO: This could really make use of KnownFPClass of specific value
// range, (i.e., close enough to 1)
- if (SimplifyDemandedFPClass(I, 0, SrcDemandedMask, KnownSrc, Depth + 1))
+ if (SimplifyDemandedFPClass(I, 0, SrcDemandedMask, KnownSrc, SQ,
+ Depth + 1))
return I;
// exp(+/-0) = 1
@@ -3113,7 +3123,8 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I,
DemandedSrcMask |= fcPosNormal;
KnownFPClass KnownSrc;
- if (SimplifyDemandedFPClass(I, 0, DemandedSrcMask, KnownSrc, Depth + 1))
+ if (SimplifyDemandedFPClass(I, 0, DemandedSrcMask, KnownSrc, SQ,
+ Depth + 1))
return I;
Known = KnownFPClass::log(KnownSrc, Mode);
@@ -3134,7 +3145,8 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I,
DemandedSrcMask |= fcPosSubnormal;
KnownFPClass KnownSrc;
- if (SimplifyDemandedFPClass(I, 0, DemandedSrcMask, KnownSrc, Depth + 1))
+ if (SimplifyDemandedFPClass(I, 0, DemandedSrcMask, KnownSrc, SQ,
+ Depth + 1))
return I;
// Infer the source cannot be negative if the result cannot be nan.
@@ -3192,7 +3204,8 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I,
SrcDemandedMask |= fcNegFinite;
KnownFPClass KnownSrc;
- if (SimplifyDemandedFPClass(CI, 0, SrcDemandedMask, KnownSrc, Depth + 1))
+ if (SimplifyDemandedFPClass(CI, 0, SrcDemandedMask, KnownSrc, SQ,
+ Depth + 1))
return CI;
Type *EltTy = VTy->getScalarType();
@@ -3227,7 +3240,8 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I,
DemandedSrcMask |= fcPosSubnormal | fcPosNormal;
KnownFPClass KnownSrc;
- if (SimplifyDemandedFPClass(CI, 0, DemandedSrcMask, KnownSrc, Depth + 1))
+ if (SimplifyDemandedFPClass(CI, 0, DemandedSrcMask, KnownSrc, SQ,
+ Depth + 1))
return I;
// Note: Possibly dropping snan quiet.
@@ -3287,7 +3301,7 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I,
}
case Intrinsic::fptrunc_round:
return simplifyDemandedUseFPClassFPTrunc(*this, *CI, FMF, DemandedMask,
- Known, Depth);
+ Known, SQ, Depth);
case Intrinsic::canonicalize: {
Type *EltTy = VTy->getScalarType();
@@ -3324,7 +3338,8 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I,
KnownFPClass KnownSrc;
// Simplify upstream operations before trying to simplify this call.
- if (SimplifyDemandedFPClass(I, 0, SrcDemandedMask, KnownSrc, Depth + 1))
+ if (SimplifyDemandedFPClass(I, 0, SrcDemandedMask, KnownSrc, SQ,
+ Depth + 1))
return I;
// Perform the canonicalization to see if this folded to a constant.
@@ -3366,8 +3381,8 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I,
}
case Instruction::Select: {
KnownFPClass KnownLHS, KnownRHS;
- if (SimplifyDemandedFPClass(I, 2, DemandedMask, KnownRHS, Depth + 1) ||
- SimplifyDemandedFPClass(I, 1, DemandedMask, KnownLHS, Depth + 1))
+ if (SimplifyDemandedFPClass(I, 2, DemandedMask, KnownRHS, SQ, Depth + 1) ||
+ SimplifyDemandedFPClass(I, 1, DemandedMask, KnownLHS, SQ, Depth + 1))
return I;
if (KnownLHS.isKnownNever(DemandedMask))
@@ -3385,15 +3400,16 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I,
}
case Instruction::ExtractElement: {
// TODO: Handle demanded element mask
- if (SimplifyDemandedFPClass(I, 0, DemandedMask, Known, Depth + 1))
+ if (SimplifyDemandedFPClass(I, 0, DemandedMask, Known, SQ, Depth + 1))
return I;
Known.knownNot(~DemandedMask);
break;
}
case Instruction::InsertElement: {
KnownFPClass KnownInserted, KnownVec;
- if (SimplifyDemandedFPClass(I, 1, DemandedMask, KnownInserted, Depth + 1) ||
- SimplifyDemandedFPClass(I, 0, DemandedMask, KnownVec, Depth + 1))
+ if (SimplifyDemandedFPClass(I, 1, DemandedMask, KnownInserted, SQ,
+ Depth + 1) ||
+ SimplifyDemandedFPClass(I, 0, DemandedMask, KnownVec, SQ, Depth + 1))
return I;
// TODO: Use demanded elements logic from computeKnownFPClass
@@ -3403,8 +3419,8 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I,
}
case Instruction::ShuffleVector: {
KnownFPClass KnownLHS, KnownRHS;
- if (SimplifyDemandedFPClass(I, 1, DemandedMask, KnownRHS, Depth + 1) ||
- SimplifyDemandedFPClass(I, 0, DemandedMask, KnownLHS, Depth + 1))
+ if (SimplifyDemandedFPClass(I, 1, DemandedMask, KnownRHS, SQ, Depth + 1) ||
+ SimplifyDemandedFPClass(I, 0, DemandedMask, KnownLHS, SQ, Depth + 1))
return I;
// TODO: This is overly conservative and should consider demanded elements,
@@ -3415,8 +3431,8 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I,
}
case Instruction::InsertValue: {
KnownFPClass KnownAgg, KnownElt;
- if (SimplifyDemandedFPClass(I, 0, DemandedMask, KnownAgg, Depth + 1) ||
- SimplifyDemandedFPClass(I, 1, DemandedMask, KnownElt, Depth + 1))
+ if (SimplifyDemandedFPClass(I, 0, DemandedMask, KnownAgg, SQ, Depth + 1) ||
+ SimplifyDemandedFPClass(I, 1, DemandedMask, KnownElt, SQ, Depth + 1))
return I;
Known = KnownAgg | KnownElt;
@@ -3442,7 +3458,7 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I,
SrcDemandedMask |= fcNegInf;
KnownFPClass KnownSrc;
- if (SimplifyDemandedFPClass(II, 0, SrcDemandedMask, KnownSrc,
+ if (SimplifyDemandedFPClass(II, 0, SrcDemandedMask, KnownSrc, SQ,
Depth + 1))
return I;
@@ -3469,11 +3485,55 @@ Value *InstCombinerImpl::SimplifyDemandedUseFPClass(Instruction *I,
}
KnownFPClass KnownSrc;
- if (SimplifyDemandedFPClass(I, 0, DemandedMask, KnownSrc, Depth + 1))
+ if (SimplifyDemandedFPClass(I, 0, DemandedMask, KnownSrc, SQ, Depth + 1))
return I;
Known = KnownSrc;
break;
}
+ case Instruction::PHI: {
+ const unsigned PhiRecursionLimit = MaxAnalysisRecursionDepth - 2;
+ if (Depth >= PhiRecursionLimit)
+ break;
+
+ PHINode *P = cast<PHINode>(I);
+ SimplifyQuery ContextSQ = SQ.getWithoutCondContext();
+
+ bool First = true;
+ bool Changed = false;
+ for (unsigned I = 0, E = P->getNumIncomingValues(); I != E; ++I) {
+ // TODO: Better support for self recursive phi
+ if (P->getIncomingValue(I) == P)
+ continue;
+
+ BasicBlock *PredBB = P->getIncomingBlock(I);
+ const Instruction *CtxI = PredBB->getTerminator();
+
+ // Attempt to simplify all incoming edges at a time. If we simplify one
+ // incoming edge, the phi may fold away, losing information on a later
+ // visit.
+ KnownFPClass KnownSrc;
+ if (SimplifyDemandedFPClass(
+ P, P->getOperandNumForIncomingValue(I), DemandedMask, KnownSrc,
+ ContextSQ.getWithInstruction(CtxI), Depth + 1)) {
+ // Fixup the other block references to the simplified value.
+ P->setIncomingValueForBlock(PredBB, P->getIncomingValue(I));
+ Changed = true;
+ }
+
+ if (First) {
+ Known = KnownSrc;
+ First = false;
+ } else {
+ Known |= KnownSrc;
+ }
+ }
+
+ if (Changed)
+ return P;
+
+ Known.knownNot(~DemandedMask);
+ break;
+ }
default:
Known = computeKnownFPClass(I, DemandedMask, SQ, Depth + 1);
Known.knownNot(~DemandedMask);
@@ -3624,6 +3684,7 @@ Value *InstCombinerImpl::SimplifyMultipleUseDemandedFPClass(
bool InstCombinerImpl::SimplifyDemandedFPClass(Instruction *I, unsigned OpNo,
FPClassTest DemandedMask,
KnownFPClass &Known,
+ const SimplifyQuery &SQ,
unsigned Depth) {
Use &U = I->getOperandUse(OpNo);
Value *V = U.get();
@@ -3640,7 +3701,7 @@ bool InstCombinerImpl::SimplifyDemandedFPClass(Instruction *I, unsigned OpNo,
Instruction *VInst = dyn_cast<Instruction>(V);
if (!VInst) {
// Handle constants and arguments
- Known = computeKnownFPClass(V, fcAllFlags, SQ.getWithInstruction(I), Depth);
+ Known = computeKnownFPClass(V, fcAllFlags, SQ, Depth);
Known.knownNot(~DemandedMask);
if (Known.KnownFPClasses == fcNone) {
@@ -3673,13 +3734,12 @@ bool InstCombinerImpl::SimplifyDemandedFPClass(Instruction *I, unsigned OpNo,
if (VInst->hasOneUse()) {
// If the instruction has one use, we can directly simplify it.
- NewVal = SimplifyDemandedUseFPClass(VInst, DemandedMask, Known,
- SQ.getWithInstruction(I), Depth);
+ NewVal = SimplifyDemandedUseFPClass(VInst, DemandedMask, Known, SQ, Depth);
} else {
// If there are multiple uses of this instruction, then we can simplify
// VInst to some other value, but not modify the instruction.
- NewVal = SimplifyMultipleUseDemandedFPClass(
- VInst, DemandedMask, Known, SQ.getWithInstruction(I), Depth);
+ NewVal = SimplifyMultipleUseDemandedFPClass(VInst, DemandedMask, Known, SQ,
+ Depth);
}
if (!NewVal)
diff --git a/llvm/lib/Transforms/InstCombine/InstructionCombining.cpp b/llvm/lib/Transforms/InstCombine/InstructionCombining.cpp
index 72aa241085449..c623d6d437c59 100644
--- a/llvm/lib/Transforms/InstCombine/InstructionCombining.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstructionCombining.cpp
@@ -4197,7 +4197,8 @@ Instruction *InstCombinerImpl::visitReturnInst(ReturnInst &RI) {
return nullptr;
KnownFPClass KnownClass;
- if (SimplifyDemandedFPClass(&RI, 0, ~ReturnClass, KnownClass))
+ if (SimplifyDemandedFPClass(&RI, 0, ~ReturnClass, KnownClass,
+ SQ.getWithInstruction(&RI)))
return &RI;
return nullptr;
diff --git a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-phi.ll b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-phi.ll
index a064d8b65a457..367a5db8e8ed6 100644
--- a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-phi.ll
+++ b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-phi.ll
@@ -9,10 +9,9 @@ define nofpclass(nan) half @ret_phi_if_ret_0(i1 %cond1, i1 %cond2, half %unknown
; CHECK-NEXT: [[ENTRY:.*]]:
; CHECK-NEXT: br i1 [[COND1]], label %[[IF:.*]], label %[[RET:.*]]
; CHECK: [[IF]]:
-; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND2]], half 0xH7E00, half [[UNKNOWN]]
; CHECK-NEXT: br label %[[RET]]
; CHECK: [[RET]]:
-; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[SELECT]], %[[IF]] ], [ 0xH0000, %[[ENTRY]] ]
+; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[UNKNOWN]], %[[IF]] ], [ 0xH0000, %[[ENTRY]] ]
; CHECK-NEXT: ret half [[PHI]]
;
entry:
@@ -58,7 +57,7 @@ define nofpclass(inf norm sub zero) half @ret_phi_only_nan(i1 %cond1, i1 %cond2,
; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND2]], half 0xH7E00, half [[UNKNOWN]]
; CHECK-NEXT: br label %[[RET]]
; CHECK: [[RET]]:
-; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[SELECT]], %[[IF]] ], [ 0xH0000, %[[ENTRY]] ]
+; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[SELECT]], %[[IF]] ], [ poison, %[[ENTRY]] ]
; CHECK-NEXT: ret half [[PHI]]
;
entry:
@@ -79,10 +78,9 @@ define nofpclass(nan) half @ret_phi_if_ret_1(i1 %cond1, i1 %cond2, half %unknown
; CHECK-NEXT: [[ENTRY:.*]]:
; CHECK-NEXT: br i1 [[COND1]], label %[[IF:.*]], label %[[RET:.*]]
; CHECK: [[IF]]:
-; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND2]], half 0xH7E00, half [[UNKNOWN]]
; CHECK-NEXT: br label %[[RET]]
; CHECK: [[RET]]:
-; CHECK-NEXT: [[PHI:%.*]] = phi half [ 0xH0000, %[[ENTRY]] ], [ [[SELECT]], %[[IF]] ]
+; CHECK-NEXT: [[PHI:%.*]] = phi half [ 0xH0000, %[[ENTRY]] ], [ [[UNKNOWN]], %[[IF]] ]
; CHECK-NEXT: ret half [[PHI]]
;
entry:
@@ -102,7 +100,6 @@ define nofpclass(nan) half @ret_repeated_switch_pred(i8 %switch.cond, i1 %cond2,
; CHECK-LABEL: define nofpclass(nan) half @ret_repeated_switch_pred(
; CHECK-SAME: i8 [[SWITCH_COND:%.*]], i1 [[COND2:%.*]], half [[UNKNOWN:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*]]:
-; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND2]], half 0xH7E00, half [[UNKNOWN]]
; CHECK-NEXT: switch i8 [[SWITCH_COND]], label %[[DEFAULT:.*]] [
; CHECK-NEXT: i8 0, label %[[RET:.*]]
; CHECK-NEXT: i8 1, label %[[RET]]
@@ -113,7 +110,7 @@ define nofpclass(nan) half @ret_repeated_switch_pred(i8 %switch.cond, i1 %cond2,
; CHECK: [[DEFAULT]]:
; CHECK-NEXT: unreachable
; CHECK: [[RET]]:
-; CHECK-NEXT: [[PHI:%.*]] = phi half [ 0xH0000, %[[IF]] ], [ [[SELECT]], %[[ENTRY]] ], [ [[SELECT]], %[[ENTRY]] ]
+; CHECK-NEXT: [[PHI:%.*]] = phi half [ 0xH0000, %[[IF]] ], [ [[UNKNOWN]], %[[ENTRY]] ], [ [[UNKNOWN]], %[[ENTRY]] ]
; CHECK-NEXT: ret half [[PHI]]
;
entry:
@@ -142,10 +139,9 @@ define nofpclass(nan) half @ret_phi_chain(i1 %cond1, i1 %cond2, i1 %cond3, half
; CHECK-NEXT: [[ENTRY:.*]]:
; CHECK-NEXT: br i1 [[COND1]], label %[[IF0:.*]], label %[[IF1:.*]]
; CHECK: [[IF0]]:
-; CHECK-NEXT: [[SELECT0:%.*]] = select i1 [[COND2]], half 0xH7E00, half [[UNKNOWN]]
; CHECK-NEXT: br i1 [[COND2]], label %[[IF1]], label %[[RET:.*]]
; CHECK: [[IF1]]:
-; CHECK-NEXT: [[PHI0:%.*]] = phi half [ [[SELECT0]], %[[IF0]] ], [ 0xH0000, %[[ENTRY]] ]
+; CHECK-NEXT: [[PHI0:%.*]] = phi half [ [[UNKNOWN]], %[[IF0]] ], [ 0xH0000, %[[ENTRY]] ]
; CHECK-NEXT: br label %[[RET]]
; CHECK: [[RET]]:
; CHECK-NEXT: [[PHI1:%.*]] = phi half [ [[PHI0]], %[[IF1]] ], [ 0xH0000, %[[IF0]] ]
@@ -172,10 +168,9 @@ define nofpclass(nan) half @basic_loop_break_entry_block(i1 %cond1, i1 %cond2, h
; CHECK-LABEL: define nofpclass(nan) half @basic_loop_break_entry_block(
; CHECK-SAME: i1 [[COND1:%.*]], i1 [[COND2:%.*]], half [[UNKNOWN:%.*]], ptr [[P0:%.*]], ptr [[P1:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*]]:
-; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND2]], half 0xH7E00, half [[UNKNOWN]]
; CHECK-NEXT: br label %[[LOOP:.*]]
; CHECK: [[LOOP]]:
-; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[LOAD:%.*]], %[[LOOP]] ], [ [[SELECT]], %[[ENTRY]] ]
+; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[LOAD:%.*]], %[[LOOP]] ], [ [[UNKNOWN]], %[[ENTRY]] ]
; CHECK-NEXT: [[LOAD]] = load half, ptr [[P1]], align 2
; CHECK-NEXT: [[BREAK_COND:%.*]] = load i1, ptr [[P0]], align 1
; CHECK-NEXT: br i1 [[BREAK_COND]], label %[[RET:.*]], label %[[LOOP]]
@@ -202,9 +197,8 @@ define nofpclass(nan) half @basic_loop_break_mid_loop(i1 %cond1, i1 %cond2, half
; CHECK-NEXT: [[ENTRY:.*]]:
; CHECK-NEXT: br label %[[LOOP:.*]]
; CHECK: [[LOOP]]:
-; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[SELECT:%.*]], %[[LOOP]] ], [ 0xH0000, %[[ENTRY]] ]
-; CHECK-NEXT: [[LOAD:%.*]] = load half, ptr [[P1]], align 2
-; CHECK-NEXT: [[SELECT]] = select i1 [[COND2]], half 0xH7E00, half [[LOAD]]
+; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[LOAD:%.*]], %[[LOOP]] ], [ 0xH0000, %[[ENTRY]] ]
+; CHECK-NEXT: [[LOAD]] = load half, ptr [[P1]], align 2
; CHECK-NEXT: [[BREAK_COND:%.*]] = load i1, ptr [[P0]], align 1
; CHECK-NEXT: br i1 [[BREAK_COND]], label %[[RET:.*]], label %[[LOOP]]
; CHECK: [[RET]]:
@@ -230,9 +224,8 @@ define nofpclass(inf) half @recurrence(i1 %select.cond, half %unknown, ptr %p0,
; CHECK-NEXT: [[ENTRY:.*]]:
; CHECK-NEXT: br label %[[LOOP:.*]]
; CHECK: [[LOOP]]:
-; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[SELECT:%.*]], %[[LOOP]] ], [ 0xH0000, %[[ENTRY]] ]
-; CHECK-NEXT: [[LOAD:%.*]] = load half, ptr [[P1]], align 2
-; CHECK-NEXT: [[SELECT]] = select i1 [[SELECT_COND]], half 0xH7C00, half [[LOAD]]
+; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[LOAD:%.*]], %[[LOOP]] ], [ 0xH0000, %[[ENTRY]] ]
+; CHECK-NEXT: [[LOAD]] = load half, ptr [[P1]], align 2
; CHECK-NEXT: [[BREAK_COND:%.*]] = load i1, ptr [[P0]], align 1
; CHECK-NEXT: br i1 [[BREAK_COND]], label %[[RET:.*]], label %[[LOOP]]
; CHECK: [[RET]]:
@@ -259,10 +252,9 @@ define nofpclass(nan) half @path_dependent(i1 %select.cond, half %unknown, half
; CHECK-NEXT: [[IS_NAN:%.*]] = fcmp uno half [[X]], 0xH0000
; CHECK-NEXT: br i1 [[IS_NAN]], label %[[IF:.*]], label %[[RET:.*]]
; CHECK: [[IF]]:
-; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[SELECT_COND]], half [[X]], half [[UNKNOWN]]
; CHECK-NEXT: br label %[[RET]]
; CHECK: [[RET]]:
-; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[SELECT]], %[[IF]] ], [ 0xH0000, %[[ENTRY]] ]
+; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[UNKNOWN]], %[[IF]] ], [ 0xH0000, %[[ENTRY]] ]
; CHECK-NEXT: ret half [[PHI]]
;
entry:
@@ -312,13 +304,12 @@ define nofpclass(nan) half @diamond_same_select(i1 %select.cond, half %unknown,
; CHECK-NEXT: [[IS_NAN:%.*]] = fcmp uno half [[X]], 0xH0000
; CHECK-NEXT: br i1 [[IS_NAN]], label %[[IF:.*]], label %[[ELSE:.*]]
; CHECK: [[IF]]:
-; CHECK-NEXT: [[SELECT0:%.*]] = select i1 [[SELECT_COND]], half [[X]], half [[UNKNOWN]]
; CHECK-NEXT: br label %[[ENDIF:.*]]
; CHECK: [[ELSE]]:
; CHECK-NEXT: [[SELECT1:%.*]] = select i1 [[SELECT_COND]], half [[X]], half [[UNKNOWN]]
; CHECK-NEXT: br label %[[ENDIF]]
; CHECK: [[ENDIF]]:
-; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[SELECT0]], %[[IF]] ], [ [[SELECT1]], %[[ELSE]] ]
+; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[UNKNOWN]], %[[IF]] ], [ [[SELECT1]], %[[ELSE]] ]
; CHECK-NEXT: ret half [[PHI]]
;
entry:
@@ -344,7 +335,7 @@ define nofpclass(nan) half @remove_nan_start_value(ptr %p0, ptr %p1) {
; CHECK-NEXT: [[ENTRY:.*]]:
; CHECK-NEXT: br label %[[LOOP:.*]]
; CHECK: [[LOOP]]:
-; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[LOAD:%.*]], %[[LOOP]] ], [ 0xH7E00, %[[ENTRY]] ]
+; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[LOAD:%.*]], %[[LOOP]] ], [ poison, %[[ENTRY]] ]
; CHECK-NEXT: [[LOAD]] = load half, ptr [[P1]], align 2
; CHECK-NEXT: [[BREAK_COND:%.*]] = load i1, ptr [[P0]], align 1
; CHECK-NEXT: br i1 [[BREAK_COND]], label %[[RET:.*]], label %[[LOOP]]
@@ -399,7 +390,7 @@ define nofpclass(nan) half @loop_break_if_nan(ptr %p0) {
; CHECK-NEXT: [[ENTRY:.*]]:
; CHECK-NEXT: br label %[[LOOP:.*]]
; CHECK: [[LOOP]]:
-; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[LOAD:%.*]], %[[LOOP]] ], [ 0xH7E00, %[[ENTRY]] ]
+; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[LOAD:%.*]], %[[LOOP]] ], [ poison, %[[ENTRY]] ]
; CHECK-NEXT: [[LOAD]] = load half, ptr [[P0]], align 2
; CHECK-NEXT: [[IS_NAN:%.*]] = fcmp uno half [[LOAD]], 0xH0000
; CHECK-NEXT: br i1 [[IS_NAN]], label %[[RET:.*]], label %[[LOOP]]
@@ -448,16 +439,13 @@ ret:
define nofpclass(nan) half @ret_loop_under_if_phi(half %unknown, i1 %cond, i1 %cond2, ptr %p0, ptr %p1) {
; CHECK-LABEL: define nofpclass(nan) half @ret_loop_under_if_phi(
; CHECK-SAME: half [[UNKNOWN:%.*]], i1 [[COND:%.*]], i1 [[COND2:%.*]], ptr [[P0:%.*]], ptr [[P1:%.*]]) {
-; CHECK-NEXT: [[ENTRY:.*]]:
+; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: br i1 [[COND]], label %[[LOOP:.*]], label %[[RET:.*]]
; CHECK: [[LOOP]]:
-; CHECK-NEXT: [[LOOP_PHI:%.*]] = phi half [ [[LOOP_SELECT:%.*]], %[[LOOP]] ], [ 0xH7E00, %[[ENTRY]] ]
-; CHECK-NEXT: [[LOOP_SELECT]] = select i1 [[COND2]], half 0xH7E00, half [[UNKNOWN]]
; CHECK-NEXT: [[LOOP_COND:%.*]] = load i1, ptr [[P1]], align 1
; CHECK-NEXT: br i1 [[LOOP_COND]], label %[[RET]], label %[[LOOP]]
; CHECK: [[RET]]:
-; CHECK-NEXT: [[OUTER_PHI:%.*]] = phi half [ 0xH7E00, %[[ENTRY]] ], [ [[LOOP_PHI]], %[[LOOP]] ]
-; CHECK-NEXT: ret half [[OUTER_PHI]]
+; CHECK-NEXT: ret half [[UNKNOWN]]
;
entry:
%entry.select = select i1 %cond2, half 0xH7E00, half %unknown
@@ -481,10 +469,9 @@ define nofpclass(nan) half @assume_in_loop(half %assumed.nan.in.loop, half %unkn
; CHECK-NEXT: [[ENTRY:.*]]:
; CHECK-NEXT: br i1 [[COND]], label %[[LOOP:.*]], label %[[RET:.*]]
; CHECK: [[LOOP]]:
-; CHECK-NEXT: [[LOOP_PHI:%.*]] = phi half [ [[LOOP_SELECT:%.*]], %[[LOOP]] ], [ [[ASSUMED_NAN_IN_LOOP]], %[[ENTRY]] ]
+; CHECK-NEXT: [[LOOP_PHI:%.*]] = phi half [ [[UNKNOWN]], %[[LOOP]] ], [ [[ASSUMED_NAN_IN_LOOP]], %[[ENTRY]] ]
; CHECK-NEXT: [[IS_NAN:%.*]] = fcmp uno half [[ASSUMED_NAN_IN_LOOP]], 0xH0000
; CHECK-NEXT: call void @llvm.assume(i1 [[IS_NAN]])
-; CHECK-NEXT: [[LOOP_SELECT]] = select i1 [[COND2]], half [[ASSUMED_NAN_IN_LOOP]], half [[UNKNOWN]]
; CHECK-NEXT: [[LOOP_COND:%.*]] = load i1, ptr [[P1]], align 1
; CHECK-NEXT: br i1 [[LOOP_COND]], label %[[RET]], label %[[LOOP]]
; CHECK: [[RET]]:
@@ -515,10 +502,9 @@ define nofpclass(nan) half @ret_phi_nan_check(half %checked.if.nan, half %unknow
; CHECK-NEXT: [[IS_NAN:%.*]] = fcmp uno half [[CHECKED_IF_NAN]], 0xH0000
; CHECK-NEXT: br i1 [[IS_NAN]], label %[[IF_NAN:.*]], label %[[RET:.*]]
; CHECK: [[IF_NAN]]:
-; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND]], half [[CHECKED_IF_NAN]], half [[UNKNOWN]]
; CHECK-NEXT: br label %[[RET]]
; CHECK: [[RET]]:
-; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[CHECKED_IF_NAN]], %[[ENTRY]] ], [ [[SELECT]], %[[IF_NAN]] ]
+; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[CHECKED_IF_NAN]], %[[ENTRY]] ], [ [[UNKNOWN]], %[[IF_NAN]] ]
; CHECK-NEXT: ret half [[PHI]]
;
entry:
@@ -542,7 +528,6 @@ define nofpclass(nan inf) half @edge_case_if_chain(half %x, i1 %cond, ptr %p0, p
; CHECK-NEXT: br i1 [[IS_INF]], label %[[IS_INF:.*]], label %[[ELSE:.*]]
; CHECK: [[IS_INF]]:
; CHECK-NEXT: [[LOAD0:%.*]] = load half, ptr [[P0]], align 2
-; CHECK-NEXT: [[VAL0:%.*]] = select i1 [[COND]], half [[X]], half [[LOAD0]]
; CHECK-NEXT: br label %[[RET:.*]]
; CHECK: [[ELSE]]:
; CHECK-NEXT: [[IS_NAN:%.*]] = fcmp uno half [[X]], 0xH0000
@@ -551,10 +536,9 @@ define nofpclass(nan inf) half @edge_case_if_chain(half %x, i1 %cond, ptr %p0, p
; CHECK-NEXT: br i1 [[IS_NAN]], label %[[IS_NAN:.*]], label %[[RET]]
; CHECK: [[IS_NAN]]:
; CHECK-NEXT: [[LOAD2:%.*]] = load half, ptr [[P2]], align 2
-; CHECK-NEXT: [[VAL2:%.*]] = select i1 [[COND]], half [[X]], half [[LOAD2]]
; CHECK-NEXT: br label %[[RET]]
; CHECK: [[RET]]:
-; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[VAL0]], %[[IS_INF]] ], [ [[VAL1]], %[[ELSE]] ], [ [[VAL2]], %[[IS_NAN]] ]
+; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[LOAD0]], %[[IS_INF]] ], [ [[VAL1]], %[[ELSE]] ], [ [[LOAD2]], %[[IS_NAN]] ]
; CHECK-NEXT: ret half [[PHI]]
;
entry:
@@ -591,10 +575,9 @@ define nofpclass(nan) half @evaluate_phi_input_at_incoming_edge(half %known.nan.
; CHECK-NEXT: [[IS_NAN:%.*]] = fcmp uno half [[KNOWN_NAN_IN_BRANCH]], 0xH0000
; CHECK-NEXT: br i1 [[IS_NAN]], label %[[IS_NAN:.*]], label %[[RET:.*]]
; CHECK: [[IS_NAN]]:
-; CHECK-NEXT: [[ENTRY_SELECT:%.*]] = select i1 [[COND]], half [[KNOWN_NAN_IN_BRANCH]], half [[UNKNOWN]]
; CHECK-NEXT: br label %[[RET]]
; CHECK: [[RET]]:
-; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[KNOWN_NAN_IN_BRANCH]], %[[ENTRY]] ], [ [[ENTRY_SELECT]], %[[IS_NAN]] ]
+; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[KNOWN_NAN_IN_BRANCH]], %[[ENTRY]] ], [ [[UNKNOWN]], %[[IS_NAN]] ]
; CHECK-NEXT: ret half [[PHI]]
;
entry:
diff --git a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass.ll b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass.ll
index 8b139a5ac9b79..5d86caca2e545 100644
--- a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass.ll
+++ b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass.ll
@@ -1719,8 +1719,7 @@ define nofpclass(inf) float @ret_nofpclass_inf__simple_phi_inf_or_unknown(i1 %co
; CHECK: bb0:
; CHECK-NEXT: br label [[RET]]
; CHECK: ret:
-; CHECK-NEXT: [[PHI:%.*]] = phi float [ 0x7FF0000000000000, [[ENTRY:%.*]] ], [ [[X]], [[BB0]] ]
-; CHECK-NEXT: ret float [[PHI]]
+; CHECK-NEXT: ret float [[X]]
;
entry:
br i1 %cond, label %bb0, label %ret
@@ -1745,7 +1744,7 @@ define nofpclass(inf) float @ret_nofpclass_inf__phi_0(i1 %cond0, float %unknown)
; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 [[COND0]], label [[LOOP:%.*]], label [[RET:%.*]]
; CHECK: loop:
-; CHECK-NEXT: [[PHI_LOOP:%.*]] = phi float [ 0x7FF0000000000000, [[ENTRY:%.*]] ], [ [[LOOP_FUNC:%.*]], [[LOOP]] ]
+; CHECK-NEXT: [[PHI_LOOP:%.*]] = phi float [ poison, [[ENTRY:%.*]] ], [ [[LOOP_FUNC:%.*]], [[LOOP]] ]
; CHECK-NEXT: [[LOOP_FUNC]] = call nofpclass(nan) float @loop.func()
; CHECK-NEXT: [[LOOP_COND:%.*]] = call i1 @loop.cond()
; CHECK-NEXT: br i1 [[LOOP_COND]], label [[RET]], label [[LOOP]]
@@ -1827,11 +1826,10 @@ define nofpclass(inf) float @ret_nofpclass_inf__phi_switch_repeated_predecessor(
; CHECK-NEXT: i32 1, label [[LOOP]]
; CHECK-NEXT: ]
; CHECK: loop:
-; CHECK-NEXT: [[PHI_LOOP:%.*]] = phi float [ 0x7FF0000000000000, [[ENTRY:%.*]] ], [ 0x7FF0000000000000, [[ENTRY]] ], [ [[UNKNOWN]], [[LOOP]] ]
; CHECK-NEXT: [[LOOP_COND:%.*]] = call i1 @loop.cond()
; CHECK-NEXT: br i1 [[LOOP_COND]], label [[RET]], label [[LOOP]]
; CHECK: ret:
-; CHECK-NEXT: [[PHI_RET:%.*]] = phi float [ 0.000000e+00, [[ENTRY]] ], [ [[PHI_LOOP]], [[LOOP]] ]
+; CHECK-NEXT: [[PHI_RET:%.*]] = phi float [ 0.000000e+00, [[ENTRY:%.*]] ], [ [[UNKNOWN]], [[LOOP]] ]
; CHECK-NEXT: ret float [[PHI_RET]]
;
entry:
More information about the llvm-branch-commits
mailing list