[SimplifyLibCalls] Support pow(x, -0.5) in replacePowWithSqrt without NSZ/noInfs.

[fhahn]

Summary

This patch enables the following expansion in replacePowWithSqrt:

pow(x, -0.5) to (x == -infinity ? +0.0 : fabs(1/sqrt(x)))

I am not entirely sure about handling x == +-0.0, as it seems like different
implementations treat it differently. E.g. on Linux

If x is +0 or -0, and y is less than 0 and not an odd integer, a pole error
occurs and +HUGE_VAL, +HUGE_VALF, or +HUGE_VALL, is returned.

On MacOS

pow(+-0, y) returns +infinity and raises the "divide-by-zero" floating-point
exception for y < 0 and not an odd integer.

So on MacOS we should do the right thing and return +infinity for both
+0 and -0, but on Linux we should actually return +HUGE_VAL.

[paulwalker-arm]

There is this nugget from the C documentation:

HUGE_VALF, HUGE_VAL, HUGE_VALL: On implementations that support floating-point infinities, these macros always expand to the positive infinities of float, double, and long double, respectively.

[evandro]

Can you please rebase it, for D50036 touched the same function?

lib/Transforms/Utils/SimplifyLibCalls.cpp

1228

This one and the line below could be shared with the else clause.

[fhahn]

In D50900#1204646, @evandro wrote:

Can you please rebase it, for D50036 touched the same function?

Will do, thanks!

We were also thinking about expanding pow(x, n+0.5) -> x * x * x * ... * sqrt(x). Is this something you have also planned on adding?

[evandro]

In D50900#1204771, @fhahn wrote:

We were also thinking about expanding pow(x, n+0.5) -> x * x * x * ... * sqrt(x). Is this something you have also planned on adding?

No, I don't think that we'll repeat ourselves on this one. LOL Go ahead.

[fhahn]

Looks like we do not need this after D50036, because 1/+inf gets folded to +0.

lib/Transforms/Utils/SimplifyLibCalls.cpp

Value *LibCallSimplifier::replacePowWithSqrt(CallInst *Pow, IRBuilder<> &B) {
   Value *Sqrt, *Base = Pow->getArgOperand(0), *Expo = Pow->getArgOperand(1);
   Type *Ty = Pow->getType();
 
   const APFloat *ExpoF;
   if (!match(Expo, m_APFloat(ExpoF)) ||
       (!ExpoF->isExactlyValue(0.5) && !ExpoF->isExactlyValue(-0.5)))
     return nullptr;
 
-  if (ExpoF->isExactlyValue(-0.5) &&
-      (!Pow->hasNoSignedZeros() || !Pow->hasNoInfs()))
-    return nullptr;
-
   // If errno is never set, then use the intrinsic for sqrt().
   if (Pow->hasFnAttr(Attribute::ReadNone)) {
     Function *SqrtFn = Intrinsic::getDeclaration(Pow->getModule(),
                                                  Intrinsic::sqrt, Ty);
     Sqrt = B.CreateCall(SqrtFn, Base);
   }
   // Otherwise, use the libcall for sqrt().
   else if (hasUnaryFloatFn(TLI, Ty, LibFunc_sqrt, LibFunc_sqrtf, LibFunc_sqrtl))
     // TODO: We also should check that the target can in fact lower the sqrt()
     // libcall. We currently have no way to ask this question, so we ask if
     // the target has a sqrt() libcall, which is not exactly the same.
     Sqrt = emitUnaryFloatFnCall(Base, TLI->getName(LibFunc_sqrt), B,
                                 Pow->getCalledFunction()->getAttributes());
   else
     return nullptr;
 
   // If the exponent is negative, then get the reciprocal.
   if (ExpoF->isNegative())
     Sqrt = B.CreateFDiv(ConstantFP::get(Ty, 1.0), Sqrt, "reciprocal");
 
-  // Deal with x == -0. We expand pow(x, 0.5/-0.5) to fabs(sqrt(x)|1/sqrt(x)).
-  // This is faster than calling pow(), and still handles -0 correctly.
+  // Deal with x == -0.0. We expand pow(x, 0.5|-0.5) to fabs(sqrt(x)|1/sqrt(x)).
+  // This is faster than calling pow(), and still handles -0.0 correctly.
   if (!Pow->hasNoSignedZeros()) {
     Function *FAbsFn =
         Intrinsic::getDeclaration(Pow->getModule(), Intrinsic::fabs, Ty);
     Sqrt = B.CreateCall(FAbsFn, Sqrt, "abs");
   }
 
   // Deal with x == -infinity. We expand
   //  * pow(x, 0.5) to (x == -infinity ? +infinity : Sqrt))
+  //  * pow(x, -0.5) to (x == -infinity ? +0.0 : Sqrt))
   // This is faster than calling pow(), and still handles negative infinity
   // correctly.
   if (!Pow->hasNoInfs()) {
     Value *NegInf = ConstantFP::getInfinity(Ty, true);
+    if (ExpoF->isNegative()) {
+      Value *PositiveZero = ConstantFP::get(Ty, 0.0);
+      Value *FCmp = B.CreateFCmpOEQ(Base, NegInf);
+      Sqrt = B.CreateSelect(FCmp, PositiveZero, Sqrt);
+    } else {
       Value *PosInf = ConstantFP::getInfinity(Ty);
       Value *FCmp = B.CreateFCmpOEQ(Base, NegInf, "isinf");
       Sqrt = B.CreateSelect(FCmp, PosInf, Sqrt);
     }
+  }
   return Sqrt;
 }
 
 Value *LibCallSimplifier::optimizePow(CallInst *Pow, IRBuilder<> &B) {
   Value *Base = Pow->getArgOperand(0), *Expo = Pow->getArgOperand(1);
   Function *Callee = Pow->getCalledFunction();
   AttributeList Attrs = Callee->getAttributes();
   StringRef Name = Callee->getName();

test/Transforms/InstCombine/pow-sqrt.ll

 ; CHECK-LABEL: @pow_intrinsic_half_fast(
 ; CHECK-NEXT:    [[TMP1:%.*]] = call fast double @llvm.sqrt.f64(double [[X:%.*]])
 ; CHECK-NEXT:    ret double [[TMP1]]
 ;
   %pow = call fast double @llvm.pow.f64(double %x, double 5.0e-01)
   ret double %pow
 }
 
-; FIXME:
 ; -0.5 means take the reciprocal.
 
 define float @pow_libcall_neghalf_no_FMF(float %x) {
 ; CHECK-LABEL: @pow_libcall_neghalf_no_FMF(
-; CHECK-NEXT:    [[POW:%.*]] = call float @powf(float [[X:%.*]], float -5.000000e-01)
-; CHECK-NEXT:    ret float [[POW]]
+; CHECK-NEXT:    [[SQRTF:%.*]] = call float @sqrtf(float [[X:%.*]])
+; CHECK-NEXT:    [[RECIPROCAL:%.*]] = fdiv float 1.000000e+00, [[SQRTF]]
+; CHECK-NEXT:    [[ABS:%.*]] = call float @llvm.fabs.f32(float [[RECIPROCAL]])
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp oeq float [[X]], 0xFFF0000000000000
+; CHECK-NEXT:    [[TMP2:%.*]] = select i1 [[TMP1]], float 0.000000e+00, float [[ABS]]
+; CHECK-NEXT:    ret float [[TMP2]]
 ;
   %pow = call float @powf(float %x, float -5.0e-01)
   ret float %pow
 }
 
-; FIXME:
-
 define <2 x double> @pow_intrinsic_neghalf_no_FMF(<2 x double> %x) {
 ; CHECK-LABEL: @pow_intrinsic_neghalf_no_FMF(
-; CHECK-NEXT:    [[POW:%.*]] = call <2 x double> @llvm.pow.v2f64(<2 x double> [[X:%.*]], <2 x double> <double -5.000000e-01, double -5.000000e-01>)
-; CHECK-NEXT:    ret <2 x double> [[POW]]
+; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x double> @llvm.sqrt.v2f64(<2 x double> [[X:%.*]])
+; CHECK-NEXT:    [[RECIPROCAL:%.*]] = fdiv <2 x double> <double 1.000000e+00, double 1.000000e+00>, [[TMP1]]
+; CHECK-NEXT:    [[ABS:%.*]] = call <2 x double> @llvm.fabs.v2f64(<2 x double> [[RECIPROCAL]])
+; CHECK-NEXT:    [[TMP2:%.*]] = fcmp oeq <2 x double> [[X]], <double 0xFFF0000000000000, double 0xFFF0000000000000>
+; CHECK-NEXT:    [[TMP3:%.*]] = select <2 x i1> [[TMP2]], <2 x double> zeroinitializer, <2 x double> [[ABS]]
+; CHECK-NEXT:    ret <2 x double> [[TMP3]]
 ;
   %pow = call <2 x double> @llvm.pow.v2f64(<2 x double> %x, <2 x double> <double -5.0e-01, double -5.0e-01>)
   ret <2 x double> %pow
 }
 
-; FIXME:
 ; If we can disregard INFs, no need for a select.
 
 define double @pow_libcall_neghalf_ninf(double %x) {
 ; CHECK-LABEL: @pow_libcall_neghalf_ninf(
-; CHECK-NEXT:    [[POW:%.*]] = call ninf double @pow(double [[X:%.*]], double -5.000000e-01)
-; CHECK-NEXT:    ret double [[POW]]
+; CHECK-NEXT:    [[SQRT:%.*]] = call ninf double @sqrt(double [[X:%.*]])
+; CHECK-NEXT:    [[RECIPROCAL:%.*]] = fdiv ninf double 1.000000e+00, [[SQRT]]
+; CHECK-NEXT:    [[ABS:%.*]] = call ninf double @llvm.fabs.f64(double [[RECIPROCAL]])
+; CHECK-NEXT:    ret double [[ABS]]
 ;
   %pow = call ninf double @pow(double %x, double -5.0e-01)
   ret double %pow
 }
 
-; FIXME:
-
 define <2 x double> @pow_intrinsic_neghalf_ninf(<2 x double> %x) {
 ; CHECK-LABEL: @pow_intrinsic_neghalf_ninf(
-; CHECK-NEXT:    [[POW:%.*]] = call ninf <2 x double> @llvm.pow.v2f64(<2 x double> [[X:%.*]], <2 x double> <double -5.000000e-01, double -5.000000e-01>)
-; CHECK-NEXT:    ret <2 x double> [[POW]]
+; CHECK-NEXT:    [[TMP1:%.*]] = call ninf <2 x double> @llvm.sqrt.v2f64(<2 x double> [[X:%.*]])
+; CHECK-NEXT:    [[RECIPROCAL:%.*]] = fdiv ninf <2 x double> <double 1.000000e+00, double 1.000000e+00>, [[TMP1]]
+; CHECK-NEXT:    [[ABS:%.*]] = call ninf <2 x double> @llvm.fabs.v2f64(<2 x double> [[RECIPROCAL]])
+; CHECK-NEXT:    ret <2 x double> [[ABS]]
 ;
   %pow = call ninf <2 x double> @llvm.pow.v2f64(<2 x double> %x, <2 x double> <double -5.0e-01, double -5.0e-01>)
   ret <2 x double> %pow
 }
 
-; FIXME:
-; If we can disregard -0.0, no need for fabs.
-
 define double @pow_libcall_neghalf_nsz(double %x) {
 ; CHECK-LABEL: @pow_libcall_neghalf_nsz(
-; CHECK-NEXT:    [[POW:%.*]] = call nsz double @pow(double [[X:%.*]], double -5.000000e-01)
-; CHECK-NEXT:    ret double [[POW]]
+; CHECK-NEXT:    [[SQRT:%.*]] = call nsz double @sqrt(double [[X:%.*]])
+; CHECK-NEXT:    [[RECIPROCAL:%.*]] = fdiv nsz double 1.000000e+00, [[SQRT]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp nsz oeq double [[X]], 0xFFF0000000000000
+; CHECK-NEXT:    [[TMP2:%.*]] = select i1 [[TMP1]], double 0.000000e+00, double [[RECIPROCAL]]
+; CHECK-NEXT:    ret double [[TMP2]]
 ;
   %pow = call nsz double @pow(double %x, double -5.0e-01)
   ret double %pow
 }
 
-; FIXME:
-
 define double @pow_intrinsic_neghalf_nsz(double %x) {
 ; CHECK-LABEL: @pow_intrinsic_neghalf_nsz(
-; CHECK-NEXT:    [[POW:%.*]] = call nsz double @llvm.pow.f64(double [[X:%.*]], double -5.000000e-01)
-; CHECK-NEXT:    ret double [[POW]]
+; CHECK-NEXT:    [[TMP1:%.*]] = call nsz double @llvm.sqrt.f64(double [[X:%.*]])
+; CHECK-NEXT:    [[RECIPROCAL:%.*]] = fdiv nsz double 1.000000e+00, [[TMP1]]
+; CHECK-NEXT:    [[TMP2:%.*]] = fcmp nsz oeq double [[X]], 0xFFF0000000000000
+; CHECK-NEXT:    [[TMP3:%.*]] = select i1 [[TMP2]], double 0.000000e+00, double [[RECIPROCAL]]
+; CHECK-NEXT:    ret double [[TMP3]]
 ;
   %pow = call nsz double @llvm.pow.f64(double %x, double -5.0e-01)
   ret double %pow
 }
 
 ; This is just recip-sqrt.
 
 define double @pow_intrinsic_neghalf_ninf_nsz(double %x) {