[InstCombine] Remove hasNoInfs check for pow(C,y) -> exp2(log2(C)*y)

[foad]

Summary

We already check hasNoNaNs and that x is finite and strictly positive.
That only leaves the following special cases (taken from the Linux man
page for pow):

If the absolute value of x is less than 1, and y is negative infinity, the result is positive infinity.
If the absolute value of x is greater than 1, and y is negative infinity, the result is +0.
If the absolute value of x is less than 1, and y is positive infinity, the result is +0.
If the absolute value of x is greater than 1, and y is positive infinity, the result is positive infinity.

The transformation preserves all of these, so there is no need to limit
it to hasNoInfs.

[evandro]

pow(∞, y) → 0 if y < 0 or ∞ if y > 0
exp2(log2(∞) * y) → exp2(∞ * y) → exp2(∞) → 0 if y < 0 or ∞ if y > 0

[foad]

In D79409#2023511, @evandro wrote:

pow(∞, y) → 0 if y < 0 or ∞ if y > 0
exp2(log2(∞) * y) → exp2(∞ * y) → exp2(∞) → 0 if y < 0 or ∞ if y > 0

We check that x is a finite constant before doing the transformation. It's only y that could be infinite.

[evandro]

pow(x, -∞) → ∞ if |x| < 1 or 0 if |x| > 1
pow(x, +∞) → 0 if |x| < 1 or ∞ if |x| > 1
exp2(log2(x) * -∞) → exp2(±∞) → ∞ if x < 2 or 0 if x > 2
exp2(log2(x) * +∞) → exp2(±∞) → 0 if x < 2 or ∞ if x > 2

[foad]

In D79409#2023671, @evandro wrote:

exp2(log2(x) * -∞) → exp2(±∞) → ∞ if x < 2 or 0 if x > 2
exp2(log2(x) * +∞) → exp2(±∞) → 0 if x < 2 or ∞ if x > 2

No, the sign of log2(x) depends on whether x is less or greater than 1, not less or greater than 2.

[evandro]

In D79409#2023674, @foad wrote:

No, the sign of log2(x) depends on whether x is less or greater than 1, not less or greater than 2.

You're right.

pow(x, -∞) → ∞ if x < 1 or 0 if x > 1
pow(x, +∞) → 0 if x < 1 or ∞ if x > 1

exp2(log2(x) * -∞) → exp2(±∞) → ∞ if x < 1 or 0 if x > 1
exp2(log2(x) * +∞) → exp2(±∞) → 0 if x < 1 or ∞ if x > 1

Therefore the identity holds.

[foad]

Thanks for the careful checking. Actually there is one problematic case:
pow(1, ±∞) → 1
exp2(log2(1) * ±∞) → exp2(0 * ±∞) → exp2(NaN) → NaN
I guess we never hit this case in practice because it will have been simplified elsewhere, but I will add something to the patch to handle it.

[foad]

Rebase. Check for x == 1.

[spatel]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

1690–1691

There's no way for Base to be 1.0 after here, so we can use an assert rather than 'if' clause in the new code.

[foad]

Assert.

[foad]

Fix silly mistake in last revision.

[evandro]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

1569

This comment makes more sense immediately before the assert(). Personally, it could also be shorter.

[foad]

Move and shorten the comment.

[foad]

Ping!

[spatel]

LGTM

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

Value *LibCallSimplifier::replacePowWithExp(CallInst *Pow, IRBuilderBase &B) {
 
   // pow(10.0, x) -> exp10(x)
   // TODO: There is no exp10() intrinsic yet, but some day there shall be one.
   if (match(Base, m_SpecificFP(10.0)) &&
       hasFloatFn(TLI, Ty, LibFunc_exp10, LibFunc_exp10f, LibFunc_exp10l))
     return emitUnaryFloatFnCall(Expo, TLI, LibFunc_exp10, LibFunc_exp10f,
                                 LibFunc_exp10l, B, Attrs);
 
-  // pow(n, x) -> exp2(log2(n) * x)
-  if (Pow->hasApproxFunc() && Pow->hasNoNaNs() && Pow->hasNoInfs() &&
-      BaseF->isFiniteNonZero() && !BaseF->isNegative()) {
-    Value *Log = nullptr;
+  // pow(x, y) -> exp2(log2(x) * y)
+  // We can do this transformation for any positive finite n except 1.0, because
+  // pow has this behaviour:
+  //   If x is +1, the result is 1.0 (even if y is a NaN).
+  // which is hard to preserve if y might be infinite or NaN.
+  if (Pow->hasApproxFunc() && Pow->hasNoNaNs() && BaseF->isFiniteNonZero() &&
+      !BaseF->isNegative()) {
+    assert(!match(Base, m_FPOne()) &&
+           "pow(1.0, y) should have been simplified earlier!");
+
     if (Ty->isFloatTy())
       Log = ConstantFP::get(Ty, std::log2(BaseF->convertToFloat()));
     else if (Ty->isDoubleTy())
       Log = ConstantFP::get(Ty, std::log2(BaseF->convertToDouble()));
 
     if (Log) {
       Value *FMul = B.CreateFMul(Log, Expo, "mul");
       if (Pow->doesNotAccessMemory())
Value *LibCallSimplifier::optimizePow(CallInst *Pow, IRBuilderBase &B) {
   // unless the result is expected to be double precision.
   if (UnsafeFPShrink && Name == TLI->getName(LibFunc_pow) &&
       hasFloatVersion(Name))
     Shrunk = optimizeBinaryDoubleFP(Pow, B, true);
 
   // Evaluate special cases related to the base.
 
   // pow(1.0, x) -> 1.0
   if (match(Base, m_FPOne()))
     return Base;
 
   if (Value *Exp = replacePowWithExp(Pow, B))
     return Exp;
 
   // Evaluate special cases related to the exponent.
 
   // pow(x, -1.0) -> 1.0 / x
   if (match(Expo, m_SpecificFP(-1.0)))

llvm/test/Transforms/InstCombine/pow-exp.ll

 ; CHECK-NEXT:    ret double [[CALL]]
 ;
   %call = tail call afn ninf double @pow(double 0x3FE6666666666666, double %e)
   ret double %call
 }
 
 define double @pow_ok_base_no_ninf(double %e) {
 ; CHECK-LABEL: @pow_ok_base_no_ninf(
-; CHECK-NEXT:    [[CALL:%.*]] = tail call nnan afn double @pow(double 0x3FE6666666666666, double [[E:%.*]])
-; CHECK-NEXT:    ret double [[CALL]]
+; CHECK-NEXT:    [[MUL:%.*]] = fmul nnan afn double [[E:%.*]], 0xBFE0776{{.*}}
+; CHECK-NEXT:    [[EXP2:%.*]] = call nnan afn double @exp2(double [[MUL]])
+; CHECK-NEXT:    ret double [[EXP2]]
 ;
   %call = tail call afn nnan double @pow(double 0x3FE6666666666666, double %e)
   ret double %call
 }
 
 define float @powf_zero_base(float %e) {
 ; CHECK-LABEL: @powf_zero_base(
 ; CHECK-NEXT:    [[CALL:%.*]] = tail call nnan ninf afn float @powf(float 0.000000e+00, float [[E:%.*]])