[SimplifyLibCall] Inline calls to cabs when it's safe to do so.

[paulwalker-arm]

Summary

When unsafe algerbra is allowed calls to cabs(r) can be replaced by:

sqrt(creal(r)*creal(r) + cimag(r)*cimag(r))

[hfinkel]

LGTM.

At least on PowerPC, the signature is simply two arguments:

declare double @cabs(double, double)
declare float @cabsf(float, float)
declare ppc_fp128 @cabsl(ppc_fp128, ppc_fp128)

If you could add support for that signature as well, that would be much appreciated.

[paulwalker-arm]

Adds support for versions of cabs that take discrete real and imaginary parameters.

[hfinkel]

Thanks!

[hfinkel]

Do you have commit access?

[paulwalker-arm]

Not yet.

[fhahn]

I can commit this for you Paul, but I think you can request commit access now ;)

include/llvm/Analysis/TargetLibraryInfo.def

 TLI_DEFINE_ENUM_INTERNAL(bcmp)
 TLI_DEFINE_STRING_INTERNAL("bcmp")
 /// void bcopy(const void *s1, void *s2, size_t n);
 TLI_DEFINE_ENUM_INTERNAL(bcopy)
 TLI_DEFINE_STRING_INTERNAL("bcopy")
 /// void bzero(void *s, size_t n);
 TLI_DEFINE_ENUM_INTERNAL(bzero)
 TLI_DEFINE_STRING_INTERNAL("bzero")
+/// double cabs(double complex z)
+TLI_DEFINE_ENUM_INTERNAL(cabs)
+TLI_DEFINE_STRING_INTERNAL("cabs")
+/// float cabs(float complex z)
+TLI_DEFINE_ENUM_INTERNAL(cabsf)
+TLI_DEFINE_STRING_INTERNAL("cabsf")
+/// long double cabs(long double complex z)
+TLI_DEFINE_ENUM_INTERNAL(cabsl)
+TLI_DEFINE_STRING_INTERNAL("cabsl")
 /// void *calloc(size_t count, size_t size);
 TLI_DEFINE_ENUM_INTERNAL(calloc)
 TLI_DEFINE_STRING_INTERNAL("calloc")
 /// double cbrt(double x);
 TLI_DEFINE_ENUM_INTERNAL(cbrt)
 TLI_DEFINE_STRING_INTERNAL("cbrt")
 /// float cbrtf(float x);
 TLI_DEFINE_ENUM_INTERNAL(cbrtf)

include/llvm/Transforms/Utils/SimplifyLibCalls.h

private:
   Value *optimizeMemCpy(CallInst *CI, IRBuilder<> &B);
   Value *optimizeMemMove(CallInst *CI, IRBuilder<> &B);
   Value *optimizeMemSet(CallInst *CI, IRBuilder<> &B);
   Value *optimizeWcslen(CallInst *CI, IRBuilder<> &B);
   // Wrapper for all String/Memory Library Call Optimizations
   Value *optimizeStringMemoryLibCall(CallInst *CI, IRBuilder<> &B);
 
   // Math Library Optimizations
+  Value *optimizeCAbs(CallInst *CI, IRBuilder<> &B);
   Value *optimizeCos(CallInst *CI, IRBuilder<> &B);
   Value *optimizePow(CallInst *CI, IRBuilder<> &B);
   Value *optimizeExp2(CallInst *CI, IRBuilder<> &B);
   Value *optimizeFMinFMax(CallInst *CI, IRBuilder<> &B);
   Value *optimizeLog(CallInst *CI, IRBuilder<> &B);
   Value *optimizeSqrt(CallInst *CI, IRBuilder<> &B);
   Value *optimizeSinCosPi(CallInst *CI, IRBuilder<> &B);
   Value *optimizeTan(CallInst *CI, IRBuilder<> &B);

lib/Analysis/TargetLibraryInfo.cpp

if (T.isOSWindows() && !T.isOSCygMing()) {
     TLI.setUnavailable(LibFunc_acoshf);
     TLI.setUnavailable(LibFunc_acoshl);
     TLI.setUnavailable(LibFunc_asinh);
     TLI.setUnavailable(LibFunc_asinhf);
     TLI.setUnavailable(LibFunc_asinhl);
     TLI.setUnavailable(LibFunc_atanh);
     TLI.setUnavailable(LibFunc_atanhf);
     TLI.setUnavailable(LibFunc_atanhl);
+    TLI.setUnavailable(LibFunc_cabs);
+    TLI.setUnavailable(LibFunc_cabsf);
+    TLI.setUnavailable(LibFunc_cabsl);
     TLI.setUnavailable(LibFunc_cbrt);
     TLI.setUnavailable(LibFunc_cbrtf);
     TLI.setUnavailable(LibFunc_cbrtl);
     TLI.setUnavailable(LibFunc_exp2);
     TLI.setUnavailable(LibFunc_exp2f);
     TLI.setUnavailable(LibFunc_exp2l);
     TLI.setUnavailable(LibFunc_expm1);
     TLI.setUnavailable(LibFunc_expm1f);
case LibFunc_posix_memalign:
     return (NumParams == 3 && FTy.getReturnType()->isIntegerTy(32) &&
             FTy.getParamType(0)->isPointerTy() &&
             FTy.getParamType(1) == SizeTTy && FTy.getParamType(2) == SizeTTy);
 
   case LibFunc_wcslen:
     return (NumParams == 1 && FTy.getParamType(0)->isPointerTy() &&
             FTy.getReturnType()->isIntegerTy());
 
+  case LibFunc_cabs:
+  case LibFunc_cabsf:
+  case LibFunc_cabsl:
+    // NOTE: These prototypes are target specific and currently only supports
+    // "complex" being passed as an array. Add other calling conventions as
+    // necessary to take advantage of libcall optimizations.
+    return (NumParams == 1 &&
+            FTy.getParamType(0)->isArrayTy() &&
+            FTy.getParamType(0)->getArrayNumElements() == 2 &&
+            FTy.getReturnType() == FTy.getParamType(0)->getArrayElementType() &&
+            FTy.getReturnType()->isFloatingPointTy());
+
   case LibFunc::NumLibFuncs:
     break;
   }
 
   llvm_unreachable("Invalid libfunc");
 }
 
 bool TargetLibraryInfoImpl::getLibFunc(const Function &FDecl,

lib/Transforms/Utils/SimplifyLibCalls.cpp

static Value *optimizeBinaryDoubleFP(CallInst *CI, IRBuilder<> &B) {
   // fmin((double)floatval1, (double)floatval2)
   //                      -> (double)fminf(floatval1, floatval2)
   // TODO: Handle intrinsics in the same way as in optimizeUnaryDoubleFP().
   Value *V = emitBinaryFloatFnCall(V1, V2, Callee->getName(), B,
                                    Callee->getAttributes());
   return B.CreateFPExt(V, B.getDoubleTy());
 }
 
+// cabs(z) -> sqrt((creal(z)*creal(z)) + (cimag(z)*cimag(z)))
+Value *LibCallSimplifier::optimizeCAbs(CallInst *CI, IRBuilder<> &B) {
+  if (!CI->isFast())
+    return nullptr;
+
+  // Propagate fast-math flags from the existing call to new instructions.
+  IRBuilder<>::FastMathFlagGuard Guard(B);
+  B.setFastMathFlags(CI->getFastMathFlags());
+
+  Value *Op = CI->getArgOperand(0);
+  Value *Real = B.CreateExtractValue(Op, 0, "real");
+  Value *Imag = B.CreateExtractValue(Op, 1, "imag");
+
+  Value *RealReal = B.CreateFMul(Real, Real);
+  Value *ImagImag = B.CreateFMul(Imag, Imag);
+
+  Function *FSqrt = Intrinsic::getDeclaration(CI->getModule(), Intrinsic::sqrt,
+                                              CI->getType());
+  return B.CreateCall(FSqrt, B.CreateFAdd(RealReal, ImagImag), "cabs");
+}
+
 Value *LibCallSimplifier::optimizeCos(CallInst *CI, IRBuilder<> &B) {
   Function *Callee = CI->getCalledFunction();
   Value *Ret = nullptr;
   StringRef Name = Callee->getName();
   if (UnsafeFPShrink && Name == "cos" && hasFloatVersion(Name))
     Ret = optimizeUnaryDoubleFP(CI, B, true);
 
   // cos(-x) -> cos(x)
case LibFunc_copysign:
     return nullptr;
   case LibFunc_fminf:
   case LibFunc_fmin:
   case LibFunc_fminl:
   case LibFunc_fmaxf:
   case LibFunc_fmax:
   case LibFunc_fmaxl:
     return optimizeFMinFMax(CI, Builder);
+  case LibFunc_cabs:
+  case LibFunc_cabsf:
+  case LibFunc_cabsl:
+    return optimizeCAbs(CI, Builder);
   default:
     return nullptr;
   }
 }
 
 Value *LibCallSimplifier::optimizeCall(CallInst *CI) {
   // TODO: Split out the code below that operates on FP calls so that
   //       we can all non-FP calls with the StrictFP attribute to be

test/Transforms/InstCombine/cabs.ll

+; RUN: opt < %s -instcombine -S | FileCheck %s
+
+define double @std_cabs([2 x double] %z) {
+; CHECK-LABEL: define double @std_cabs(
+; CHECK: tail call double @cabs(
+  %call = tail call double @cabs([2 x double] %z)
+  ret double %call
+}
+
+define float @std_cabsf([2 x float] %z) {
+; CHECK-LABEL: define float @std_cabsf(
+; CHECK: tail call float @cabsf(
+  %call = tail call float @cabsf([2 x float] %z)
+  ret float %call
+}
+
+define fp128 @std_cabsl([2 x fp128] %z) {
+; CHECK-LABEL: define fp128 @std_cabsl(
+; CHECK: tail call fp128 @cabsl(
+  %call = tail call fp128 @cabsl([2 x fp128] %z)
+  ret fp128 %call
+}
+
+define double @fast_cabs([2 x double] %z) {
+; CHECK-LABEL: define double @fast_cabs(
+; CHECK: %real = extractvalue [2 x double] %z, 0
+; CHECK: %imag = extractvalue [2 x double] %z, 1
+; CHECK: %1 = fmul fast double %real, %real
+; CHECK: %2 = fmul fast double %imag, %imag
+; CHECK: %3 = fadd fast double %1, %2
+; CHECK: %cabs = call fast double @llvm.sqrt.f64(double %3)
+; CHECK: ret double %cabs
+  %call = tail call fast double @cabs([2 x double] %z)
+  ret double %call
+}
+
+define float @fast_cabsf([2 x float] %z) {
+; CHECK-LABEL: define float @fast_cabsf(
+; CHECK: %real = extractvalue [2 x float] %z, 0
+; CHECK: %imag = extractvalue [2 x float] %z, 1
+; CHECK: %1 = fmul fast float %real, %real
+; CHECK: %2 = fmul fast float %imag, %imag
+; CHECK: %3 = fadd fast float %1, %2
+; CHECK: %cabs = call fast float @llvm.sqrt.f32(float %3)
+; CHECK: ret float %cabs
+  %call = tail call fast float @cabsf([2 x float] %z)
+  ret float %call
+}
+
+define fp128 @fast_cabsl([2 x fp128] %z) {
+; CHECK-LABEL: define fp128 @fast_cabsl(
+; CHECK: %real = extractvalue [2 x fp128] %z, 0
+; CHECK: %imag = extractvalue [2 x fp128] %z, 1
+; CHECK: %1 = fmul fast fp128 %real, %real
+; CHECK: %2 = fmul fast fp128 %imag, %imag
+; CHECK: %3 = fadd fast fp128 %1, %2
+; CHECK: %cabs = call fast fp128 @llvm.sqrt.f128(fp128 %3)
+; CHECK: ret fp128 %cabs
+  %call = tail call fast fp128 @cabsl([2 x fp128] %z)
+  ret fp128 %call
+}
+
+declare double @cabs([2 x double])
+declare float @cabsf([2 x float])
+declare fp128 @cabsl([2 x fp128])

unittests/Analysis/TargetLibraryInfoTest.cpp

parseAssembly(
     "declare double @ceil(double)\n"
     "declare float @ceilf(float)\n"
     "declare x86_fp80 @ceill(x86_fp80)\n"
     "declare i32 @chown(i8*, i32, i32)\n"
     "declare void @clearerr(%struct*)\n"
     "declare double @copysign(double, double)\n"
     "declare float @copysignf(float, float)\n"
     "declare x86_fp80 @copysignl(x86_fp80, x86_fp80)\n"
+    "declare double @cabs([2 x double])\n"
+    "declare float @cabsf([2 x float])\n"
+    "declare x86_fp80 @cabsl([2 x x86_fp80])\n"
     "declare double @cos(double)\n"
     "declare float @cosf(float)\n"
     "declare double @cosh(double)\n"
     "declare float @coshf(float)\n"
     "declare x86_fp80 @coshl(x86_fp80)\n"
     "declare x86_fp80 @cosl(x86_fp80)\n"
     "declare i8* @ctermid(i8*)\n"
     "declare double @exp(double)\n"