[llvm] [ValueTracking][KnownFPClass] Cover known no-infinity cases for powi (PR #191736)
via llvm-commits
llvm-commits at lists.llvm.org
Mon Apr 13 05:24:56 PDT 2026
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-llvm-support
Author: Max Graey (MaxGraey)
<details>
<summary>Changes</summary>
Teach `computeKnownFPClass` to infer non-infinity cass for `powi`.
Rules out `inf` for `powi(x, exp)` when:
- `x ?= inf` && `exp > 0`
- `x ?= +/-0` && `exp < 0`
- `x ?= finite` && `|exp| > 1`
- `x ?= subnormal` && `exp ?= -1`
where `?=` is maybe equal.
It's a bit conservative, and we could refine it further, but I'd take an iterative improvements.
---
Full diff: https://github.com/llvm/llvm-project/pull/191736.diff
4 Files Affected:
- (modified) llvm/lib/Analysis/ValueTracking.cpp (+13-4)
- (modified) llvm/lib/Support/KnownFPClass.cpp (+33-1)
- (modified) llvm/test/Transforms/Attributor/nofpclass-powi.ll (+42)
- (modified) llvm/unittests/Analysis/ValueTrackingTest.cpp (+68)
``````````diff
diff --git a/llvm/lib/Analysis/ValueTracking.cpp b/llvm/lib/Analysis/ValueTracking.cpp
index 5b52efb9e1dc6..54e04eccc6613 100644
--- a/llvm/lib/Analysis/ValueTracking.cpp
+++ b/llvm/lib/Analysis/ValueTracking.cpp
@@ -5459,7 +5459,7 @@ void computeKnownFPClass(const Value *V, const APInt &DemandedElts,
break;
}
case Intrinsic::powi: {
- if ((InterestedClasses & fcNegative) == fcNone)
+ if ((InterestedClasses & (fcNan | fcInf | fcNegative)) == fcNone)
break;
const Value *Exp = II->getArgOperand(1);
@@ -5469,11 +5469,20 @@ void computeKnownFPClass(const Value *V, const APInt &DemandedElts,
computeKnownBits(Exp, isa<VectorType>(ExpTy) ? DemandedElts : APInt(1, 1),
ExponentKnownBits, Q, Depth + 1);
+ FPClassTest InterestedSrcs = fcNone;
+ if (InterestedClasses & fcNan)
+ InterestedSrcs |= fcNan;
+ if (!ExponentKnownBits.isZero()) {
+ if (InterestedClasses & fcInf)
+ InterestedSrcs |= fcFinite | fcInf;
+ if ((InterestedClasses & fcNegative) && !ExponentKnownBits.isEven())
+ InterestedSrcs |= fcNegative;
+ }
+
KnownFPClass KnownSrc;
- if (ExponentKnownBits.isZero() || !ExponentKnownBits.isEven()) {
- computeKnownFPClass(II->getArgOperand(0), DemandedElts, fcNegative,
+ if (InterestedSrcs != fcNone)
+ computeKnownFPClass(II->getArgOperand(0), DemandedElts, InterestedSrcs,
KnownSrc, Q, Depth + 1);
- }
Known = KnownFPClass::powi(KnownSrc, ExponentKnownBits);
break;
diff --git a/llvm/lib/Support/KnownFPClass.cpp b/llvm/lib/Support/KnownFPClass.cpp
index 96a1b26daf04d..6a33569ef9717 100644
--- a/llvm/lib/Support/KnownFPClass.cpp
+++ b/llvm/lib/Support/KnownFPClass.cpp
@@ -862,7 +862,6 @@ KnownFPClass KnownFPClass::ldexp(const KnownFPClass &KnownSrc,
return Known;
}
-// TODO: Detect no-infinity cases
KnownFPClass KnownFPClass::powi(const KnownFPClass &KnownSrc,
const KnownBits &ExponentKnownBits) {
KnownFPClass Known;
@@ -880,6 +879,39 @@ KnownFPClass KnownFPClass::powi(const KnownFPClass &KnownSrc,
return Known;
}
+ // powi(x, exp) --> inf
+ // when:
+ // * powi(inf, exp), exp > 0
+ // * powi(+/-0, exp), exp < 0
+ // * powi(finite, exp), |exp| > 1
+ // * powi(subnormal, -1)
+ // TODO:
+ // This simple all or nothing approach. We can do better
+ // and cover sign/parity and exp > 1 vs exp < -1 separately.
+ {
+ APInt MinExp = ExponentKnownBits.getSignedMinValue();
+ APInt MaxExp = ExponentKnownBits.getSignedMaxValue();
+
+ // powi(inf, exp), exp > 0
+ bool MayInfSrc =
+ !KnownSrc.isKnownNever(fcInf) && MaxExp.isStrictlyPositive();
+
+ // powi(+/-0, exp), exp < 0
+ bool MayDivByZero = !KnownSrc.isKnownNever(fcZero) && MinExp.isNegative();
+
+ // powi(finite, exp), |exp| > 1
+ bool MayFinite = !KnownSrc.isKnownNever(fcNormal | fcSubnormal);
+ bool MayAbsExpGT1 = MinExp.slt(-1) || MaxExp.sgt(1);
+ bool MayFiniteOverflow = MayFinite && MayAbsExpGT1;
+
+ // powi(subnormal, -1)
+ bool MayBeNegOne = ExponentKnownBits.Zero.isZero();
+ bool MaySubnormInv = !KnownSrc.isKnownNever(fcSubnormal) && MayBeNegOne;
+
+ if (!MayInfSrc && !MayDivByZero && !MayFiniteOverflow && !MaySubnormInv)
+ Known.knownNot(fcInf);
+ }
+
if (ExponentKnownBits.isEven()) {
Known.knownNot(fcNegative);
return Known;
diff --git a/llvm/test/Transforms/Attributor/nofpclass-powi.ll b/llvm/test/Transforms/Attributor/nofpclass-powi.ll
index 476f2da040fda..66513435cd4bc 100644
--- a/llvm/test/Transforms/Attributor/nofpclass-powi.ll
+++ b/llvm/test/Transforms/Attributor/nofpclass-powi.ll
@@ -157,6 +157,48 @@ define float @ret_powi_f32_no_inf(float nofpclass(inf) %arg0, i32 %arg1) #0 {
ret float %call
}
+define float @ret_powi_f32_finite_exp_one(float nofpclass(inf) %arg0) #0 {
+; CHECK-LABEL: define nofpclass(inf) float @ret_powi_f32_finite_exp_one
+; CHECK-SAME: (float nofpclass(inf) [[ARG0:%.*]]) #[[ATTR1]] {
+; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(inf) float @llvm.powi.f32.i32(float nofpclass(inf) [[ARG0]], i32 noundef 1) #[[ATTR6]]
+; CHECK-NEXT: ret float [[CALL]]
+;
+ %call = call float @llvm.powi.f32.i32(float %arg0, i32 1)
+ ret float %call
+}
+
+define float @ret_powi_f32_normal_exp_neg_one(float nofpclass(inf zero sub) %arg0) #0 {
+; CHECK-LABEL: define nofpclass(inf) float @ret_powi_f32_normal_exp_neg_one
+; CHECK-SAME: (float nofpclass(inf zero sub) [[ARG0:%.*]]) #[[ATTR1]] {
+; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(inf) float @llvm.powi.f32.i32(float nofpclass(inf zero sub) [[ARG0]], i32 noundef -1) #[[ATTR6]]
+; CHECK-NEXT: ret float [[CALL]]
+;
+ %call = call float @llvm.powi.f32.i32(float %arg0, i32 -1)
+ ret float %call
+}
+
+define float @ret_powi_f32_inf_or_nan_exp_neg_one(float nofpclass(zero norm sub) %arg0) #0 {
+; CHECK-LABEL: define nofpclass(inf) float @ret_powi_f32_inf_or_nan_exp_neg_one
+; CHECK-SAME: (float nofpclass(zero sub norm) [[ARG0:%.*]]) #[[ATTR1]] {
+; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(inf) float @llvm.powi.f32.i32(float nofpclass(zero sub norm) [[ARG0]], i32 noundef -1) #[[ATTR6]]
+; CHECK-NEXT: ret float [[CALL]]
+;
+ %call = call float @llvm.powi.f32.i32(float %arg0, i32 -1)
+ ret float %call
+}
+
+define float @ret_powi_f32_zero_or_nan_exp_nonnegative(float nofpclass(inf norm sub) %arg0, i32 %arg1) #0 {
+; CHECK-LABEL: define nofpclass(inf) float @ret_powi_f32_zero_or_nan_exp_nonnegative
+; CHECK-SAME: (float nofpclass(inf sub norm) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR1]] {
+; CHECK-NEXT: [[NONNEG:%.*]] = and i32 [[ARG1]], 2147483647
+; CHECK-NEXT: [[CALL:%.*]] = call nofpclass(inf) float @llvm.powi.f32.i32(float nofpclass(inf sub norm) [[ARG0]], i32 [[NONNEG]]) #[[ATTR6]]
+; CHECK-NEXT: ret float [[CALL]]
+;
+ %nonneg = and i32 %arg1, 2147483647
+ %call = call float @llvm.powi.f32.i32(float %arg0, i32 %nonneg)
+ ret float %call
+}
+
define float @ret_powi_f32_no_nan_inf(float nofpclass(nan inf) %arg0, i32 %arg1) #0 {
; CHECK-LABEL: define nofpclass(nan) float @ret_powi_f32_no_nan_inf
; CHECK-SAME: (float nofpclass(nan inf) [[ARG0:%.*]], i32 [[ARG1:%.*]]) #[[ATTR1]] {
diff --git a/llvm/unittests/Analysis/ValueTrackingTest.cpp b/llvm/unittests/Analysis/ValueTrackingTest.cpp
index de481e39307cb..1d3c9a2724c45 100644
--- a/llvm/unittests/Analysis/ValueTrackingTest.cpp
+++ b/llvm/unittests/Analysis/ValueTrackingTest.cpp
@@ -1913,6 +1913,74 @@ TEST_F(ComputeKnownFPClassTest, MaximumNumSignBit) {
expectKnownFPClass(fcPositive, false, A7);
}
+TEST_F(ComputeKnownFPClassTest, PowiInfFirst) {
+ parseAssembly(
+ "declare float @llvm.powi.f32.i32(float, i32)\n"
+ "define float @test(i1 %cond, i32 %x, float %unknown,\n"
+ " float nofpclass(inf) %finite,\n"
+ " float nofpclass(zero sub inf) %normal,\n"
+ " float nofpclass(zero inf) %finite.may.sub,\n"
+ " float nofpclass(inf norm sub) %zero.or.nan) {\n"
+ " %small = zext i1 %cond to i32\n"
+ " %nonneg = and i32 %x, 2147483647\n"
+ " %A = call float @llvm.powi.f32.i32(float %finite, i32 1)\n"
+ " %A2 = call float @llvm.powi.f32.i32(float %finite, i32 2)\n"
+ " %A3 = call float @llvm.powi.f32.i32(float %normal, i32 -1)\n"
+ " %A4 = call float @llvm.powi.f32.i32(float %finite, i32 %small)\n"
+ " %A5 = call float @llvm.powi.f32.i32(float %unknown, i32 %small)\n"
+ " %A6 = call float @llvm.powi.f32.i32(float %finite.may.sub, i32 -1)\n"
+ " %A7 = call float @llvm.powi.f32.i32(float %zero.or.nan, i32 %nonneg)\n"
+ " ret float %A\n"
+ "}\n");
+ expectKnownFPClass(~fcInf, std::nullopt, A);
+ expectKnownFPClass(fcPositive | fcNan, std::nullopt, A2);
+ expectKnownFPClass(~fcInf, std::nullopt, A3);
+ expectKnownFPClass(~fcInf, std::nullopt, A4);
+ expectKnownFPClass(fcAllFlags, std::nullopt, A5);
+ expectKnownFPClass(fcAllFlags, std::nullopt, A6);
+ expectKnownFPClass(~fcInf, std::nullopt, A7);
+
+ auto ExpectKnownNeverInf = [&](Instruction *I, bool Expected) {
+ KnownFPClass Known = computeKnownFPClass(I, M->getDataLayout(), fcInf);
+ EXPECT_EQ(Expected, Known.isKnownNeverInfinity());
+ };
+
+ ExpectKnownNeverInf(A, true);
+ ExpectKnownNeverInf(A2, false);
+ ExpectKnownNeverInf(A3, true);
+ ExpectKnownNeverInf(A4, true);
+ ExpectKnownNeverInf(A5, false);
+ ExpectKnownNeverInf(A6, false);
+ ExpectKnownNeverInf(A7, true);
+}
+
+TEST_F(ComputeKnownFPClassTest, PowiInfSecond) {
+ parseAssembly(
+ "declare float @llvm.powi.f32.i32(float, i32)\n"
+ "define float @test(i32 %x, float %unknown,\n"
+ " float nofpclass(inf) %finite,\n"
+ " float nofpclass(inf norm sub) %zero.or.nan,\n"
+ " float nofpclass(zero norm sub) %inf.or.nan) {\n"
+ " %neg = or i32 %x, -2147483648\n"
+ " %nonneg = and i32 %x, 2147483647\n"
+ " %A = call float @llvm.powi.f32.i32(float %unknown, i32 0)\n"
+ " %A2 = call float @llvm.powi.f32.i32(float %finite, i32 -2)\n"
+ " %A3 = call float @llvm.powi.f32.i32(float %zero.or.nan, i32 -1)\n"
+ " %A4 = call float @llvm.powi.f32.i32(float %inf.or.nan, i32 -1)\n"
+ " %A5 = call float @llvm.powi.f32.i32(float %inf.or.nan, i32 %neg)\n"
+ " %A6 = call float @llvm.powi.f32.i32(float %finite, i32 %nonneg)\n"
+ " %A7 = call float @llvm.powi.f32.i32(float %zero.or.nan, i32 %neg)\n"
+ " ret float %A\n"
+ "}\n");
+ expectKnownFPClass(fcPosNormal | fcNan, std::nullopt, A);
+ expectKnownFPClass(fcPositive | fcNan, std::nullopt, A2);
+ expectKnownFPClass(fcAllFlags, std::nullopt, A3);
+ expectKnownFPClass(~fcInf, std::nullopt, A4);
+ expectKnownFPClass(~fcInf, std::nullopt, A5);
+ expectKnownFPClass(fcAllFlags, std::nullopt, A6);
+ expectKnownFPClass(fcAllFlags, std::nullopt, A7);
+}
+
TEST_F(ComputeKnownFPClassTest, Phi) {
parseAssembly(
"define float @test(i1 %cond, float nofpclass(nan inf) %arg0, float nofpclass(nan) %arg1) {\n"
``````````
</details>
https://github.com/llvm/llvm-project/pull/191736
More information about the llvm-commits
mailing list