[llvm] 930996e - [ValueTracking][NFC] Pass `SimplifyQuery` to `computeKnownFPClass` family (#80657)
via llvm-commits
llvm-commits at lists.llvm.org
Mon Feb 5 10:30:16 PST 2024
Author: Yingwei Zheng
Date: 2024-02-06T02:30:12+08:00
New Revision: 930996e9e442d69a321cd5c945543d37c97f4c0e
URL: https://github.com/llvm/llvm-project/commit/930996e9e442d69a321cd5c945543d37c97f4c0e
DIFF: https://github.com/llvm/llvm-project/commit/930996e9e442d69a321cd5c945543d37c97f4c0e.diff
LOG: [ValueTracking][NFC] Pass `SimplifyQuery` to `computeKnownFPClass` family (#80657)
This patch refactors the interface of the `computeKnownFPClass` family
to pass `SimplifyQuery` directly.
The motivation of this patch is to compute known fpclass with
`DomConditionCache`, which was introduced by
https://github.com/llvm/llvm-project/pull/73662. With
`DomConditionCache`, we can do more optimization with context-sensitive
information.
Example (extracted from
[fmt/format.h](https://github.com/fmtlib/fmt/blob/e17bc67547a66cdd378ca6a90c56b865d30d6168/include/fmt/format.h#L3555-L3566)):
```
define float @test(float %x, i1 %cond) {
%i32 = bitcast float %x to i32
%cmp = icmp slt i32 %i32, 0
br i1 %cmp, label %if.then1, label %if.else
if.then1:
%fneg = fneg float %x
br label %if.end
if.else:
br i1 %cond, label %if.then2, label %if.end
if.then2:
br label %if.end
if.end:
%value = phi float [ %fneg, %if.then1 ], [ %x, %if.then2 ], [ %x, %if.else ]
%ret = call float @llvm.fabs.f32(float %value)
ret float %ret
}
```
We can prove the signbit of `%value` is always zero. Then the fabs can
be eliminated.
Added:
Modified:
llvm/include/llvm/Analysis/ValueTracking.h
llvm/lib/Analysis/InstructionSimplify.cpp
llvm/lib/Analysis/ValueTracking.cpp
llvm/lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp
llvm/lib/Target/AMDGPU/AMDGPUInstCombineIntrinsic.cpp
llvm/lib/Target/AMDGPU/AMDGPULibCalls.cpp
llvm/lib/Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp
llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp
llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp
llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp
llvm/lib/Transforms/InstCombine/InstCombineInternal.h
llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp
llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/Analysis/ValueTracking.h b/llvm/include/llvm/Analysis/ValueTracking.h
index 3dc738c83558e..d9287ae9e5e98 100644
--- a/llvm/include/llvm/Analysis/ValueTracking.h
+++ b/llvm/include/llvm/Analysis/ValueTracking.h
@@ -479,34 +479,35 @@ inline KnownFPClass operator|(const KnownFPClass &LHS, KnownFPClass &&RHS) {
/// point classes should be queried. Queries not specified in \p
/// InterestedClasses should be reliable if they are determined during the
/// query.
-KnownFPClass computeKnownFPClass(
- const Value *V, const APInt &DemandedElts, const DataLayout &DL,
- FPClassTest InterestedClasses = fcAllFlags, unsigned Depth = 0,
- const TargetLibraryInfo *TLI = nullptr, AssumptionCache *AC = nullptr,
- const Instruction *CxtI = nullptr, const DominatorTree *DT = nullptr,
- bool UseInstrInfo = true);
+KnownFPClass computeKnownFPClass(const Value *V, const APInt &DemandedElts,
+ FPClassTest InterestedClasses, unsigned Depth,
+ const SimplifyQuery &SQ);
-KnownFPClass computeKnownFPClass(
- const Value *V, const DataLayout &DL,
- FPClassTest InterestedClasses = fcAllFlags, unsigned Depth = 0,
- const TargetLibraryInfo *TLI = nullptr, AssumptionCache *AC = nullptr,
- const Instruction *CxtI = nullptr, const DominatorTree *DT = nullptr,
- bool UseInstrInfo = true);
+KnownFPClass computeKnownFPClass(const Value *V, FPClassTest InterestedClasses,
+ unsigned Depth, const SimplifyQuery &SQ);
-/// Wrapper to account for known fast math flags at the use instruction.
inline KnownFPClass computeKnownFPClass(
- const Value *V, FastMathFlags FMF, const DataLayout &DL,
+ const Value *V, const DataLayout &DL,
FPClassTest InterestedClasses = fcAllFlags, unsigned Depth = 0,
const TargetLibraryInfo *TLI = nullptr, AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr, const DominatorTree *DT = nullptr,
bool UseInstrInfo = true) {
+ return computeKnownFPClass(
+ V, InterestedClasses, Depth,
+ SimplifyQuery(DL, TLI, DT, AC, CxtI, UseInstrInfo));
+}
+
+/// Wrapper to account for known fast math flags at the use instruction.
+inline KnownFPClass computeKnownFPClass(const Value *V, FastMathFlags FMF,
+ FPClassTest InterestedClasses,
+ unsigned Depth,
+ const SimplifyQuery &SQ) {
if (FMF.noNaNs())
InterestedClasses &= ~fcNan;
if (FMF.noInfs())
InterestedClasses &= ~fcInf;
- KnownFPClass Result = computeKnownFPClass(V, DL, InterestedClasses, Depth,
- TLI, AC, CxtI, DT, UseInstrInfo);
+ KnownFPClass Result = computeKnownFPClass(V, InterestedClasses, Depth, SQ);
if (FMF.noNaNs())
Result.KnownFPClasses &= ~fcNan;
@@ -518,15 +519,9 @@ inline KnownFPClass computeKnownFPClass(
/// Return true if we can prove that the specified FP value is never equal to
/// -0.0. Users should use caution when considering PreserveSign
/// denormal-fp-math.
-inline bool cannotBeNegativeZero(const Value *V, const DataLayout &DL,
- const TargetLibraryInfo *TLI = nullptr,
- unsigned Depth = 0,
- AssumptionCache *AC = nullptr,
- const Instruction *CtxI = nullptr,
- const DominatorTree *DT = nullptr,
- bool UseInstrInfo = true) {
- KnownFPClass Known = computeKnownFPClass(V, DL, fcNegZero, Depth, TLI, AC,
- CtxI, DT, UseInstrInfo);
+inline bool cannotBeNegativeZero(const Value *V, unsigned Depth,
+ const SimplifyQuery &SQ) {
+ KnownFPClass Known = computeKnownFPClass(V, fcNegZero, Depth, SQ);
return Known.isKnownNeverNegZero();
}
@@ -538,69 +533,44 @@ inline bool cannotBeNegativeZero(const Value *V, const DataLayout &DL,
/// -0 --> true
/// x > +0 --> true
/// x < -0 --> false
-inline bool cannotBeOrderedLessThanZero(const Value *V, const DataLayout &DL,
- const TargetLibraryInfo *TLI = nullptr,
- unsigned Depth = 0,
- AssumptionCache *AC = nullptr,
- const Instruction *CtxI = nullptr,
- const DominatorTree *DT = nullptr,
- bool UseInstrInfo = true) {
+inline bool cannotBeOrderedLessThanZero(const Value *V, unsigned Depth,
+ const SimplifyQuery &SQ) {
KnownFPClass Known =
- computeKnownFPClass(V, DL, KnownFPClass::OrderedLessThanZeroMask, Depth,
- TLI, AC, CtxI, DT, UseInstrInfo);
+ computeKnownFPClass(V, KnownFPClass::OrderedLessThanZeroMask, Depth, SQ);
return Known.cannotBeOrderedLessThanZero();
}
/// Return true if the floating-point scalar value is not an infinity or if
/// the floating-point vector value has no infinities. Return false if a value
/// could ever be infinity.
-inline bool isKnownNeverInfinity(const Value *V, const DataLayout &DL,
- const TargetLibraryInfo *TLI = nullptr,
- unsigned Depth = 0,
- AssumptionCache *AC = nullptr,
- const Instruction *CtxI = nullptr,
- const DominatorTree *DT = nullptr,
- bool UseInstrInfo = true) {
- KnownFPClass Known = computeKnownFPClass(V, DL, fcInf, Depth, TLI, AC, CtxI,
- DT, UseInstrInfo);
+inline bool isKnownNeverInfinity(const Value *V, unsigned Depth,
+ const SimplifyQuery &SQ) {
+ KnownFPClass Known = computeKnownFPClass(V, fcInf, Depth, SQ);
return Known.isKnownNeverInfinity();
}
/// Return true if the floating-point value can never contain a NaN or infinity.
-inline bool isKnownNeverInfOrNaN(
- const Value *V, const DataLayout &DL, const TargetLibraryInfo *TLI,
- unsigned Depth = 0, AssumptionCache *AC = nullptr,
- const Instruction *CtxI = nullptr, const DominatorTree *DT = nullptr,
- bool UseInstrInfo = true) {
- KnownFPClass Known = computeKnownFPClass(V, DL, fcInf | fcNan, Depth, TLI, AC,
- CtxI, DT, UseInstrInfo);
+inline bool isKnownNeverInfOrNaN(const Value *V, unsigned Depth,
+ const SimplifyQuery &SQ) {
+ KnownFPClass Known = computeKnownFPClass(V, fcInf | fcNan, Depth, SQ);
return Known.isKnownNeverNaN() && Known.isKnownNeverInfinity();
}
/// Return true if the floating-point scalar value is not a NaN or if the
/// floating-point vector value has no NaN elements. Return false if a value
/// could ever be NaN.
-inline bool isKnownNeverNaN(const Value *V, const DataLayout &DL,
- const TargetLibraryInfo *TLI, unsigned Depth = 0,
- AssumptionCache *AC = nullptr,
- const Instruction *CtxI = nullptr,
- const DominatorTree *DT = nullptr,
- bool UseInstrInfo = true) {
- KnownFPClass Known = computeKnownFPClass(V, DL, fcNan, Depth, TLI, AC, CtxI,
- DT, UseInstrInfo);
+inline bool isKnownNeverNaN(const Value *V, unsigned Depth,
+ const SimplifyQuery &SQ) {
+ KnownFPClass Known = computeKnownFPClass(V, fcNan, Depth, SQ);
return Known.isKnownNeverNaN();
}
/// Return false if we can prove that the specified FP value's sign bit is 0.
/// Return true if we can prove that the specified FP value's sign bit is 1.
/// Otherwise return std::nullopt.
-inline std::optional<bool> computeKnownFPSignBit(
- const Value *V, const DataLayout &DL,
- const TargetLibraryInfo *TLI = nullptr, unsigned Depth = 0,
- AssumptionCache *AC = nullptr, const Instruction *CtxI = nullptr,
- const DominatorTree *DT = nullptr, bool UseInstrInfo = true) {
- KnownFPClass Known = computeKnownFPClass(V, DL, fcAllFlags, Depth, TLI, AC,
- CtxI, DT, UseInstrInfo);
+inline std::optional<bool> computeKnownFPSignBit(const Value *V, unsigned Depth,
+ const SimplifyQuery &SQ) {
+ KnownFPClass Known = computeKnownFPClass(V, fcAllFlags, Depth, SQ);
return Known.SignBit;
}
diff --git a/llvm/lib/Analysis/InstructionSimplify.cpp b/llvm/lib/Analysis/InstructionSimplify.cpp
index c10b9d9be101b..2793b798f35f3 100644
--- a/llvm/lib/Analysis/InstructionSimplify.cpp
+++ b/llvm/lib/Analysis/InstructionSimplify.cpp
@@ -1852,9 +1852,6 @@ static Value *simplifyAndOrOfFCmps(const SimplifyQuery &Q, FCmpInst *LHS,
if (LHS0->getType() != RHS0->getType())
return nullptr;
- const DataLayout &DL = Q.DL;
- const TargetLibraryInfo *TLI = Q.TLI;
-
FCmpInst::Predicate PredL = LHS->getPredicate(), PredR = RHS->getPredicate();
if ((PredL == FCmpInst::FCMP_ORD && PredR == FCmpInst::FCMP_ORD && IsAnd) ||
(PredL == FCmpInst::FCMP_UNO && PredR == FCmpInst::FCMP_UNO && !IsAnd)) {
@@ -1867,9 +1864,9 @@ static Value *simplifyAndOrOfFCmps(const SimplifyQuery &Q, FCmpInst *LHS,
// (fcmp uno X, NNAN) | (fcmp uno X, Y) --> fcmp uno X, Y
// (fcmp uno X, NNAN) | (fcmp uno Y, X) --> fcmp uno Y, X
if (((LHS1 == RHS0 || LHS1 == RHS1) &&
- isKnownNeverNaN(LHS0, DL, TLI, 0, Q.AC, Q.CxtI, Q.DT)) ||
+ isKnownNeverNaN(LHS0, /*Depth=*/0, Q)) ||
((LHS0 == RHS0 || LHS0 == RHS1) &&
- isKnownNeverNaN(LHS1, DL, TLI, 0, Q.AC, Q.CxtI, Q.DT)))
+ isKnownNeverNaN(LHS1, /*Depth=*/0, Q)))
return RHS;
// (fcmp ord X, Y) & (fcmp ord NNAN, X) --> fcmp ord X, Y
@@ -1881,9 +1878,9 @@ static Value *simplifyAndOrOfFCmps(const SimplifyQuery &Q, FCmpInst *LHS,
// (fcmp uno X, Y) | (fcmp uno X, NNAN) --> fcmp uno X, Y
// (fcmp uno Y, X) | (fcmp uno X, NNAN) --> fcmp uno Y, X
if (((RHS1 == LHS0 || RHS1 == LHS1) &&
- isKnownNeverNaN(RHS0, DL, TLI, 0, Q.AC, Q.CxtI, Q.DT)) ||
+ isKnownNeverNaN(RHS0, /*Depth=*/0, Q)) ||
((RHS0 == LHS0 || RHS0 == LHS1) &&
- isKnownNeverNaN(RHS1, DL, TLI, 0, Q.AC, Q.CxtI, Q.DT)))
+ isKnownNeverNaN(RHS1, /*Depth=*/0, Q)))
return LHS;
}
@@ -4106,9 +4103,8 @@ static Value *simplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
// This catches the 2 variable input case, constants are handled below as a
// class-like compare.
if (Pred == FCmpInst::FCMP_ORD || Pred == FCmpInst::FCMP_UNO) {
- if (FMF.noNaNs() ||
- (isKnownNeverNaN(RHS, Q.DL, Q.TLI, 0, Q.AC, Q.CxtI, Q.DT) &&
- isKnownNeverNaN(LHS, Q.DL, Q.TLI, 0, Q.AC, Q.CxtI, Q.DT)))
+ if (FMF.noNaNs() || (isKnownNeverNaN(RHS, /*Depth=*/0, Q) &&
+ isKnownNeverNaN(LHS, /*Depth=*/0, Q)))
return ConstantInt::get(RetTy, Pred == FCmpInst::FCMP_ORD);
}
@@ -4122,8 +4118,7 @@ static Value *simplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
fcAllFlags) {
if (FullKnownClassLHS)
return *FullKnownClassLHS;
- return computeKnownFPClass(LHS, FMF, Q.DL, InterestedFlags, 0, Q.TLI, Q.AC,
- Q.CxtI, Q.DT, Q.IIQ.UseInstrInfo);
+ return computeKnownFPClass(LHS, FMF, InterestedFlags, 0, Q);
};
if (C && Q.CxtI) {
@@ -5631,7 +5626,7 @@ simplifyFAddInst(Value *Op0, Value *Op1, FastMathFlags FMF,
// fadd X, 0 ==> X, when we know X is not -0
if (canIgnoreSNaN(ExBehavior, FMF))
if (match(Op1, m_PosZeroFP()) &&
- (FMF.noSignedZeros() || cannotBeNegativeZero(Op0, Q.DL, Q.TLI)))
+ (FMF.noSignedZeros() || cannotBeNegativeZero(Op0, /*Depth=*/0, Q)))
return Op0;
if (!isDefaultFPEnvironment(ExBehavior, Rounding))
@@ -5693,7 +5688,7 @@ simplifyFSubInst(Value *Op0, Value *Op1, FastMathFlags FMF,
// fsub X, -0 ==> X, when we know X is not -0
if (canIgnoreSNaN(ExBehavior, FMF))
if (match(Op1, m_NegZeroFP()) &&
- (FMF.noSignedZeros() || cannotBeNegativeZero(Op0, Q.DL, Q.TLI)))
+ (FMF.noSignedZeros() || cannotBeNegativeZero(Op0, /*Depth=*/0, Q)))
return Op0;
// fsub -0.0, (fsub -0.0, X) ==> X
@@ -5762,8 +5757,8 @@ static Value *simplifyFMAFMul(Value *Op0, Value *Op1, FastMathFlags FMF,
return ConstantFP::getZero(Op0->getType());
// +normal number * (-)0.0 --> (-)0.0
- KnownFPClass Known = computeKnownFPClass(
- Op0, FMF, Q.DL, fcInf | fcNan, /*Depth=*/0, Q.TLI, Q.AC, Q.CxtI, Q.DT);
+ KnownFPClass Known =
+ computeKnownFPClass(Op0, FMF, fcInf | fcNan, /*Depth=*/0, Q);
if (Known.SignBit == false && Known.isKnownNever(fcInf | fcNan))
return Op1;
}
@@ -6217,8 +6212,7 @@ static Value *simplifyUnaryIntrinsic(Function *F, Value *Op0,
Value *X;
switch (IID) {
case Intrinsic::fabs:
- if (computeKnownFPSignBit(Op0, Q.DL, Q.TLI, /*Depth=*/0, Q.AC, Q.CxtI,
- Q.DT) == false)
+ if (computeKnownFPSignBit(Op0, /*Depth=*/0, Q) == false)
return Op0;
break;
case Intrinsic::bswap:
diff --git a/llvm/lib/Analysis/ValueTracking.cpp b/llvm/lib/Analysis/ValueTracking.cpp
index f7388bbb4a47a..58db81f470130 100644
--- a/llvm/lib/Analysis/ValueTracking.cpp
+++ b/llvm/lib/Analysis/ValueTracking.cpp
@@ -5302,26 +5302,23 @@ void computeKnownFPClass(const Value *V, const APInt &DemandedElts,
}
}
-KnownFPClass llvm::computeKnownFPClass(
- const Value *V, const APInt &DemandedElts, const DataLayout &DL,
- FPClassTest InterestedClasses, unsigned Depth, const TargetLibraryInfo *TLI,
- AssumptionCache *AC, const Instruction *CxtI, const DominatorTree *DT,
- bool UseInstrInfo) {
+KnownFPClass llvm::computeKnownFPClass(const Value *V,
+ const APInt &DemandedElts,
+ FPClassTest InterestedClasses,
+ unsigned Depth,
+ const SimplifyQuery &SQ) {
KnownFPClass KnownClasses;
- ::computeKnownFPClass(
- V, DemandedElts, InterestedClasses, KnownClasses, Depth,
- SimplifyQuery(DL, TLI, DT, AC, safeCxtI(V, CxtI), UseInstrInfo));
+ ::computeKnownFPClass(V, DemandedElts, InterestedClasses, KnownClasses, Depth,
+ SQ);
return KnownClasses;
}
-KnownFPClass llvm::computeKnownFPClass(
- const Value *V, const DataLayout &DL, FPClassTest InterestedClasses,
- unsigned Depth, const TargetLibraryInfo *TLI, AssumptionCache *AC,
- const Instruction *CxtI, const DominatorTree *DT, bool UseInstrInfo) {
+KnownFPClass llvm::computeKnownFPClass(const Value *V,
+ FPClassTest InterestedClasses,
+ unsigned Depth,
+ const SimplifyQuery &SQ) {
KnownFPClass Known;
- ::computeKnownFPClass(
- V, Known, InterestedClasses, Depth,
- SimplifyQuery(DL, TLI, DT, AC, safeCxtI(V, CxtI), UseInstrInfo));
+ ::computeKnownFPClass(V, Known, InterestedClasses, Depth, SQ);
return Known;
}
diff --git a/llvm/lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp b/llvm/lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp
index 87b1957c799e2..c4293f59204d0 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp
+++ b/llvm/lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp
@@ -2095,7 +2095,8 @@ bool AMDGPUCodeGenPrepareImpl::visitMinNum(IntrinsicInst &I) {
// Match pattern for fract intrinsic in contexts where the nan check has been
// optimized out (and hope the knowledge the source can't be nan wasn't lost).
- if (!I.hasNoNaNs() && !isKnownNeverNaN(FractArg, *DL, TLInfo))
+ if (!I.hasNoNaNs() &&
+ !isKnownNeverNaN(FractArg, /*Depth=*/0, SimplifyQuery(*DL, TLInfo)))
return false;
IRBuilder<> Builder(&I);
diff --git a/llvm/lib/Target/AMDGPU/AMDGPUInstCombineIntrinsic.cpp b/llvm/lib/Target/AMDGPU/AMDGPUInstCombineIntrinsic.cpp
index 703b0738a3855..fb829fab0a2c1 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUInstCombineIntrinsic.cpp
+++ b/llvm/lib/Target/AMDGPU/AMDGPUInstCombineIntrinsic.cpp
@@ -343,13 +343,9 @@ bool GCNTTIImpl::canSimplifyLegacyMulToMul(const Instruction &I,
return true;
}
- auto *TLI = &IC.getTargetLibraryInfo();
- if (isKnownNeverInfOrNaN(Op0, IC.getDataLayout(), TLI, 0,
- &IC.getAssumptionCache(), &I,
- &IC.getDominatorTree()) &&
- isKnownNeverInfOrNaN(Op1, IC.getDataLayout(), TLI, 0,
- &IC.getAssumptionCache(), &I,
- &IC.getDominatorTree())) {
+ SimplifyQuery SQ = IC.getSimplifyQuery().getWithInstruction(&I);
+ if (isKnownNeverInfOrNaN(Op0, /*Depth=*/0, SQ) &&
+ isKnownNeverInfOrNaN(Op1, /*Depth=*/0, SQ)) {
// Neither operand is infinity or NaN.
return true;
}
diff --git a/llvm/lib/Target/AMDGPU/AMDGPULibCalls.cpp b/llvm/lib/Target/AMDGPU/AMDGPULibCalls.cpp
index 1b2f74cf153bf..2da896edc79a7 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPULibCalls.cpp
+++ b/llvm/lib/Target/AMDGPU/AMDGPULibCalls.cpp
@@ -607,7 +607,7 @@ static bool isKnownIntegral(const Value *V, const DataLayout &DL,
// Need to check int size cannot produce infinity, which computeKnownFPClass
// knows how to do already.
- return isKnownNeverInfinity(I, DL);
+ return isKnownNeverInfinity(I, /*Depth=*/0, SimplifyQuery(DL));
case Instruction::Call: {
const CallInst *CI = cast<CallInst>(I);
switch (CI->getIntrinsicID()) {
@@ -619,7 +619,7 @@ static bool isKnownIntegral(const Value *V, const DataLayout &DL,
case Intrinsic::round:
case Intrinsic::roundeven:
return (FMF.noInfs() && FMF.noNaNs()) ||
- isKnownNeverInfOrNaN(I, DL, nullptr);
+ isKnownNeverInfOrNaN(I, /*Depth=*/0, SimplifyQuery(DL));
default:
break;
}
@@ -754,8 +754,9 @@ bool AMDGPULibCalls::fold(CallInst *CI) {
// pow(x, y) -> powr(x, y) for x >= -0.0
// TODO: Account for flags on current call
if (PowrFunc &&
- cannotBeOrderedLessThanZero(FPOp->getOperand(0), M->getDataLayout(),
- TLInfo, 0, AC, Call, DT)) {
+ cannotBeOrderedLessThanZero(
+ FPOp->getOperand(0), /*Depth=*/0,
+ SimplifyQuery(M->getDataLayout(), TLInfo, DT, AC, Call))) {
Call->setCalledFunction(PowrFunc);
return fold_pow(FPOp, B, PowrInfo) || true;
}
diff --git a/llvm/lib/Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp b/llvm/lib/Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp
index 49fa0f59d4882..e586e9eda1322 100644
--- a/llvm/lib/Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp
+++ b/llvm/lib/Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp
@@ -425,8 +425,8 @@ static bool foldSqrt(Instruction &I, TargetTransformInfo &TTI,
Value *Arg = Call->getArgOperand(0);
if (TTI.haveFastSqrt(Ty) &&
(Call->hasNoNaNs() ||
- cannotBeOrderedLessThanZero(Arg, M->getDataLayout(), &TLI, 0, &AC, &I,
- &DT))) {
+ cannotBeOrderedLessThanZero(
+ Arg, 0, SimplifyQuery(M->getDataLayout(), &TLI, &DT, &AC, &I)))) {
IRBuilder<> Builder(&I);
IRBuilderBase::FastMathFlagGuard Guard(Builder);
Builder.setFastMathFlags(Call->getFastMathFlags());
diff --git a/llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp b/llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp
index 8a00b75a1f740..cfff5df9ff500 100644
--- a/llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp
@@ -2842,7 +2842,8 @@ Instruction *InstCombinerImpl::visitFSub(BinaryOperator &I) {
// Note that if this fsub was really an fneg, the fadd with -0.0 will get
// killed later. We still limit that particular transform with 'hasOneUse'
// because an fneg is assumed better/cheaper than a generic fsub.
- if (I.hasNoSignedZeros() || cannotBeNegativeZero(Op0, SQ.DL, SQ.TLI)) {
+ if (I.hasNoSignedZeros() ||
+ cannotBeNegativeZero(Op0, 0, getSimplifyQuery().getWithInstruction(&I))) {
if (match(Op1, m_OneUse(m_FSub(m_Value(X), m_Value(Y))))) {
Value *NewSub = Builder.CreateFSubFMF(Y, X, &I);
return BinaryOperator::CreateFAddFMF(Op0, NewSub, &I);
diff --git a/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp b/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp
index b7e73856f4060..df24c9bab099a 100644
--- a/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp
@@ -2413,7 +2413,7 @@ Instruction *InstCombinerImpl::visitCallInst(CallInst &CI) {
case Intrinsic::copysign: {
Value *Mag = II->getArgOperand(0), *Sign = II->getArgOperand(1);
if (std::optional<bool> KnownSignBit = computeKnownFPSignBit(
- Sign, getDataLayout(), &TLI, /*Depth=*/0, &AC, II, &DT)) {
+ Sign, /*Depth=*/0, getSimplifyQuery().getWithInstruction(II))) {
if (*KnownSignBit) {
// If we know that the sign argument is negative, reduce to FNABS:
// copysign Mag, -Sign --> fneg (fabs Mag)
diff --git a/llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp b/llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp
index 15ec3fd2ceca0..380cb3504209d 100644
--- a/llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp
@@ -7714,12 +7714,12 @@ Instruction *InstCombinerImpl::visitFCmpInst(FCmpInst &I) {
// If we're just checking for a NaN (ORD/UNO) and have a non-NaN operand,
// then canonicalize the operand to 0.0.
if (Pred == CmpInst::FCMP_ORD || Pred == CmpInst::FCMP_UNO) {
- if (!match(Op0, m_PosZeroFP()) && isKnownNeverNaN(Op0, DL, &TLI, 0,
- &AC, &I, &DT))
+ if (!match(Op0, m_PosZeroFP()) &&
+ isKnownNeverNaN(Op0, 0, getSimplifyQuery().getWithInstruction(&I)))
return replaceOperand(I, 0, ConstantFP::getZero(OpType));
if (!match(Op1, m_PosZeroFP()) &&
- isKnownNeverNaN(Op1, DL, &TLI, 0, &AC, &I, &DT))
+ isKnownNeverNaN(Op1, 0, getSimplifyQuery().getWithInstruction(&I)))
return replaceOperand(I, 1, ConstantFP::getZero(OpType));
}
diff --git a/llvm/lib/Transforms/InstCombine/InstCombineInternal.h b/llvm/lib/Transforms/InstCombine/InstCombineInternal.h
index b75ab9ad30142..97459a8fbd657 100644
--- a/llvm/lib/Transforms/InstCombine/InstCombineInternal.h
+++ b/llvm/lib/Transforms/InstCombine/InstCombineInternal.h
@@ -202,16 +202,17 @@ class LLVM_LIBRARY_VISIBILITY InstCombinerImpl final
FPClassTest Interested = fcAllFlags,
const Instruction *CtxI = nullptr,
unsigned Depth = 0) const {
- return llvm::computeKnownFPClass(Val, FMF, DL, Interested, Depth, &TLI, &AC,
- CtxI, &DT);
+ return llvm::computeKnownFPClass(
+ Val, FMF, Interested, Depth,
+ getSimplifyQuery().getWithInstruction(CtxI));
}
KnownFPClass computeKnownFPClass(Value *Val,
FPClassTest Interested = fcAllFlags,
const Instruction *CtxI = nullptr,
unsigned Depth = 0) const {
- return llvm::computeKnownFPClass(Val, DL, Interested, Depth, &TLI, &AC,
- CtxI, &DT);
+ return llvm::computeKnownFPClass(
+ Val, Interested, Depth, getSimplifyQuery().getWithInstruction(CtxI));
}
/// Check if fmul \p MulVal, +0.0 will yield +0.0 (or signed zero is
diff --git a/llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp b/llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp
index 453e4d788705f..2756f81ed9e62 100644
--- a/llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp
@@ -99,7 +99,8 @@ static Instruction *foldSelectBinOpIdentity(SelectInst &Sel,
// transform. Bail out if we can not exclude that possibility.
if (isa<FPMathOperator>(BO))
if (!BO->hasNoSignedZeros() &&
- !cannotBeNegativeZero(Y, IC.getDataLayout(), &TLI))
+ !cannotBeNegativeZero(Y, 0,
+ IC.getSimplifyQuery().getWithInstruction(&Sel)))
return nullptr;
// BO = binop Y, X
diff --git a/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp b/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp
index 52eef9ab58a4d..3d1ce110e3a28 100644
--- a/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp
+++ b/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp
@@ -2167,7 +2167,8 @@ Value *LibCallSimplifier::replacePowWithSqrt(CallInst *Pow, IRBuilderBase &B) {
// pow(-Inf, 0.5) is optionally required to have a result of +Inf (not setting
// errno), but sqrt(-Inf) is required by various standards to set errno.
if (!Pow->doesNotAccessMemory() && !Pow->hasNoInfs() &&
- !isKnownNeverInfinity(Base, DL, TLI, 0, AC, Pow))
+ !isKnownNeverInfinity(Base, 0,
+ SimplifyQuery(DL, TLI, /*DT=*/nullptr, AC, Pow)))
return nullptr;
Sqrt = getSqrtCall(Base, AttributeList(), Pow->doesNotAccessMemory(), Mod, B,
More information about the llvm-commits
mailing list