SimplifyLibCalls: Remove checks for fabs

[arsenm]

Summary

Use the intrinsic instead of emitting the libcall which
will be replaced by the intrinsic.

There are some additional places using this like ConstantFolding that may want to stay

[davide]

lib/Transforms/Utils/SimplifyLibCalls.cpp

1100–1103

You can fold Callee->getParent() as the first argument of getDeclaration because it has only one use, no?

[arsenm]

lib/Transforms/Utils/SimplifyLibCalls.cpp

1100–1103

I usually prefer always using variables to avoid uglier line wraps

[davide]

I expected
define float @test_simplify7(float %x) {
in InstCombine/pow-1.ll to be updated, does it still pass?

[arsenm]

In D28453#639173, @davide wrote:

I expected
define float @test_simplify7(float %x) {
in InstCombine/pow-1.ll to be updated, does it still pass?

The same change is done in D28405 since the call is later replaced

[efriedma]

LGTM with a minor tweak.

There are some additional places using this like ConstantFolding that may want to stay

I don't see why this would be worth keeping. instcombine will transform fabs(const)->llvm.fabs(const)->const.

test/Transforms/InstCombine/win-math.ll

277

Update this comment to reflect the fact that we aren't calling fabsf?

[arsenm]

r292176

lib/Transforms/Utils/SimplifyLibCalls.cpp

Value *LibCallSimplifier::optimizePow(CallInst *CI, IRBuilder<> &B) {
   if (!Op2C)
     return Ret;
 
   if (Op2C->getValueAPF().isZero()) // pow(x, 0.0) -> 1.0
     return ConstantFP::get(CI->getType(), 1.0);
 
   if (Op2C->isExactlyValue(0.5) &&
       hasUnaryFloatFn(TLI, Op2->getType(), LibFunc::sqrt, LibFunc::sqrtf,
-                      LibFunc::sqrtl) &&
-      hasUnaryFloatFn(TLI, Op2->getType(), LibFunc::fabs, LibFunc::fabsf,
-                      LibFunc::fabsl)) {
+                      LibFunc::sqrtl)) {
 
     // In -ffast-math, pow(x, 0.5) -> sqrt(x).
     if (CI->hasUnsafeAlgebra()) {
       IRBuilder<>::FastMathFlagGuard Guard(B);
       B.setFastMathFlags(CI->getFastMathFlags());
 
       // Unlike other math intrinsics, sqrt has differerent semantics
       // from the libc function. See LangRef for details.
       return emitUnaryFloatFnCall(Op1, TLI->getName(LibFunc::sqrt), B,
                                   Callee->getAttributes());
     }
 
     // Expand pow(x, 0.5) to (x == -infinity ? +infinity : fabs(sqrt(x))).
     // This is faster than calling pow, and still handles negative zero
     // and negative infinity correctly.
     // TODO: In finite-only mode, this could be just fabs(sqrt(x)).
     Value *Inf = ConstantFP::getInfinity(CI->getType());
     Value *NegInf = ConstantFP::getInfinity(CI->getType(), true);
     Value *Sqrt = emitUnaryFloatFnCall(Op1, "sqrt", B, Callee->getAttributes());
-    Value *FAbs =
-        emitUnaryFloatFnCall(Sqrt, "fabs", B, Callee->getAttributes());
+
+    Module *M = Callee->getParent();
+    Function *FabsF = Intrinsic::getDeclaration(M, Intrinsic::fabs,
+                                                CI->getType());
+    Value *FAbs = B.CreateCall(FabsF, Sqrt);
+
     Value *FCmp = B.CreateFCmpOEQ(Op1, NegInf);
     Value *Sel = B.CreateSelect(FCmp, Inf, FAbs);
     return Sel;
   }
 
   if (Op2C->isExactlyValue(1.0)) // pow(x, 1.0) -> x
     return Op1;
   if (Op2C->isExactlyValue(2.0)) // pow(x, 2.0) -> x*x

test/Transforms/InstCombine/win-math.ll

 ; MINGW64-NOT: double @round
     %1 = fpext float %x to double
     %2 = call double @round(double %1)
     %3 = fptrunc double %2 to float
     ret float %3
 }
 
 declare float @powf(float, float)
 ; win32 lacks sqrtf&fabsf, win64 lacks fabsf
 define float @float_powsqrt(float %x) nounwind readnone {
 ; WIN32-LABEL: @float_powsqrt(
 ; WIN32-NOT: float @sqrtf
 ; WIN32: float @powf
+
 ; WIN64-LABEL: @float_powsqrt(
-; WIN64-NOT: float @sqrtf
-; WIN64: float @powf
+; WIN64: float @sqrtf
+; WIN64: float @llvm.fabs.f32(
+; WIN64-NOT: float @powf
+
 ; MINGW32-LABEL: @float_powsqrt(
 ; MINGW32: float @sqrtf
 ; MINGW32: float @llvm.fabs.f32
 ; MINGW32-NOT: float @powf
 ; MINGW64-LABEL: @float_powsqrt(
 ; MINGW64: float @sqrtf
 ; MINGW64: float @llvm.fabs.f32(
 ; MINGW64-NOT: float @powf
     %1 = call float @powf(float %x, float 0.5)
     ret float %1
 }