Remove *_finite library support, following upstream

[serge-sans-paille]

Summary

Since https://sourceware.org/git/?p=glibc.git;a=commit;h=7bdb921d70bf9f93948e2e311fef9ef439314e41, glibc no longer provides access to the *_finite symbols. LLVM should no longer generate such symbols.

[serge-sans-paille]

Update some tests

[efriedma]

I'm a little concerned we're dropping the code to recognize calls in the source code too soon. Existing headers will generate calls to *_finite with fast-math, and people will continue to use existing headers for the next few years, until everyone updates their distro/sysroot.

I'm fine getting rid of the code to lower the intrinsics to *_finite calls if they're not actually faster in practice.

[serge-sans-paille]

I'm fine getting rid of the code to lower the intrinsics to *_finite calls if they're not actually faster in practice.

Well the problem is rather that they're no longer available in libm. I get your point though, and will limit that patch to the lowering step.

[serge-sans-paille]

As hinted by @efriedma , only remove lowering to *_finite calls in Codegen.

I contacted the libm maintainer and here is his explanation:

They were only ever an ABI (selected by use of -ffinite-math-only or
options implying it, which resulted in the headers using "asm" to redirect
calls to some libm functions), not an API. The change means that ABI has
turned into compat symbols (only available for existing binaries, not for
anything newly linked, not included in static libm at all, not included in
shared libm for future glibc ports such as RV32), so, yes, in any case
where tools generate direct calls to those functions (rather than just
following the "asm" annotations on function declarations in the headers),
they need to stop doing so.

[efriedma]

Code changes are what I expect, yes.

Missing test changes?

[andrew.w.kaylor]

It's a little weird that we're still recognizing these as LibFuncs, but I guess that's necessary to keep the optimizations like constant folding working with them. I see that ConstantFolding already calls the non-finite-restricted versions of the functions when it's doing compile-time evaluation. It would be good to have a comment somewhere (probably in TargetLibraryInfo.cpp below the note about math-finite.h) explaining the handling of these functions.

[serge-sans-paille]

@andrew.w.kaylor / @efriedma : comments taken into account.

[efriedma]

LGTM with one minor comment.

llvm/test/CodeGen/AArch64/illegal-float-ops.ll

2

You probably don't need the ANDROID-AARCH64 lines in the test anymore. Maybe just delete them, and make the Android run-line use the same CHECK lines?

[serge-sans-paille]

Update test case, according to @efriedma suggestion.

[efriedma]

LGTM

[hans]

Please include the PR number next time :-) PR45034 in this case.

llvm/lib/Analysis/TargetLibraryInfo.cpp

if (!T.isOSLinux() || !T.isGNUEnvironment()) {
     TLI.setUnavailable(LibFunc_ftello64);
     TLI.setUnavailable(LibFunc_lstat64);
     TLI.setUnavailable(LibFunc_open64);
     TLI.setUnavailable(LibFunc_stat64);
     TLI.setUnavailable(LibFunc_statvfs64);
     TLI.setUnavailable(LibFunc_tmpfile64);
 
     // Relaxed math functions are included in math-finite.h on Linux (GLIBC).
+    // Note that math-finite.h is no longer supported by top-of-tree GLIBC,
+    // so we keep these functions around just so that they're recognized by
+    // the ConstantFolder.
     TLI.setUnavailable(LibFunc_acos_finite);
     TLI.setUnavailable(LibFunc_acosf_finite);
     TLI.setUnavailable(LibFunc_acosl_finite);
     TLI.setUnavailable(LibFunc_acosh_finite);
     TLI.setUnavailable(LibFunc_acoshf_finite);
     TLI.setUnavailable(LibFunc_acoshl_finite);
     TLI.setUnavailable(LibFunc_asin_finite);
     TLI.setUnavailable(LibFunc_asinf_finite);

llvm/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp

   return true;
 }
 
 void SelectionDAGLegalize::ConvertNodeToLibcall(SDNode *Node) {
   LLVM_DEBUG(dbgs() << "Trying to convert node to libcall\n");
   SmallVector<SDValue, 8> Results;
   SDLoc dl(Node);
   // FIXME: Check flags on the node to see if we can use a finite call.
-  bool CanUseFiniteLibCall = TM.Options.NoInfsFPMath && TM.Options.NoNaNsFPMath;
   unsigned Opc = Node->getOpcode();
   switch (Opc) {
   case ISD::ATOMIC_FENCE: {
     // If the target didn't lower this, lower it to '__sync_synchronize()' call
     // FIXME: handle "fence singlethread" more efficiently.
     TargetLowering::ArgListTy Args;
 
     TargetLowering::CallLoweringInfo CLI(DAG);
ExpandFPLibCall(Node, RTLIB::COS_F32, RTLIB::COS_F64,
                     RTLIB::COS_PPCF128, Results);
     break;
   case ISD::FSINCOS:
     // Expand into sincos libcall.
     ExpandSinCosLibCall(Node, Results);
     break;
   case ISD::FLOG:
   case ISD::STRICT_FLOG:
-    if (CanUseFiniteLibCall && DAG.getLibInfo().has(LibFunc_log_finite))
-      ExpandFPLibCall(Node, RTLIB::LOG_FINITE_F32,
-                      RTLIB::LOG_FINITE_F64,
-                      RTLIB::LOG_FINITE_F80,
-                      RTLIB::LOG_FINITE_F128,
-                      RTLIB::LOG_FINITE_PPCF128, Results);
-    else
-      ExpandFPLibCall(Node, RTLIB::LOG_F32, RTLIB::LOG_F64,
-                      RTLIB::LOG_F80, RTLIB::LOG_F128,
-                      RTLIB::LOG_PPCF128, Results);
+    ExpandFPLibCall(Node, RTLIB::LOG_F32, RTLIB::LOG_F64, RTLIB::LOG_F80,
+                    RTLIB::LOG_F128, RTLIB::LOG_PPCF128, Results);
     break;
   case ISD::FLOG2:
   case ISD::STRICT_FLOG2:
-    if (CanUseFiniteLibCall && DAG.getLibInfo().has(LibFunc_log2_finite))
-      ExpandFPLibCall(Node, RTLIB::LOG2_FINITE_F32,
-                      RTLIB::LOG2_FINITE_F64,
-                      RTLIB::LOG2_FINITE_F80,
-                      RTLIB::LOG2_FINITE_F128,
-                      RTLIB::LOG2_FINITE_PPCF128, Results);
-    else
-      ExpandFPLibCall(Node, RTLIB::LOG2_F32, RTLIB::LOG2_F64,
-                      RTLIB::LOG2_F80, RTLIB::LOG2_F128,
-                      RTLIB::LOG2_PPCF128, Results);
+    ExpandFPLibCall(Node, RTLIB::LOG2_F32, RTLIB::LOG2_F64, RTLIB::LOG2_F80,
+                    RTLIB::LOG2_F128, RTLIB::LOG2_PPCF128, Results);
     break;
   case ISD::FLOG10:
   case ISD::STRICT_FLOG10:
-    if (CanUseFiniteLibCall && DAG.getLibInfo().has(LibFunc_log10_finite))
-      ExpandFPLibCall(Node, RTLIB::LOG10_FINITE_F32,
-                      RTLIB::LOG10_FINITE_F64,
-                      RTLIB::LOG10_FINITE_F80,
-                      RTLIB::LOG10_FINITE_F128,
-                      RTLIB::LOG10_FINITE_PPCF128, Results);
-    else
-      ExpandFPLibCall(Node, RTLIB::LOG10_F32, RTLIB::LOG10_F64,
-                      RTLIB::LOG10_F80, RTLIB::LOG10_F128,
-                      RTLIB::LOG10_PPCF128, Results);
+    ExpandFPLibCall(Node, RTLIB::LOG10_F32, RTLIB::LOG10_F64, RTLIB::LOG10_F80,
+                    RTLIB::LOG10_F128, RTLIB::LOG10_PPCF128, Results);
     break;
   case ISD::FEXP:
   case ISD::STRICT_FEXP:
-    if (CanUseFiniteLibCall && DAG.getLibInfo().has(LibFunc_exp_finite))
-      ExpandFPLibCall(Node, RTLIB::EXP_FINITE_F32,
-                      RTLIB::EXP_FINITE_F64,
-                      RTLIB::EXP_FINITE_F80,
-                      RTLIB::EXP_FINITE_F128,
-                      RTLIB::EXP_FINITE_PPCF128, Results);
-    else
-      ExpandFPLibCall(Node, RTLIB::EXP_F32, RTLIB::EXP_F64,
-                      RTLIB::EXP_F80, RTLIB::EXP_F128,
-                      RTLIB::EXP_PPCF128, Results);
+    ExpandFPLibCall(Node, RTLIB::EXP_F32, RTLIB::EXP_F64, RTLIB::EXP_F80,
+                    RTLIB::EXP_F128, RTLIB::EXP_PPCF128, Results);
     break;
   case ISD::FEXP2:
   case ISD::STRICT_FEXP2:
-    if (CanUseFiniteLibCall && DAG.getLibInfo().has(LibFunc_exp2_finite))
-      ExpandFPLibCall(Node, RTLIB::EXP2_FINITE_F32,
-                      RTLIB::EXP2_FINITE_F64,
-                      RTLIB::EXP2_FINITE_F80,
-                      RTLIB::EXP2_FINITE_F128,
-                      RTLIB::EXP2_FINITE_PPCF128, Results);
-    else
-      ExpandFPLibCall(Node, RTLIB::EXP2_F32, RTLIB::EXP2_F64,
-                      RTLIB::EXP2_F80, RTLIB::EXP2_F128,
-                      RTLIB::EXP2_PPCF128, Results);
+    ExpandFPLibCall(Node, RTLIB::EXP2_F32, RTLIB::EXP2_F64, RTLIB::EXP2_F80,
+                    RTLIB::EXP2_F128, RTLIB::EXP2_PPCF128, Results);
     break;
   case ISD::FTRUNC:
   case ISD::STRICT_FTRUNC:
     ExpandFPLibCall(Node, RTLIB::TRUNC_F32, RTLIB::TRUNC_F64,
                     RTLIB::TRUNC_F80, RTLIB::TRUNC_F128,
                     RTLIB::TRUNC_PPCF128, Results);
     break;
   case ISD::FFLOOR:
case ISD::STRICT_FPOWI: {
     }
     ExpandFPLibCall(Node, RTLIB::POWI_F32, RTLIB::POWI_F64,
                     RTLIB::POWI_F80, RTLIB::POWI_F128,
                     RTLIB::POWI_PPCF128, Results);
     break;
   }
   case ISD::FPOW:
   case ISD::STRICT_FPOW:
-    if (CanUseFiniteLibCall && DAG.getLibInfo().has(LibFunc_pow_finite))
-      ExpandFPLibCall(Node, RTLIB::POW_FINITE_F32,
-                      RTLIB::POW_FINITE_F64,
-                      RTLIB::POW_FINITE_F80,
-                      RTLIB::POW_FINITE_F128,
-                      RTLIB::POW_FINITE_PPCF128, Results);
-    else
-      ExpandFPLibCall(Node, RTLIB::POW_F32, RTLIB::POW_F64,
-                      RTLIB::POW_F80, RTLIB::POW_F128,
-                      RTLIB::POW_PPCF128, Results);
+    ExpandFPLibCall(Node, RTLIB::POW_F32, RTLIB::POW_F64, RTLIB::POW_F80,
+                    RTLIB::POW_F128, RTLIB::POW_PPCF128, Results);
     break;
   case ISD::LROUND:
   case ISD::STRICT_LROUND:
     ExpandArgFPLibCall(Node, RTLIB::LROUND_F32,
                        RTLIB::LROUND_F64, RTLIB::LROUND_F80,
                        RTLIB::LROUND_F128,
                        RTLIB::LROUND_PPCF128, Results);
     break;

llvm/test/CodeGen/AArch64/illegal-float-ops.ll

 ; RUN: llc -mtriple=aarch64-none-linux-gnu -verify-machineinstrs -o - %s | FileCheck %s
-; RUN: llc -mtriple=aarch64-linux-android -verify-machineinstrs -o - %s | FileCheck --check-prefix=ANDROID-AARCH64 %s
+; RUN: llc -mtriple=aarch64-linux-android -verify-machineinstrs -o - %s | FileCheck %s
 
 @varfloat = global float 0.0
 @vardouble = global double 0.0
 @varfp128 = global fp128 zeroinitializer
 
 declare float @llvm.cos.f32(float)
 declare double @llvm.cos.f64(double)
 declare fp128 @llvm.cos.f128(fp128)
; CHECK: bl __fixunstfti
   %b = add nsw i128 %conv.i, 48
   ret i128 %b
 }
 
 define void @test_exp_finite(double %double) #0 {
   %expdouble = call double @llvm.exp.f64(double %double)
   store double %expdouble, double* @vardouble
   ; ANDROID-AARCH64-NOT: bl __exp_finite
-  ; CHECK: bl __exp_finite
+  ; CHECK: bl exp
 
   ret void
 }
 
 define void @test_exp2_finite(double %double) #0 {
   %expdouble = call double @llvm.exp2.f64(double %double)
   store double %expdouble, double* @vardouble
-  ; ANDROID-AARCH64-NOT: bl __exp2_finite
-  ; CHECK: bl __exp2_finite
+  ; CHECK-NOT: bl __exp2_finite
+  ; CHECK: bl exp2
 
   ret void
 }
 
 define void @test_log_finite(double %double) #0 {
   %logdouble = call double @llvm.log.f64(double %double)
   store double %logdouble, double* @vardouble
-  ; ANDROID-AARCH64-NOT: bl __log_finite
-  ; CHECK: bl __log_finite
+  ; CHECK-NOT: bl __log_finite
+  ; CHECK: bl log
   ret void
 }
 
 define void @test_log2_finite(double %double) #0 {
   %log2double = call double @llvm.log2.f64(double %double)
   store double %log2double, double* @vardouble
-  ; ANDROID-AARCH64-NOT: bl __log2_finite
-  ; CHECK: bl __log2_finite
+  ; CHECK-NOT: bl __log2_finite
+  ; CHECK: bl log2
   ret void
 }
 
 define void @test_log10_finite(double %double) #0 {
   %log10double = call double @llvm.log10.f64(double %double)
   store double %log10double, double* @vardouble
-  ; ANDROID-AARCH64-NOT: bl __log10_finite
-  ; CHECK: bl __log10_finite
+  ; CHECK-NOT: bl __log10_finite
+  ; CHECK: bl log10
   ret void
 }
 
 define void @test_pow_finite(double %double) #0 {
   %powdouble = call double @llvm.pow.f64(double %double, double %double)
   store double %powdouble, double* @vardouble
-  ; ANDROID-AARCH64-NOT: bl __pow_finite
-  ; CHECK: bl __pow_finite
+  ; CHECK-NOT: bl __pow_finite
+  ; CHECK: bl pow
   ret void
 }
 
 attributes #0 = { "no-infs-fp-math"="true" "no-nans-fp-math"="true" }

llvm/test/CodeGen/X86/finite-libcalls.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc < %s -mtriple=x86_64-pc-linux-gnu     | FileCheck %s --check-prefix=CHECK --check-prefix=GNU
 ; RUN: llc < %s -mtriple=x86_64-pc-windows-msvc  | FileCheck %s --check-prefix=CHECK --check-prefix=WIN
 ; RUN: llc < %s -mtriple=x86_64-apple-darwin     | FileCheck %s --check-prefix=CHECK --check-prefix=MAC
 
 ; PR35672 - https://bugs.llvm.org/show_bug.cgi?id=35672
 ; FIXME: We would not need the function-level attributes if FMF were propagated to DAG nodes for this case.
 
 define float @exp_f32(float %x) #0 {
 ; GNU-LABEL: exp_f32:
 ; GNU:       # %bb.0:
-; GNU-NEXT:    jmp __expf_finite # TAILCALL
+; GNU-NEXT:    jmp expf # TAILCALL
 ;
 ; WIN-LABEL: exp_f32:
 ; WIN:       # %bb.0:
 ; WIN-NEXT:    jmp expf # TAILCALL
 ;
 ; MAC-LABEL: exp_f32:
 ; MAC:       ## %bb.0:
 ; MAC-NEXT:    jmp _expf ## TAILCALL
   %r = tail call nnan ninf float @llvm.exp.f32(float %x)
   ret float %r
 }
 
 define double @exp_f64(double %x) #0 {
 ; GNU-LABEL: exp_f64:
 ; GNU:       # %bb.0:
-; GNU-NEXT:    jmp __exp_finite # TAILCALL
+; GNU-NEXT:    jmp exp # TAILCALL
 ;
 ; WIN-LABEL: exp_f64:
 ; WIN:       # %bb.0:
 ; WIN-NEXT:    jmp exp # TAILCALL
 ;
 ; MAC-LABEL: exp_f64:
 ; MAC:       ## %bb.0:
 ; MAC-NEXT:    jmp _exp ## TAILCALL
   %r = tail call nnan ninf double @llvm.exp.f64(double %x)
   ret double %r
 }
 
 define x86_fp80 @exp_f80(x86_fp80 %x) #0 {
 ; GNU-LABEL: exp_f80:
 ; GNU:       # %bb.0:
 ; GNU-NEXT:    subq $24, %rsp
 ; GNU-NEXT:    fldt {{[0-9]+}}(%rsp)
 ; GNU-NEXT:    fstpt (%rsp)
-; GNU-NEXT:    callq __expl_finite
+; GNU-NEXT:    callq expl
 ; GNU-NEXT:    addq $24, %rsp
 ; GNU-NEXT:    retq
 ;
 ; WIN-LABEL: exp_f80:
 ; WIN:       # %bb.0:
 ; WIN-NEXT:    pushq %rsi
 ; WIN-NEXT:    subq $64, %rsp
 ; WIN-NEXT:    movq %rcx, %rsi

 ; MAC-NEXT:    retq
   %r = tail call nnan ninf x86_fp80 @llvm.exp.f80(x86_fp80 %x)
   ret x86_fp80 %r
 }
 
 define float @exp2_f32(float %x) #0 {
 ; GNU-LABEL: exp2_f32:
 ; GNU:       # %bb.0:
-; GNU-NEXT:    jmp __exp2f_finite # TAILCALL
+; GNU-NEXT:    jmp exp2f # TAILCALL
 ;
 ; WIN-LABEL: exp2_f32:
 ; WIN:       # %bb.0:
 ; WIN-NEXT:    jmp exp2f # TAILCALL
 ;
 ; MAC-LABEL: exp2_f32:
 ; MAC:       ## %bb.0:
 ; MAC-NEXT:    jmp _exp2f ## TAILCALL
   %r = tail call nnan ninf float @llvm.exp2.f32(float %x)
   ret float %r
 }
 
 define double @exp2_f64(double %x) #0 {
 ; GNU-LABEL: exp2_f64:
 ; GNU:       # %bb.0:
-; GNU-NEXT:    jmp __exp2_finite # TAILCALL
+; GNU-NEXT:    jmp exp2 # TAILCALL
 ;
 ; WIN-LABEL: exp2_f64:
 ; WIN:       # %bb.0:
 ; WIN-NEXT:    jmp exp2 # TAILCALL
 ;
 ; MAC-LABEL: exp2_f64:
 ; MAC:       ## %bb.0:
 ; MAC-NEXT:    jmp _exp2 ## TAILCALL
   %r = tail call nnan ninf double @llvm.exp2.f64(double %x)
   ret double %r
 }
 
 define x86_fp80 @exp2_f80(x86_fp80 %x) #0 {
 ; GNU-LABEL: exp2_f80:
 ; GNU:       # %bb.0:
 ; GNU-NEXT:    subq $24, %rsp
 ; GNU-NEXT:    fldt {{[0-9]+}}(%rsp)
 ; GNU-NEXT:    fstpt (%rsp)
-; GNU-NEXT:    callq __exp2l_finite
+; GNU-NEXT:    callq exp2l
 ; GNU-NEXT:    addq $24, %rsp
 ; GNU-NEXT:    retq
 ;
 ; WIN-LABEL: exp2_f80:
 ; WIN:       # %bb.0:
 ; WIN-NEXT:    pushq %rsi
 ; WIN-NEXT:    subq $64, %rsp
 ; WIN-NEXT:    movq %rcx, %rsi

 ; MAC-NEXT:    retq
   %r = tail call nnan ninf x86_fp80 @llvm.exp2.f80(x86_fp80 %x)
   ret x86_fp80 %r
 }
 
 define float @log_f32(float %x) #0 {
 ; GNU-LABEL: log_f32:
 ; GNU:       # %bb.0:
-; GNU-NEXT:    jmp __logf_finite # TAILCALL
+; GNU-NEXT:    jmp logf # TAILCALL
 ;
 ; WIN-LABEL: log_f32:
 ; WIN:       # %bb.0:
 ; WIN-NEXT:    jmp logf # TAILCALL
 ;
 ; MAC-LABEL: log_f32:
 ; MAC:       ## %bb.0:
 ; MAC-NEXT:    jmp _logf ## TAILCALL
   %r = tail call nnan ninf float @llvm.log.f32(float %x)
   ret float %r
 }
 
 define double @log_f64(double %x) #0 {
 ; GNU-LABEL: log_f64:
 ; GNU:       # %bb.0:
-; GNU-NEXT:    jmp __log_finite # TAILCALL
+; GNU-NEXT:    jmp log # TAILCALL
 ;
 ; WIN-LABEL: log_f64:
 ; WIN:       # %bb.0:
 ; WIN-NEXT:    jmp log # TAILCALL
 ;
 ; MAC-LABEL: log_f64:
 ; MAC:       ## %bb.0:
 ; MAC-NEXT:    jmp _log ## TAILCALL
   %r = tail call nnan ninf double @llvm.log.f64(double %x)
   ret double %r
 }
 
 define x86_fp80 @log_f80(x86_fp80 %x) #0 {
 ; GNU-LABEL: log_f80:
 ; GNU:       # %bb.0:
 ; GNU-NEXT:    subq $24, %rsp
 ; GNU-NEXT:    fldt {{[0-9]+}}(%rsp)
 ; GNU-NEXT:    fstpt (%rsp)
-; GNU-NEXT:    callq __logl_finite
+; GNU-NEXT:    callq logl
 ; GNU-NEXT:    addq $24, %rsp
 ; GNU-NEXT:    retq
 ;
 ; WIN-LABEL: log_f80:
 ; WIN:       # %bb.0:
 ; WIN-NEXT:    pushq %rsi
 ; WIN-NEXT:    subq $64, %rsp
 ; WIN-NEXT:    movq %rcx, %rsi

 ; MAC-NEXT:    retq
   %r = tail call nnan ninf x86_fp80 @llvm.log.f80(x86_fp80 %x)
   ret x86_fp80 %r
 }
 
 define float @log2_f32(float %x) #0 {
 ; GNU-LABEL: log2_f32:
 ; GNU:       # %bb.0:
-; GNU-NEXT:    jmp __log2f_finite # TAILCALL
+; GNU-NEXT:    jmp log2f # TAILCALL
 ;
 ; WIN-LABEL: log2_f32:
 ; WIN:       # %bb.0:
 ; WIN-NEXT:    jmp log2f # TAILCALL
 ;
 ; MAC-LABEL: log2_f32:
 ; MAC:       ## %bb.0:
 ; MAC-NEXT:    jmp _log2f ## TAILCALL
   %r = tail call nnan ninf float @llvm.log2.f32(float %x)
   ret float %r
 }
 
 define double @log2_f64(double %x) #0 {
 ; GNU-LABEL: log2_f64:
 ; GNU:       # %bb.0:
-; GNU-NEXT:    jmp __log2_finite # TAILCALL
+; GNU-NEXT:    jmp log2 # TAILCALL
 ;
 ; WIN-LABEL: log2_f64:
 ; WIN:       # %bb.0:
 ; WIN-NEXT:    jmp log2 # TAILCALL
 ;
 ; MAC-LABEL: log2_f64:
 ; MAC:       ## %bb.0:
 ; MAC-NEXT:    jmp _log2 ## TAILCALL
   %r = tail call nnan ninf double @llvm.log2.f64(double %x)
   ret double %r
 }
 
 define x86_fp80 @log2_f80(x86_fp80 %x) #0 {
 ; GNU-LABEL: log2_f80:
 ; GNU:       # %bb.0:
 ; GNU-NEXT:    subq $24, %rsp
 ; GNU-NEXT:    fldt {{[0-9]+}}(%rsp)
 ; GNU-NEXT:    fstpt (%rsp)
-; GNU-NEXT:    callq __log2l_finite
+; GNU-NEXT:    callq log2l
 ; GNU-NEXT:    addq $24, %rsp
 ; GNU-NEXT:    retq
 ;
 ; WIN-LABEL: log2_f80:
 ; WIN:       # %bb.0:
 ; WIN-NEXT:    pushq %rsi
 ; WIN-NEXT:    subq $64, %rsp
 ; WIN-NEXT:    movq %rcx, %rsi

 ; MAC-NEXT:    retq
   %r = tail call nnan ninf x86_fp80 @llvm.log2.f80(x86_fp80 %x)
   ret x86_fp80 %r
 }
 
 define float @log10_f32(float %x) #0 {
 ; GNU-LABEL: log10_f32:
 ; GNU:       # %bb.0:
-; GNU-NEXT:    jmp __log10f_finite # TAILCALL
+; GNU-NEXT:    jmp log10f # TAILCALL
 ;
 ; WIN-LABEL: log10_f32:
 ; WIN:       # %bb.0:
 ; WIN-NEXT:    jmp log10f # TAILCALL
 ;
 ; MAC-LABEL: log10_f32:
 ; MAC:       ## %bb.0:
 ; MAC-NEXT:    jmp _log10f ## TAILCALL
   %r = tail call nnan ninf float @llvm.log10.f32(float %x)
   ret float %r
 }
 
 define double @log10_f64(double %x) #0 {
 ; GNU-LABEL: log10_f64:
 ; GNU:       # %bb.0:
-; GNU-NEXT:    jmp __log10_finite # TAILCALL
+; GNU-NEXT:    jmp log10 # TAILCALL
 ;
 ; WIN-LABEL: log10_f64:
 ; WIN:       # %bb.0:
 ; WIN-NEXT:    jmp log10 # TAILCALL
 ;
 ; MAC-LABEL: log10_f64:
 ; MAC:       ## %bb.0:
 ; MAC-NEXT:    jmp _log10 ## TAILCALL
   %r = tail call nnan ninf double @llvm.log10.f64(double %x)
   ret double %r
 }
 
 define x86_fp80 @log10_f80(x86_fp80 %x) #0 {
 ; GNU-LABEL: log10_f80:
 ; GNU:       # %bb.0:
 ; GNU-NEXT:    subq $24, %rsp
 ; GNU-NEXT:    fldt {{[0-9]+}}(%rsp)
 ; GNU-NEXT:    fstpt (%rsp)
-; GNU-NEXT:    callq __log10l_finite
+; GNU-NEXT:    callq log10l
 ; GNU-NEXT:    addq $24, %rsp
 ; GNU-NEXT:    retq
 ;
 ; WIN-LABEL: log10_f80:
 ; WIN:       # %bb.0:
 ; WIN-NEXT:    pushq %rsi
 ; WIN-NEXT:    subq $64, %rsp
 ; WIN-NEXT:    movq %rcx, %rsi
; MAC-NEXT:    retq
   %r = tail call nnan ninf x86_fp80 @llvm.log10.f80(x86_fp80 %x)
   ret x86_fp80 %r
 }
 
 define float @pow_f32(float %x) #0 {
 ; GNU-LABEL: pow_f32:
 ; GNU:       # %bb.0:
 ; GNU-NEXT:    movaps %xmm0, %xmm1
-; GNU-NEXT:    jmp __powf_finite # TAILCALL
+; GNU-NEXT:    jmp powf # TAILCALL
 ;
 ; WIN-LABEL: pow_f32:
 ; WIN:       # %bb.0:
 ; WIN-NEXT:    movaps %xmm0, %xmm1
 ; WIN-NEXT:    jmp powf # TAILCALL
 ;
 ; MAC-LABEL: pow_f32:
 ; MAC:       ## %bb.0:
 ; MAC-NEXT:    movaps %xmm0, %xmm1
 ; MAC-NEXT:    jmp _powf ## TAILCALL
   %r = tail call nnan ninf float @llvm.pow.f32(float %x, float %x)
   ret float %r
 }
 
 define double @pow_f64(double %x) #0 {
 ; GNU-LABEL: pow_f64:
 ; GNU:       # %bb.0:
 ; GNU-NEXT:    movaps %xmm0, %xmm1
-; GNU-NEXT:    jmp __pow_finite # TAILCALL
+; GNU-NEXT:    jmp pow # TAILCALL
 ;
 ; WIN-LABEL: pow_f64:
 ; WIN:       # %bb.0:
 ; WIN-NEXT:    movaps %xmm0, %xmm1
 ; WIN-NEXT:    jmp pow # TAILCALL
 ;
 ; MAC-LABEL: pow_f64:
 ; MAC:       ## %bb.0:
 ; MAC-NEXT:    movaps %xmm0, %xmm1
 ; MAC-NEXT:    jmp _pow ## TAILCALL
   %r = tail call nnan ninf double @llvm.pow.f64(double %x, double %x)
   ret double %r
 }
 
 define x86_fp80 @pow_f80(x86_fp80 %x) #0 {
 ; GNU-LABEL: pow_f80:
 ; GNU:       # %bb.0:
 ; GNU-NEXT:    subq $40, %rsp
 ; GNU-NEXT:    fldt {{[0-9]+}}(%rsp)
 ; GNU-NEXT:    fld %st(0)
 ; GNU-NEXT:    fstpt {{[0-9]+}}(%rsp)
 ; GNU-NEXT:    fstpt (%rsp)
-; GNU-NEXT:    callq __powl_finite
+; GNU-NEXT:    callq powl
 ; GNU-NEXT:    addq $40, %rsp
 ; GNU-NEXT:    retq
 ;
 ; WIN-LABEL: pow_f80:
 ; WIN:       # %bb.0:
 ; WIN-NEXT:    pushq %rsi
 ; WIN-NEXT:    subq $80, %rsp
 ; WIN-NEXT:    movq %rcx, %rsi