[Analysis] enhance FP library function prototype checking to match types with name suffix

[spatel]

Summary

I missed some existing test diffs in D63214 (not currently shown there), and this is the root cause: we loosely matched libm function names without checking that the return/parameter types correspond to the name.

The rule is:

1. No suffix --> double
2. 'f' suffix --> float
3. 'l' suffix --> long double

I'm not sure how to deal with long double yet, so I left that as TODOs.

The AMDGPU tests are adjusted to have the correct libm names without changing anything else. The instcombine sqrt test is the intentional diff. There are more comprehensive existing instcombine tests that will fail when transforming double functions to float functions, so I didn't bother adding tests for each name.

[cameron.mcinally]

LGTM, assuming the test writer was not intentionally playing games with the fabs(...) calls.

[efriedma]

AVR intentionally makes the C type "double" a single-precision float ("float" in IR). So we could fail to recognize "fabs" etc. on AVR with this patch, I think?

[spatel]

In D63294#1549185, @efriedma wrote:

AVR intentionally makes the C type "double" a single-precision float ("float" in IR). So we could fail to recognize "fabs" etc. on AVR with this patch, I think?

How do we test that? If that's a problem here, we might have an existing problem in clang because we convert to LLVM intrinsics in clang/lib/CodeGen using similar checks.

Note that this an extension of the existing checks, and we have seen bugs caused by matching libcall signatures too loosely:
rL258428
D16198 / rL258325

[efriedma]

How do we test that?

The following should produce ret float 0.000000e+00:

echo "double sqrt(double x); double z() { return sqrt(0); }" | clang --target=avr -x c - -o - -S -emit-llvm -O2

Not sure what you're talking about with clang; it does the right thing, as far as I can tell.

[spatel]

In D63294#1550775, @efriedma wrote:

Not sure what you're talking about with clang; it does the right thing, as far as I can tell.

When compiling for AVR, clang will turn the libcall that uses doubles in C source into:

%call = call addrspace(1) float @sqrt(float 0.000000e+00) #2

Should clang translate that call into "sqrtf" to be more accurate? Similarly, if the source was written with "sqrtl" and "long double", we'd get this IR out of clang:

%call = call addrspace(1) float @sqrtl(float 0.000000e+00) #2

[spatel]

In D63294#1550878, @spatel wrote:

In D63294#1550775, @efriedma wrote:

Not sure what you're talking about with clang; it does the right thing, as far as I can tell.

When compiling for AVR, clang will turn the libcall that uses doubles in C source into:

%call = call addrspace(1) float @sqrt(float 0.000000e+00) #2

Should clang translate that call into "sqrtf" to be more accurate? Similarly, if the source was written with "sqrtl" and "long double", we'd get this IR out of clang:

%call = call addrspace(1) float @sqrtl(float 0.000000e+00) #2

And I should've mentioned this in the earlier comment, both of those calls can be translated to the LLVM sqrt intrinsic (if we have no-errno) because checking for builtins appears to be done solely by name:

bool Builtin::Context::isBuiltinFunc(const char *Name) {
  StringRef FuncName(Name);
  for (unsigned i = Builtin::NotBuiltin + 1; i != Builtin::FirstTSBuiltin; ++i)
    if (FuncName.equals(BuiltinInfo[i].Name))
      return strchr(BuiltinInfo[i].Attributes, 'f') != nullptr;

  return false;
}

[efriedma]

Should clang translate that call into "sqrtf" to be more accurate?

On a target where sqrtf/sqrt/sqrtl have argument and return types with the same representation, we could rewrite the name of the function declaration, but I don't see why we would. The C type "float" and the LLVM IR type "float" are not the same thing in general; the suffix denotes the C type, not the LLVM IR type.

[spatel]

Abandoning - please see D63214 for the revised test in test/Transforms/InstCombine/double-float-shrink-1.ll that this patch was seeking to preserve.

llvm/lib/Analysis/TargetLibraryInfo.cpp

case LibFunc_nvvm_reflect:
     return (NumParams == 1 && FTy.getParamType(0)->isPointerTy());
 
   case LibFunc_sincospi_stret:
   case LibFunc_sincospif_stret:
     return (NumParams == 1 && FTy.getParamType(0)->isFloatingPointTy());
 
   case LibFunc_acos:
   case LibFunc_acos_finite:
-  case LibFunc_acosf:
-  case LibFunc_acosf_finite:
   case LibFunc_acosh:
   case LibFunc_acosh_finite:
-  case LibFunc_acoshf:
-  case LibFunc_acoshf_finite:
-  case LibFunc_acoshl:
-  case LibFunc_acoshl_finite:
-  case LibFunc_acosl:
-  case LibFunc_acosl_finite:
   case LibFunc_asin:
   case LibFunc_asin_finite:
-  case LibFunc_asinf:
-  case LibFunc_asinf_finite:
   case LibFunc_asinh:
-  case LibFunc_asinhf:
-  case LibFunc_asinhl:
-  case LibFunc_asinl:
-  case LibFunc_asinl_finite:
   case LibFunc_atan:
-  case LibFunc_atanf:
   case LibFunc_atanh:
   case LibFunc_atanh_finite:
-  case LibFunc_atanhf:
-  case LibFunc_atanhf_finite:
-  case LibFunc_atanhl:
-  case LibFunc_atanhl_finite:
-  case LibFunc_atanl:
   case LibFunc_cbrt:
-  case LibFunc_cbrtf:
-  case LibFunc_cbrtl:
   case LibFunc_ceil:
-  case LibFunc_ceilf:
-  case LibFunc_ceill:
   case LibFunc_cos:
-  case LibFunc_cosf:
   case LibFunc_cosh:
   case LibFunc_cosh_finite:
-  case LibFunc_coshf:
-  case LibFunc_coshf_finite:
-  case LibFunc_coshl:
-  case LibFunc_coshl_finite:
-  case LibFunc_cosl:
   case LibFunc_exp10:
   case LibFunc_exp10_finite:
-  case LibFunc_exp10f:
-  case LibFunc_exp10f_finite:
-  case LibFunc_exp10l:
-  case LibFunc_exp10l_finite:
   case LibFunc_exp2:
   case LibFunc_exp2_finite:
-  case LibFunc_exp2f:
-  case LibFunc_exp2f_finite:
-  case LibFunc_exp2l:
-  case LibFunc_exp2l_finite:
   case LibFunc_exp:
   case LibFunc_exp_finite:
-  case LibFunc_expf:
-  case LibFunc_expf_finite:
-  case LibFunc_expl:
-  case LibFunc_expl_finite:
   case LibFunc_expm1:
-  case LibFunc_expm1f:
-  case LibFunc_expm1l:
   case LibFunc_fabs:
-  case LibFunc_fabsf:
-  case LibFunc_fabsl:
   case LibFunc_floor:
-  case LibFunc_floorf:
-  case LibFunc_floorl:
   case LibFunc_log10:
   case LibFunc_log10_finite:
-  case LibFunc_log10f:
-  case LibFunc_log10f_finite:
-  case LibFunc_log10l:
-  case LibFunc_log10l_finite:
   case LibFunc_log1p:
-  case LibFunc_log1pf:
-  case LibFunc_log1pl:
   case LibFunc_log2:
   case LibFunc_log2_finite:
-  case LibFunc_log2f:
-  case LibFunc_log2f_finite:
-  case LibFunc_log2l:
-  case LibFunc_log2l_finite:
   case LibFunc_log:
   case LibFunc_log_finite:
   case LibFunc_logb:
-  case LibFunc_logbf:
-  case LibFunc_logbl:
-  case LibFunc_logf:
-  case LibFunc_logf_finite:
-  case LibFunc_logl:
-  case LibFunc_logl_finite:
   case LibFunc_nearbyint:
-  case LibFunc_nearbyintf:
-  case LibFunc_nearbyintl:
   case LibFunc_rint:
-  case LibFunc_rintf:
-  case LibFunc_rintl:
   case LibFunc_round:
-  case LibFunc_roundf:
-  case LibFunc_roundl:
   case LibFunc_sin:
-  case LibFunc_sinf:
   case LibFunc_sinh:
   case LibFunc_sinh_finite:
-  case LibFunc_sinhf:
-  case LibFunc_sinhf_finite:
-  case LibFunc_sinhl:
-  case LibFunc_sinhl_finite:
-  case LibFunc_sinl:
   case LibFunc_sqrt:
   case LibFunc_sqrt_finite:
+  case LibFunc_tan:
+  case LibFunc_tanh:
+  case LibFunc_trunc:
+    return (NumParams == 1 && FTy.getReturnType()->isDoubleTy() &&
+            FTy.getReturnType() == FTy.getParamType(0));
+
+  case LibFunc_acosf:
+  case LibFunc_acosf_finite:
+  case LibFunc_acoshf:
+  case LibFunc_acoshf_finite:
+  case LibFunc_asinf:
+  case LibFunc_asinf_finite:
+  case LibFunc_asinhf:
+  case LibFunc_atanf:
+  case LibFunc_atanhf:
+  case LibFunc_atanhf_finite:
+  case LibFunc_cbrtf:
+  case LibFunc_ceilf:
+  case LibFunc_cosf:
+  case LibFunc_coshf:
+  case LibFunc_coshf_finite:
+  case LibFunc_exp10f:
+  case LibFunc_exp10f_finite:
+  case LibFunc_exp2f:
+  case LibFunc_exp2f_finite:
+  case LibFunc_expf:
+  case LibFunc_expf_finite:
+  case LibFunc_expm1f:
+  case LibFunc_fabsf:
+  case LibFunc_floorf:
+  case LibFunc_log10f:
+  case LibFunc_log10f_finite:
+  case LibFunc_log1pf:
+  case LibFunc_log2f:
+  case LibFunc_log2f_finite:
+  case LibFunc_logf:
+  case LibFunc_logf_finite:
+  case LibFunc_logbf:
+  case LibFunc_nearbyintf:
+  case LibFunc_rintf:
+  case LibFunc_roundf:
+  case LibFunc_sinf:
+  case LibFunc_sinhf:
+  case LibFunc_sinhf_finite:
   case LibFunc_sqrtf:
   case LibFunc_sqrtf_finite:
-  case LibFunc_sqrtl:
-  case LibFunc_sqrtl_finite:
-  case LibFunc_tan:
   case LibFunc_tanf:
-  case LibFunc_tanh:
   case LibFunc_tanhf:
-  case LibFunc_tanhl:
-  case LibFunc_tanl:
-  case LibFunc_trunc:
   case LibFunc_truncf:
+    return (NumParams == 1 && FTy.getReturnType()->isFloatTy() &&
+            FTy.getReturnType() == FTy.getParamType(0));
+
+  case LibFunc_acoshl:
+  case LibFunc_acoshl_finite:
+  case LibFunc_acosl:
+  case LibFunc_acosl_finite:
+  case LibFunc_asinl:
+  case LibFunc_asinl_finite:
+  case LibFunc_asinhl:
+  case LibFunc_atanl:
+  case LibFunc_atanhl:
+  case LibFunc_atanhl_finite:
+  case LibFunc_cbrtl:
+  case LibFunc_ceill:
+  case LibFunc_cosl:
+  case LibFunc_coshl:
+  case LibFunc_coshl_finite:
+  case LibFunc_exp10l:
+  case LibFunc_exp10l_finite:
+  case LibFunc_exp2l:
+  case LibFunc_exp2l_finite:
+  case LibFunc_expl:
+  case LibFunc_expl_finite:
+  case LibFunc_expm1l:
+  case LibFunc_fabsl:
+  case LibFunc_floorl:
+  case LibFunc_log10l:
+  case LibFunc_log10l_finite:
+  case LibFunc_log1pl:
+  case LibFunc_log2l:
+  case LibFunc_log2l_finite:
+  case LibFunc_logl:
+  case LibFunc_logl_finite:
+  case LibFunc_logbl:
+  case LibFunc_nearbyintl:
+  case LibFunc_rintl:
+  case LibFunc_roundl:
+  case LibFunc_sinl:
+  case LibFunc_sinhl:
+  case LibFunc_sinhl_finite:
+  case LibFunc_sqrtl:
+  case LibFunc_sqrtl_finite:
+  case LibFunc_tanl:
+  case LibFunc_tanhl:
   case LibFunc_truncl:
+    // TODO: This should match 'long double' more precisely, but that might be
+    //       platform-dependent. It can not be half/float/double?
     return (NumParams == 1 && FTy.getReturnType()->isFloatingPointTy() &&
             FTy.getReturnType() == FTy.getParamType(0));
 
   case LibFunc_atan2:
   case LibFunc_atan2_finite:
-  case LibFunc_atan2f:
-  case LibFunc_atan2f_finite:
-  case LibFunc_atan2l:
-  case LibFunc_atan2l_finite:
   case LibFunc_fmin:
-  case LibFunc_fminf:
-  case LibFunc_fminl:
   case LibFunc_fmax:
-  case LibFunc_fmaxf:
-  case LibFunc_fmaxl:
   case LibFunc_fmod:
-  case LibFunc_fmodf:
-  case LibFunc_fmodl:
   case LibFunc_copysign:
-  case LibFunc_copysignf:
-  case LibFunc_copysignl:
   case LibFunc_pow:
   case LibFunc_pow_finite:
+      return (NumParams == 2 && FTy.getReturnType()->isDoubleTy() &&
+              FTy.getReturnType() == FTy.getParamType(0) &&
+              FTy.getReturnType() == FTy.getParamType(1));
+
+  case LibFunc_atan2f:
+  case LibFunc_atan2f_finite:
+  case LibFunc_fminf:
+  case LibFunc_fmaxf:
+  case LibFunc_fmodf:
+  case LibFunc_copysignf:
   case LibFunc_powf:
   case LibFunc_powf_finite:
+      return (NumParams == 2 && FTy.getReturnType()->isFloatTy() &&
+              FTy.getReturnType() == FTy.getParamType(0) &&
+              FTy.getReturnType() == FTy.getParamType(1));
+
+  case LibFunc_atan2l:
+  case LibFunc_atan2l_finite:
+  case LibFunc_fminl:
+  case LibFunc_fmaxl:
+  case LibFunc_fmodl:
+  case LibFunc_copysignl:
   case LibFunc_powl:
   case LibFunc_powl_finite:
+    // TODO: This should match 'long double' more precisely, but that might be
+    //       platform-dependent. It can not be half/float/double?
     return (NumParams == 2 && FTy.getReturnType()->isFloatingPointTy() &&
             FTy.getReturnType() == FTy.getParamType(0) &&
             FTy.getReturnType() == FTy.getParamType(1));
 
   case LibFunc_ldexp:
+      return (NumParams == 2 && FTy.getReturnType()->isDoubleTy() &&
+              FTy.getReturnType() == FTy.getParamType(0) &&
+              FTy.getParamType(1)->isIntegerTy(32));
+
   case LibFunc_ldexpf:
+      return (NumParams == 2 && FTy.getReturnType()->isFloatTy() &&
+              FTy.getReturnType() == FTy.getParamType(0) &&
+              FTy.getParamType(1)->isIntegerTy(32));
+
   case LibFunc_ldexpl:
+    // TODO: This should match 'long double' more precisely, but that might be
+    //       platform-dependent. It can not be half/float/double?
     return (NumParams == 2 && FTy.getReturnType()->isFloatingPointTy() &&
             FTy.getReturnType() == FTy.getParamType(0) &&
             FTy.getParamType(1)->isIntegerTy(32));
 
   case LibFunc_ffs:
   case LibFunc_ffsl:
   case LibFunc_ffsll:
   case LibFunc_fls:

llvm/test/CodeGen/AMDGPU/complex-folding.ll

 ;RUN: llc < %s -march=r600 -mcpu=redwood | FileCheck %s
 
 ; CHECK: {{^}}main:
 ; CHECK-NOT: MOV
 define amdgpu_ps void @main(<4 x float> inreg %reg0) {
 entry:
   %0 = extractelement <4 x float> %reg0, i32 0
-  %1 = call float @fabs(float %0)
+  %1 = call float @fabsf(float %0)
   %2 = fptoui float %1 to i32
   %3 = bitcast i32 %2 to float
   %4 = insertelement <4 x float> undef, float %3, i32 0
   call void @llvm.r600.store.swizzle(<4 x float> %4, i32 0, i32 0)
   ret void
 }
 
-declare float @fabs(float ) readnone
+declare float @fabsf(float) readnone
 declare void @llvm.r600.store.swizzle(<4 x float>, i32, i32)

llvm/test/CodeGen/AMDGPU/fabs.ll

 ; FUNC-LABEL: {{^}}s_fabs_fn_free:
 ; R600-NOT: AND
 ; R600: |PV.{{[XYZW]}}|
 
 ; SI: s_and_b32 s{{[0-9]+}}, s{{[0-9]+}}, 0x7fffffff
 ; VI: s_bitset0_b32 s{{[0-9]+}}, 31
 define amdgpu_kernel void @s_fabs_fn_free(float addrspace(1)* %out, i32 %in) {
   %bc= bitcast i32 %in to float
-  %fabs = call float @fabs(float %bc)
+  %fabs = call float @fabsf(float %bc)
   store float %fabs, float addrspace(1)* %out
   ret void
 }
 
 ; FUNC-LABEL: {{^}}s_fabs_free:
 ; R600-NOT: AND
 ; R600: |PV.{{[XYZW]}}|
 

 
 ; GCN-LABEL: {{^}}fabs_fn_fold:
 ; SI: s_load_dwordx2 s{{\[}}[[ABS_VALUE:[0-9]+]]:[[MUL_VAL:[0-9]+]]{{\]}}, s[{{[0-9]+:[0-9]+}}], 0xb
 ; VI: s_load_dwordx2 s{{\[}}[[ABS_VALUE:[0-9]+]]:[[MUL_VAL:[0-9]+]]{{\]}}, s[{{[0-9]+:[0-9]+}}], 0x2c
 ; GCN-NOT: and
 ; GCN: v_mov_b32_e32 [[V_MUL_VI:v[0-9]+]], s[[MUL_VAL]]
 ; GCN: v_mul_f32_e64 v{{[0-9]+}}, |s[[ABS_VALUE]]|, [[V_MUL_VI]]
 define amdgpu_kernel void @fabs_fn_fold(float addrspace(1)* %out, float %in0, float %in1) {
-  %fabs = call float @fabs(float %in0)
+  %fabs = call float @fabsf(float %in0)
   %fmul = fmul float %fabs, %in1
   store float %fmul, float addrspace(1)* %out
   ret void
 }
 
 ; FUNC-LABEL: {{^}}fabs_fold:
 ; SI: s_load_dwordx2 s{{\[}}[[ABS_VALUE:[0-9]+]]:[[MUL_VAL:[0-9]+]]{{\]}}, s[{{[0-9]+:[0-9]+}}], 0xb
 ; VI: s_load_dwordx2 s{{\[}}[[ABS_VALUE:[0-9]+]]:[[MUL_VAL:[0-9]+]]{{\]}}, s[{{[0-9]+:[0-9]+}}], 0x2c
define amdgpu_kernel void @bitpreserve_fabs_f32(float addrspace(1)* %out, float %in) {
   %in.bc = bitcast float %in to i32
   %int.abs = and i32 %in.bc, 2147483647
   %bc = bitcast i32 %int.abs to float
   %fadd = fadd float %bc, 1.0
   store float %fadd, float addrspace(1)* %out
   ret void
 }
 
-declare float @fabs(float) readnone
+declare float @fabsf(float) readnone
 declare float @llvm.fabs.f32(float) readnone
 declare <2 x float> @llvm.fabs.v2f32(<2 x float>) readnone
 declare <4 x float> @llvm.fabs.v4f32(<4 x float>) readnone

llvm/test/CodeGen/AMDGPU/floor.ll

 ; RUN: llc -march=r600 -mcpu=redwood < %s | FileCheck %s
 
 ; CHECK: FLOOR * T{{[0-9]+\.[XYZW], T[0-9]+\.[XYZW]}}
 define amdgpu_ps void @test(<4 x float> inreg %reg0) {
    %r0 = extractelement <4 x float> %reg0, i32 0
-   %r1 = call float @floor(float %r0)
+   %r1 = call float @floorf(float %r0)
    %vec = insertelement <4 x float> undef, float %r1, i32 0
    call void @llvm.r600.store.swizzle(<4 x float> %vec, i32 0, i32 0)
    ret void
 }
 
-declare float @floor(float) readonly
+declare float @floorf(float) readonly
 declare void @llvm.r600.store.swizzle(<4 x float>, i32, i32)
 

llvm/test/CodeGen/AMDGPU/fneg-fabs.ll

 ; FUNC-LABEL: {{^}}fneg_fabs_fn_free_f32:
 ; R600-NOT: AND
 ; R600: |PV.{{[XYZW]}}|
 ; R600: -PV
 
 ; SI: s_or_b32 s{{[0-9]+}}, s{{[0-9]+}}, 0x80000000
 define amdgpu_kernel void @fneg_fabs_fn_free_f32(float addrspace(1)* %out, i32 %in) {
   %bc = bitcast i32 %in to float
-  %fabs = call float @fabs(float %bc)
+  %fabs = call float @fabsf(float %bc)
   %fsub = fsub float -0.000000e+00, %fabs
   store float %fsub, float addrspace(1)* %out
   ret void
 }
 
 ; FUNC-LABEL: {{^}}fneg_fabs_f32:
 ; SI: s_or_b32 s{{[0-9]+}}, s{{[0-9]+}}, 0x80000000
 define amdgpu_kernel void @fneg_fabs_f32(float addrspace(1)* %out, float %in) {

 ; SI: v_or_b32_e32 v{{[0-9]+}}, [[SIGNBITK]], v{{[0-9]+}}
 define amdgpu_kernel void @fneg_fabs_v4f32(<4 x float> addrspace(1)* %out, <4 x float> %in) {
   %fabs = call <4 x float> @llvm.fabs.v4f32(<4 x float> %in)
   %fsub = fsub <4 x float> <float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00>, %fabs
   store <4 x float> %fsub, <4 x float> addrspace(1)* %out
   ret void
 }
 
-declare float @fabs(float) readnone
+declare float @fabsf(float) readnone
 declare float @llvm.fabs.f32(float) readnone
 declare <2 x float> @llvm.fabs.v2f32(<2 x float>) readnone
 declare <4 x float> @llvm.fabs.v4f32(<4 x float>) readnone

llvm/test/CodeGen/AMDGPU/r600-infinite-loop-bug-while-reorganizing-vector.ll

main_body:
   %tmp6 = insertelement <4 x float> %tmp5, float %tmp2, i32 1
   %tmp7 = insertelement <4 x float> %tmp6, float %tmp3, i32 2
   %tmp8 = insertelement <4 x float> %tmp7, float %tmp4, i32 3
   %tmp9 = call <4 x float> @llvm.r600.cube(<4 x float> %tmp8)
   %tmp10 = extractelement <4 x float> %tmp9, i32 0
   %tmp11 = extractelement <4 x float> %tmp9, i32 1
   %tmp12 = extractelement <4 x float> %tmp9, i32 2
   %tmp13 = extractelement <4 x float> %tmp9, i32 3
-  %tmp14 = call float @fabs(float %tmp12)
+  %tmp14 = call float @fabsf(float %tmp12)
   %tmp15 = fdiv float 1.000000e+00, %tmp14
   %tmp16 = fmul float %tmp10, %tmp15
   %tmp17 = fadd float %tmp16, 1.500000e+00
   %tmp18 = fmul float %tmp11, %tmp15
   %tmp19 = fadd float %tmp18, 1.500000e+00
   %tmp20 = insertelement <4 x float> undef, float %tmp19, i32 0
   %tmp21 = insertelement <4 x float> %tmp20, float %tmp17, i32 1
   %tmp22 = insertelement <4 x float> %tmp21, float %tmp13, i32 2
main_body:
   call void @llvm.r600.store.swizzle(<4 x float> %tmp38, i32 0, i32 0)
   ret void
 }
 
 ; Function Attrs: readnone
 declare <4 x float> @llvm.r600.cube(<4 x float>) #0
 
 ; Function Attrs: readnone
-declare float @fabs(float) #0
+declare float @fabsf(float) #0
 
 declare void @llvm.r600.store.swizzle(<4 x float>, i32, i32)
 
 ; Function Attrs: readnone
 declare <4 x float> @llvm.r600.texc(<4 x float>, i32, i32, i32, i32, i32, i32, i32, i32, i32) #0
 
 attributes #0 = { nounwind readnone }

llvm/test/CodeGen/AMDGPU/schedule-if-2.ll

main_body:
   %6 = icmp eq i32 %5, 0
   %7 = sext i1 %6 to i32
   %8 = bitcast i32 %7 to float
   %9 = bitcast float %8 to i32
   %10 = icmp ne i32 %9, 0
   br i1 %10, label %IF, label %ELSE
 
 IF:                                               ; preds = %main_body
-  %11 = call float @fabs(float %2)
+  %11 = call float @fabsf(float %2)
   %12 = fcmp ueq float %11, 0x7FF0000000000000
   %13 = select i1 %12, float 1.000000e+00, float 0.000000e+00
   %14 = fsub float -0.000000e+00, %13
   %15 = fptosi float %14 to i32
   %16 = bitcast i32 %15 to float
   %17 = bitcast float %16 to i32
   %18 = icmp ne i32 %17, 0
   %. = select i1 %18, float 0x36A0000000000000, float 0.000000e+00
IF23:                                             ; preds = %ELSE
   %56 = sitofp i32 %55 to float
   %57 = load <4 x float>, <4 x float> addrspace(8)* null
   %58 = extractelement <4 x float> %57, i32 0
   %59 = fsub float -0.000000e+00, %58
   %60 = fadd float %2, %59
   br label %ENDIF
 }
 
-declare float @fabs(float) #0
+declare float @fabsf(float) #0
 
 declare void @llvm.r600.store.swizzle(<4 x float>, i32, i32)
 
 attributes #0 = { readonly }

llvm/test/Transforms/InstCombine/sqrt-nofast.ll

entry:
   %1 = load float, float* %x.addr, align 4
   %mul = fmul fast float %0, %1
   %2 = call float @llvm.sqrt.f32(float %mul)
   ret float %2
 }
 
 declare float @llvm.sqrt.f32(float) #1
 
-; FIXME:
 ; This is a function called "sqrtf", but its type is double.
 ; Assume it is a user function rather than a libm function,
 ; so don't transform it.
 
 define double @fake_sqrt(double %a, double %b) {
 ; CHECK-LABEL: @fake_sqrt(
-; CHECK-NEXT:    [[FABS:%.*]] = call fast double @llvm.fabs.f64(double [[A:%.*]])
-; CHECK-NEXT:    ret double [[FABS]]
+; CHECK-NEXT:    [[C:%.*]] = fmul fast double [[A:%.*]], [[A]]
+; CHECK-NEXT:    [[E:%.*]] = call fast double @sqrtf(double [[C]]) #1
+; CHECK-NEXT:    ret double [[E]]
 ;
   %c = fmul fast double %a, %a
   %e = call fast double @sqrtf(double %c) readnone
   ret double %e
 }
 
 declare double @sqrtf(double) readnone ; This is not the 'sqrt' you're looking for.