Attachment #655054 for bug #710984

View | Details | Raw Unified | Return to bug 710984
Collapse All | Expand All

Lines 479-484 static void initialize(TargetLibraryInfoImpl &TLI, const Triple &T, Link Here

(-)a/lib/Analysis/TargetLibraryInfo.cpp (+3 lines)
479	TLI.setUnavailable(LibFunc_tmpfile64);	479	TLI.setUnavailable(LibFunc_tmpfile64);
480		480
481	// Relaxed math functions are included in math-finite.h on Linux (GLIBC).	481	// Relaxed math functions are included in math-finite.h on Linux (GLIBC).
		482	// Note that math-finite.h is no longer supported by top-of-tree GLIBC,
		483	// so we keep these functions around just so that they're recognized by
		484	// the ConstantFolder.
482	TLI.setUnavailable(LibFunc_acos_finite);	485	TLI.setUnavailable(LibFunc_acos_finite);
483	TLI.setUnavailable(LibFunc_acosf_finite);	486	TLI.setUnavailable(LibFunc_acosf_finite);
484	TLI.setUnavailable(LibFunc_acosl_finite);	487	TLI.setUnavailable(LibFunc_acosl_finite);




  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: {

    break;
  case ISD::FLOG:
  case ISD::STRICT_FLOG:
    ExpandFPLibCall(Node, RTLIB::LOG_F32, RTLIB::LOG_F64, RTLIB::LOG_F80,
                    RTLIB::LOG_F128, RTLIB::LOG_PPCF128, Results);
                                        RTLIB::LOG_FINITE_F64,
                                        RTLIB::LOG_FINITE_F80,
                                        RTLIB::LOG_FINITE_F128,
                                        RTLIB::LOG_FINITE_PPCF128));
    else
      Results.push_back(ExpandFPLibCall(Node, RTLIB::LOG_F32, RTLIB::LOG_F64,
                                        RTLIB::LOG_F80, RTLIB::LOG_F128,
                                        RTLIB::LOG_PPCF128));
    break;
  case ISD::FLOG2:
  case ISD::STRICT_FLOG2:
    ExpandFPLibCall(Node, RTLIB::LOG2_F32, RTLIB::LOG2_F64, RTLIB::LOG2_F80,
                    RTLIB::LOG2_F128, RTLIB::LOG2_PPCF128, Results);
                                        RTLIB::LOG2_FINITE_F64,
                                        RTLIB::LOG2_FINITE_F80,
                                        RTLIB::LOG2_FINITE_F128,
                                        RTLIB::LOG2_FINITE_PPCF128));
    else
      Results.push_back(ExpandFPLibCall(Node, RTLIB::LOG2_F32, RTLIB::LOG2_F64,
                                        RTLIB::LOG2_F80, RTLIB::LOG2_F128,
                                        RTLIB::LOG2_PPCF128));
    break;
  case ISD::FLOG10:
  case ISD::STRICT_FLOG10:
    ExpandFPLibCall(Node, RTLIB::LOG10_F32, RTLIB::LOG10_F64, RTLIB::LOG10_F80,
                    RTLIB::LOG10_F128, RTLIB::LOG10_PPCF128, Results);
                                        RTLIB::LOG10_FINITE_F64,
                                        RTLIB::LOG10_FINITE_F80,
                                        RTLIB::LOG10_FINITE_F128,
                                        RTLIB::LOG10_FINITE_PPCF128));
    else
      Results.push_back(ExpandFPLibCall(Node, RTLIB::LOG10_F32, RTLIB::LOG10_F64,
                                        RTLIB::LOG10_F80, RTLIB::LOG10_F128,
                                        RTLIB::LOG10_PPCF128));
    break;
  case ISD::FEXP:
  case ISD::STRICT_FEXP:
    ExpandFPLibCall(Node, RTLIB::EXP_F32, RTLIB::EXP_F64, RTLIB::EXP_F80,
                    RTLIB::EXP_F128, RTLIB::EXP_PPCF128, Results);
                                        RTLIB::EXP_FINITE_F64,
                                        RTLIB::EXP_FINITE_F80,
                                        RTLIB::EXP_FINITE_F128,
                                        RTLIB::EXP_FINITE_PPCF128));
    else
      Results.push_back(ExpandFPLibCall(Node, RTLIB::EXP_F32, RTLIB::EXP_F64,
                                        RTLIB::EXP_F80, RTLIB::EXP_F128,
                                        RTLIB::EXP_PPCF128));
    break;
  case ISD::FEXP2:
  case ISD::STRICT_FEXP2:
    ExpandFPLibCall(Node, RTLIB::EXP2_F32, RTLIB::EXP2_F64, RTLIB::EXP2_F80,
                    RTLIB::EXP2_F128, RTLIB::EXP2_PPCF128, Results);
                                        RTLIB::EXP2_FINITE_F64,
                                        RTLIB::EXP2_FINITE_F80,
                                        RTLIB::EXP2_FINITE_F128,
                                        RTLIB::EXP2_FINITE_PPCF128));
    else
      Results.push_back(ExpandFPLibCall(Node, RTLIB::EXP2_F32, RTLIB::EXP2_F64,
                                        RTLIB::EXP2_F80, RTLIB::EXP2_F128,
                                        RTLIB::EXP2_PPCF128));
    break;
  case ISD::FTRUNC:
  case ISD::STRICT_FTRUNC:

    break;
  case ISD::FPOW:
  case ISD::STRICT_FPOW:
    ExpandFPLibCall(Node, RTLIB::POW_F32, RTLIB::POW_F64, RTLIB::POW_F80,
                    RTLIB::POW_F128, RTLIB::POW_PPCF128, Results);
                                        RTLIB::POW_FINITE_F64,
                                        RTLIB::POW_FINITE_F80,
                                        RTLIB::POW_FINITE_F128,
                                        RTLIB::POW_FINITE_PPCF128));
    else
      Results.push_back(ExpandFPLibCall(Node, RTLIB::POW_F32, RTLIB::POW_F64,
                                        RTLIB::POW_F80, RTLIB::POW_F128,
                                        RTLIB::POW_PPCF128));
    break;
  case ISD::FDIV:
    Results.push_back(ExpandFPLibCall(Node, RTLIB::DIV_F32, RTLIB::DIV_F64,




; RUN: llc -mtriple=aarch64-none-linux-gnu -verify-machineinstrs -o - %s | FileCheck %s
; RUN: llc -mtriple=aarch64-linux-android -verify-machineinstrs -o - %s | FileCheck %s

@varfloat = global float 0.0
@vardouble = global double 0.0

  %expdouble = call double @llvm.exp.f64(double %double)
  store double %expdouble, double* @vardouble
  ; ANDROID-AARCH64-NOT: 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
  ; 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
  ; 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
  ; 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
  ; 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
  ; CHECK-NOT: bl __pow_finite
  ; CHECK: bl pow
  ret void
}




define float @exp_f32(float %x) #0 {
; GNU-LABEL: exp_f32:
; GNU:       # %bb.0:
; GNU-NEXT:    jmp expf # TAILCALL
;
; WIN-LABEL: exp_f32:
; WIN:       # %bb.0:

define double @exp_f64(double %x) #0 {
; GNU-LABEL: exp_f64:
; GNU:       # %bb.0:
; GNU-NEXT:    jmp exp # TAILCALL
;
; WIN-LABEL: exp_f64:
; WIN:       # %bb.0:

; GNU-NEXT:    subq $24, %rsp
; GNU-NEXT:    fldt {{[0-9]+}}(%rsp)
; GNU-NEXT:    fstpt (%rsp)
; GNU-NEXT:    callq expl
; GNU-NEXT:    addq $24, %rsp
; GNU-NEXT:    retq
;

define float @exp2_f32(float %x) #0 {
; GNU-LABEL: exp2_f32:
; GNU:       # %bb.0:
; GNU-NEXT:    jmp exp2f # TAILCALL
;
; WIN-LABEL: exp2_f32:
; WIN:       # %bb.0:

define double @exp2_f64(double %x) #0 {
; GNU-LABEL: exp2_f64:
; GNU:       # %bb.0:
; GNU-NEXT:    jmp exp2 # TAILCALL
;
; WIN-LABEL: exp2_f64:
; WIN:       # %bb.0:

; GNU-NEXT:    subq $24, %rsp
; GNU-NEXT:    fldt {{[0-9]+}}(%rsp)
; GNU-NEXT:    fstpt (%rsp)
; GNU-NEXT:    callq exp2l
; GNU-NEXT:    addq $24, %rsp
; GNU-NEXT:    retq
;

define float @log_f32(float %x) #0 {
; GNU-LABEL: log_f32:
; GNU:       # %bb.0:
; GNU-NEXT:    jmp logf # TAILCALL
;
; WIN-LABEL: log_f32:
; WIN:       # %bb.0:

define double @log_f64(double %x) #0 {
; GNU-LABEL: log_f64:
; GNU:       # %bb.0:
; GNU-NEXT:    jmp log # TAILCALL
;
; WIN-LABEL: log_f64:
; WIN:       # %bb.0:

; GNU-NEXT:    subq $24, %rsp
; GNU-NEXT:    fldt {{[0-9]+}}(%rsp)
; GNU-NEXT:    fstpt (%rsp)
; GNU-NEXT:    callq logl
; GNU-NEXT:    addq $24, %rsp
; GNU-NEXT:    retq
;

define float @log2_f32(float %x) #0 {
; GNU-LABEL: log2_f32:
; GNU:       # %bb.0:
; GNU-NEXT:    jmp log2f # TAILCALL
;
; WIN-LABEL: log2_f32:
; WIN:       # %bb.0:

define double @log2_f64(double %x) #0 {
; GNU-LABEL: log2_f64:
; GNU:       # %bb.0:
; GNU-NEXT:    jmp log2 # TAILCALL
;
; WIN-LABEL: log2_f64:
; WIN:       # %bb.0:

; GNU-NEXT:    subq $24, %rsp
; GNU-NEXT:    fldt {{[0-9]+}}(%rsp)
; GNU-NEXT:    fstpt (%rsp)
; GNU-NEXT:    callq log2l
; GNU-NEXT:    addq $24, %rsp
; GNU-NEXT:    retq
;

define float @log10_f32(float %x) #0 {
; GNU-LABEL: log10_f32:
; GNU:       # %bb.0:
; GNU-NEXT:    jmp log10f # TAILCALL
;
; WIN-LABEL: log10_f32:
; WIN:       # %bb.0:

define double @log10_f64(double %x) #0 {
; GNU-LABEL: log10_f64:
; GNU:       # %bb.0:
; GNU-NEXT:    jmp log10 # TAILCALL
;
; WIN-LABEL: log10_f64:
; WIN:       # %bb.0:

; GNU-NEXT:    subq $24, %rsp
; GNU-NEXT:    fldt {{[0-9]+}}(%rsp)
; GNU-NEXT:    fstpt (%rsp)
; GNU-NEXT:    callq log10l
; GNU-NEXT:    addq $24, %rsp
; GNU-NEXT:    retq
;

; GNU-LABEL: pow_f32:
; GNU:       # %bb.0:
; GNU-NEXT:    movaps %xmm0, %xmm1
; GNU-NEXT:    jmp powf # TAILCALL
;
; WIN-LABEL: pow_f32:
; WIN:       # %bb.0:

; GNU-LABEL: pow_f64:
; GNU:       # %bb.0:
; GNU-NEXT:    movaps %xmm0, %xmm1
; GNU-NEXT:    jmp pow # TAILCALL
;
; WIN-LABEL: pow_f64:
; WIN:       # %bb.0:

; GNU-NEXT:    fld %st(0)
; GNU-NEXT:    fstpt {{[0-9]+}}(%rsp)
; GNU-NEXT:    fstpt (%rsp)
; GNU-NEXT:    callq powl
; GNU-NEXT:    addq $40, %rsp
; GNU-NEXT:    retq
;

Return to bug 710984

Lines 3731-3737 void SelectionDAGLegalize::ConvertNodeToLibcall(SDNode *Node) { Link Here

(-)a/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp (-61 / +12 lines)
3731	SmallVector<SDValue, 8> Results;	3731	SmallVector<SDValue, 8> Results;
3732	SDLoc dl(Node);	3732	SDLoc dl(Node);
3733	// FIXME: Check flags on the node to see if we can use a finite call.	3733	// FIXME: Check flags on the node to see if we can use a finite call.
3734	bool CanUseFiniteLibCall = TM.Options.NoInfsFPMath && TM.Options.NoNaNsFPMath;
3735	unsigned Opc = Node->getOpcode();	3734	unsigned Opc = Node->getOpcode();
3736	switch (Opc) {	3735	switch (Opc) {
3737	case ISD::ATOMIC_FENCE: {	3736	case ISD::ATOMIC_FENCE: {
Lines 3834-3901 void SelectionDAGLegalize::ConvertNodeToLibcall(SDNode *Node) { Link Here
3834	break;	3833	break;
3835	case ISD::FLOG:	3834	case ISD::FLOG:
3836	case ISD::STRICT_FLOG:	3835	case ISD::STRICT_FLOG:
3837	if (CanUseFiniteLibCall && DAG.getLibInfo().has(LibFunc_log_finite))	3836	ExpandFPLibCall(Node, RTLIB::LOG_F32, RTLIB::LOG_F64, RTLIB::LOG_F80,
3838	Results.push_back(ExpandFPLibCall(Node, RTLIB::LOG_FINITE_F32,	3837	RTLIB::LOG_F128, RTLIB::LOG_PPCF128, Results);
3839	RTLIB::LOG_FINITE_F64,
3840	RTLIB::LOG_FINITE_F80,
3841	RTLIB::LOG_FINITE_F128,
3842	RTLIB::LOG_FINITE_PPCF128));
3843	else
3844	Results.push_back(ExpandFPLibCall(Node, RTLIB::LOG_F32, RTLIB::LOG_F64,
3845	RTLIB::LOG_F80, RTLIB::LOG_F128,
3846	RTLIB::LOG_PPCF128));
3847	break;	3838	break;
3848	case ISD::FLOG2:	3839	case ISD::FLOG2:
3849	case ISD::STRICT_FLOG2:	3840	case ISD::STRICT_FLOG2:
3850	if (CanUseFiniteLibCall && DAG.getLibInfo().has(LibFunc_log2_finite))	3841	ExpandFPLibCall(Node, RTLIB::LOG2_F32, RTLIB::LOG2_F64, RTLIB::LOG2_F80,
3851	Results.push_back(ExpandFPLibCall(Node, RTLIB::LOG2_FINITE_F32,	3842	RTLIB::LOG2_F128, RTLIB::LOG2_PPCF128, Results);
3852	RTLIB::LOG2_FINITE_F64,
3853	RTLIB::LOG2_FINITE_F80,
3854	RTLIB::LOG2_FINITE_F128,
3855	RTLIB::LOG2_FINITE_PPCF128));
3856	else
3857	Results.push_back(ExpandFPLibCall(Node, RTLIB::LOG2_F32, RTLIB::LOG2_F64,
3858	RTLIB::LOG2_F80, RTLIB::LOG2_F128,
3859	RTLIB::LOG2_PPCF128));
3860	break;	3843	break;
3861	case ISD::FLOG10:	3844	case ISD::FLOG10:
3862	case ISD::STRICT_FLOG10:	3845	case ISD::STRICT_FLOG10:
3863	if (CanUseFiniteLibCall && DAG.getLibInfo().has(LibFunc_log10_finite))	3846	ExpandFPLibCall(Node, RTLIB::LOG10_F32, RTLIB::LOG10_F64, RTLIB::LOG10_F80,
3864	Results.push_back(ExpandFPLibCall(Node, RTLIB::LOG10_FINITE_F32,	3847	RTLIB::LOG10_F128, RTLIB::LOG10_PPCF128, Results);
3865	RTLIB::LOG10_FINITE_F64,
3866	RTLIB::LOG10_FINITE_F80,
3867	RTLIB::LOG10_FINITE_F128,
3868	RTLIB::LOG10_FINITE_PPCF128));
3869	else
3870	Results.push_back(ExpandFPLibCall(Node, RTLIB::LOG10_F32, RTLIB::LOG10_F64,
3871	RTLIB::LOG10_F80, RTLIB::LOG10_F128,
3872	RTLIB::LOG10_PPCF128));
3873	break;	3848	break;
3874	case ISD::FEXP:	3849	case ISD::FEXP:
3875	case ISD::STRICT_FEXP:	3850	case ISD::STRICT_FEXP:
3876	if (CanUseFiniteLibCall && DAG.getLibInfo().has(LibFunc_exp_finite))	3851	ExpandFPLibCall(Node, RTLIB::EXP_F32, RTLIB::EXP_F64, RTLIB::EXP_F80,
3877	Results.push_back(ExpandFPLibCall(Node, RTLIB::EXP_FINITE_F32,	3852	RTLIB::EXP_F128, RTLIB::EXP_PPCF128, Results);
3878	RTLIB::EXP_FINITE_F64,
3879	RTLIB::EXP_FINITE_F80,
3880	RTLIB::EXP_FINITE_F128,
3881	RTLIB::EXP_FINITE_PPCF128));
3882	else
3883	Results.push_back(ExpandFPLibCall(Node, RTLIB::EXP_F32, RTLIB::EXP_F64,
3884	RTLIB::EXP_F80, RTLIB::EXP_F128,
3885	RTLIB::EXP_PPCF128));
3886	break;	3853	break;
3887	case ISD::FEXP2:	3854	case ISD::FEXP2:
3888	case ISD::STRICT_FEXP2:	3855	case ISD::STRICT_FEXP2:
3889	if (CanUseFiniteLibCall && DAG.getLibInfo().has(LibFunc_exp2_finite))	3856	ExpandFPLibCall(Node, RTLIB::EXP2_F32, RTLIB::EXP2_F64, RTLIB::EXP2_F80,
3890	Results.push_back(ExpandFPLibCall(Node, RTLIB::EXP2_FINITE_F32,	3857	RTLIB::EXP2_F128, RTLIB::EXP2_PPCF128, Results);
3891	RTLIB::EXP2_FINITE_F64,
3892	RTLIB::EXP2_FINITE_F80,
3893	RTLIB::EXP2_FINITE_F128,
3894	RTLIB::EXP2_FINITE_PPCF128));
3895	else
3896	Results.push_back(ExpandFPLibCall(Node, RTLIB::EXP2_F32, RTLIB::EXP2_F64,
3897	RTLIB::EXP2_F80, RTLIB::EXP2_F128,
3898	RTLIB::EXP2_PPCF128));
3899	break;	3858	break;
3900	case ISD::FTRUNC:	3859	case ISD::FTRUNC:
3901	case ISD::STRICT_FTRUNC:	3860	case ISD::STRICT_FTRUNC:
Lines 3945-3960 void SelectionDAGLegalize::ConvertNodeToLibcall(SDNode *Node) { Link Here
3945	break;	3904	break;
3946	case ISD::FPOW:	3905	case ISD::FPOW:
3947	case ISD::STRICT_FPOW:	3906	case ISD::STRICT_FPOW:
3948	if (CanUseFiniteLibCall && DAG.getLibInfo().has(LibFunc_pow_finite))	3907	ExpandFPLibCall(Node, RTLIB::POW_F32, RTLIB::POW_F64, RTLIB::POW_F80,
3949	Results.push_back(ExpandFPLibCall(Node, RTLIB::POW_FINITE_F32,	3908	RTLIB::POW_F128, RTLIB::POW_PPCF128, Results);
3950	RTLIB::POW_FINITE_F64,
3951	RTLIB::POW_FINITE_F80,
3952	RTLIB::POW_FINITE_F128,
3953	RTLIB::POW_FINITE_PPCF128));
3954	else
3955	Results.push_back(ExpandFPLibCall(Node, RTLIB::POW_F32, RTLIB::POW_F64,
3956	RTLIB::POW_F80, RTLIB::POW_F128,
3957	RTLIB::POW_PPCF128));
3958	break;	3909	break;
3959	case ISD::FDIV:	3910	case ISD::FDIV:
3960	Results.push_back(ExpandFPLibCall(Node, RTLIB::DIV_F32, RTLIB::DIV_F64,	3911	Results.push_back(ExpandFPLibCall(Node, RTLIB::DIV_F32, RTLIB::DIV_F64,

Lines 1-5 Link Here

(-)a/test/CodeGen/AArch64/illegal-float-ops.ll (-12 / +12 lines)
1	; RUN: llc -mtriple=aarch64-none-linux-gnu -verify-machineinstrs -o - %s \| FileCheck %s	1	; RUN: llc -mtriple=aarch64-none-linux-gnu -verify-machineinstrs -o - %s \| FileCheck %s
2	; RUN: llc -mtriple=aarch64-linux-android -verify-machineinstrs -o - %s \| FileCheck --check-prefix=ANDROID-AARCH64 %s	2	; RUN: llc -mtriple=aarch64-linux-android -verify-machineinstrs -o - %s \| FileCheck %s
3		3
4	@varfloat = global float 0.0	4	@varfloat = global float 0.0
5	@vardouble = global double 0.0	5	@vardouble = global double 0.0
Lines 251-257 define void @test_exp_finite(double %double) #0 { Link Here
251	%expdouble = call double @llvm.exp.f64(double %double)	251	%expdouble = call double @llvm.exp.f64(double %double)
252	store double %expdouble, double* @vardouble	252	store double %expdouble, double* @vardouble
253	; ANDROID-AARCH64-NOT: bl __exp_finite	253	; ANDROID-AARCH64-NOT: bl __exp_finite
254	; CHECK: bl __exp_finite	254	; CHECK: bl exp
255		255
256	ret void	256	ret void
257	}	257	}
Lines 259-266 define void @test_exp_finite(double %double) #0 { Link Here
259	define void @test_exp2_finite(double %double) #0 {	259	define void @test_exp2_finite(double %double) #0 {
260	%expdouble = call double @llvm.exp2.f64(double %double)	260	%expdouble = call double @llvm.exp2.f64(double %double)
261	store double %expdouble, double* @vardouble	261	store double %expdouble, double* @vardouble
262	; ANDROID-AARCH64-NOT: bl __exp2_finite	262	; CHECK-NOT: bl __exp2_finite
263	; CHECK: bl __exp2_finite	263	; CHECK: bl exp2
264		264
265	ret void	265	ret void
266	}	266	}
Lines 268-299 define void @test_exp2_finite(double %double) #0 { Link Here
268	define void @test_log_finite(double %double) #0 {	268	define void @test_log_finite(double %double) #0 {
269	%logdouble = call double @llvm.log.f64(double %double)	269	%logdouble = call double @llvm.log.f64(double %double)
270	store double %logdouble, double* @vardouble	270	store double %logdouble, double* @vardouble
271	; ANDROID-AARCH64-NOT: bl __log_finite	271	; CHECK-NOT: bl __log_finite
272	; CHECK: bl __log_finite	272	; CHECK: bl log
273	ret void	273	ret void
274	}	274	}
275		275
276	define void @test_log2_finite(double %double) #0 {	276	define void @test_log2_finite(double %double) #0 {
277	%log2double = call double @llvm.log2.f64(double %double)	277	%log2double = call double @llvm.log2.f64(double %double)
278	store double %log2double, double* @vardouble	278	store double %log2double, double* @vardouble
279	; ANDROID-AARCH64-NOT: bl __log2_finite	279	; CHECK-NOT: bl __log2_finite
280	; CHECK: bl __log2_finite	280	; CHECK: bl log2
281	ret void	281	ret void
282	}	282	}
283		283
284	define void @test_log10_finite(double %double) #0 {	284	define void @test_log10_finite(double %double) #0 {
285	%log10double = call double @llvm.log10.f64(double %double)	285	%log10double = call double @llvm.log10.f64(double %double)
286	store double %log10double, double* @vardouble	286	store double %log10double, double* @vardouble
287	; ANDROID-AARCH64-NOT: bl __log10_finite	287	; CHECK-NOT: bl __log10_finite
288	; CHECK: bl __log10_finite	288	; CHECK: bl log10
289	ret void	289	ret void
290	}	290	}
291		291
292	define void @test_pow_finite(double %double) #0 {	292	define void @test_pow_finite(double %double) #0 {
293	%powdouble = call double @llvm.pow.f64(double %double, double %double)	293	%powdouble = call double @llvm.pow.f64(double %double, double %double)
294	store double %powdouble, double* @vardouble	294	store double %powdouble, double* @vardouble
295	; ANDROID-AARCH64-NOT: bl __pow_finite	295	; CHECK-NOT: bl __pow_finite
296	; CHECK: bl __pow_finite	296	; CHECK: bl pow
297	ret void	297	ret void
298	}	298	}

Lines 9-15 Link Here

(-)a/test/CodeGen/X86/finite-libcalls.ll (-18 / +18 lines)
9	define float @exp_f32(float %x) #0 {	9	define float @exp_f32(float %x) #0 {
10	; GNU-LABEL: exp_f32:	10	; GNU-LABEL: exp_f32:
11	; GNU: # %bb.0:	11	; GNU: # %bb.0:
12	; GNU-NEXT: jmp __expf_finite # TAILCALL	12	; GNU-NEXT: jmp expf # TAILCALL
13	;	13	;
14	; WIN-LABEL: exp_f32:	14	; WIN-LABEL: exp_f32:
15	; WIN: # %bb.0:	15	; WIN: # %bb.0:
Lines 25-31 define float @exp_f32(float %x) #0 { Link Here
25	define double @exp_f64(double %x) #0 {	25	define double @exp_f64(double %x) #0 {
26	; GNU-LABEL: exp_f64:	26	; GNU-LABEL: exp_f64:
27	; GNU: # %bb.0:	27	; GNU: # %bb.0:
28	; GNU-NEXT: jmp __exp_finite # TAILCALL	28	; GNU-NEXT: jmp exp # TAILCALL
29	;	29	;
30	; WIN-LABEL: exp_f64:	30	; WIN-LABEL: exp_f64:
31	; WIN: # %bb.0:	31	; WIN: # %bb.0:
Lines 44-50 define x86_fp80 @exp_f80(x86_fp80 %x) #0 { Link Here
44	; GNU-NEXT: subq $24, %rsp	44	; GNU-NEXT: subq $24, %rsp
45	; GNU-NEXT: fldt {{[0-9]+}}(%rsp)	45	; GNU-NEXT: fldt {{[0-9]+}}(%rsp)
46	; GNU-NEXT: fstpt (%rsp)	46	; GNU-NEXT: fstpt (%rsp)
47	; GNU-NEXT: callq __expl_finite	47	; GNU-NEXT: callq expl
48	; GNU-NEXT: addq $24, %rsp	48	; GNU-NEXT: addq $24, %rsp
49	; GNU-NEXT: retq	49	; GNU-NEXT: retq
50	;	50	;
Lines 80-86 define x86_fp80 @exp_f80(x86_fp80 %x) #0 { Link Here
80	define float @exp2_f32(float %x) #0 {	80	define float @exp2_f32(float %x) #0 {
81	; GNU-LABEL: exp2_f32:	81	; GNU-LABEL: exp2_f32:
82	; GNU: # %bb.0:	82	; GNU: # %bb.0:
83	; GNU-NEXT: jmp __exp2f_finite # TAILCALL	83	; GNU-NEXT: jmp exp2f # TAILCALL
84	;	84	;
85	; WIN-LABEL: exp2_f32:	85	; WIN-LABEL: exp2_f32:
86	; WIN: # %bb.0:	86	; WIN: # %bb.0:
Lines 96-102 define float @exp2_f32(float %x) #0 { Link Here
96	define double @exp2_f64(double %x) #0 {	96	define double @exp2_f64(double %x) #0 {
97	; GNU-LABEL: exp2_f64:	97	; GNU-LABEL: exp2_f64:
98	; GNU: # %bb.0:	98	; GNU: # %bb.0:
99	; GNU-NEXT: jmp __exp2_finite # TAILCALL	99	; GNU-NEXT: jmp exp2 # TAILCALL
100	;	100	;
101	; WIN-LABEL: exp2_f64:	101	; WIN-LABEL: exp2_f64:
102	; WIN: # %bb.0:	102	; WIN: # %bb.0:
Lines 115-121 define x86_fp80 @exp2_f80(x86_fp80 %x) #0 { Link Here
115	; GNU-NEXT: subq $24, %rsp	115	; GNU-NEXT: subq $24, %rsp
116	; GNU-NEXT: fldt {{[0-9]+}}(%rsp)	116	; GNU-NEXT: fldt {{[0-9]+}}(%rsp)
117	; GNU-NEXT: fstpt (%rsp)	117	; GNU-NEXT: fstpt (%rsp)
118	; GNU-NEXT: callq __exp2l_finite	118	; GNU-NEXT: callq exp2l
119	; GNU-NEXT: addq $24, %rsp	119	; GNU-NEXT: addq $24, %rsp
120	; GNU-NEXT: retq	120	; GNU-NEXT: retq
121	;	121	;
Lines 151-157 define x86_fp80 @exp2_f80(x86_fp80 %x) #0 { Link Here
151	define float @log_f32(float %x) #0 {	151	define float @log_f32(float %x) #0 {
152	; GNU-LABEL: log_f32:	152	; GNU-LABEL: log_f32:
153	; GNU: # %bb.0:	153	; GNU: # %bb.0:
154	; GNU-NEXT: jmp __logf_finite # TAILCALL	154	; GNU-NEXT: jmp logf # TAILCALL
155	;	155	;
156	; WIN-LABEL: log_f32:	156	; WIN-LABEL: log_f32:
157	; WIN: # %bb.0:	157	; WIN: # %bb.0:
Lines 167-173 define float @log_f32(float %x) #0 { Link Here
167	define double @log_f64(double %x) #0 {	167	define double @log_f64(double %x) #0 {
168	; GNU-LABEL: log_f64:	168	; GNU-LABEL: log_f64:
169	; GNU: # %bb.0:	169	; GNU: # %bb.0:
170	; GNU-NEXT: jmp __log_finite # TAILCALL	170	; GNU-NEXT: jmp log # TAILCALL
171	;	171	;
172	; WIN-LABEL: log_f64:	172	; WIN-LABEL: log_f64:
173	; WIN: # %bb.0:	173	; WIN: # %bb.0:
Lines 186-192 define x86_fp80 @log_f80(x86_fp80 %x) #0 { Link Here
186	; GNU-NEXT: subq $24, %rsp	186	; GNU-NEXT: subq $24, %rsp
187	; GNU-NEXT: fldt {{[0-9]+}}(%rsp)	187	; GNU-NEXT: fldt {{[0-9]+}}(%rsp)
188	; GNU-NEXT: fstpt (%rsp)	188	; GNU-NEXT: fstpt (%rsp)
189	; GNU-NEXT: callq __logl_finite	189	; GNU-NEXT: callq logl
190	; GNU-NEXT: addq $24, %rsp	190	; GNU-NEXT: addq $24, %rsp
191	; GNU-NEXT: retq	191	; GNU-NEXT: retq
192	;	192	;
Lines 222-228 define x86_fp80 @log_f80(x86_fp80 %x) #0 { Link Here
222	define float @log2_f32(float %x) #0 {	222	define float @log2_f32(float %x) #0 {
223	; GNU-LABEL: log2_f32:	223	; GNU-LABEL: log2_f32:
224	; GNU: # %bb.0:	224	; GNU: # %bb.0:
225	; GNU-NEXT: jmp __log2f_finite # TAILCALL	225	; GNU-NEXT: jmp log2f # TAILCALL
226	;	226	;
227	; WIN-LABEL: log2_f32:	227	; WIN-LABEL: log2_f32:
228	; WIN: # %bb.0:	228	; WIN: # %bb.0:
Lines 238-244 define float @log2_f32(float %x) #0 { Link Here
238	define double @log2_f64(double %x) #0 {	238	define double @log2_f64(double %x) #0 {
239	; GNU-LABEL: log2_f64:	239	; GNU-LABEL: log2_f64:
240	; GNU: # %bb.0:	240	; GNU: # %bb.0:
241	; GNU-NEXT: jmp __log2_finite # TAILCALL	241	; GNU-NEXT: jmp log2 # TAILCALL
242	;	242	;
243	; WIN-LABEL: log2_f64:	243	; WIN-LABEL: log2_f64:
244	; WIN: # %bb.0:	244	; WIN: # %bb.0:
Lines 257-263 define x86_fp80 @log2_f80(x86_fp80 %x) #0 { Link Here
257	; GNU-NEXT: subq $24, %rsp	257	; GNU-NEXT: subq $24, %rsp
258	; GNU-NEXT: fldt {{[0-9]+}}(%rsp)	258	; GNU-NEXT: fldt {{[0-9]+}}(%rsp)
259	; GNU-NEXT: fstpt (%rsp)	259	; GNU-NEXT: fstpt (%rsp)
260	; GNU-NEXT: callq __log2l_finite	260	; GNU-NEXT: callq log2l
261	; GNU-NEXT: addq $24, %rsp	261	; GNU-NEXT: addq $24, %rsp
262	; GNU-NEXT: retq	262	; GNU-NEXT: retq
263	;	263	;
Lines 293-299 define x86_fp80 @log2_f80(x86_fp80 %x) #0 { Link Here
293	define float @log10_f32(float %x) #0 {	293	define float @log10_f32(float %x) #0 {
294	; GNU-LABEL: log10_f32:	294	; GNU-LABEL: log10_f32:
295	; GNU: # %bb.0:	295	; GNU: # %bb.0:
296	; GNU-NEXT: jmp __log10f_finite # TAILCALL	296	; GNU-NEXT: jmp log10f # TAILCALL
297	;	297	;
298	; WIN-LABEL: log10_f32:	298	; WIN-LABEL: log10_f32:
299	; WIN: # %bb.0:	299	; WIN: # %bb.0:
Lines 309-315 define float @log10_f32(float %x) #0 { Link Here
309	define double @log10_f64(double %x) #0 {	309	define double @log10_f64(double %x) #0 {
310	; GNU-LABEL: log10_f64:	310	; GNU-LABEL: log10_f64:
311	; GNU: # %bb.0:	311	; GNU: # %bb.0:
312	; GNU-NEXT: jmp __log10_finite # TAILCALL	312	; GNU-NEXT: jmp log10 # TAILCALL
313	;	313	;
314	; WIN-LABEL: log10_f64:	314	; WIN-LABEL: log10_f64:
315	; WIN: # %bb.0:	315	; WIN: # %bb.0:
Lines 328-334 define x86_fp80 @log10_f80(x86_fp80 %x) #0 { Link Here
328	; GNU-NEXT: subq $24, %rsp	328	; GNU-NEXT: subq $24, %rsp
329	; GNU-NEXT: fldt {{[0-9]+}}(%rsp)	329	; GNU-NEXT: fldt {{[0-9]+}}(%rsp)
330	; GNU-NEXT: fstpt (%rsp)	330	; GNU-NEXT: fstpt (%rsp)
331	; GNU-NEXT: callq __log10l_finite	331	; GNU-NEXT: callq log10l
332	; GNU-NEXT: addq $24, %rsp	332	; GNU-NEXT: addq $24, %rsp
333	; GNU-NEXT: retq	333	; GNU-NEXT: retq
334	;	334	;
Lines 365-371 define float @pow_f32(float %x) #0 { Link Here
365	; GNU-LABEL: pow_f32:	365	; GNU-LABEL: pow_f32:
366	; GNU: # %bb.0:	366	; GNU: # %bb.0:
367	; GNU-NEXT: movaps %xmm0, %xmm1	367	; GNU-NEXT: movaps %xmm0, %xmm1
368	; GNU-NEXT: jmp __powf_finite # TAILCALL	368	; GNU-NEXT: jmp powf # TAILCALL
369	;	369	;
370	; WIN-LABEL: pow_f32:	370	; WIN-LABEL: pow_f32:
371	; WIN: # %bb.0:	371	; WIN: # %bb.0:
Lines 384-390 define double @pow_f64(double %x) #0 { Link Here
384	; GNU-LABEL: pow_f64:	384	; GNU-LABEL: pow_f64:
385	; GNU: # %bb.0:	385	; GNU: # %bb.0:
386	; GNU-NEXT: movaps %xmm0, %xmm1	386	; GNU-NEXT: movaps %xmm0, %xmm1
387	; GNU-NEXT: jmp __pow_finite # TAILCALL	387	; GNU-NEXT: jmp pow # TAILCALL
388	;	388	;
389	; WIN-LABEL: pow_f64:	389	; WIN-LABEL: pow_f64:
390	; WIN: # %bb.0:	390	; WIN: # %bb.0:
Lines 407-413 define x86_fp80 @pow_f80(x86_fp80 %x) #0 { Link Here
407	; GNU-NEXT: fld %st(0)	407	; GNU-NEXT: fld %st(0)
408	; GNU-NEXT: fstpt {{[0-9]+}}(%rsp)	408	; GNU-NEXT: fstpt {{[0-9]+}}(%rsp)
409	; GNU-NEXT: fstpt (%rsp)	409	; GNU-NEXT: fstpt (%rsp)
410	; GNU-NEXT: callq __powl_finite	410	; GNU-NEXT: callq powl
411	; GNU-NEXT: addq $40, %rsp	411	; GNU-NEXT: addq $40, %rsp
412	; GNU-NEXT: retq	412	; GNU-NEXT: retq
413	;	413	;