Skip to content
Snippets Groups Projects
Commit 4b86c474 authored by Evandro Menezes's avatar Evandro Menezes
Browse files

[TargetLibraryInfo] Update run time support for Windows 

It seems that the run time for Windows has changed and supports more math
functions than it used to, especially on AArch64, ARM, and AMD64.

Fixes PR40541.

Differential revision: https://reviews.llvm.org/D57625

llvm-svn: 353733
parent e57fe23f
No related branches found
No related tags found
No related merge requests found
Expand all Hide whitespace changes
Inline Side-by-side
llvm/lib/Analysis/TargetLibraryInfo.cpp
+ 64
− 35
View file @ 4b86c474
...@@ -160,8 +160,25 @@ static void initialize(TargetLibraryInfoImpl &TLI, const Triple &T, ...@@ -160,8 +160,25 @@ static void initialize(TargetLibraryInfoImpl &TLI, const Triple &T,
} }
if (T.isOSWindows() && !T.isOSCygMing()) { if (T.isOSWindows() && !T.isOSCygMing()) {
if (T.getArch() == Triple::x86) { // XXX: The earliest documentation available at the moment is for VS2015/VC19:
// Win32 does not support float math functions, in general. // https://docs.microsoft.com/en-us/cpp/c-runtime-library/floating-point-support?view=vs-2015
// XXX: In order to use an MSVCRT older than VC19,
// the specific library version must be explicit in the target triple,
// e.g., x86_64-pc-windows-msvc18.
bool hasPartialC99 = true;
if (T.isKnownWindowsMSVCEnvironment()) {
unsigned Major, Minor, Micro;
T.getEnvironmentVersion(Major, Minor, Micro);
hasPartialC99 = (Major == 0 || Major >= 19);
}
// Latest targets support float math functions, in part.
bool hasPartialFloat = (T.getArch() == Triple::aarch64 ||
T.getArch() == Triple::arm ||
T.getArch() == Triple::x86_64);
// Win32 does not support float math functions, in general.
if (!hasPartialFloat) {
TLI.setUnavailable(LibFunc_acosf); TLI.setUnavailable(LibFunc_acosf);
TLI.setUnavailable(LibFunc_asinf); TLI.setUnavailable(LibFunc_asinf);
TLI.setUnavailable(LibFunc_atanf); TLI.setUnavailable(LibFunc_atanf);
...@@ -172,8 +189,6 @@ static void initialize(TargetLibraryInfoImpl &TLI, const Triple &T, ...@@ -172,8 +189,6 @@ static void initialize(TargetLibraryInfoImpl &TLI, const Triple &T,
TLI.setUnavailable(LibFunc_coshf); TLI.setUnavailable(LibFunc_coshf);
TLI.setUnavailable(LibFunc_expf); TLI.setUnavailable(LibFunc_expf);
TLI.setUnavailable(LibFunc_floorf); TLI.setUnavailable(LibFunc_floorf);
TLI.setUnavailable(LibFunc_fminf);
TLI.setUnavailable(LibFunc_fmaxf);
TLI.setUnavailable(LibFunc_fmodf); TLI.setUnavailable(LibFunc_fmodf);
TLI.setUnavailable(LibFunc_logf); TLI.setUnavailable(LibFunc_logf);
TLI.setUnavailable(LibFunc_log10f); TLI.setUnavailable(LibFunc_log10f);
...@@ -185,11 +200,13 @@ static void initialize(TargetLibraryInfoImpl &TLI, const Triple &T, ...@@ -185,11 +200,13 @@ static void initialize(TargetLibraryInfoImpl &TLI, const Triple &T,
TLI.setUnavailable(LibFunc_tanf); TLI.setUnavailable(LibFunc_tanf);
TLI.setUnavailable(LibFunc_tanhf); TLI.setUnavailable(LibFunc_tanhf);
} }
TLI.setUnavailable(LibFunc_fabsf); // Win32 and Win64 both lack fabsf TLI.setUnavailable(LibFunc_fabsf);
TLI.setUnavailable(LibFunc_fmaxf);
TLI.setUnavailable(LibFunc_fminf);
TLI.setUnavailable(LibFunc_frexpf); TLI.setUnavailable(LibFunc_frexpf);
TLI.setUnavailable(LibFunc_ldexpf); TLI.setUnavailable(LibFunc_ldexpf);
// Win32 does not support long double. // Win32 does not support long double math functions.
TLI.setUnavailable(LibFunc_acosl); TLI.setUnavailable(LibFunc_acosl);
TLI.setUnavailable(LibFunc_asinl); TLI.setUnavailable(LibFunc_asinl);
TLI.setUnavailable(LibFunc_atanl); TLI.setUnavailable(LibFunc_atanl);
...@@ -207,6 +224,7 @@ static void initialize(TargetLibraryInfoImpl &TLI, const Triple &T, ...@@ -207,6 +224,7 @@ static void initialize(TargetLibraryInfoImpl &TLI, const Triple &T,
TLI.setUnavailable(LibFunc_frexpl); TLI.setUnavailable(LibFunc_frexpl);
TLI.setUnavailable(LibFunc_ldexpl); TLI.setUnavailable(LibFunc_ldexpl);
TLI.setUnavailable(LibFunc_logl); TLI.setUnavailable(LibFunc_logl);
TLI.setUnavailable(LibFunc_log10l);
TLI.setUnavailable(LibFunc_modfl); TLI.setUnavailable(LibFunc_modfl);
TLI.setUnavailable(LibFunc_powl); TLI.setUnavailable(LibFunc_powl);
TLI.setUnavailable(LibFunc_sinl); TLI.setUnavailable(LibFunc_sinl);
...@@ -216,51 +234,62 @@ static void initialize(TargetLibraryInfoImpl &TLI, const Triple &T, ...@@ -216,51 +234,62 @@ static void initialize(TargetLibraryInfoImpl &TLI, const Triple &T,
TLI.setUnavailable(LibFunc_tanhl); TLI.setUnavailable(LibFunc_tanhl);
// Win32 does not fully support C99 math functions. // Win32 does not fully support C99 math functions.
TLI.setUnavailable(LibFunc_acosh); if (!hasPartialC99) {
TLI.setUnavailable(LibFunc_acosh);
TLI.setUnavailable(LibFunc_asinh);
TLI.setUnavailable(LibFunc_atanh);
TLI.setUnavailable(LibFunc_cbrt);
TLI.setUnavailable(LibFunc_exp2);
TLI.setUnavailable(LibFunc_expm1);
TLI.setUnavailable(LibFunc_log1p);
TLI.setUnavailable(LibFunc_log2);
TLI.setUnavailable(LibFunc_logb);
TLI.setUnavailable(LibFunc_nearbyint);
TLI.setUnavailable(LibFunc_rint);
TLI.setUnavailable(LibFunc_round);
TLI.setUnavailable(LibFunc_trunc);
}
// Win32 does not support float C99 math functions, in general.
TLI.setUnavailable(LibFunc_acoshf); TLI.setUnavailable(LibFunc_acoshf);
TLI.setUnavailable(LibFunc_acoshl);
TLI.setUnavailable(LibFunc_asinh);
TLI.setUnavailable(LibFunc_asinhf); TLI.setUnavailable(LibFunc_asinhf);
TLI.setUnavailable(LibFunc_asinhl);
TLI.setUnavailable(LibFunc_atanh);
TLI.setUnavailable(LibFunc_atanhf); TLI.setUnavailable(LibFunc_atanhf);
TLI.setUnavailable(LibFunc_atanhl);
TLI.setUnavailable(LibFunc_cabs);
TLI.setUnavailable(LibFunc_cabsf); TLI.setUnavailable(LibFunc_cabsf);
TLI.setUnavailable(LibFunc_cabsl);
TLI.setUnavailable(LibFunc_cbrt);
TLI.setUnavailable(LibFunc_cbrtf); TLI.setUnavailable(LibFunc_cbrtf);
TLI.setUnavailable(LibFunc_cbrtl);
TLI.setUnavailable(LibFunc_exp2);
TLI.setUnavailable(LibFunc_exp2f); TLI.setUnavailable(LibFunc_exp2f);
TLI.setUnavailable(LibFunc_exp2l);
TLI.setUnavailable(LibFunc_expm1);
TLI.setUnavailable(LibFunc_expm1f); TLI.setUnavailable(LibFunc_expm1f);
TLI.setUnavailable(LibFunc_expm1l);
TLI.setUnavailable(LibFunc_log2);
TLI.setUnavailable(LibFunc_log2f);
TLI.setUnavailable(LibFunc_log2l);
TLI.setUnavailable(LibFunc_log1p);
TLI.setUnavailable(LibFunc_log1pf); TLI.setUnavailable(LibFunc_log1pf);
TLI.setUnavailable(LibFunc_log2f);
if (!hasPartialFloat || !hasPartialC99)
TLI.setUnavailable(LibFunc_logbf);
TLI.setUnavailable(LibFunc_nearbyintf);
TLI.setUnavailable(LibFunc_rintf);
TLI.setUnavailable(LibFunc_roundf);
TLI.setUnavailable(LibFunc_truncf);
// Win32 does not support long double C99 math functions.
TLI.setUnavailable(LibFunc_acoshl);
TLI.setUnavailable(LibFunc_asinhl);
TLI.setUnavailable(LibFunc_atanhl);
TLI.setUnavailable(LibFunc_cabsl);
TLI.setUnavailable(LibFunc_cbrtl);
TLI.setUnavailable(LibFunc_exp2l);
TLI.setUnavailable(LibFunc_expm1l);
TLI.setUnavailable(LibFunc_log1pl); TLI.setUnavailable(LibFunc_log1pl);
TLI.setUnavailable(LibFunc_logb); TLI.setUnavailable(LibFunc_log2l);
TLI.setUnavailable(LibFunc_logbf);
TLI.setUnavailable(LibFunc_logbl); TLI.setUnavailable(LibFunc_logbl);
TLI.setUnavailable(LibFunc_nearbyint);
TLI.setUnavailable(LibFunc_nearbyintf);
TLI.setUnavailable(LibFunc_nearbyintl); TLI.setUnavailable(LibFunc_nearbyintl);
TLI.setUnavailable(LibFunc_rint);
TLI.setUnavailable(LibFunc_rintf);
TLI.setUnavailable(LibFunc_rintl); TLI.setUnavailable(LibFunc_rintl);
TLI.setUnavailable(LibFunc_round);
TLI.setUnavailable(LibFunc_roundf);
TLI.setUnavailable(LibFunc_roundl); TLI.setUnavailable(LibFunc_roundl);
TLI.setUnavailable(LibFunc_trunc);
TLI.setUnavailable(LibFunc_truncf);
TLI.setUnavailable(LibFunc_truncl); TLI.setUnavailable(LibFunc_truncl);
// Win32 supports some C99 math functions, but with mangled names. // Win32 supports some C89 and C99 math functions, but with mangled names.
TLI.setAvailableWithName(LibFunc_cabs, "_cabs");
TLI.setAvailableWithName(LibFunc_copysign, "_copysign"); TLI.setAvailableWithName(LibFunc_copysign, "_copysign");
if (hasPartialFloat)
TLI.setAvailableWithName(LibFunc_copysignf, "_copysignf");
if (hasPartialFloat && hasPartialC99)
TLI.setAvailableWithName(LibFunc_logbf, "_logbf");
// Win32 does not support these C99 functions. // Win32 does not support these C99 functions.
TLI.setUnavailable(LibFunc_atoll); TLI.setUnavailable(LibFunc_atoll);
......
llvm/test/Transforms/InstCombine/double-float-shrink-1.ll
+ 79
− 53
View file @ 4b86c474
; RUN: opt < %s -instcombine -S -mtriple x86_64-unknown-linux-gnu | FileCheck %s --check-prefixes=CHECK,LINUX,LIN64 ; RUN: opt < %s -instcombine -S -mtriple x86_64-unknown-linux-gnu | FileCheck %s --check-prefixes=CHECK,LINUX,LINMS
; RUN: opt < %s -instcombine -S -mtriple x86_64-pc-win32 | FileCheck %s --check-prefixes=CHECK,WIN64,WIN96,LIN64 ; RUN: opt < %s -instcombine -S -mtriple x86_64-pc-win32 | FileCheck %s --check-prefixes=CHECK,MSVC,LINMS
; RUN: opt < %s -instcombine -S -mtriple i386-pc-win32 | FileCheck %s --check-prefixes=CHECK,WIN32,WIN96 ; RUN: opt < %s -instcombine -S -mtriple x86_64-pc-windows-msvc16 | FileCheck %s --check-prefixes=CHECK,MSVC,MS64
; RUN: opt < %s -instcombine -S -mtriple i386-pc-windows-msvc | FileCheck %s --check-prefixes=CHECK,MSVC,MS32
; RUN: opt < %s -instcombine -S -mtriple i686-pc-windows-msvc17 | FileCheck %s --check-prefixes=CHECK,MSVC,MS32
; Check for and against shrinkage when using the ; Check for and against shrinkage when using the
; unsafe-fp-math function attribute on a math lib ; unsafe-fp-math function attribute on a math lib
...@@ -10,9 +12,11 @@ ...@@ -10,9 +12,11 @@
define float @acos_test1(float %f) { define float @acos_test1(float %f) {
; CHECK-LABEL: @acos_test1( ; CHECK-LABEL: @acos_test1(
; LIN64-NEXT: [[ACOSF:%.*]] = call fast float @acosf(float [[F:%.*]]) ; LINMS-NEXT: [[ACOSF:%.*]] = call fast float @acosf(float [[F:%.*]])
; LIN64-NEXT: ret float [[ACOSF]] ; LINMS-NEXT: ret float [[ACOSF]]
; WIN32: [[ACOSF:%.*]] = call fast double @acos(double [[F:%.*]]) ; MS64-NEXT: [[ACOSF:%.*]] = call fast float @acosf(float [[F:%.*]])
; MS64-NEXT: ret float [[ACOSF]]
; MS32: [[ACOSF:%.*]] = call fast double @acos(double [[F:%.*]])
; ;
%conv = fpext float %f to double %conv = fpext float %f to double
%call = call fast double @acos(double %conv) %call = call fast double @acos(double %conv)
...@@ -35,7 +39,7 @@ define float @acosh_test1(float %f) { ...@@ -35,7 +39,7 @@ define float @acosh_test1(float %f) {
; CHECK-LABEL: @acosh_test1( ; CHECK-LABEL: @acosh_test1(
; LINUX-NEXT: [[ACOSHF:%.*]] = call fast float @acoshf(float [[F:%.*]]) ; LINUX-NEXT: [[ACOSHF:%.*]] = call fast float @acoshf(float [[F:%.*]])
; LINUX-NEXT: ret float [[ACOSHF]] ; LINUX-NEXT: ret float [[ACOSHF]]
; WIN96: [[ACOSHF:%.*]] = call fast double @acosh(double [[F:%.*]]) ; MSVC: [[ACOSHF:%.*]] = call fast double @acosh(double [[F:%.*]])
; ;
%conv = fpext float %f to double %conv = fpext float %f to double
%call = call fast double @acosh(double %conv) %call = call fast double @acosh(double %conv)
...@@ -56,9 +60,11 @@ define double @acosh_test2(float %f) { ...@@ -56,9 +60,11 @@ define double @acosh_test2(float %f) {
define float @asin_test1(float %f) { define float @asin_test1(float %f) {
; CHECK-LABEL: @asin_test1( ; CHECK-LABEL: @asin_test1(
; LIN64-NEXT: [[ASINF:%.*]] = call fast float @asinf(float [[F:%.*]]) ; LINMS-NEXT: [[ASINF:%.*]] = call fast float @asinf(float [[F:%.*]])
; LIN64-NEXT: ret float [[ASINF]] ; LINMS-NEXT: ret float [[ASINF]]
; WIN32: [[ASINF:%.*]] = call fast double @asin(double [[F:%.*]]) ; MS64-NEXT: [[ASINF:%.*]] = call fast float @asinf(float [[F:%.*]])
; MS64-NEXT: ret float [[ASINF]]
; MS32: [[ASINF:%.*]] = call fast double @asin(double [[F:%.*]])
; ;
%conv = fpext float %f to double %conv = fpext float %f to double
%call = call fast double @asin(double %conv) %call = call fast double @asin(double %conv)
...@@ -81,7 +87,7 @@ define float @asinh_test1(float %f) { ...@@ -81,7 +87,7 @@ define float @asinh_test1(float %f) {
; CHECK-LABEL: @asinh_test1( ; CHECK-LABEL: @asinh_test1(
; LINUX-NEXT: [[ASINHF:%.*]] = call fast float @asinhf(float [[F:%.*]]) ; LINUX-NEXT: [[ASINHF:%.*]] = call fast float @asinhf(float [[F:%.*]])
; LINUX-NEXT: ret float [[ASINHF]] ; LINUX-NEXT: ret float [[ASINHF]]
; WIN96: [[ASINHF:%.*]] = call fast double @asinh(double [[F:%.*]]) ; MSVC: [[ASINHF:%.*]] = call fast double @asinh(double [[F:%.*]])
; ;
%conv = fpext float %f to double %conv = fpext float %f to double
%call = call fast double @asinh(double %conv) %call = call fast double @asinh(double %conv)
...@@ -102,9 +108,11 @@ define double @asinh_test2(float %f) { ...@@ -102,9 +108,11 @@ define double @asinh_test2(float %f) {
define float @atan_test1(float %f) { define float @atan_test1(float %f) {
; CHECK-LABEL: @atan_test1( ; CHECK-LABEL: @atan_test1(
; LIN64-NEXT: [[ATANF:%.*]] = call fast float @atanf(float [[F:%.*]]) ; LINMS-NEXT: [[ATANF:%.*]] = call fast float @atanf(float [[F:%.*]])
; LIN64-NEXT: ret float [[ATANF]] ; LINMS-NEXT: ret float [[ATANF]]
; WIN32: [[ATANF:%.*]] = call fast double @atan(double [[F:%.*]]) ; MS64-NEXT: [[ATANF:%.*]] = call fast float @atanf(float [[F:%.*]])
; MS64-NEXT: ret float [[ATANF]]
; MS32: [[ATANF:%.*]] = call fast double @atan(double [[F:%.*]])
; ;
%conv = fpext float %f to double %conv = fpext float %f to double
%call = call fast double @atan(double %conv) %call = call fast double @atan(double %conv)
...@@ -127,7 +135,7 @@ define float @atanh_test1(float %f) { ...@@ -127,7 +135,7 @@ define float @atanh_test1(float %f) {
; CHECK-LABEL: @atanh_test1( ; CHECK-LABEL: @atanh_test1(
; LINUX-NEXT: [[ATANHF:%.*]] = call fast float @atanhf(float [[F:%.*]]) ; LINUX-NEXT: [[ATANHF:%.*]] = call fast float @atanhf(float [[F:%.*]])
; LINUX-NEXT: ret float [[ATANHF]] ; LINUX-NEXT: ret float [[ATANHF]]
; WIN96: [[ATANHF:%.*]] = call fast double @atanh(double [[F:%.*]]) ; MSVC: [[ATANHF:%.*]] = call fast double @atanh(double [[F:%.*]])
; ;
%conv = fpext float %f to double %conv = fpext float %f to double
%call = call fast double @atanh(double %conv) %call = call fast double @atanh(double %conv)
...@@ -150,7 +158,7 @@ define float @cbrt_test1(float %f) { ...@@ -150,7 +158,7 @@ define float @cbrt_test1(float %f) {
; CHECK-LABEL: @cbrt_test1( ; CHECK-LABEL: @cbrt_test1(
; LINUX-NEXT: [[CBRTF:%.*]] = call fast float @cbrtf(float [[F:%.*]]) ; LINUX-NEXT: [[CBRTF:%.*]] = call fast float @cbrtf(float [[F:%.*]])
; LINUX-NEXT: ret float [[CBRTF]] ; LINUX-NEXT: ret float [[CBRTF]]
; WIN96: [[CBRTF:%.*]] = call fast double @cbrt(double [[F:%.*]]) ; MSVC: [[CBRTF:%.*]] = call fast double @cbrt(double [[F:%.*]])
; ;
%conv = fpext float %f to double %conv = fpext float %f to double
%call = call fast double @cbrt(double %conv) %call = call fast double @cbrt(double %conv)
...@@ -171,9 +179,11 @@ define double @cbrt_test2(float %f) { ...@@ -171,9 +179,11 @@ define double @cbrt_test2(float %f) {
define float @exp_test1(float %f) { define float @exp_test1(float %f) {
; CHECK-LABEL: @exp_test1( ; CHECK-LABEL: @exp_test1(
; LIN64-NEXT: [[EXPF:%.*]] = call fast float @expf(float [[F:%.*]]) ; LINMS-NEXT: [[EXPF:%.*]] = call fast float @expf(float [[F:%.*]])
; LIN64-NEXT: ret float [[EXPF]] ; LINMS-NEXT: ret float [[EXPF]]
; WIN32: [[EXPF:%.*]] = call fast double @exp(double [[F:%.*]]) ; MS64-NEXT: [[EXPF:%.*]] = call fast float @expf(float [[F:%.*]])
; MS64-NEXT: ret float [[EXPF]]
; MS32: [[EXPF:%.*]] = call fast double @exp(double [[F:%.*]])
; ;
%conv = fpext float %f to double %conv = fpext float %f to double
%call = call fast double @exp(double %conv) %call = call fast double @exp(double %conv)
...@@ -196,7 +206,7 @@ define float @expm1_test1(float %f) { ...@@ -196,7 +206,7 @@ define float @expm1_test1(float %f) {
; CHECK-LABEL: @expm1_test1( ; CHECK-LABEL: @expm1_test1(
; LINUX-NEXT: [[EXPM1F:%.*]] = call fast float @expm1f(float [[F:%.*]]) ; LINUX-NEXT: [[EXPM1F:%.*]] = call fast float @expm1f(float [[F:%.*]])
; LINUX-NEXT: ret float [[EXPM1F]] ; LINUX-NEXT: ret float [[EXPM1F]]
; WIN96: [[EXPM1F:%.*]] = call fast double @expm1(double [[F:%.*]]) ; MSVC: [[EXPM1F:%.*]] = call fast double @expm1(double [[F:%.*]])
; ;
%conv = fpext float %f to double %conv = fpext float %f to double
%call = call fast double @expm1(double %conv) %call = call fast double @expm1(double %conv)
...@@ -243,9 +253,11 @@ define double @exp10_test2(float %f) { ...@@ -243,9 +253,11 @@ define double @exp10_test2(float %f) {
define float @log_test1(float %f) { define float @log_test1(float %f) {
; CHECK-LABEL: @log_test1( ; CHECK-LABEL: @log_test1(
; LIN64-NEXT: [[LOGF:%.*]] = call fast float @logf(float [[F:%.*]]) ; LINMS-NEXT: [[LOGF:%.*]] = call fast float @logf(float [[F:%.*]])
; LIN64-NEXT: ret float [[LOGF]] ; LINMS-NEXT: ret float [[LOGF]]
; WIN32: [[LOGF:%.*]] = call fast double @log(double [[F:%.*]]) ; MS64-NEXT: [[LOGF:%.*]] = call fast float @logf(float [[F:%.*]])
; MS64-NEXT: ret float [[LOGF]]
; MS32: [[LOGF:%.*]] = call fast double @log(double [[F:%.*]])
; ;
%conv = fpext float %f to double %conv = fpext float %f to double
%call = call fast double @log(double %conv) %call = call fast double @log(double %conv)
...@@ -266,9 +278,11 @@ define double @log_test2(float %f) { ...@@ -266,9 +278,11 @@ define double @log_test2(float %f) {
define float @log10_test1(float %f) { define float @log10_test1(float %f) {
; CHECK-LABEL: @log10_test1( ; CHECK-LABEL: @log10_test1(
; LIN64-NEXT: [[LOG10F:%.*]] = call fast float @log10f(float [[F:%.*]]) ; LINMS-NEXT: [[LOG10F:%.*]] = call fast float @log10f(float [[F:%.*]])
; LIN64-NEXT: ret float [[LOG10F]] ; LINMS-NEXT: ret float [[LOG10F]]
; WIN32: [[LOG10F:%.*]] = call fast double @log10(double [[F:%.*]]) ; MS64-NEXT: [[LOG10F:%.*]] = call fast float @log10f(float [[F:%.*]])
; MS64-NEXT: ret float [[LOG10F]]
; MS32: [[LOG10F:%.*]] = call fast double @log10(double [[F:%.*]])
; ;
%conv = fpext float %f to double %conv = fpext float %f to double
%call = call fast double @log10(double %conv) %call = call fast double @log10(double %conv)
...@@ -291,7 +305,7 @@ define float @log1p_test1(float %f) { ...@@ -291,7 +305,7 @@ define float @log1p_test1(float %f) {
; CHECK-LABEL: @log1p_test1( ; CHECK-LABEL: @log1p_test1(
; LINUX-NEXT: [[LOG1PF:%.*]] = call fast float @log1pf(float [[F:%.*]]) ; LINUX-NEXT: [[LOG1PF:%.*]] = call fast float @log1pf(float [[F:%.*]])
; LINUX-NEXT: ret float [[LOG1PF]] ; LINUX-NEXT: ret float [[LOG1PF]]
; WIN96: [[LOG1PF:%.*]] = call fast double @log1p(double [[F:%.*]]) ; MSVC: [[LOG1PF:%.*]] = call fast double @log1p(double [[F:%.*]])
; ;
%conv = fpext float %f to double %conv = fpext float %f to double
%call = call fast double @log1p(double %conv) %call = call fast double @log1p(double %conv)
...@@ -313,8 +327,8 @@ define double @log1p_test2(float %f) { ...@@ -313,8 +327,8 @@ define double @log1p_test2(float %f) {
define float @log2_test1(float %f) { define float @log2_test1(float %f) {
; CHECK-LABEL: @log2_test1( ; CHECK-LABEL: @log2_test1(
; LINUX-NEXT: [[LOG2F:%.*]] = call fast float @log2f(float [[F:%.*]]) ; LINUX-NEXT: [[LOG2F:%.*]] = call fast float @log2f(float [[F:%.*]])
; LINUX-NEXT: ret float [[LOG2F]] ; LINUX-NEXT: ret float [[LOG2F]]
; WIN96: [[LOG2F:%.*]] = call fast double @log2(double [[F:%.*]]) ; MSVC: [[LOG2F:%.*]] = call fast double @log2(double [[F:%.*]])
; ;
%conv = fpext float %f to double %conv = fpext float %f to double
%call = call fast double @log2(double %conv) %call = call fast double @log2(double %conv)
...@@ -335,9 +349,9 @@ define double @log2_test2(float %f) { ...@@ -335,9 +349,9 @@ define double @log2_test2(float %f) {
define float @logb_test1(float %f) { define float @logb_test1(float %f) {
; CHECK-LABEL: @logb_test1( ; CHECK-LABEL: @logb_test1(
; LINUX-NEXT: [[LOGBF:%.*]] = call fast float @logbf(float [[F:%.*]]) ; LINMS-NEXT: [[LOGBF:%.*]] = call fast float @logbf(float [[F:%.*]])
; LINUX-NEXT: ret float [[LOGBF]] ; LINMS-NEXT: ret float [[LOGBF]]
; WIN96: [[LOGBF:%.*]] = call fast double @logb(double [[F:%.*]]) ; MS64: [[LOGBF:%.*]] = call fast double @logb(double [[F:%.*]])
; ;
%conv = fpext float %f to double %conv = fpext float %f to double
%call = call fast double @logb(double %conv) %call = call fast double @logb(double %conv)
...@@ -358,9 +372,11 @@ define double @logb_test2(float %f) { ...@@ -358,9 +372,11 @@ define double @logb_test2(float %f) {
define float @pow_test1(float %f, float %g) { define float @pow_test1(float %f, float %g) {
; CHECK-LABEL: @pow_test1( ; CHECK-LABEL: @pow_test1(
; LIN64-NEXT: [[POWF:%.*]] = call fast float @powf(float %f, float %g) ; LINMS-NEXT: [[POWF:%.*]] = call fast float @powf(float %f, float %g)
; LIN64-NEXT: ret float [[POWF]] ; LINMS-NEXT: ret float [[POWF]]
; WIN32: [[POWF:%.*]] = call fast double @pow(double %df, double %dg) ; MS64-NEXT: [[POWF:%.*]] = call fast float @powf(float %f, float %g)
; MS64-NEXT: ret float [[POWF]]
; MS32: [[POWF:%.*]] = call fast double @pow(double %df, double %dg)
; ;
%df = fpext float %f to double %df = fpext float %f to double
%dg = fpext float %g to double %dg = fpext float %g to double
...@@ -382,9 +398,11 @@ define double @pow_test2(float %f, float %g) { ...@@ -382,9 +398,11 @@ define double @pow_test2(float %f, float %g) {
define float @sin_test1(float %f) { define float @sin_test1(float %f) {
; CHECK-LABEL: @sin_test1( ; CHECK-LABEL: @sin_test1(
; LIN64-NEXT: [[SINF:%.*]] = call fast float @sinf(float [[F:%.*]]) ; LINMS-NEXT: [[SINF:%.*]] = call fast float @sinf(float [[F:%.*]])
; LIN64-NEXT: ret float [[SINF]] ; LINMS-NEXT: ret float [[SINF]]
; WIN32: [[SINF:%.*]] = call fast double @sin(double [[F:%.*]]) ; MS64-NEXT: [[SINF:%.*]] = call fast float @sinf(float [[F:%.*]])
; MS64-NEXT: ret float [[SINF]]
; MS32: [[SINF:%.*]] = call fast double @sin(double [[F:%.*]])
; ;
%conv = fpext float %f to double %conv = fpext float %f to double
%call = call fast double @sin(double %conv) %call = call fast double @sin(double %conv)
...@@ -405,9 +423,11 @@ define double @sin_test2(float %f) { ...@@ -405,9 +423,11 @@ define double @sin_test2(float %f) {
define float @sqrt_test1(float %f) { define float @sqrt_test1(float %f) {
; CHECK-LABEL: @sqrt_test1( ; CHECK-LABEL: @sqrt_test1(
; LIN64-NEXT: [[SQRTF:%.*]] = call float @sqrtf(float [[F:%.*]]) ; LINMS-NEXT: [[SQRTF:%.*]] = call float @sqrtf(float [[F:%.*]])
; LIN64-NEXT: ret float [[SQRTF]] ; LINMS-NEXT: ret float [[SQRTF]]
; WIN32: [[SQRTF:%.*]] = call double @sqrt(double [[F:%.*]]) ; MS64-NEXT: [[SQRTF:%.*]] = call float @sqrtf(float [[F:%.*]])
; MS64-NEXT: ret float [[SQRTF]]
; MS32: [[SQRTF:%.*]] = call double @sqrt(double [[F:%.*]])
; ;
%conv = fpext float %f to double %conv = fpext float %f to double
%call = call double @sqrt(double %conv) %call = call double @sqrt(double %conv)
...@@ -428,9 +448,11 @@ define double @sqrt_test2(float %f) { ...@@ -428,9 +448,11 @@ define double @sqrt_test2(float %f) {
define float @sqrt_int_test1(float %f) { define float @sqrt_int_test1(float %f) {
; CHECK-LABEL: @sqrt_int_test1( ; CHECK-LABEL: @sqrt_int_test1(
; LIN64-NEXT: [[TMP1:%.*]] = call float @llvm.sqrt.f32(float [[F:%.*]]) ; LINMS-NEXT: [[TMP1:%.*]] = call float @llvm.sqrt.f32(float [[F:%.*]])
; LIN64-NEXT: ret float [[TMP1]] ; LINMS-NEXT: ret float [[TMP1]]
; WIN32: [[TMP1:%.*]] = call double @llvm.sqrt.f64(double [[F:%.*]]) ; MS64-NEXT: [[TMP1:%.*]] = call float @llvm.sqrt.f32(float [[F:%.*]])
; MS64-NEXT: ret float [[TMP1]]
; MS32: [[TMP1:%.*]] = call double @llvm.sqrt.f64(double [[F:%.*]])
; ;
%conv = fpext float %f to double %conv = fpext float %f to double
%call = call double @llvm.sqrt.f64(double %conv) %call = call double @llvm.sqrt.f64(double %conv)
...@@ -451,9 +473,11 @@ define double @sqrt_int_test2(float %f) { ...@@ -451,9 +473,11 @@ define double @sqrt_int_test2(float %f) {
define float @tan_test1(float %f) { define float @tan_test1(float %f) {
; CHECK-LABEL: @tan_test1( ; CHECK-LABEL: @tan_test1(
; LIN64-NEXT: [[TANF:%.*]] = call fast float @tanf(float [[F:%.*]]) ; LINMS-NEXT: [[TANF:%.*]] = call fast float @tanf(float [[F:%.*]])
; LIN64-NEXT: ret float [[TANF]] ; LINMS-NEXT: ret float [[TANF]]
; WIN32: [[TANF:%.*]] = call fast double @tan(double [[F:%.*]]) ; MS64-NEXT: [[TANF:%.*]] = call fast float @tanf(float [[F:%.*]])
; MS64-NEXT: ret float [[TANF]]
; MS32: [[TANF:%.*]] = call fast double @tan(double [[F:%.*]])
; ;
%conv = fpext float %f to double %conv = fpext float %f to double
%call = call fast double @tan(double %conv) %call = call fast double @tan(double %conv)
...@@ -473,9 +497,11 @@ define double @tan_test2(float %f) { ...@@ -473,9 +497,11 @@ define double @tan_test2(float %f) {
} }
define float @tanh_test1(float %f) { define float @tanh_test1(float %f) {
; CHECK-LABEL: @tanh_test1( ; CHECK-LABEL: @tanh_test1(
; LIN64-NEXT: [[TANHF:%.*]] = call fast float @tanhf(float [[F:%.*]]) ; LINMS-NEXT: [[TANHF:%.*]] = call fast float @tanhf(float [[F:%.*]])
; LIN64-NEXT: ret float [[TANHF]] ; LINMS-NEXT: ret float [[TANHF]]
; WIN32: [[TANHF:%.*]] = call fast double @tanh(double [[F:%.*]]) ; MS64-NEXT: [[TANHF:%.*]] = call fast float @tanhf(float [[F:%.*]])
; MS64-NEXT: ret float [[TANHF]]
; MS32: [[TANHF:%.*]] = call fast double @tanh(double [[F:%.*]])
; ;
%conv = fpext float %f to double %conv = fpext float %f to double
%call = call fast double @tanh(double %conv) %call = call fast double @tanh(double %conv)
...@@ -498,9 +524,9 @@ define double @tanh_test2(float %f) { ...@@ -498,9 +524,9 @@ define double @tanh_test2(float %f) {
; flags are propagated for shrunken *binary* double FP calls. ; flags are propagated for shrunken *binary* double FP calls.
define float @max1(float %a, float %b) { define float @max1(float %a, float %b) {
; CHECK-LABEL: @max1( ; CHECK-LABEL: @max1(
; LIN64-NEXT: [[FMAXF:%.*]] = call arcp float @fmaxf(float [[A:%.*]], float [[B:%.*]]) ; LINUX-NEXT: [[FMAXF:%.*]] = call arcp float @fmaxf(float [[A:%.*]], float [[B:%.*]])
; LIN64-NEXT: ret float [[FMAXF]] ; LINUX-NEXT: ret float [[FMAXF]]
; WIN32: [[FMAXF:%.*]] = call arcp double @fmax(double [[A:%.*]], double [[B:%.*]]) ; MSVC: [[FMAXF:%.*]] = call arcp double @fmax(double [[A:%.*]], double [[B:%.*]])
; ;
%c = fpext float %a to double %c = fpext float %a to double
%d = fpext float %b to double %d = fpext float %b to double
......
llvm/test/Transforms/InstCombine/double-float-shrink-2.ll
+ 12
− 45
View file @ 4b86c474
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instcombine -S -mtriple "i386-pc-linux" | FileCheck --check-prefixes=CHECK,DO-SIMPLIFY %s ; RUN: opt < %s -instcombine -S -mtriple "i386-pc-linux" | FileCheck %s
; RUN: opt < %s -instcombine -S -mtriple "i386-pc-win32" | FileCheck --check-prefixes=CHECK,DONT-SIMPLIFY %s ; RUN: opt < %s -instcombine -S -mtriple "i386-pc-win32" | FileCheck %s
; RUN: opt < %s -instcombine -S -mtriple "x86_64-pc-win32" | FileCheck --check-prefixes=CHECK,C89-SIMPLIFY %s ; RUN: opt < %s -instcombine -S -mtriple "x86_64-pc-win32" | FileCheck %s
; RUN: opt < %s -instcombine -S -mtriple "i386-pc-mingw32" | FileCheck --check-prefixes=CHECK,DO-SIMPLIFY %s ; RUN: opt < %s -instcombine -S -mtriple "i386-pc-mingw32" | FileCheck %s
; RUN: opt < %s -instcombine -S -mtriple "x86_64-pc-mingw32" | FileCheck --check-prefixes=CHECK,DO-SIMPLIFY %s ; RUN: opt < %s -instcombine -S -mtriple "x86_64-pc-mingw32" | FileCheck %s
; RUN: opt < %s -instcombine -S -mtriple "sparc-sun-solaris" | FileCheck --check-prefixes=CHECK,DO-SIMPLIFY %s ; RUN: opt < %s -instcombine -S -mtriple "sparc-sun-solaris" | FileCheck %s
; RUN: opt < %s -instcombine -S -mtriple "x86_64-pc-win32" -enable-debugify 2>&1 | FileCheck --check-prefix=DBG-VALID %s ; RUN: opt < %s -instcombine -S -mtriple "x86_64-pc-win32" -enable-debugify 2>&1 | FileCheck --check-prefix=DBG-VALID %s
declare double @floor(double) declare double @floor(double)
...@@ -61,19 +61,8 @@ define float @test_shrink_libcall_ceil(float %C) { ...@@ -61,19 +61,8 @@ define float @test_shrink_libcall_ceil(float %C) {
define float @test_shrink_libcall_round(float %C) { define float @test_shrink_libcall_round(float %C) {
; CHECK-LABEL: @test_shrink_libcall_round( ; CHECK-LABEL: @test_shrink_libcall_round(
; CHECK-NEXT: [[F:%.*]] = call float @llvm.round.f32(float [[C:%.*]])
; DO-SIMPLIFY-NEXT: [[F:%.*]] = call float @llvm.round.f32(float [[C:%.*]]) ; CHECK-NEXT: ret float [[F]]
; DO-SIMPLIFY-NEXT: ret float [[F]]
;
; DONT-SIMPLIFY-NEXT: [[D:%.*]] = fpext float [[C:%.*]] to double
; DONT-SIMPLIFY-NEXT: [[E:%.*]] = call double @round(double [[D]])
; DONT-SIMPLIFY-NEXT: [[F:%.*]] = fptrunc double [[E]] to float
; DONT-SIMPLIFY-NEXT: ret float [[F]]
;
; C89-SIMPLIFY-NEXT: [[D:%.*]] = fpext float [[C:%.*]] to double
; C89-SIMPLIFY-NEXT: [[E:%.*]] = call double @round(double [[D]])
; C89-SIMPLIFY-NEXT: [[F:%.*]] = fptrunc double [[E]] to float
; C89-SIMPLIFY-NEXT: ret float [[F]]
; ;
%D = fpext float %C to double %D = fpext float %C to double
; --> roundf ; --> roundf
...@@ -84,19 +73,8 @@ define float @test_shrink_libcall_round(float %C) { ...@@ -84,19 +73,8 @@ define float @test_shrink_libcall_round(float %C) {
define float @test_shrink_libcall_nearbyint(float %C) { define float @test_shrink_libcall_nearbyint(float %C) {
; CHECK-LABEL: @test_shrink_libcall_nearbyint( ; CHECK-LABEL: @test_shrink_libcall_nearbyint(
; CHECK-NEXT: [[F:%.*]] = call float @llvm.nearbyint.f32(float [[C:%.*]])
; DO-SIMPLIFY-NEXT: [[F:%.*]] = call float @llvm.nearbyint.f32(float [[C:%.*]]) ; CHECK-NEXT: ret float [[F]]
; DO-SIMPLIFY-NEXT: ret float [[F]]
;
; DONT-SIMPLIFY-NEXT: [[D:%.*]] = fpext float [[C:%.*]] to double
; DONT-SIMPLIFY-NEXT: [[E:%.*]] = call double @nearbyint(double [[D]])
; DONT-SIMPLIFY-NEXT: [[F:%.*]] = fptrunc double [[E]] to float
; DONT-SIMPLIFY-NEXT: ret float [[F]]
;
; C89-SIMPLIFY-NEXT: [[D:%.*]] = fpext float [[C:%.*]] to double
; C89-SIMPLIFY-NEXT: [[E:%.*]] = call double @nearbyint(double [[D]])
; C89-SIMPLIFY-NEXT: [[F:%.*]] = fptrunc double [[E]] to float
; C89-SIMPLIFY-NEXT: ret float [[F]]
; ;
%D = fpext float %C to double %D = fpext float %C to double
; --> nearbyintf ; --> nearbyintf
...@@ -107,19 +85,8 @@ define float @test_shrink_libcall_nearbyint(float %C) { ...@@ -107,19 +85,8 @@ define float @test_shrink_libcall_nearbyint(float %C) {
define float @test_shrink_libcall_trunc(float %C) { define float @test_shrink_libcall_trunc(float %C) {
; CHECK-LABEL: @test_shrink_libcall_trunc( ; CHECK-LABEL: @test_shrink_libcall_trunc(
; CHECK-NEXT: [[F:%.*]] = call float @llvm.trunc.f32(float [[C:%.*]])
; DO-SIMPLIFY-NEXT: [[F:%.*]] = call float @llvm.trunc.f32(float [[C:%.*]]) ; CHECK-NEXT: ret float [[F]]
; DO-SIMPLIFY-NEXT: ret float [[F]]
;
; DONT-SIMPLIFY-NEXT: [[D:%.*]] = fpext float [[C:%.*]] to double
; DONT-SIMPLIFY-NEXT: [[E:%.*]] = call double @trunc(double [[D]])
; DONT-SIMPLIFY-NEXT: [[F:%.*]] = fptrunc double [[E]] to float
; DONT-SIMPLIFY-NEXT: ret float [[F]]
;
; C89-SIMPLIFY-NEXT: [[D:%.*]] = fpext float [[C:%.*]] to double
; C89-SIMPLIFY-NEXT: [[E:%.*]] = call double @trunc(double [[D]])
; C89-SIMPLIFY-NEXT: [[F:%.*]] = fptrunc double [[E]] to float
; C89-SIMPLIFY-NEXT: ret float [[F]]
; ;
%D = fpext float %C to double %D = fpext float %C to double
; --> truncf ; --> truncf
......
llvm/test/Transforms/InstCombine/pow-1.ll
+ 122
− 70
View file @ 4b86c474
This diff is collapsed.
llvm/test/Transforms/InstCombine/win-math.ll
+ 118
− 94
View file @ 4b86c474
; RUN: opt -O2 -S -mtriple=i386-pc-win32 < %s | FileCheck %s --check-prefixes=CHECK,WIN32 ; RUN: opt < %s -O2 -S -mtriple=i386-pc-windows-msvc18 | FileCheck %s --check-prefixes=CHECK,MSVCXX,MSVC32
; RUN: opt -O2 -S -mtriple=x86_64-pc-win32 < %s | FileCheck %s --check-prefixes=CHECK,WIN64 ; RUN: opt < %s -O2 -S -mtriple=i386-pc-windows-msvc | FileCheck %s --check-prefixes=CHECK,MSVC19,MSVC51
; RUN: opt -O2 -S -mtriple=i386-pc-mingw32 < %s | FileCheck %s --check-prefixes=CHECK,MINGW32 ; RUN: opt < %s -O2 -S -mtriple=x86_64-pc-windows-msvc17 | FileCheck %s --check-prefixes=CHECK,MSVCXX,MSVC64
; RUN: opt -O2 -S -mtriple=x86_64-pc-mingw32 < %s | FileCheck %s --check-prefixes=CHECK,MINGW64 ; RUN: opt < %s -O2 -S -mtriple=x86_64-pc-win32 | FileCheck %s --check-prefixes=CHECK,MSVC19,MSVC83
; RUN: opt < %s -O2 -S -mtriple=i386-pc-mingw32 | FileCheck %s --check-prefixes=CHECK,MINGW32
; RUN: opt < %s -O2 -S -mtriple=x86_64-pc-mingw32 | FileCheck %s --check-prefixes=CHECK,MINGW64
; x86 win32 msvcrt does not provide entry points for single-precision libm. ; x86 win32 msvcrt does not provide entry points for single-precision libm.
; x86-64 win32 msvcrt does (except for fabsf) ; x86-64 win32 msvcrt does, but with exceptions
; msvcrt does not provide C99 math, but mingw32 does. ; msvcrt does not provide all of C99 math, but mingw32 does.
declare double @acos(double %x) declare double @acos(double %x)
define float @float_acos(float %x) nounwind readnone { define float @float_acos(float %x) nounwind readnone {
; CHECK-LABEL: @float_acos( ; CHECK-LABEL: @float_acos(
; WIN32-NOT: float @acosf ; MSVCXX-NOT: float @acosf
; WIN32: double @acos ; MSVCXX: double @acos
; WIN64-NOT: float @acosf ; MSVC19-NOT: float @acosf
; WIN64: double @acos ; MSVC19: double @acos
%1 = fpext float %x to double %1 = fpext float %x to double
%2 = call double @acos(double %1) %2 = call double @acos(double %1)
%3 = fptrunc double %2 to float %3 = fptrunc double %2 to float
...@@ -23,10 +25,10 @@ define float @float_acos(float %x) nounwind readnone { ...@@ -23,10 +25,10 @@ define float @float_acos(float %x) nounwind readnone {
declare double @asin(double %x) declare double @asin(double %x)
define float @float_asin(float %x) nounwind readnone { define float @float_asin(float %x) nounwind readnone {
; CHECK-LABEL: @float_asin( ; CHECK-LABEL: @float_asin(
; WIN32-NOT: float @asinf ; MSVCXX-NOT: float @asinf
; WIN32: double @asin ; MSVCXX: double @asin
; WIN64-NOT: float @asinf ; MSVC19-NOT: float @asinf
; WIN64: double @asin ; MSVC19: double @asin
%1 = fpext float %x to double %1 = fpext float %x to double
%2 = call double @asin(double %1) %2 = call double @asin(double %1)
%3 = fptrunc double %2 to float %3 = fptrunc double %2 to float
...@@ -36,10 +38,10 @@ define float @float_asin(float %x) nounwind readnone { ...@@ -36,10 +38,10 @@ define float @float_asin(float %x) nounwind readnone {
declare double @atan(double %x) declare double @atan(double %x)
define float @float_atan(float %x) nounwind readnone { define float @float_atan(float %x) nounwind readnone {
; CHECK-LABEL: @float_atan( ; CHECK-LABEL: @float_atan(
; WIN32-NOT: float @atanf ; MSVCXX-NOT: float @atanf
; WIN32: double @atan ; MSVCXX: double @atan
; WIN64-NOT: float @atanf ; MSVC19-NOT: float @atanf
; WIN64: double @atan ; MSVC19: double @atan
%1 = fpext float %x to double %1 = fpext float %x to double
%2 = call double @atan(double %1) %2 = call double @atan(double %1)
%3 = fptrunc double %2 to float %3 = fptrunc double %2 to float
...@@ -49,10 +51,10 @@ define float @float_atan(float %x) nounwind readnone { ...@@ -49,10 +51,10 @@ define float @float_atan(float %x) nounwind readnone {
declare double @atan2(double %x, double %y) declare double @atan2(double %x, double %y)
define float @float_atan2(float %x, float %y) nounwind readnone { define float @float_atan2(float %x, float %y) nounwind readnone {
; CHECK-LABEL: @float_atan2( ; CHECK-LABEL: @float_atan2(
; WIN32-NOT: float @atan2f ; MSVCXX-NOT: float @atan2f
; WIN32: double @atan2 ; MSVCXX: double @atan2
; WIN64-NOT: float @atan2f ; MSVC19-NOT: float @atan2f
; WIN64: double @atan2 ; MSVC19: double @atan2
%1 = fpext float %x to double %1 = fpext float %x to double
%2 = fpext float %y to double %2 = fpext float %y to double
%3 = call double @atan2(double %1, double %2) %3 = call double @atan2(double %1, double %2)
...@@ -63,10 +65,10 @@ define float @float_atan2(float %x, float %y) nounwind readnone { ...@@ -63,10 +65,10 @@ define float @float_atan2(float %x, float %y) nounwind readnone {
declare double @ceil(double %x) declare double @ceil(double %x)
define float @float_ceil(float %x) nounwind readnone { define float @float_ceil(float %x) nounwind readnone {
; CHECK-LABEL: @float_ceil( ; CHECK-LABEL: @float_ceil(
; WIN32-NOT: float @ceilf ; MSVCXX-NOT: float @ceilf
; WIN32: float @llvm.ceil.f32 ; MSVCXX: float @llvm.ceil.f32
; WIN64-NOT: double @ceil ; MSVC19-NOT: double @ceil
; WIN64: float @llvm.ceil.f32 ; MSVC19: float @llvm.ceil.f32
; MINGW32-NOT: double @ceil ; MINGW32-NOT: double @ceil
; MINGW32: float @llvm.ceil.f32 ; MINGW32: float @llvm.ceil.f32
; MINGW64-NOT: double @ceil ; MINGW64-NOT: double @ceil
...@@ -80,10 +82,10 @@ define float @float_ceil(float %x) nounwind readnone { ...@@ -80,10 +82,10 @@ define float @float_ceil(float %x) nounwind readnone {
declare double @_copysign(double %x) declare double @_copysign(double %x)
define float @float_copysign(float %x) nounwind readnone { define float @float_copysign(float %x) nounwind readnone {
; CHECK-LABEL: @float_copysign( ; CHECK-LABEL: @float_copysign(
; WIN32-NOT: float @_copysignf ; MSVCXX-NOT: float @_copysignf
; WIN32: double @_copysign ; MSVCXX: double @_copysign
; WIN64-NOT: float @_copysignf ; MSVC19-NOT: float @_copysignf
; WIN64: double @_copysign ; MSVC19: double @_copysign
%1 = fpext float %x to double %1 = fpext float %x to double
%2 = call double @_copysign(double %1) %2 = call double @_copysign(double %1)
%3 = fptrunc double %2 to float %3 = fptrunc double %2 to float
...@@ -93,10 +95,10 @@ define float @float_copysign(float %x) nounwind readnone { ...@@ -93,10 +95,10 @@ define float @float_copysign(float %x) nounwind readnone {
declare double @cos(double %x) declare double @cos(double %x)
define float @float_cos(float %x) nounwind readnone { define float @float_cos(float %x) nounwind readnone {
; CHECK-LABEL: @float_cos( ; CHECK-LABEL: @float_cos(
; WIN32-NOT: float @cosf ; MSVCXX-NOT: float @cosf
; WIN32: double @cos ; MSVCXX: double @cos
; WIN64-NOT: float @cosf ; MSVC19-NOT: float @cosf
; WIN64: double @cos ; MSVC19: double @cos
%1 = fpext float %x to double %1 = fpext float %x to double
%2 = call double @cos(double %1) %2 = call double @cos(double %1)
%3 = fptrunc double %2 to float %3 = fptrunc double %2 to float
...@@ -106,10 +108,10 @@ define float @float_cos(float %x) nounwind readnone { ...@@ -106,10 +108,10 @@ define float @float_cos(float %x) nounwind readnone {
declare double @cosh(double %x) declare double @cosh(double %x)
define float @float_cosh(float %x) nounwind readnone { define float @float_cosh(float %x) nounwind readnone {
; CHECK-LABEL: @float_cosh( ; CHECK-LABEL: @float_cosh(
; WIN32-NOT: float @coshf ; MSVCXX-NOT: float @coshf
; WIN32: double @cosh ; MSVCXX: double @cosh
; WIN64-NOT: float @coshf ; MSVC19-NOT: float @coshf
; WIN64: double @cosh ; MSVC19: double @cosh
%1 = fpext float %x to double %1 = fpext float %x to double
%2 = call double @cosh(double %1) %2 = call double @cosh(double %1)
%3 = fptrunc double %2 to float %3 = fptrunc double %2 to float
...@@ -119,10 +121,10 @@ define float @float_cosh(float %x) nounwind readnone { ...@@ -119,10 +121,10 @@ define float @float_cosh(float %x) nounwind readnone {
declare double @exp(double %x, double %y) declare double @exp(double %x, double %y)
define float @float_exp(float %x, float %y) nounwind readnone { define float @float_exp(float %x, float %y) nounwind readnone {
; CHECK-LABEL: @float_exp( ; CHECK-LABEL: @float_exp(
; WIN32-NOT: float @expf ; MSVCXX-NOT: float @expf
; WIN32: double @exp ; MSVCXX: double @exp
; WIN64-NOT: float @expf ; MSVC19-NOT: float @expf
; WIN64: double @exp ; MSVC19: double @exp
%1 = fpext float %x to double %1 = fpext float %x to double
%2 = fpext float %y to double %2 = fpext float %y to double
%3 = call double @exp(double %1, double %2) %3 = call double @exp(double %1, double %2)
...@@ -133,10 +135,10 @@ define float @float_exp(float %x, float %y) nounwind readnone { ...@@ -133,10 +135,10 @@ define float @float_exp(float %x, float %y) nounwind readnone {
declare double @fabs(double %x, double %y) declare double @fabs(double %x, double %y)
define float @float_fabs(float %x, float %y) nounwind readnone { define float @float_fabs(float %x, float %y) nounwind readnone {
; CHECK-LABEL: @float_fabs( ; CHECK-LABEL: @float_fabs(
; WIN32-NOT: float @fabsf ; MSVCXX-NOT: float @fabsf
; WIN32: double @fabs ; MSVCXX: double @fabs
; WIN64-NOT: float @fabsf ; MSVC19-NOT: float @fabsf
; WIN64: double @fabs ; MSVC19: double @fabs
%1 = fpext float %x to double %1 = fpext float %x to double
%2 = fpext float %y to double %2 = fpext float %y to double
%3 = call double @fabs(double %1, double %2) %3 = call double @fabs(double %1, double %2)
...@@ -147,10 +149,10 @@ define float @float_fabs(float %x, float %y) nounwind readnone { ...@@ -147,10 +149,10 @@ define float @float_fabs(float %x, float %y) nounwind readnone {
declare double @floor(double %x) declare double @floor(double %x)
define float @float_floor(float %x) nounwind readnone { define float @float_floor(float %x) nounwind readnone {
; CHECK-LABEL: @float_floor( ; CHECK-LABEL: @float_floor(
; WIN32-NOT: float @floorf ; MSVCXX-NOT: float @floorf
; WIN32: float @llvm.floor.f32 ; MSVCXX: float @llvm.floor.f32
; WIN64-NOT: double @floor ; MSVC19-NOT: double @floor
; WIN64: float @llvm.floor.f32 ; MSVC19: float @llvm.floor.f32
; MINGW32-NOT: double @floor ; MINGW32-NOT: double @floor
; MINGW32: float @llvm.floor.f32 ; MINGW32: float @llvm.floor.f32
; MINGW64-NOT: double @floor ; MINGW64-NOT: double @floor
...@@ -163,11 +165,11 @@ define float @float_floor(float %x) nounwind readnone { ...@@ -163,11 +165,11 @@ define float @float_floor(float %x) nounwind readnone {
declare double @fmod(double %x, double %y) declare double @fmod(double %x, double %y)
define float @float_fmod(float %x, float %y) nounwind readnone { define float @float_fmod(float %x, float %y) nounwind readnone {
; WIN32-LABEL: @float_fmod( ; MSVCXX-LABEL: @float_fmod(
; WIN32-NOT: float @fmodf ; MSVCXX-NOT: float @fmodf
; WIN32: double @fmod ; MSVCXX: double @fmod
; WIN64-NOT: float @fmodf ; MSVC19-NOT: float @fmodf
; WIN64: double @fmod ; MSVC19: double @fmod
%1 = fpext float %x to double %1 = fpext float %x to double
%2 = fpext float %y to double %2 = fpext float %y to double
%3 = call double @fmod(double %1, double %2) %3 = call double @fmod(double %1, double %2)
...@@ -178,23 +180,36 @@ define float @float_fmod(float %x, float %y) nounwind readnone { ...@@ -178,23 +180,36 @@ define float @float_fmod(float %x, float %y) nounwind readnone {
declare double @log(double %x) declare double @log(double %x)
define float @float_log(float %x) nounwind readnone { define float @float_log(float %x) nounwind readnone {
; CHECK-LABEL: @float_log( ; CHECK-LABEL: @float_log(
; WIN32-NOT: float @logf ; MSVCXX-NOT: float @logf
; WIN32: double @log ; MSVCXX: double @log
; WIN64-NOT: float @logf ; MSVC19-NOT: float @logf
; WIN64: double @log ; MSVC19: double @log
%1 = fpext float %x to double %1 = fpext float %x to double
%2 = call double @log(double %1) %2 = call double @log(double %1)
%3 = fptrunc double %2 to float %3 = fptrunc double %2 to float
ret float %3 ret float %3
} }
declare double @logb(double %x)
define float @float_logb(float %x) nounwind readnone {
; CHECK-LABEL: @float_logb(
; MSVCXX-NOT: float @logbf
; MSVCXX: double @logb
; MSVC19-NOT: float @logbf
; MSVC19: double @logb
%1 = fpext float %x to double
%2 = call double @logb(double %1)
%3 = fptrunc double %2 to float
ret float %3
}
declare double @pow(double %x, double %y) declare double @pow(double %x, double %y)
define float @float_pow(float %x, float %y) nounwind readnone { define float @float_pow(float %x, float %y) nounwind readnone {
; CHECK-LABEL: @float_pow( ; CHECK-LABEL: @float_pow(
; WIN32-NOT: float @powf ; MSVCXX-NOT: float @powf
; WIN32: double @pow ; MSVCXX: double @pow
; WIN64-NOT: float @powf ; MSVC19-NOT: float @powf
; WIN64: double @pow ; MSVC19: double @pow
%1 = fpext float %x to double %1 = fpext float %x to double
%2 = fpext float %y to double %2 = fpext float %y to double
%3 = call double @pow(double %1, double %2) %3 = call double @pow(double %1, double %2)
...@@ -205,10 +220,10 @@ define float @float_pow(float %x, float %y) nounwind readnone { ...@@ -205,10 +220,10 @@ define float @float_pow(float %x, float %y) nounwind readnone {
declare double @sin(double %x) declare double @sin(double %x)
define float @float_sin(float %x) nounwind readnone { define float @float_sin(float %x) nounwind readnone {
; CHECK-LABEL: @float_sin( ; CHECK-LABEL: @float_sin(
; WIN32-NOT: float @sinf ; MSVCXX-NOT: float @sinf
; WIN32: double @sin ; MSVCXX: double @sin
; WIN64-NOT: float @sinf ; MSVC19-NOT: float @sinf
; WIN64: double @sin ; MSVC19: double @sin
%1 = fpext float %x to double %1 = fpext float %x to double
%2 = call double @sin(double %1) %2 = call double @sin(double %1)
%3 = fptrunc double %2 to float %3 = fptrunc double %2 to float
...@@ -218,10 +233,10 @@ define float @float_sin(float %x) nounwind readnone { ...@@ -218,10 +233,10 @@ define float @float_sin(float %x) nounwind readnone {
declare double @sinh(double %x) declare double @sinh(double %x)
define float @float_sinh(float %x) nounwind readnone { define float @float_sinh(float %x) nounwind readnone {
; CHECK-LABEL: @float_sinh( ; CHECK-LABEL: @float_sinh(
; WIN32-NOT: float @sinhf ; MSVCXX-NOT: float @sinhf
; WIN32: double @sinh ; MSVCXX: double @sinh
; WIN64-NOT: float @sinhf ; MSVC19-NOT: float @sinhf
; WIN64: double @sinh ; MSVC19: double @sinh
%1 = fpext float %x to double %1 = fpext float %x to double
%2 = call double @sinh(double %1) %2 = call double @sinh(double %1)
%3 = fptrunc double %2 to float %3 = fptrunc double %2 to float
...@@ -231,10 +246,14 @@ define float @float_sinh(float %x) nounwind readnone { ...@@ -231,10 +246,14 @@ define float @float_sinh(float %x) nounwind readnone {
declare double @sqrt(double %x) declare double @sqrt(double %x)
define float @float_sqrt(float %x) nounwind readnone { define float @float_sqrt(float %x) nounwind readnone {
; CHECK-LABEL: @float_sqrt( ; CHECK-LABEL: @float_sqrt(
; WIN32-NOT: float @sqrtf ; MSVC32-NOT: float @sqrtf
; WIN32: double @sqrt ; MSVC32: double @sqrt
; WIN64-NOT: double @sqrt ; MSVC51-NOT: float @sqrtf
; WIN64: float @sqrtf ; MSVC51: double @sqrt
; MSVC64-NOT: double @sqrt
; MSVC64: float @sqrtf
; MSVC83-NOT: double @sqrt
; MSVC83: float @sqrtf
; MINGW32-NOT: double @sqrt ; MINGW32-NOT: double @sqrt
; MINGW32: float @sqrtf ; MINGW32: float @sqrtf
; MINGW64-NOT: double @sqrt ; MINGW64-NOT: double @sqrt
...@@ -248,10 +267,10 @@ define float @float_sqrt(float %x) nounwind readnone { ...@@ -248,10 +267,10 @@ define float @float_sqrt(float %x) nounwind readnone {
declare double @tan(double %x) declare double @tan(double %x)
define float @float_tan(float %x) nounwind readnone { define float @float_tan(float %x) nounwind readnone {
; CHECK-LABEL: @float_tan( ; CHECK-LABEL: @float_tan(
; WIN32-NOT: float @tanf ; MSVCXX-NOT: float @tanf
; WIN32: double @tan ; MSVCXX: double @tan
; WIN64-NOT: float @tanf ; MSVC19-NOT: float @tanf
; WIN64: double @tan ; MSVC19: double @tan
%1 = fpext float %x to double %1 = fpext float %x to double
%2 = call double @tan(double %1) %2 = call double @tan(double %1)
%3 = fptrunc double %2 to float %3 = fptrunc double %2 to float
...@@ -261,24 +280,24 @@ define float @float_tan(float %x) nounwind readnone { ...@@ -261,24 +280,24 @@ define float @float_tan(float %x) nounwind readnone {
declare double @tanh(double %x) declare double @tanh(double %x)
define float @float_tanh(float %x) nounwind readnone { define float @float_tanh(float %x) nounwind readnone {
; CHECK-LABEL: @float_tanh( ; CHECK-LABEL: @float_tanh(
; WIN32-NOT: float @tanhf ; MSVCXX-NOT: float @tanhf
; WIN32: double @tanh ; MSVCXX: double @tanh
; WIN64-NOT: float @tanhf ; MSVC19-NOT: float @tanhf
; WIN64: double @tanh ; MSVC19: double @tanh
%1 = fpext float %x to double %1 = fpext float %x to double
%2 = call double @tanh(double %1) %2 = call double @tanh(double %1)
%3 = fptrunc double %2 to float %3 = fptrunc double %2 to float
ret float %3 ret float %3
} }
; win32 does not have round; mingw32 does ; win32 does not have roundf; mingw32 does
declare double @round(double %x) declare double @round(double %x)
define float @float_round(float %x) nounwind readnone { define float @float_round(float %x) nounwind readnone {
; CHECK-LABEL: @float_round( ; CHECK-LABEL: @float_round(
; WIN32-NOT: float @roundf ; MSVCXX-NOT: double @roundf
; WIN32: double @round ; MSVCXX: double @round
; WIN64-NOT: float @roundf ; MSVC19-NOT: double @round
; WIN64: double @round ; MSVC19: float @llvm.round.f32
; MINGW32-NOT: double @round ; MINGW32-NOT: double @round
; MINGW32: float @llvm.round.f32 ; MINGW32: float @llvm.round.f32
; MINGW64-NOT: double @round ; MINGW64-NOT: double @round
...@@ -291,15 +310,20 @@ define float @float_round(float %x) nounwind readnone { ...@@ -291,15 +310,20 @@ define float @float_round(float %x) nounwind readnone {
declare float @powf(float, float) declare float @powf(float, float)
; win32 lacks sqrtf&fabsf, win64 lacks fabsf, but ; win32 lacks sqrtf & fabsf, win64 lacks fabsf, but
; calls to the intrinsics can be emitted instead. ; calls to the intrinsics can be emitted instead.
define float @float_powsqrt(float %x) nounwind readnone { define float @float_powsqrt(float %x) nounwind readnone {
; CHECK-LABEL: @float_powsqrt( ; CHECK-LABEL: @float_powsqrt(
; WIN32-NOT: float @sqrtf ; MSVC32-NOT: float @sqrtf
; WIN32: float @powf ; MSVC32: float @powf
; WIN64-NOT: float @powf ; MSVC51-NOT: float @sqrtf
; WIN64: float @sqrtf ; MSVC51: float @powf
; WIN64: float @llvm.fabs.f32( ; MSVC64-NOT: float @powf
; MSVC64: float @sqrtf
; MSVC64: float @llvm.fabs.f32(
; MSVC83-NOT: float @powf
; MSVC83: float @sqrtf
; MSVC83: float @llvm.fabs.f32(
; MINGW32-NOT: float @powf ; MINGW32-NOT: float @powf
; MINGW32: float @sqrtf ; MINGW32: float @sqrtf
; MINGW32: float @llvm.fabs.f32 ; MINGW32: float @llvm.fabs.f32
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment