From 3cd8c16d7fc1fd12befce3c40d8a34b50df4638c Mon Sep 17 00:00:00 2001 From: Andrew Kaylor Date: Fri, 12 May 2017 22:11:12 +0000 Subject: [PATCH] [TLI] Add declarations for various math header file routines from math-finite.h that create '___finite as functions Patch by Chris Chrulski Differential Revision: https://reviews.llvm.org/D31787 llvm-svn: 302955 --- llvm/include/llvm/Analysis/TargetLibraryInfo.def | 127 ++++++++++++++++++++- llvm/lib/Analysis/TargetLibraryInfo.cpp | 86 ++++++++++++++ .../test/Transforms/InferFunctionAttrs/annotate.ll | 126 ++++++++++++++++++++ .../test/Transforms/InferFunctionAttrs/no-proto.ll | 126 ++++++++++++++++++++ llvm/unittests/Analysis/TargetLibraryInfoTest.cpp | 46 ++++++++ 5 files changed, 510 insertions(+), 1 deletion(-) diff --git a/llvm/include/llvm/Analysis/TargetLibraryInfo.def b/llvm/include/llvm/Analysis/TargetLibraryInfo.def index 099a3c7..9cbe917 100644 --- a/llvm/include/llvm/Analysis/TargetLibraryInfo.def +++ b/llvm/include/llvm/Analysis/TargetLibraryInfo.def @@ -161,6 +161,60 @@ TLI_DEFINE_STRING_INTERNAL("_Znwm") /// void *new(unsigned long, nothrow); TLI_DEFINE_ENUM_INTERNAL(ZnwmRKSt9nothrow_t) TLI_DEFINE_STRING_INTERNAL("_ZnwmRKSt9nothrow_t") +/// double __acos_finite(double x); +TLI_DEFINE_ENUM_INTERNAL(acos_finite) +TLI_DEFINE_STRING_INTERNAL("__acos_finite") +/// float __acosf_finite(float x); +TLI_DEFINE_ENUM_INTERNAL(acosf_finite) +TLI_DEFINE_STRING_INTERNAL("__acosf_finite") +/// double __acosh_finite(double x); +TLI_DEFINE_ENUM_INTERNAL(acosh_finite) +TLI_DEFINE_STRING_INTERNAL("__acosh_finite") +/// float __acoshf_finite(float x); +TLI_DEFINE_ENUM_INTERNAL(acoshf_finite) +TLI_DEFINE_STRING_INTERNAL("__acoshf_finite") +/// long double __acoshl_finite(long double x); +TLI_DEFINE_ENUM_INTERNAL(acoshl_finite) +TLI_DEFINE_STRING_INTERNAL("__acoshl_finite") +/// long double __acosl_finite(long double x); +TLI_DEFINE_ENUM_INTERNAL(acosl_finite) +TLI_DEFINE_STRING_INTERNAL("__acosl_finite") +/// double __asin_finite(double x); +TLI_DEFINE_ENUM_INTERNAL(asin_finite) +TLI_DEFINE_STRING_INTERNAL("__asin_finite") +/// float __asinf_finite(float x); +TLI_DEFINE_ENUM_INTERNAL(asinf_finite) +TLI_DEFINE_STRING_INTERNAL("__asinf_finite") +/// long double __asinl_finite(long double x); +TLI_DEFINE_ENUM_INTERNAL(asinl_finite) +TLI_DEFINE_STRING_INTERNAL("__asinl_finite") +/// double atan2_finite(double y, double x); +TLI_DEFINE_ENUM_INTERNAL(atan2_finite) +TLI_DEFINE_STRING_INTERNAL("__atan2_finite") +/// float atan2f_finite(float y, float x); +TLI_DEFINE_ENUM_INTERNAL(atan2f_finite) +TLI_DEFINE_STRING_INTERNAL("__atan2f_finite") +/// long double atan2l_finite(long double y, long double x); +TLI_DEFINE_ENUM_INTERNAL(atan2l_finite) +TLI_DEFINE_STRING_INTERNAL("__atan2l_finite") +/// double __atanh_finite(double x); +TLI_DEFINE_ENUM_INTERNAL(atanh_finite) +TLI_DEFINE_STRING_INTERNAL("__atanh_finite") +/// float __atanhf_finite(float x); +TLI_DEFINE_ENUM_INTERNAL(atanhf_finite) +TLI_DEFINE_STRING_INTERNAL("__atanhf_finite") +/// long double __atanhl_finite(long double x); +TLI_DEFINE_ENUM_INTERNAL(atanhl_finite) +TLI_DEFINE_STRING_INTERNAL("__atanhl_finite") +/// double __cosh_finite(double x); +TLI_DEFINE_ENUM_INTERNAL(cosh_finite) +TLI_DEFINE_STRING_INTERNAL("__cosh_finite") +/// float __coshf_finite(float x); +TLI_DEFINE_ENUM_INTERNAL(coshf_finite) +TLI_DEFINE_STRING_INTERNAL("__coshf_finite") +/// long double __coshl_finite(long double x); +TLI_DEFINE_ENUM_INTERNAL(coshl_finite) +TLI_DEFINE_STRING_INTERNAL("__coshl_finite") /// double __cospi(double x); TLI_DEFINE_ENUM_INTERNAL(cospi) TLI_DEFINE_STRING_INTERNAL("__cospi") @@ -180,12 +234,66 @@ TLI_DEFINE_STRING_INTERNAL("__cxa_guard_acquire") /// void __cxa_guard_release(guard_t *guard); TLI_DEFINE_ENUM_INTERNAL(cxa_guard_release) TLI_DEFINE_STRING_INTERNAL("__cxa_guard_release") +/// double __exp10_finite(double x); +TLI_DEFINE_ENUM_INTERNAL(exp10_finite) +TLI_DEFINE_STRING_INTERNAL("__exp10_finite") +/// float __exp10f_finite(float x); +TLI_DEFINE_ENUM_INTERNAL(exp10f_finite) +TLI_DEFINE_STRING_INTERNAL("__exp10f_finite") +/// long double __exp10l_finite(long double x); +TLI_DEFINE_ENUM_INTERNAL(exp10l_finite) +TLI_DEFINE_STRING_INTERNAL("__exp10l_finite") +/// double __exp2_finite(double x); +TLI_DEFINE_ENUM_INTERNAL(exp2_finite) +TLI_DEFINE_STRING_INTERNAL("__exp2_finite") +/// float __exp2f_finite(float x); +TLI_DEFINE_ENUM_INTERNAL(exp2f_finite) +TLI_DEFINE_STRING_INTERNAL("__exp2f_finite") +/// long double __exp2l_finite(long double x); +TLI_DEFINE_ENUM_INTERNAL(exp2l_finite) +TLI_DEFINE_STRING_INTERNAL("__exp2l_finite") +/// double __exp_finite(double x); +TLI_DEFINE_ENUM_INTERNAL(exp_finite) +TLI_DEFINE_STRING_INTERNAL("__exp_finite") +/// float __expf_finite(float x); +TLI_DEFINE_ENUM_INTERNAL(expf_finite) +TLI_DEFINE_STRING_INTERNAL("__expf_finite") +/// long double __expl_finite(long double x); +TLI_DEFINE_ENUM_INTERNAL(expl_finite) +TLI_DEFINE_STRING_INTERNAL("__expl_finite") /// int __isoc99_scanf (const char *format, ...) TLI_DEFINE_ENUM_INTERNAL(dunder_isoc99_scanf) TLI_DEFINE_STRING_INTERNAL("__isoc99_scanf") /// int __isoc99_sscanf(const char *s, const char *format, ...) TLI_DEFINE_ENUM_INTERNAL(dunder_isoc99_sscanf) TLI_DEFINE_STRING_INTERNAL("__isoc99_sscanf") +/// double __log10_finite(double x); +TLI_DEFINE_ENUM_INTERNAL(log10_finite) +TLI_DEFINE_STRING_INTERNAL("__log10_finite") +/// float __log10f_finite(float x); +TLI_DEFINE_ENUM_INTERNAL(log10f_finite) +TLI_DEFINE_STRING_INTERNAL("__log10f_finite") +/// long double __log10l_finite(long double x); +TLI_DEFINE_ENUM_INTERNAL(log10l_finite) +TLI_DEFINE_STRING_INTERNAL("__log10l_finite") +/// double __log2_finite(double x); +TLI_DEFINE_ENUM_INTERNAL(log2_finite) +TLI_DEFINE_STRING_INTERNAL("__log2_finite") +/// float __log2f_finite(float x); +TLI_DEFINE_ENUM_INTERNAL(log2f_finite) +TLI_DEFINE_STRING_INTERNAL("__log2f_finite") +/// long double __log2l_finite(long double x); +TLI_DEFINE_ENUM_INTERNAL(log2l_finite) +TLI_DEFINE_STRING_INTERNAL("__log2l_finite") +/// double __log_finite(double x); +TLI_DEFINE_ENUM_INTERNAL(log_finite) +TLI_DEFINE_STRING_INTERNAL("__log_finite") +/// float __logf_finite(float x); +TLI_DEFINE_ENUM_INTERNAL(logf_finite) +TLI_DEFINE_STRING_INTERNAL("__logf_finite") +/// long double __logl_finite(long double x); +TLI_DEFINE_ENUM_INTERNAL(logl_finite) +TLI_DEFINE_STRING_INTERNAL("__logl_finite") /// void *__memcpy_chk(void *s1, const void *s2, size_t n, size_t s1size); TLI_DEFINE_ENUM_INTERNAL(memcpy_chk) TLI_DEFINE_STRING_INTERNAL("__memcpy_chk") @@ -199,13 +307,30 @@ TLI_DEFINE_STRING_INTERNAL("__memset_chk") // int __nvvm_reflect(const char *) TLI_DEFINE_ENUM_INTERNAL(nvvm_reflect) TLI_DEFINE_STRING_INTERNAL("__nvvm_reflect") - +/// double __pow_finite(double x, double y); +TLI_DEFINE_ENUM_INTERNAL(pow_finite) +TLI_DEFINE_STRING_INTERNAL("__pow_finite") +/// float _powf_finite(float x, float y); +TLI_DEFINE_ENUM_INTERNAL(powf_finite) +TLI_DEFINE_STRING_INTERNAL("__powf_finite") +/// long double __powl_finite(long double x, long double y); +TLI_DEFINE_ENUM_INTERNAL(powl_finite) +TLI_DEFINE_STRING_INTERNAL("__powl_finite") /// double __sincospi_stret(double x); TLI_DEFINE_ENUM_INTERNAL(sincospi_stret) TLI_DEFINE_STRING_INTERNAL("__sincospi_stret") /// float __sincospif_stret(float x); TLI_DEFINE_ENUM_INTERNAL(sincospif_stret) TLI_DEFINE_STRING_INTERNAL("__sincospif_stret") +/// double __sinh_finite(double x); +TLI_DEFINE_ENUM_INTERNAL(sinh_finite) +TLI_DEFINE_STRING_INTERNAL("__sinh_finite") +/// float _sinhf_finite(float x); +TLI_DEFINE_ENUM_INTERNAL(sinhf_finite) +TLI_DEFINE_STRING_INTERNAL("__sinhf_finite") +/// long double __sinhl_finite(long double x); +TLI_DEFINE_ENUM_INTERNAL(sinhl_finite) +TLI_DEFINE_STRING_INTERNAL("__sinhl_finite") /// double __sinpi(double x); TLI_DEFINE_ENUM_INTERNAL(sinpi) TLI_DEFINE_STRING_INTERNAL("__sinpi") diff --git a/llvm/lib/Analysis/TargetLibraryInfo.cpp b/llvm/lib/Analysis/TargetLibraryInfo.cpp index 848e1b4..7464745 100644 --- a/llvm/lib/Analysis/TargetLibraryInfo.cpp +++ b/llvm/lib/Analysis/TargetLibraryInfo.cpp @@ -241,6 +241,50 @@ static void initialize(TargetLibraryInfoImpl &TLI, const Triple &T, TLI.setUnavailable(LibFunc_tanhf); } + // These definitions are due to math-finite.h header on Linux + 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); + TLI.setUnavailable(LibFunc_asinl_finite); + TLI.setUnavailable(LibFunc_atan2_finite); + TLI.setUnavailable(LibFunc_atan2f_finite); + TLI.setUnavailable(LibFunc_atan2l_finite); + TLI.setUnavailable(LibFunc_atanh_finite); + TLI.setUnavailable(LibFunc_atanhf_finite); + TLI.setUnavailable(LibFunc_atanhl_finite); + TLI.setUnavailable(LibFunc_cosh_finite); + TLI.setUnavailable(LibFunc_coshf_finite); + TLI.setUnavailable(LibFunc_coshl_finite); + TLI.setUnavailable(LibFunc_exp10_finite); + TLI.setUnavailable(LibFunc_exp10f_finite); + TLI.setUnavailable(LibFunc_exp10l_finite); + TLI.setUnavailable(LibFunc_exp2_finite); + TLI.setUnavailable(LibFunc_exp2f_finite); + TLI.setUnavailable(LibFunc_exp2l_finite); + TLI.setUnavailable(LibFunc_exp_finite); + TLI.setUnavailable(LibFunc_expf_finite); + TLI.setUnavailable(LibFunc_expl_finite); + TLI.setUnavailable(LibFunc_log10_finite); + TLI.setUnavailable(LibFunc_log10f_finite); + TLI.setUnavailable(LibFunc_log10l_finite); + TLI.setUnavailable(LibFunc_log2_finite); + TLI.setUnavailable(LibFunc_log2f_finite); + TLI.setUnavailable(LibFunc_log2l_finite); + TLI.setUnavailable(LibFunc_log_finite); + TLI.setUnavailable(LibFunc_logf_finite); + TLI.setUnavailable(LibFunc_logl_finite); + TLI.setUnavailable(LibFunc_pow_finite); + TLI.setUnavailable(LibFunc_powf_finite); + TLI.setUnavailable(LibFunc_powl_finite); + TLI.setUnavailable(LibFunc_sinh_finite); + TLI.setUnavailable(LibFunc_sinhf_finite); + TLI.setUnavailable(LibFunc_sinhl_finite); + // Win32 does *not* provide provide these functions, but they are // generally available on POSIX-compliant systems: TLI.setUnavailable(LibFunc_access); @@ -1004,22 +1048,34 @@ bool TargetLibraryInfoImpl::isValidProtoForLibFunc(const FunctionType &FTy, return (NumParams == 1 && FTy.getParamType(0)->isFloatingPointTy()); case LibFunc_acos: + case LibFunc_acos_finite: case LibFunc_acosf: + case LibFunc_acosf_finite: case LibFunc_acosh: + case LibFunc_acosh_finite: case LibFunc_acoshf: + case LibFunc_acoshf_finite: case LibFunc_acoshl: + case LibFunc_acoshl_finite: case LibFunc_acosl: + case LibFunc_acosl_finite: case LibFunc_asin: + case LibFunc_asin_finite: case LibFunc_asinf: + case LibFunc_asinf_finite: case LibFunc_asinh: case LibFunc_asinhf: case LibFunc_asinhl: case LibFunc_asinl: + case LibFunc_asinl_finite: case LibFunc_atan: case LibFunc_atanf: case LibFunc_atanh: + case LibFunc_atanh_finite: case LibFunc_atanhf: + case LibFunc_atanhf_finite: case LibFunc_atanhl: + case LibFunc_atanhl_finite: case LibFunc_atanl: case LibFunc_cbrt: case LibFunc_cbrtf: @@ -1030,18 +1086,30 @@ bool TargetLibraryInfoImpl::isValidProtoForLibFunc(const FunctionType &FTy, case LibFunc_cos: case LibFunc_cosf: case LibFunc_cosh: + case LibFunc_cosh_finite: case LibFunc_coshf: + case LibFunc_coshf_finite: case LibFunc_coshl: + case LibFunc_coshl_finite: case LibFunc_cosl: case LibFunc_exp10: + case LibFunc_exp10_finite: case LibFunc_exp10f: + case LibFunc_exp10f_finite: case LibFunc_exp10l: + case LibFunc_exp10l_finite: case LibFunc_exp2: + case LibFunc_exp2_finite: case LibFunc_exp2f: + case LibFunc_exp2f_finite: case LibFunc_exp2l: + case LibFunc_exp2l_finite: case LibFunc_exp: + case LibFunc_exp_finite: case LibFunc_expf: + case LibFunc_expf_finite: case LibFunc_expl: + case LibFunc_expl_finite: case LibFunc_expm1: case LibFunc_expm1f: case LibFunc_expm1l: @@ -1052,20 +1120,29 @@ bool TargetLibraryInfoImpl::isValidProtoForLibFunc(const FunctionType &FTy, case LibFunc_floorf: case LibFunc_floorl: case LibFunc_log10: + case LibFunc_log10_finite: case LibFunc_log10f: + case LibFunc_log10f_finite: case LibFunc_log10l: + case LibFunc_log10l_finite: case LibFunc_log1p: case LibFunc_log1pf: case LibFunc_log1pl: case LibFunc_log2: + case LibFunc_log2_finite: case LibFunc_log2f: + case LibFunc_log2f_finite: case LibFunc_log2l: + case LibFunc_log2l_finite: case LibFunc_log: + case LibFunc_log_finite: case LibFunc_logb: case LibFunc_logbf: case LibFunc_logbl: case LibFunc_logf: + case LibFunc_logf_finite: case LibFunc_logl: + case LibFunc_logl_finite: case LibFunc_nearbyint: case LibFunc_nearbyintf: case LibFunc_nearbyintl: @@ -1078,8 +1155,11 @@ bool TargetLibraryInfoImpl::isValidProtoForLibFunc(const FunctionType &FTy, case LibFunc_sin: case LibFunc_sinf: case LibFunc_sinh: + case LibFunc_sinh_finite: case LibFunc_sinhf: + case LibFunc_sinhf_finite: case LibFunc_sinhl: + case LibFunc_sinhl_finite: case LibFunc_sinl: case LibFunc_sqrt: case LibFunc_sqrt_finite: @@ -1100,8 +1180,11 @@ bool TargetLibraryInfoImpl::isValidProtoForLibFunc(const FunctionType &FTy, FTy.getReturnType() == FTy.getParamType(0)); case LibFunc_atan2: + case LibFunc_atan2_finite: case LibFunc_atan2f: + case LibFunc_atan2f_finite: case LibFunc_atan2l: + case LibFunc_atan2l_finite: case LibFunc_fmin: case LibFunc_fminf: case LibFunc_fminl: @@ -1115,8 +1198,11 @@ bool TargetLibraryInfoImpl::isValidProtoForLibFunc(const FunctionType &FTy, case LibFunc_copysignf: case LibFunc_copysignl: case LibFunc_pow: + case LibFunc_pow_finite: case LibFunc_powf: + case LibFunc_powf_finite: case LibFunc_powl: + case LibFunc_powl_finite: return (NumParams == 2 && FTy.getReturnType()->isFloatingPointTy() && FTy.getReturnType() == FTy.getParamType(0) && FTy.getReturnType() == FTy.getParamType(1)); diff --git a/llvm/test/Transforms/InferFunctionAttrs/annotate.ll b/llvm/test/Transforms/InferFunctionAttrs/annotate.ll index 64676bf..cb4b5cd 100644 --- a/llvm/test/Transforms/InferFunctionAttrs/annotate.ll +++ b/llvm/test/Transforms/InferFunctionAttrs/annotate.ll @@ -22,12 +22,138 @@ declare i32 @__nvvm_reflect(i8*) ; Use an opaque pointer type for all the (possibly opaque) structs. %opaque = type opaque +; CHECK: declare double @__acos_finite(double) +declare double @__acos_finite(double) + +; CHECK: declare float @__acosf_finite(float) +declare float @__acosf_finite(float) + +; CHECK: declare double @__acosh_finite(double) +declare double @__acosh_finite(double) + +; CHECK: declare float @__acoshf_finite(float) +declare float @__acoshf_finite(float) + +; CHECK: declare x86_fp80 @__acoshl_finite(x86_fp80) +declare x86_fp80 @__acoshl_finite(x86_fp80) + +; CHECK: declare x86_fp80 @__acosl_finite(x86_fp80) +declare x86_fp80 @__acosl_finite(x86_fp80) + +; CHECK: declare double @__asin_finite(double) +declare double @__asin_finite(double) + +; CHECK: declare float @__asinf_finite(float) +declare float @__asinf_finite(float) + +; CHECK: declare x86_fp80 @__asinl_finite(x86_fp80) +declare x86_fp80 @__asinl_finite(x86_fp80) + +; CHECK: declare double @__atan2_finite(double, double) +declare double @__atan2_finite(double, double) + +; CHECK: declare float @__atan2f_finite(float, float) +declare float @__atan2f_finite(float, float) + +; CHECK: declare x86_fp80 @__atan2l_finite(x86_fp80, x86_fp80) +declare x86_fp80 @__atan2l_finite(x86_fp80, x86_fp80) + +; CHECK: declare double @__atanh_finite(double) +declare double @__atanh_finite(double) + +; CHECK: declare float @__atanhf_finite(float) +declare float @__atanhf_finite(float) + +; CHECK: declare x86_fp80 @__atanhl_finite(x86_fp80) +declare x86_fp80 @__atanhl_finite(x86_fp80) + +; CHECK: declare double @__cosh_finite(double) +declare double @__cosh_finite(double) + +; CHECK: declare float @__coshf_finite(float) +declare float @__coshf_finite(float) + +; CHECK: declare x86_fp80 @__coshl_finite(x86_fp80) +declare x86_fp80 @__coshl_finite(x86_fp80) + ; CHECK: declare double @__cospi(double) declare double @__cospi(double) ; CHECK: declare float @__cospif(float) declare float @__cospif(float) +; CHECK: declare double @__exp10_finite(double) +declare double @__exp10_finite(double) + +; CHECK: declare float @__exp10f_finite(float) +declare float @__exp10f_finite(float) + +; CHECK: declare x86_fp80 @__exp10l_finite(x86_fp80) +declare x86_fp80 @__exp10l_finite(x86_fp80) + +; CHECK: declare double @__exp2_finite(double) +declare double @__exp2_finite(double) + +; CHECK: declare float @__exp2f_finite(float) +declare float @__exp2f_finite(float) + +; CHECK: declare x86_fp80 @__exp2l_finite(x86_fp80) +declare x86_fp80 @__exp2l_finite(x86_fp80) + +; CHECK: declare double @__exp_finite(double) +declare double @__exp_finite(double) + +; CHECK: declare float @__expf_finite(float) +declare float @__expf_finite(float) + +; CHECK: declare x86_fp80 @__expl_finite(x86_fp80) +declare x86_fp80 @__expl_finite(x86_fp80) + +; CHECK: declare double @__log10_finite(double) +declare double @__log10_finite(double) + +; CHECK: declare float @__log10f_finite(float) +declare float @__log10f_finite(float) + +; CHECK: declare x86_fp80 @__log10l_finite(x86_fp80) +declare x86_fp80 @__log10l_finite(x86_fp80) + +; CHECK: declare double @__log2_finite(double) +declare double @__log2_finite(double) + +; CHECK: declare float @__log2f_finite(float) +declare float @__log2f_finite(float) + +; CHECK: declare x86_fp80 @__log2l_finite(x86_fp80) +declare x86_fp80 @__log2l_finite(x86_fp80) + +; CHECK: declare double @__log_finite(double) +declare double @__log_finite(double) + +; CHECK: declare float @__logf_finite(float) +declare float @__logf_finite(float) + +; CHECK: declare x86_fp80 @__logl_finite(x86_fp80) +declare x86_fp80 @__logl_finite(x86_fp80) + +; CHECK: declare double @__pow_finite(double, double) +declare double @__pow_finite(double, double) + +; CHECK: declare float @__powf_finite(float, float) +declare float @__powf_finite(float, float) + +; CHECK: declare x86_fp80 @__powl_finite(x86_fp80, x86_fp80) +declare x86_fp80 @__powl_finite(x86_fp80, x86_fp80) + +; CHECK: declare double @__sinh_finite(double) +declare double @__sinh_finite(double) + +; CHECK: declare float @__sinhf_finite(float) +declare float @__sinhf_finite(float) + +; CHECK: declare x86_fp80 @__sinhl_finite(x86_fp80) +declare x86_fp80 @__sinhl_finite(x86_fp80) + ; CHECK: declare double @__sinpi(double) declare double @__sinpi(double) diff --git a/llvm/test/Transforms/InferFunctionAttrs/no-proto.ll b/llvm/test/Transforms/InferFunctionAttrs/no-proto.ll index 25a4805..3cab0ab 100644 --- a/llvm/test/Transforms/InferFunctionAttrs/no-proto.ll +++ b/llvm/test/Transforms/InferFunctionAttrs/no-proto.ll @@ -3,12 +3,138 @@ ; Check that we don't modify libc functions with invalid prototypes. +; CHECK: declare void @__acos_finite(...) +declare void @__acos_finite(...) + +; CHECK: declare void @__acosf_finite(...) +declare void @__acosf_finite(...) + +; CHECK: declare void @__acosh_finite(...) +declare void @__acosh_finite(...) + +; CHECK: declare void @__acoshf_finite(...) +declare void @__acoshf_finite(...) + +; CHECK: declare void @__acoshl_finite(...) +declare void @__acoshl_finite(...) + +; CHECK: declare void @__acosl_finite(...) +declare void @__acosl_finite(...) + +; CHECK: declare void @__asin_finite(...) +declare void @__asin_finite(...) + +; CHECK: declare void @__asinf_finite(...) +declare void @__asinf_finite(...) + +; CHECK: declare void @__asinl_finite(...) +declare void @__asinl_finite(...) + +; CHECK: declare void @__atan2_finite(...) +declare void @__atan2_finite(...) + +; CHECK: declare void @__atan2f_finite(...) +declare void @__atan2f_finite(...) + +; CHECK: declare void @__atan2l_finite(...) +declare void @__atan2l_finite(...) + +; CHECK: declare void @__atanh_finite(...) +declare void @__atanh_finite(...) + +; CHECK: declare void @__atanhf_finite(...) +declare void @__atanhf_finite(...) + +; CHECK: declare void @__atanhl_finite(...) +declare void @__atanhl_finite(...) + +; CHECK: declare void @__cosh_finite(...) +declare void @__cosh_finite(...) + +; CHECK: declare void @__coshf_finite(...) +declare void @__coshf_finite(...) + +; CHECK: declare void @__coshl_finite(...) +declare void @__coshl_finite(...) + ; CHECK: declare void @__cospi(...) declare void @__cospi(...) ; CHECK: declare void @__cospif(...) declare void @__cospif(...) +; CHECK: declare void @__exp10_finite(...) +declare void @__exp10_finite(...) + +; CHECK: declare void @__exp10f_finite(...) +declare void @__exp10f_finite(...) + +; CHECK: declare void @__exp10l_finite(...) +declare void @__exp10l_finite(...) + +; CHECK: declare void @__exp2_finite(...) +declare void @__exp2_finite(...) + +; CHECK: declare void @__exp2f_finite(...) +declare void @__exp2f_finite(...) + +; CHECK: declare void @__exp2l_finite(...) +declare void @__exp2l_finite(...) + +; CHECK: declare void @__exp_finite(...) +declare void @__exp_finite(...) + +; CHECK: declare void @__expf_finite(...) +declare void @__expf_finite(...) + +; CHECK: declare void @__expl_finite(...) +declare void @__expl_finite(...) + +; CHECK: declare void @__log10_finite(...) +declare void @__log10_finite(...) + +; CHECK: declare void @__log10f_finite(...) +declare void @__log10f_finite(...) + +; CHECK: declare void @__log10l_finite(...) +declare void @__log10l_finite(...) + +; CHECK: declare void @__log2_finite(...) +declare void @__log2_finite(...) + +; CHECK: declare void @__log2f_finite(...) +declare void @__log2f_finite(...) + +; CHECK: declare void @__log2l_finite(...) +declare void @__log2l_finite(...) + +; CHECK: declare void @__log_finite(...) +declare void @__log_finite(...) + +; CHECK: declare void @__logf_finite(...) +declare void @__logf_finite(...) + +; CHECK: declare void @__logl_finite(...) +declare void @__logl_finite(...) + +; CHECK: declare void @__pow_finite(...) +declare void @__pow_finite(...) + +; CHECK: declare void @__powf_finite(...) +declare void @__powf_finite(...) + +; CHECK: declare void @__powl_finite(...) +declare void @__powl_finite(...) + +; CHECK: declare void @__sinh_finite(...) +declare void @__sinh_finite(...) + +; CHECK: declare void @__sinhf_finite(...) +declare void @__sinhf_finite(...) + +; CHECK: declare void @__sinhl_finite(...) +declare void @__sinhl_finite(...) + ; CHECK: declare void @__sinpi(...) declare void @__sinpi(...) diff --git a/llvm/unittests/Analysis/TargetLibraryInfoTest.cpp b/llvm/unittests/Analysis/TargetLibraryInfoTest.cpp index 44c141d..9d852cf 100644 --- a/llvm/unittests/Analysis/TargetLibraryInfoTest.cpp +++ b/llvm/unittests/Analysis/TargetLibraryInfoTest.cpp @@ -470,6 +470,52 @@ TEST_F(TargetLibraryInfoTest, ValidProto) { "declare i32 @isascii(i32)\n" "declare i32 @isdigit(i32)\n" "declare i32 @toascii(i32)\n" + + // These functions were extracted from math-finite.h which provides + // functions similar to those in math.h, but optimized for handling + // finite values only. + "declare double @__acos_finite(double)\n" + "declare float @__acosf_finite(float)\n" + "declare x86_fp80 @__acosl_finite(x86_fp80)\n" + "declare double @__acosh_finite(double)\n" + "declare float @__acoshf_finite(float)\n" + "declare x86_fp80 @__acoshl_finite(x86_fp80)\n" + "declare double @__asin_finite(double)\n" + "declare float @__asinf_finite(float)\n" + "declare x86_fp80 @__asinl_finite(x86_fp80)\n" + "declare double @__atan2_finite(double, double)\n" + "declare float @__atan2f_finite(float, float)\n" + "declare x86_fp80 @__atan2l_finite(x86_fp80, x86_fp80)\n" + "declare double @__atanh_finite(double)\n" + "declare float @__atanhf_finite(float)\n" + "declare x86_fp80 @__atanhl_finite(x86_fp80)\n" + "declare double @__cosh_finite(double)\n" + "declare float @__coshf_finite(float)\n" + "declare x86_fp80 @__coshl_finite(x86_fp80)\n" + "declare double @__exp10_finite(double)\n" + "declare float @__exp10f_finite(float)\n" + "declare x86_fp80 @__exp10l_finite(x86_fp80)\n" + "declare double @__exp2_finite(double)\n" + "declare float @__exp2f_finite(float)\n" + "declare x86_fp80 @__exp2l_finite(x86_fp80)\n" + "declare double @__exp_finite(double)\n" + "declare float @__expf_finite(float)\n" + "declare x86_fp80 @__expl_finite(x86_fp80)\n" + "declare double @__log10_finite(double)\n" + "declare float @__log10f_finite(float)\n" + "declare x86_fp80 @__log10l_finite(x86_fp80)\n" + "declare double @__log2_finite(double)\n" + "declare float @__log2f_finite(float)\n" + "declare x86_fp80 @__log2l_finite(x86_fp80)\n" + "declare double @__log_finite(double)\n" + "declare float @__logf_finite(float)\n" + "declare x86_fp80 @__logl_finite(x86_fp80)\n" + "declare double @__pow_finite(double, double)\n" + "declare float @__powf_finite(float, float)\n" + "declare x86_fp80 @__powl_finite(x86_fp80, x86_fp80)\n" + "declare double @__sinh_finite(double)\n" + "declare float @__sinhf_finite(float)\n" + "declare x86_fp80 @__sinhl_finite(x86_fp80)\n" ); for (unsigned FI = 0; FI != LibFunc::NumLibFuncs; ++FI) { -- 2.7.4