diff --git a/llvm/include/llvm/Analysis/TargetLibraryInfo.h b/llvm/include/llvm/Analysis/TargetLibraryInfo.h --- a/llvm/include/llvm/Analysis/TargetLibraryInfo.h +++ b/llvm/include/llvm/Analysis/TargetLibraryInfo.h @@ -323,8 +323,6 @@ case LibFunc_sin: case LibFunc_sinf: case LibFunc_sinl: case LibFunc_cos: case LibFunc_cosf: case LibFunc_cosl: case LibFunc_sqrt: case LibFunc_sqrtf: case LibFunc_sqrtl: - case LibFunc_sqrt_finite: case LibFunc_sqrtf_finite: - case LibFunc_sqrtl_finite: case LibFunc_fmax: case LibFunc_fmaxf: case LibFunc_fmaxl: case LibFunc_fmin: case LibFunc_fminf: case LibFunc_fminl: case LibFunc_floor: case LibFunc_floorf: case LibFunc_floorl: diff --git a/llvm/include/llvm/Analysis/TargetLibraryInfo.def b/llvm/include/llvm/Analysis/TargetLibraryInfo.def --- a/llvm/include/llvm/Analysis/TargetLibraryInfo.def +++ b/llvm/include/llvm/Analysis/TargetLibraryInfo.def @@ -205,60 +205,6 @@ /// void *new(unsigned long, align_val_t, nothrow) TLI_DEFINE_ENUM_INTERNAL(ZnwmSt11align_val_tRKSt9nothrow_t) TLI_DEFINE_STRING_INTERNAL("_ZnwmSt11align_val_tRKSt9nothrow_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") @@ -278,66 +224,12 @@ /// 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 *__memccpy_chk(void *dst, const void *src, int c, size_t n, /// size_t dstsize) TLI_DEFINE_ENUM_INTERNAL(memccpy_chk) @@ -355,30 +247,12 @@ // 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") @@ -402,15 +276,6 @@ /// const char *format, ...); TLI_DEFINE_ENUM_INTERNAL(sprintf_chk) TLI_DEFINE_STRING_INTERNAL("__sprintf_chk") -/// double __sqrt_finite(double x); -TLI_DEFINE_ENUM_INTERNAL(sqrt_finite) -TLI_DEFINE_STRING_INTERNAL("__sqrt_finite") -/// float __sqrt_finite(float x); -TLI_DEFINE_ENUM_INTERNAL(sqrtf_finite) -TLI_DEFINE_STRING_INTERNAL("__sqrtf_finite") -/// long double __sqrt_finite(long double x); -TLI_DEFINE_ENUM_INTERNAL(sqrtl_finite) -TLI_DEFINE_STRING_INTERNAL("__sqrtl_finite") /// char *__stpcpy_chk(char *s1, const char *s2, size_t s1size); TLI_DEFINE_ENUM_INTERNAL(stpcpy_chk) TLI_DEFINE_STRING_INTERNAL("__stpcpy_chk") diff --git a/llvm/include/llvm/Analysis/VecFuncs.def b/llvm/include/llvm/Analysis/VecFuncs.def --- a/llvm/include/llvm/Analysis/VecFuncs.def +++ b/llvm/include/llvm/Analysis/VecFuncs.def @@ -181,14 +181,6 @@ TLI_DEFINE_VECFUNC("powf", "__svml_powf8", 8) TLI_DEFINE_VECFUNC("powf", "__svml_powf16", 16) -TLI_DEFINE_VECFUNC("__pow_finite", "__svml_pow2", 2) -TLI_DEFINE_VECFUNC("__pow_finite", "__svml_pow4", 4) -TLI_DEFINE_VECFUNC("__pow_finite", "__svml_pow8", 8) - -TLI_DEFINE_VECFUNC("__powf_finite", "__svml_powf4", 4) -TLI_DEFINE_VECFUNC("__powf_finite", "__svml_powf8", 8) -TLI_DEFINE_VECFUNC("__powf_finite", "__svml_powf16", 16) - TLI_DEFINE_VECFUNC("llvm.pow.f64", "__svml_pow2", 2) TLI_DEFINE_VECFUNC("llvm.pow.f64", "__svml_pow4", 4) TLI_DEFINE_VECFUNC("llvm.pow.f64", "__svml_pow8", 8) @@ -205,14 +197,6 @@ TLI_DEFINE_VECFUNC("expf", "__svml_expf8", 8) TLI_DEFINE_VECFUNC("expf", "__svml_expf16", 16) -TLI_DEFINE_VECFUNC("__exp_finite", "__svml_exp2", 2) -TLI_DEFINE_VECFUNC("__exp_finite", "__svml_exp4", 4) -TLI_DEFINE_VECFUNC("__exp_finite", "__svml_exp8", 8) - -TLI_DEFINE_VECFUNC("__expf_finite", "__svml_expf4", 4) -TLI_DEFINE_VECFUNC("__expf_finite", "__svml_expf8", 8) -TLI_DEFINE_VECFUNC("__expf_finite", "__svml_expf16", 16) - TLI_DEFINE_VECFUNC("llvm.exp.f64", "__svml_exp2", 2) TLI_DEFINE_VECFUNC("llvm.exp.f64", "__svml_exp4", 4) TLI_DEFINE_VECFUNC("llvm.exp.f64", "__svml_exp8", 8) @@ -229,14 +213,6 @@ TLI_DEFINE_VECFUNC("logf", "__svml_logf8", 8) TLI_DEFINE_VECFUNC("logf", "__svml_logf16", 16) -TLI_DEFINE_VECFUNC("__log_finite", "__svml_log2", 2) -TLI_DEFINE_VECFUNC("__log_finite", "__svml_log4", 4) -TLI_DEFINE_VECFUNC("__log_finite", "__svml_log8", 8) - -TLI_DEFINE_VECFUNC("__logf_finite", "__svml_logf4", 4) -TLI_DEFINE_VECFUNC("__logf_finite", "__svml_logf8", 8) -TLI_DEFINE_VECFUNC("__logf_finite", "__svml_logf16", 16) - TLI_DEFINE_VECFUNC("llvm.log.f64", "__svml_log2", 2) TLI_DEFINE_VECFUNC("llvm.log.f64", "__svml_log4", 4) TLI_DEFINE_VECFUNC("llvm.log.f64", "__svml_log8", 8) diff --git a/llvm/include/llvm/IR/RuntimeLibcalls.def b/llvm/include/llvm/IR/RuntimeLibcalls.def --- a/llvm/include/llvm/IR/RuntimeLibcalls.def +++ b/llvm/include/llvm/IR/RuntimeLibcalls.def @@ -137,51 +137,26 @@ HANDLE_LIBCALL(LOG_F80, "logl") HANDLE_LIBCALL(LOG_F128, "logl") HANDLE_LIBCALL(LOG_PPCF128, "logl") -HANDLE_LIBCALL(LOG_FINITE_F32, "__logf_finite") -HANDLE_LIBCALL(LOG_FINITE_F64, "__log_finite") -HANDLE_LIBCALL(LOG_FINITE_F80, "__logl_finite") -HANDLE_LIBCALL(LOG_FINITE_F128, "__logl_finite") -HANDLE_LIBCALL(LOG_FINITE_PPCF128, "__logl_finite") HANDLE_LIBCALL(LOG2_F32, "log2f") HANDLE_LIBCALL(LOG2_F64, "log2") HANDLE_LIBCALL(LOG2_F80, "log2l") HANDLE_LIBCALL(LOG2_F128, "log2l") HANDLE_LIBCALL(LOG2_PPCF128, "log2l") -HANDLE_LIBCALL(LOG2_FINITE_F32, "__log2f_finite") -HANDLE_LIBCALL(LOG2_FINITE_F64, "__log2_finite") -HANDLE_LIBCALL(LOG2_FINITE_F80, "__log2l_finite") -HANDLE_LIBCALL(LOG2_FINITE_F128, "__log2l_finite") -HANDLE_LIBCALL(LOG2_FINITE_PPCF128, "__log2l_finite") HANDLE_LIBCALL(LOG10_F32, "log10f") HANDLE_LIBCALL(LOG10_F64, "log10") HANDLE_LIBCALL(LOG10_F80, "log10l") HANDLE_LIBCALL(LOG10_F128, "log10l") HANDLE_LIBCALL(LOG10_PPCF128, "log10l") -HANDLE_LIBCALL(LOG10_FINITE_F32, "__log10f_finite") -HANDLE_LIBCALL(LOG10_FINITE_F64, "__log10_finite") -HANDLE_LIBCALL(LOG10_FINITE_F80, "__log10l_finite") -HANDLE_LIBCALL(LOG10_FINITE_F128, "__log10l_finite") -HANDLE_LIBCALL(LOG10_FINITE_PPCF128, "__log10l_finite") HANDLE_LIBCALL(EXP_F32, "expf") HANDLE_LIBCALL(EXP_F64, "exp") HANDLE_LIBCALL(EXP_F80, "expl") HANDLE_LIBCALL(EXP_F128, "expl") HANDLE_LIBCALL(EXP_PPCF128, "expl") -HANDLE_LIBCALL(EXP_FINITE_F32, "__expf_finite") -HANDLE_LIBCALL(EXP_FINITE_F64, "__exp_finite") -HANDLE_LIBCALL(EXP_FINITE_F80, "__expl_finite") -HANDLE_LIBCALL(EXP_FINITE_F128, "__expl_finite") -HANDLE_LIBCALL(EXP_FINITE_PPCF128, "__expl_finite") HANDLE_LIBCALL(EXP2_F32, "exp2f") HANDLE_LIBCALL(EXP2_F64, "exp2") HANDLE_LIBCALL(EXP2_F80, "exp2l") HANDLE_LIBCALL(EXP2_F128, "exp2l") HANDLE_LIBCALL(EXP2_PPCF128, "exp2l") -HANDLE_LIBCALL(EXP2_FINITE_F32, "__exp2f_finite") -HANDLE_LIBCALL(EXP2_FINITE_F64, "__exp2_finite") -HANDLE_LIBCALL(EXP2_FINITE_F80, "__exp2l_finite") -HANDLE_LIBCALL(EXP2_FINITE_F128, "__exp2l_finite") -HANDLE_LIBCALL(EXP2_FINITE_PPCF128, "__exp2l_finite") HANDLE_LIBCALL(SIN_F32, "sinf") HANDLE_LIBCALL(SIN_F64, "sin") HANDLE_LIBCALL(SIN_F80, "sinl") @@ -204,11 +179,6 @@ HANDLE_LIBCALL(POW_F80, "powl") HANDLE_LIBCALL(POW_F128, "powl") HANDLE_LIBCALL(POW_PPCF128, "powl") -HANDLE_LIBCALL(POW_FINITE_F32, "__powf_finite") -HANDLE_LIBCALL(POW_FINITE_F64, "__pow_finite") -HANDLE_LIBCALL(POW_FINITE_F80, "__powl_finite") -HANDLE_LIBCALL(POW_FINITE_F128, "__powl_finite") -HANDLE_LIBCALL(POW_FINITE_PPCF128, "__powl_finite") HANDLE_LIBCALL(CEIL_F32, "ceilf") HANDLE_LIBCALL(CEIL_F64, "ceil") HANDLE_LIBCALL(CEIL_F80, "ceill") diff --git a/llvm/lib/Analysis/ConstantFolding.cpp b/llvm/lib/Analysis/ConstantFolding.cpp --- a/llvm/lib/Analysis/ConstantFolding.cpp +++ b/llvm/lib/Analysis/ConstantFolding.cpp @@ -1534,35 +1534,6 @@ return Name == "tan" || Name == "tanf" || Name == "tanh" || Name == "tanhf" || Name == "trunc" || Name == "truncf"; - case '_': - // Check for various function names that get used for the math functions - // when the header files are preprocessed with the macro - // __FINITE_MATH_ONLY__ enabled. - // The '12' here is the length of the shortest name that can match. - // We need to check the size before looking at Name[1] and Name[2] - // so we may as well check a limit that will eliminate mismatches. - if (Name.size() < 12 || Name[1] != '_') - return false; - switch (Name[2]) { - default: - return false; - case 'a': - return Name == "__acos_finite" || Name == "__acosf_finite" || - Name == "__asin_finite" || Name == "__asinf_finite" || - Name == "__atan2_finite" || Name == "__atan2f_finite"; - case 'c': - return Name == "__cosh_finite" || Name == "__coshf_finite"; - case 'e': - return Name == "__exp_finite" || Name == "__expf_finite" || - Name == "__exp2_finite" || Name == "__exp2f_finite"; - case 'l': - return Name == "__log_finite" || Name == "__logf_finite" || - Name == "__log10_finite" || Name == "__log10f_finite"; - case 'p': - return Name == "__pow_finite" || Name == "__powf_finite"; - case 's': - return Name == "__sinh_finite" || Name == "__sinhf_finite"; - } } } @@ -1828,15 +1799,11 @@ break; case LibFunc_acos: case LibFunc_acosf: - case LibFunc_acos_finite: - case LibFunc_acosf_finite: if (TLI->has(Func)) return ConstantFoldFP(acos, V, Ty); break; case LibFunc_asin: case LibFunc_asinf: - case LibFunc_asin_finite: - case LibFunc_asinf_finite: if (TLI->has(Func)) return ConstantFoldFP(asin, V, Ty); break; @@ -1859,22 +1826,16 @@ break; case LibFunc_cosh: case LibFunc_coshf: - case LibFunc_cosh_finite: - case LibFunc_coshf_finite: if (TLI->has(Func)) return ConstantFoldFP(cosh, V, Ty); break; case LibFunc_exp: case LibFunc_expf: - case LibFunc_exp_finite: - case LibFunc_expf_finite: if (TLI->has(Func)) return ConstantFoldFP(exp, V, Ty); break; case LibFunc_exp2: case LibFunc_exp2f: - case LibFunc_exp2_finite: - case LibFunc_exp2f_finite: if (TLI->has(Func)) // Fold exp2(x) as pow(2, x), in case the host lacks a C99 library. return ConstantFoldBinaryFP(pow, 2.0, V, Ty); @@ -1895,23 +1856,17 @@ break; case LibFunc_log: case LibFunc_logf: - case LibFunc_log_finite: - case LibFunc_logf_finite: if (V > 0.0 && TLI->has(Func)) return ConstantFoldFP(log, V, Ty); break; case LibFunc_log2: case LibFunc_log2f: - case LibFunc_log2_finite: - case LibFunc_log2f_finite: if (V > 0.0 && TLI->has(Func)) // TODO: What about hosts that lack a C99 library? return ConstantFoldFP(Log2, V, Ty); break; case LibFunc_log10: case LibFunc_log10f: - case LibFunc_log10_finite: - case LibFunc_log10f_finite: if (V > 0.0 && TLI->has(Func)) // TODO: What about hosts that lack a C99 library? return ConstantFoldFP(log10, V, Ty); @@ -1939,8 +1894,6 @@ break; case LibFunc_sinh: case LibFunc_sinhf: - case LibFunc_sinh_finite: - case LibFunc_sinhf_finite: if (TLI->has(Func)) return ConstantFoldFP(sinh, V, Ty); break; @@ -2091,8 +2044,6 @@ break; case LibFunc_pow: case LibFunc_powf: - case LibFunc_pow_finite: - case LibFunc_powf_finite: if (TLI->has(Func)) return ConstantFoldBinaryFP(pow, Op1V, Op2V, Ty); break; @@ -2114,8 +2065,6 @@ break; case LibFunc_atan2: case LibFunc_atan2f: - case LibFunc_atan2_finite: - case LibFunc_atan2f_finite: if (TLI->has(Func)) return ConstantFoldBinaryFP(atan2, Op1V, Op2V, Ty); break; @@ -2611,7 +2560,7 @@ case LibFunc_sqrtf: return Op.isNaN() || Op.isZero() || !Op.isNegative(); - // FIXME: Add more functions: sqrt_finite, atanh, expm1, log1p, + // FIXME: Add more functions: atanh, expm1, log1p, // maybe others? default: break; diff --git a/llvm/lib/Analysis/TargetLibraryInfo.cpp b/llvm/lib/Analysis/TargetLibraryInfo.cpp --- a/llvm/lib/Analysis/TargetLibraryInfo.cpp +++ b/llvm/lib/Analysis/TargetLibraryInfo.cpp @@ -470,50 +470,6 @@ TLI.setUnavailable(LibFunc_stat64); TLI.setUnavailable(LibFunc_statvfs64); TLI.setUnavailable(LibFunc_tmpfile64); - - // Relaxed math functions are included in math-finite.h on Linux (GLIBC). - 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); } if ((T.isOSLinux() && T.isGNUEnvironment()) || @@ -1235,34 +1191,22 @@ 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: @@ -1273,30 +1217,18 @@ 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: @@ -1307,29 +1239,20 @@ 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: @@ -1342,18 +1265,12 @@ case LibFunc_sin: case LibFunc_sinf: case LibFunc_sinh: - case LibFunc_sinh_finite: case LibFunc_sinhf: - case LibFunc_sinhf_finite: case LibFunc_sinhl: - case LibFunc_sinhl_finite: case LibFunc_sinl: case LibFunc_sqrt: - case LibFunc_sqrt_finite: case LibFunc_sqrtf: - case LibFunc_sqrtf_finite: case LibFunc_sqrtl: - case LibFunc_sqrtl_finite: case LibFunc_tan: case LibFunc_tanf: case LibFunc_tanh: @@ -1367,11 +1284,8 @@ 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: @@ -1388,11 +1302,8 @@ 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/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp b/llvm/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp --- a/llvm/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp +++ b/llvm/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp @@ -3935,8 +3935,6 @@ LLVM_DEBUG(dbgs() << "Trying to convert node to libcall\n"); SmallVector 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: { @@ -4045,68 +4043,33 @@ break; case ISD::FLOG: case ISD::STRICT_FLOG: - if (CanUseFiniteLibCall && DAG.getLibInfo().has(LibFunc_log_finite)) - ExpandFPLibCall(Node, RTLIB::LOG_FINITE_F32, - RTLIB::LOG_FINITE_F64, - RTLIB::LOG_FINITE_F80, - RTLIB::LOG_FINITE_F128, - RTLIB::LOG_FINITE_PPCF128, Results); - else - ExpandFPLibCall(Node, RTLIB::LOG_F32, RTLIB::LOG_F64, - RTLIB::LOG_F80, RTLIB::LOG_F128, - RTLIB::LOG_PPCF128, Results); + ExpandFPLibCall(Node, RTLIB::LOG_F32, RTLIB::LOG_F64, + RTLIB::LOG_F80, RTLIB::LOG_F128, + RTLIB::LOG_PPCF128, Results); break; case ISD::FLOG2: case ISD::STRICT_FLOG2: - if (CanUseFiniteLibCall && DAG.getLibInfo().has(LibFunc_log2_finite)) - ExpandFPLibCall(Node, RTLIB::LOG2_FINITE_F32, - RTLIB::LOG2_FINITE_F64, - RTLIB::LOG2_FINITE_F80, - RTLIB::LOG2_FINITE_F128, - RTLIB::LOG2_FINITE_PPCF128, Results); - else - ExpandFPLibCall(Node, RTLIB::LOG2_F32, RTLIB::LOG2_F64, - RTLIB::LOG2_F80, RTLIB::LOG2_F128, - RTLIB::LOG2_PPCF128, Results); + ExpandFPLibCall(Node, RTLIB::LOG2_F32, RTLIB::LOG2_F64, + RTLIB::LOG2_F80, RTLIB::LOG2_F128, + RTLIB::LOG2_PPCF128, Results); break; case ISD::FLOG10: case ISD::STRICT_FLOG10: - if (CanUseFiniteLibCall && DAG.getLibInfo().has(LibFunc_log10_finite)) - ExpandFPLibCall(Node, RTLIB::LOG10_FINITE_F32, - RTLIB::LOG10_FINITE_F64, - RTLIB::LOG10_FINITE_F80, - RTLIB::LOG10_FINITE_F128, - RTLIB::LOG10_FINITE_PPCF128, Results); - else - ExpandFPLibCall(Node, RTLIB::LOG10_F32, RTLIB::LOG10_F64, - RTLIB::LOG10_F80, RTLIB::LOG10_F128, - RTLIB::LOG10_PPCF128, Results); + ExpandFPLibCall(Node, RTLIB::LOG10_F32, RTLIB::LOG10_F64, + RTLIB::LOG10_F80, RTLIB::LOG10_F128, + RTLIB::LOG10_PPCF128, Results); break; case ISD::FEXP: case ISD::STRICT_FEXP: - if (CanUseFiniteLibCall && DAG.getLibInfo().has(LibFunc_exp_finite)) - ExpandFPLibCall(Node, RTLIB::EXP_FINITE_F32, - RTLIB::EXP_FINITE_F64, - RTLIB::EXP_FINITE_F80, - RTLIB::EXP_FINITE_F128, - RTLIB::EXP_FINITE_PPCF128, Results); - else - ExpandFPLibCall(Node, RTLIB::EXP_F32, RTLIB::EXP_F64, - RTLIB::EXP_F80, RTLIB::EXP_F128, - RTLIB::EXP_PPCF128, Results); + ExpandFPLibCall(Node, RTLIB::EXP_F32, RTLIB::EXP_F64, + RTLIB::EXP_F80, RTLIB::EXP_F128, + RTLIB::EXP_PPCF128, Results); break; case ISD::FEXP2: case ISD::STRICT_FEXP2: - if (CanUseFiniteLibCall && DAG.getLibInfo().has(LibFunc_exp2_finite)) - ExpandFPLibCall(Node, RTLIB::EXP2_FINITE_F32, - RTLIB::EXP2_FINITE_F64, - RTLIB::EXP2_FINITE_F80, - RTLIB::EXP2_FINITE_F128, - RTLIB::EXP2_FINITE_PPCF128, Results); - else - ExpandFPLibCall(Node, RTLIB::EXP2_F32, RTLIB::EXP2_F64, - RTLIB::EXP2_F80, RTLIB::EXP2_F128, - RTLIB::EXP2_PPCF128, Results); + ExpandFPLibCall(Node, RTLIB::EXP2_F32, RTLIB::EXP2_F64, + RTLIB::EXP2_F80, RTLIB::EXP2_F128, + RTLIB::EXP2_PPCF128, Results); break; case ISD::FTRUNC: case ISD::STRICT_FTRUNC: @@ -4176,16 +4139,9 @@ } case ISD::FPOW: case ISD::STRICT_FPOW: - if (CanUseFiniteLibCall && DAG.getLibInfo().has(LibFunc_pow_finite)) - ExpandFPLibCall(Node, RTLIB::POW_FINITE_F32, - RTLIB::POW_FINITE_F64, - RTLIB::POW_FINITE_F80, - RTLIB::POW_FINITE_F128, - RTLIB::POW_FINITE_PPCF128, Results); - else - ExpandFPLibCall(Node, RTLIB::POW_F32, RTLIB::POW_F64, - RTLIB::POW_F80, RTLIB::POW_F128, - RTLIB::POW_PPCF128, Results); + ExpandFPLibCall(Node, RTLIB::POW_F32, RTLIB::POW_F64, + RTLIB::POW_F80, RTLIB::POW_F128, + RTLIB::POW_PPCF128, Results); break; case ISD::LROUND: case ISD::STRICT_LROUND: diff --git a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp --- a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp +++ b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp @@ -7685,9 +7685,6 @@ case LibFunc_sqrt: case LibFunc_sqrtf: case LibFunc_sqrtl: - case LibFunc_sqrt_finite: - case LibFunc_sqrtf_finite: - case LibFunc_sqrtl_finite: if (visitUnaryFloatCall(I, ISD::FSQRT)) return; break; diff --git a/llvm/test/CodeGen/AArch64/illegal-float-ops.ll b/llvm/test/CodeGen/AArch64/illegal-float-ops.ll --- a/llvm/test/CodeGen/AArch64/illegal-float-ops.ll +++ b/llvm/test/CodeGen/AArch64/illegal-float-ops.ll @@ -295,54 +295,4 @@ ret i128 %b } -define void @test_exp_finite(double %double) #0 { - %expdouble = call double @llvm.exp.f64(double %double) - store double %expdouble, double* @vardouble - ; ANDROID-AARCH64-NOT: bl __exp_finite - ; CHECK: bl __exp_finite - - ret void -} - -define void @test_exp2_finite(double %double) #0 { - %expdouble = call double @llvm.exp2.f64(double %double) - store double %expdouble, double* @vardouble - ; ANDROID-AARCH64-NOT: bl __exp2_finite - ; CHECK: bl __exp2_finite - - ret void -} - -define void @test_log_finite(double %double) #0 { - %logdouble = call double @llvm.log.f64(double %double) - store double %logdouble, double* @vardouble - ; ANDROID-AARCH64-NOT: bl __log_finite - ; CHECK: bl __log_finite - ret void -} - -define void @test_log2_finite(double %double) #0 { - %log2double = call double @llvm.log2.f64(double %double) - store double %log2double, double* @vardouble - ; ANDROID-AARCH64-NOT: bl __log2_finite - ; CHECK: bl __log2_finite - ret void -} - -define void @test_log10_finite(double %double) #0 { - %log10double = call double @llvm.log10.f64(double %double) - store double %log10double, double* @vardouble - ; ANDROID-AARCH64-NOT: bl __log10_finite - ; CHECK: bl __log10_finite - ret void -} - -define void @test_pow_finite(double %double) #0 { - %powdouble = call double @llvm.pow.f64(double %double, double %double) - store double %powdouble, double* @vardouble - ; ANDROID-AARCH64-NOT: bl __pow_finite - ; CHECK: bl __pow_finite - ret void -} - attributes #0 = { "no-infs-fp-math"="true" "no-nans-fp-math"="true" } diff --git a/llvm/test/CodeGen/ARM/constant-island-movwt.mir b/llvm/test/CodeGen/ARM/constant-island-movwt.mir --- a/llvm/test/CodeGen/ARM/constant-island-movwt.mir +++ b/llvm/test/CodeGen/ARM/constant-island-movwt.mir @@ -86,33 +86,18 @@ @.str.92 = private unnamed_addr constant [5 x i8] c"logf\00", align 1 @.str.93 = private unnamed_addr constant [4 x i8] c"log\00", align 1 @.str.94 = private unnamed_addr constant [5 x i8] c"logl\00", align 1 - @.str.95 = private unnamed_addr constant [14 x i8] c"__logf_finite\00", align 1 - @.str.96 = private unnamed_addr constant [13 x i8] c"__log_finite\00", align 1 - @.str.97 = private unnamed_addr constant [14 x i8] c"__logl_finite\00", align 1 @.str.98 = private unnamed_addr constant [6 x i8] c"log2f\00", align 1 @.str.99 = private unnamed_addr constant [5 x i8] c"log2\00", align 1 @.str.100 = private unnamed_addr constant [6 x i8] c"log2l\00", align 1 - @.str.101 = private unnamed_addr constant [15 x i8] c"__log2f_finite\00", align 1 - @.str.102 = private unnamed_addr constant [14 x i8] c"__log2_finite\00", align 1 - @.str.103 = private unnamed_addr constant [15 x i8] c"__log2l_finite\00", align 1 @.str.104 = private unnamed_addr constant [7 x i8] c"log10f\00", align 1 @.str.105 = private unnamed_addr constant [6 x i8] c"log10\00", align 1 @.str.106 = private unnamed_addr constant [7 x i8] c"log10l\00", align 1 - @.str.107 = private unnamed_addr constant [16 x i8] c"__log10f_finite\00", align 1 - @.str.108 = private unnamed_addr constant [15 x i8] c"__log10_finite\00", align 1 - @.str.109 = private unnamed_addr constant [16 x i8] c"__log10l_finite\00", align 1 @.str.110 = private unnamed_addr constant [5 x i8] c"expf\00", align 1 @.str.111 = private unnamed_addr constant [4 x i8] c"exp\00", align 1 @.str.112 = private unnamed_addr constant [5 x i8] c"expl\00", align 1 - @.str.113 = private unnamed_addr constant [14 x i8] c"__expf_finite\00", align 1 - @.str.114 = private unnamed_addr constant [13 x i8] c"__exp_finite\00", align 1 - @.str.115 = private unnamed_addr constant [14 x i8] c"__expl_finite\00", align 1 @.str.116 = private unnamed_addr constant [6 x i8] c"exp2f\00", align 1 @.str.117 = private unnamed_addr constant [5 x i8] c"exp2\00", align 1 @.str.118 = private unnamed_addr constant [6 x i8] c"exp2l\00", align 1 - @.str.119 = private unnamed_addr constant [15 x i8] c"__exp2f_finite\00", align 1 - @.str.120 = private unnamed_addr constant [14 x i8] c"__exp2_finite\00", align 1 - @.str.121 = private unnamed_addr constant [15 x i8] c"__exp2l_finite\00", align 1 @.str.122 = private unnamed_addr constant [5 x i8] c"sinf\00", align 1 @.str.123 = private unnamed_addr constant [4 x i8] c"sin\00", align 1 @.str.124 = private unnamed_addr constant [5 x i8] c"sinl\00", align 1 @@ -122,9 +107,6 @@ @.str.128 = private unnamed_addr constant [5 x i8] c"powf\00", align 1 @.str.129 = private unnamed_addr constant [4 x i8] c"pow\00", align 1 @.str.130 = private unnamed_addr constant [5 x i8] c"powl\00", align 1 - @.str.131 = private unnamed_addr constant [14 x i8] c"__powf_finite\00", align 1 - @.str.132 = private unnamed_addr constant [13 x i8] c"__pow_finite\00", align 1 - @.str.133 = private unnamed_addr constant [14 x i8] c"__powl_finite\00", align 1 @.str.134 = private unnamed_addr constant [6 x i8] c"ceilf\00", align 1 @.str.135 = private unnamed_addr constant [5 x i8] c"ceil\00", align 1 @.str.136 = private unnamed_addr constant [6 x i8] c"ceill\00", align 1 diff --git a/llvm/test/CodeGen/X86/sqrt-fastmath.ll b/llvm/test/CodeGen/X86/sqrt-fastmath.ll --- a/llvm/test/CodeGen/X86/sqrt-fastmath.ll +++ b/llvm/test/CodeGen/X86/sqrt-fastmath.ll @@ -3,175 +3,11 @@ ; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=+avx | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX1 ; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=+avx512f | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX512 -declare double @__sqrt_finite(double) -declare float @__sqrtf_finite(float) -declare x86_fp80 @__sqrtl_finite(x86_fp80) declare float @llvm.sqrt.f32(float) declare <4 x float> @llvm.sqrt.v4f32(<4 x float>) declare <8 x float> @llvm.sqrt.v8f32(<8 x float>) declare <16 x float> @llvm.sqrt.v16f32(<16 x float>) - -define double @finite_f64_no_estimate(double %d) #0 { -; SSE-LABEL: finite_f64_no_estimate: -; SSE: # %bb.0: -; SSE-NEXT: sqrtsd %xmm0, %xmm0 -; SSE-NEXT: retq -; -; AVX-LABEL: finite_f64_no_estimate: -; AVX: # %bb.0: -; AVX-NEXT: vsqrtsd %xmm0, %xmm0, %xmm0 -; AVX-NEXT: retq - %call = tail call double @__sqrt_finite(double %d) #2 - ret double %call -} - -; No estimates for doubles. - -define double @finite_f64_estimate(double %d) #1 { -; SSE-LABEL: finite_f64_estimate: -; SSE: # %bb.0: -; SSE-NEXT: sqrtsd %xmm0, %xmm0 -; SSE-NEXT: retq -; -; AVX-LABEL: finite_f64_estimate: -; AVX: # %bb.0: -; AVX-NEXT: vsqrtsd %xmm0, %xmm0, %xmm0 -; AVX-NEXT: retq - %call = tail call double @__sqrt_finite(double %d) #2 - ret double %call -} - -define float @finite_f32_no_estimate(float %f) #0 { -; SSE-LABEL: finite_f32_no_estimate: -; SSE: # %bb.0: -; SSE-NEXT: sqrtss %xmm0, %xmm0 -; SSE-NEXT: retq -; -; AVX-LABEL: finite_f32_no_estimate: -; AVX: # %bb.0: -; AVX-NEXT: vsqrtss %xmm0, %xmm0, %xmm0 -; AVX-NEXT: retq - %call = tail call float @__sqrtf_finite(float %f) #2 - ret float %call -} - -define float @finite_f32_estimate(float %f) #1 { -; SSE-LABEL: finite_f32_estimate: -; SSE: # %bb.0: -; SSE-NEXT: rsqrtss %xmm0, %xmm1 -; SSE-NEXT: movaps %xmm0, %xmm2 -; SSE-NEXT: mulss %xmm1, %xmm2 -; SSE-NEXT: movss {{.*#+}} xmm3 = mem[0],zero,zero,zero -; SSE-NEXT: mulss %xmm2, %xmm3 -; SSE-NEXT: mulss %xmm1, %xmm2 -; SSE-NEXT: addss {{.*}}(%rip), %xmm2 -; SSE-NEXT: mulss %xmm3, %xmm2 -; SSE-NEXT: xorps %xmm1, %xmm1 -; SSE-NEXT: cmpeqss %xmm1, %xmm0 -; SSE-NEXT: andnps %xmm2, %xmm0 -; SSE-NEXT: retq -; -; AVX1-LABEL: finite_f32_estimate: -; AVX1: # %bb.0: -; AVX1-NEXT: vrsqrtss %xmm0, %xmm0, %xmm1 -; AVX1-NEXT: vmulss %xmm1, %xmm0, %xmm2 -; AVX1-NEXT: vmulss %xmm1, %xmm2, %xmm1 -; AVX1-NEXT: vaddss {{.*}}(%rip), %xmm1, %xmm1 -; AVX1-NEXT: vmulss {{.*}}(%rip), %xmm2, %xmm2 -; AVX1-NEXT: vmulss %xmm1, %xmm2, %xmm1 -; AVX1-NEXT: vxorps %xmm2, %xmm2, %xmm2 -; AVX1-NEXT: vcmpeqss %xmm2, %xmm0, %xmm0 -; AVX1-NEXT: vandnps %xmm1, %xmm0, %xmm0 -; AVX1-NEXT: retq -; -; AVX512-LABEL: finite_f32_estimate: -; AVX512: # %bb.0: -; AVX512-NEXT: vrsqrtss %xmm0, %xmm0, %xmm1 -; AVX512-NEXT: vmulss %xmm1, %xmm0, %xmm2 -; AVX512-NEXT: vfmadd213ss {{.*#+}} xmm1 = (xmm2 * xmm1) + mem -; AVX512-NEXT: vmulss {{.*}}(%rip), %xmm2, %xmm2 -; AVX512-NEXT: vmulss %xmm1, %xmm2, %xmm1 -; AVX512-NEXT: vxorps %xmm2, %xmm2, %xmm2 -; AVX512-NEXT: vcmpeqss %xmm2, %xmm0, %k1 -; AVX512-NEXT: vmovss %xmm2, %xmm1, %xmm1 {%k1} -; AVX512-NEXT: vmovaps %xmm1, %xmm0 -; AVX512-NEXT: retq - %call = tail call float @__sqrtf_finite(float %f) #2 - ret float %call -} - -define x86_fp80 @finite_f80_no_estimate(x86_fp80 %ld) #0 { -; CHECK-LABEL: finite_f80_no_estimate: -; CHECK: # %bb.0: -; CHECK-NEXT: fldt {{[0-9]+}}(%rsp) -; CHECK-NEXT: fsqrt -; CHECK-NEXT: retq - %call = tail call x86_fp80 @__sqrtl_finite(x86_fp80 %ld) #2 - ret x86_fp80 %call -} - -; Don't die on the impossible. - -define x86_fp80 @finite_f80_estimate_but_no(x86_fp80 %ld) #1 { -; CHECK-LABEL: finite_f80_estimate_but_no: -; CHECK: # %bb.0: -; CHECK-NEXT: fldt {{[0-9]+}}(%rsp) -; CHECK-NEXT: fsqrt -; CHECK-NEXT: retq - %call = tail call x86_fp80 @__sqrtl_finite(x86_fp80 %ld) #2 - ret x86_fp80 %call -} - -; PR34994 - https://bugs.llvm.org/show_bug.cgi?id=34994 - -define float @sqrtf_check_denorms(float %x) #3 { -; SSE-LABEL: sqrtf_check_denorms: -; SSE: # %bb.0: -; SSE-NEXT: rsqrtss %xmm0, %xmm1 -; SSE-NEXT: movaps %xmm0, %xmm2 -; SSE-NEXT: mulss %xmm1, %xmm2 -; SSE-NEXT: movss {{.*#+}} xmm3 = mem[0],zero,zero,zero -; SSE-NEXT: mulss %xmm2, %xmm3 -; SSE-NEXT: mulss %xmm1, %xmm2 -; SSE-NEXT: addss {{.*}}(%rip), %xmm2 -; SSE-NEXT: mulss %xmm3, %xmm2 -; SSE-NEXT: andps {{.*}}(%rip), %xmm0 -; SSE-NEXT: cmpltss {{.*}}(%rip), %xmm0 -; SSE-NEXT: andnps %xmm2, %xmm0 -; SSE-NEXT: retq -; -; AVX1-LABEL: sqrtf_check_denorms: -; AVX1: # %bb.0: -; AVX1-NEXT: vrsqrtss %xmm0, %xmm0, %xmm1 -; AVX1-NEXT: vmulss %xmm1, %xmm0, %xmm2 -; AVX1-NEXT: vmulss %xmm1, %xmm2, %xmm1 -; AVX1-NEXT: vaddss {{.*}}(%rip), %xmm1, %xmm1 -; AVX1-NEXT: vmulss {{.*}}(%rip), %xmm2, %xmm2 -; AVX1-NEXT: vmulss %xmm1, %xmm2, %xmm1 -; AVX1-NEXT: vandps {{.*}}(%rip), %xmm0, %xmm0 -; AVX1-NEXT: vcmpltss {{.*}}(%rip), %xmm0, %xmm0 -; AVX1-NEXT: vandnps %xmm1, %xmm0, %xmm0 -; AVX1-NEXT: retq -; -; AVX512-LABEL: sqrtf_check_denorms: -; AVX512: # %bb.0: -; AVX512-NEXT: vrsqrtss %xmm0, %xmm0, %xmm1 -; AVX512-NEXT: vmulss %xmm1, %xmm0, %xmm2 -; AVX512-NEXT: vfmadd213ss {{.*#+}} xmm1 = (xmm2 * xmm1) + mem -; AVX512-NEXT: vmulss {{.*}}(%rip), %xmm2, %xmm2 -; AVX512-NEXT: vmulss %xmm1, %xmm2, %xmm1 -; AVX512-NEXT: vbroadcastss {{.*#+}} xmm2 = [NaN,NaN,NaN,NaN] -; AVX512-NEXT: vandps %xmm2, %xmm0, %xmm0 -; AVX512-NEXT: vcmpltss {{.*}}(%rip), %xmm0, %k1 -; AVX512-NEXT: vxorps %xmm0, %xmm0, %xmm0 -; AVX512-NEXT: vmovss %xmm0, %xmm1, %xmm1 {%k1} -; AVX512-NEXT: vmovaps %xmm1, %xmm0 -; AVX512-NEXT: retq - %call = tail call float @__sqrtf_finite(float %x) #2 - ret float %call -} - define <4 x float> @sqrt_v4f32_check_denorms(<4 x float> %x) #3 { ; SSE-LABEL: sqrt_v4f32_check_denorms: ; SSE: # %bb.0: diff --git a/llvm/test/Transforms/ConstProp/calls-math-finite.ll b/llvm/test/Transforms/ConstProp/calls-math-finite.ll deleted file mode 100644 --- a/llvm/test/Transforms/ConstProp/calls-math-finite.ll +++ /dev/null @@ -1,149 +0,0 @@ -; NOTE: Assertions have been autogenerated by utils/update_test_checks.py -; RUN: opt < %s -constprop -S | FileCheck %s -; RUN: opt < %s -constprop -S -mtriple=unknown-unknown-linux-musl | FileCheck -check-prefix=MUSL %s - -; Test to verify constant folding can occur when math routines are mapped -; to the ___finite versions of functions due to __FINITE_MATH_ONLY__ -; being enabled on headers on Linux. All calls should constant fold away -; in this test. - -target triple = "unknown-unknown-linux-gnu" - -declare double @__acos_finite(double) #0 -declare float @__acosf_finite(float) #0 -declare double @__asin_finite(double) #0 -declare float @__asinf_finite(float) #0 -declare double @__atan2_finite(double, double) #0 -declare float @__atan2f_finite(float, float) #0 -declare double @__cosh_finite(double) #0 -declare float @__coshf_finite(float) #0 -declare double @__exp2_finite(double) #0 -declare float @__exp2f_finite(float) #0 -declare double @__exp_finite(double) #0 -declare float @__expf_finite(float) #0 -declare double @__log10_finite(double) #0 -declare float @__log10f_finite(float) #0 -declare double @__log_finite(double) #0 -declare float @__logf_finite(float) #0 -declare double @__pow_finite(double, double) #0 -declare float @__powf_finite(float, float) #0 -declare double @__sinh_finite(double) #0 -declare float @__sinhf_finite(float) #0 - -attributes #0 = { nounwind readnone } - -define void @T() { -; CHECK-LABEL: @T( -; CHECK-NEXT: [[SLOT:%.*]] = alloca double -; CHECK-NEXT: [[SLOTF:%.*]] = alloca float -; CHECK-NEXT: store double 0.000000e+00, double* [[SLOT]] -; CHECK-NEXT: store double 0x3FF921FB54442D18, double* [[SLOT]] -; CHECK-NEXT: store double 0x3FE4978FA3269EE1, double* [[SLOT]] -; CHECK-NEXT: store double 0x402422A497D6185E, double* [[SLOT]] -; CHECK-NEXT: store double 0x403415E5BF6FB106, double* [[SLOT]] -; CHECK-NEXT: store double 8.000000e+00, double* [[SLOT]] -; CHECK-NEXT: store double 0x3FF193EA7AAD030{{[AB]}}, double* [[SLOT]] -; CHECK-NEXT: store double 0x3FDE8927964FD5FD, double* [[SLOT]] -; CHECK-NEXT: store double 1.000000e+00, double* [[SLOT]] -; CHECK-NEXT: store double 0x40240926E70949AE, double* [[SLOT]] -; CHECK-NEXT: store float 0.000000e+00, float* [[SLOTF]] -; CHECK-NEXT: store float 0x3FF921FB60000000, float* [[SLOTF]] -; CHECK-NEXT: store float 0x3FE4978FA0000000, float* [[SLOTF]] -; CHECK-NEXT: store float 0x402422A4A0000000, float* [[SLOTF]] -; CHECK-NEXT: store float 0x403415E5C0000000, float* [[SLOTF]] -; CHECK-NEXT: store float 8.000000e+00, float* [[SLOTF]] -; CHECK-NEXT: store float 0x3FF193EA80000000, float* [[SLOTF]] -; CHECK-NEXT: store float 0x3FDE8927A0000000, float* [[SLOTF]] -; CHECK-NEXT: store float 8.100000e+01, float* [[SLOTF]] -; CHECK-NEXT: store float 0x40240926E0000000, float* [[SLOTF]] -; CHECK-NEXT: ret void -; -; MUSL-LABEL: @T( -; MUSL-NEXT: [[SLOT:%.*]] = alloca double -; MUSL-NEXT: [[SLOTF:%.*]] = alloca float -; MUSL-NEXT: call -; MUSL-NEXT: store -; MUSL-NEXT: call -; MUSL-NEXT: store -; MUSL-NEXT: call -; MUSL-NEXT: store -; MUSL-NEXT: call -; MUSL-NEXT: store -; MUSL-NEXT: call -; MUSL-NEXT: store -; MUSL-NEXT: call -; MUSL-NEXT: store -; MUSL-NEXT: call -; MUSL-NEXT: store -; MUSL-NEXT: call -; MUSL-NEXT: store -; MUSL-NEXT: call -; MUSL-NEXT: store -; MUSL-NEXT: call -; MUSL-NEXT: store -; MUSL-NEXT: call -; MUSL-NEXT: store -; MUSL-NEXT: call -; MUSL-NEXT: store -; MUSL-NEXT: call -; MUSL-NEXT: store -; MUSL-NEXT: call -; MUSL-NEXT: store -; MUSL-NEXT: call -; MUSL-NEXT: store -; MUSL-NEXT: call -; MUSL-NEXT: store -; MUSL-NEXT: call -; MUSL-NEXT: store -; MUSL-NEXT: call -; MUSL-NEXT: store -; MUSL-NEXT: call -; MUSL-NEXT: store - - %slot = alloca double - %slotf = alloca float - - %ACOS = call fast double @__acos_finite(double 1.000000e+00) - store double %ACOS, double* %slot - %ASIN = call fast double @__asin_finite(double 1.000000e+00) - store double %ASIN, double* %slot - %ATAN2 = call fast double @__atan2_finite(double 3.000000e+00, double 4.000000e+00) - store double %ATAN2, double* %slot - %COSH = call fast double @__cosh_finite(double 3.000000e+00) - store double %COSH, double* %slot - %EXP = call fast double @__exp_finite(double 3.000000e+00) - store double %EXP, double* %slot - %EXP2 = call fast double @__exp2_finite(double 3.000000e+00) - store double %EXP2, double* %slot - %LOG = call fast double @__log_finite(double 3.000000e+00) - store double %LOG, double* %slot - %LOG10 = call fast double @__log10_finite(double 3.000000e+00) - store double %LOG10, double* %slot - %POW = call fast double @__pow_finite(double 1.000000e+00, double 4.000000e+00) - store double %POW, double* %slot - %SINH = call fast double @__sinh_finite(double 3.000000e+00) - store double %SINH, double* %slot - - %ACOSF = call fast float @__acosf_finite(float 1.000000e+00) - store float %ACOSF, float* %slotf - %ASINF = call fast float @__asinf_finite(float 1.000000e+00) - store float %ASINF, float* %slotf - %ATAN2F = call fast float @__atan2f_finite(float 3.000000e+00, float 4.000000e+00) - store float %ATAN2F, float* %slotf - %COSHF = call fast float @__coshf_finite(float 3.000000e+00) - store float %COSHF, float* %slotf - %EXPF = call fast float @__expf_finite(float 3.000000e+00) - store float %EXPF, float* %slotf - %EXP2F = call fast float @__exp2f_finite(float 3.000000e+00) - store float %EXP2F, float* %slotf - %LOGF = call fast float @__logf_finite(float 3.000000e+00) - store float %LOGF, float* %slotf - %LOG10F = call fast float @__log10f_finite(float 3.000000e+00) - store float %LOG10F, float* %slotf - %POWF = call fast float @__powf_finite(float 3.000000e+00, float 4.000000e+00) - store float %POWF, float* %slotf - %SINHF = call fast float @__sinhf_finite(float 3.000000e+00) - store float %SINHF, float* %slotf - ret void -} - diff --git a/llvm/test/Transforms/ConstProp/fma.ll b/llvm/test/Transforms/ConstProp/fma.ll --- a/llvm/test/Transforms/ConstProp/fma.ll +++ b/llvm/test/Transforms/ConstProp/fma.ll @@ -16,15 +16,6 @@ ret double %1 } -; Test builtin fma with all finite non-zero constants. -define double @test_all_finite() { -; CHECK-LABEL: @test_all_finite( -; CHECK-NEXT: ret double 6.100000e+01 -; - %1 = call double @llvm.fma.f64(double 7.0, double 8.0, double 5.0) - ret double %1 -} - ; Test builtin fma with a +/-NaN addend. define double @test_NaN_addend() { ; CHECK-LABEL: @test_NaN_addend( diff --git a/llvm/test/Transforms/InferFunctionAttrs/annotate.ll b/llvm/test/Transforms/InferFunctionAttrs/annotate.ll --- a/llvm/test/Transforms/InferFunctionAttrs/annotate.ll +++ b/llvm/test/Transforms/InferFunctionAttrs/annotate.ll @@ -22,138 +22,6 @@ ; 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 --- a/llvm/test/Transforms/InferFunctionAttrs/no-proto.ll +++ b/llvm/test/Transforms/InferFunctionAttrs/no-proto.ll @@ -3,138 +3,6 @@ ; 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/test/Transforms/LoopVectorize/X86/svml-calls-finite.ll b/llvm/test/Transforms/LoopVectorize/X86/svml-calls-finite.ll deleted file mode 100644 --- a/llvm/test/Transforms/LoopVectorize/X86/svml-calls-finite.ll +++ /dev/null @@ -1,187 +0,0 @@ -; RUN: opt -vector-library=SVML -loop-vectorize -S < %s | FileCheck %s - -; Test to verify that when math headers are built with -; __FINITE_MATH_ONLY__ enabled, causing use of ___finite -; function versions, vectorization can map these to vector versions. - -target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" -target triple = "x86_64-unknown-linux-gnu" - -declare float @__expf_finite(float) #0 - -; CHECK-LABEL: @exp_f32 -; CHECK: <4 x float> @__svml_expf4 -; CHECK: ret -define void @exp_f32(float* nocapture %varray) { -entry: - br label %for.body - -for.body: ; preds = %for.body, %entry - %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ] - %tmp = trunc i64 %indvars.iv to i32 - %conv = sitofp i32 %tmp to float - %call = tail call fast float @__expf_finite(float %conv) - %arrayidx = getelementptr inbounds float, float* %varray, i64 %indvars.iv - store float %call, float* %arrayidx, align 4 - %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 - %exitcond = icmp eq i64 %indvars.iv.next, 1000 - br i1 %exitcond, label %for.end, label %for.body, !llvm.loop !1 - -for.end: ; preds = %for.body - ret void -} - -!1 = distinct !{!1, !2, !3} -!2 = !{!"llvm.loop.vectorize.width", i32 4} -!3 = !{!"llvm.loop.vectorize.enable", i1 true} - - -declare double @__exp_finite(double) #0 - -; CHECK-LABEL: @exp_f64 -; CHECK: <4 x double> @__svml_exp4 -; CHECK: ret -define void @exp_f64(double* nocapture %varray) { -entry: - br label %for.body - -for.body: ; preds = %for.body, %entry - %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ] - %tmp = trunc i64 %indvars.iv to i32 - %conv = sitofp i32 %tmp to double - %call = tail call fast double @__exp_finite(double %conv) - %arrayidx = getelementptr inbounds double, double* %varray, i64 %indvars.iv - store double %call, double* %arrayidx, align 4 - %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 - %exitcond = icmp eq i64 %indvars.iv.next, 1000 - br i1 %exitcond, label %for.end, label %for.body, !llvm.loop !11 - -for.end: ; preds = %for.body - ret void -} - -!11 = distinct !{!11, !12, !13} -!12 = !{!"llvm.loop.vectorize.width", i32 4} -!13 = !{!"llvm.loop.vectorize.enable", i1 true} - - - - -declare float @__logf_finite(float) #0 - -; CHECK-LABEL: @log_f32 -; CHECK: <4 x float> @__svml_logf4 -; CHECK: ret -define void @log_f32(float* nocapture %varray) { -entry: - br label %for.body - -for.body: ; preds = %for.body, %entry - %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ] - %tmp = trunc i64 %indvars.iv to i32 - %conv = sitofp i32 %tmp to float - %call = tail call fast float @__logf_finite(float %conv) - %arrayidx = getelementptr inbounds float, float* %varray, i64 %indvars.iv - store float %call, float* %arrayidx, align 4 - %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 - %exitcond = icmp eq i64 %indvars.iv.next, 1000 - br i1 %exitcond, label %for.end, label %for.body, !llvm.loop !21 - -for.end: ; preds = %for.body - ret void -} - -!21 = distinct !{!21, !22, !23} -!22 = !{!"llvm.loop.vectorize.width", i32 4} -!23 = !{!"llvm.loop.vectorize.enable", i1 true} - - -declare double @__log_finite(double) #0 - -; CHECK-LABEL: @log_f64 -; CHECK: <4 x double> @__svml_log4 -; CHECK: ret -define void @log_f64(double* nocapture %varray) { -entry: - br label %for.body - -for.body: ; preds = %for.body, %entry - %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ] - %tmp = trunc i64 %indvars.iv to i32 - %conv = sitofp i32 %tmp to double - %call = tail call fast double @__log_finite(double %conv) - %arrayidx = getelementptr inbounds double, double* %varray, i64 %indvars.iv - store double %call, double* %arrayidx, align 4 - %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 - %exitcond = icmp eq i64 %indvars.iv.next, 1000 - br i1 %exitcond, label %for.end, label %for.body, !llvm.loop !31 - -for.end: ; preds = %for.body - ret void -} - -!31 = distinct !{!31, !32, !33} -!32 = !{!"llvm.loop.vectorize.width", i32 4} -!33 = !{!"llvm.loop.vectorize.enable", i1 true} - - -declare float @__powf_finite(float, float) #0 - -; CHECK-LABEL: @pow_f32 -; CHECK: <4 x float> @__svml_powf4 -; CHECK: ret -define void @pow_f32(float* nocapture %varray, float* nocapture readonly %exp) { -entry: - br label %for.body - -for.body: ; preds = %for.body, %entry - %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ] - %tmp = trunc i64 %indvars.iv to i32 - %conv = sitofp i32 %tmp to float - %arrayidx = getelementptr inbounds float, float* %exp, i64 %indvars.iv - %tmp1 = load float, float* %arrayidx, align 4 - %tmp2 = tail call fast float @__powf_finite(float %conv, float %tmp1) - %arrayidx2 = getelementptr inbounds float, float* %varray, i64 %indvars.iv - store float %tmp2, float* %arrayidx2, align 4 - %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 - %exitcond = icmp eq i64 %indvars.iv.next, 1000 - br i1 %exitcond, label %for.end, label %for.body, !llvm.loop !41 - -for.end: ; preds = %for.body - ret void -} - -!41 = distinct !{!41, !42, !43} -!42 = !{!"llvm.loop.vectorize.width", i32 4} -!43 = !{!"llvm.loop.vectorize.enable", i1 true} - - -declare double @__pow_finite(double, double) #0 - -; CHECK-LABEL: @pow_f64 -; CHECK: <4 x double> @__svml_pow4 -; CHECK: ret -define void @pow_f64(double* nocapture %varray, double* nocapture readonly %exp) { -entry: - br label %for.body - -for.body: ; preds = %for.body, %entry - %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ] - %tmp = trunc i64 %indvars.iv to i32 - %conv = sitofp i32 %tmp to double - %arrayidx = getelementptr inbounds double, double* %exp, i64 %indvars.iv - %tmp1 = load double, double* %arrayidx, align 4 - %tmp2 = tail call fast double @__pow_finite(double %conv, double %tmp1) - %arrayidx2 = getelementptr inbounds double, double* %varray, i64 %indvars.iv - store double %tmp2, double* %arrayidx2, align 4 - %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 - %exitcond = icmp eq i64 %indvars.iv.next, 1000 - br i1 %exitcond, label %for.end, label %for.body, !llvm.loop !51 - -for.end: ; preds = %for.body - ret void -} - -!51 = distinct !{!51, !52, !53} -!52 = !{!"llvm.loop.vectorize.width", i32 4} -!53 = !{!"llvm.loop.vectorize.enable", i1 true} diff --git a/llvm/unittests/Analysis/TargetLibraryInfoTest.cpp b/llvm/unittests/Analysis/TargetLibraryInfoTest.cpp --- a/llvm/unittests/Analysis/TargetLibraryInfoTest.cpp +++ b/llvm/unittests/Analysis/TargetLibraryInfoTest.cpp @@ -497,9 +497,6 @@ "declare i8* @__strndup(i8*, i64)\n" "declare i8* @__strtok_r(i8*, i8*, i8**)\n" - "declare double @__sqrt_finite(double)\n" - "declare float @__sqrtf_finite(float)\n" - "declare x86_fp80 @__sqrtl_finite(x86_fp80)\n" "declare double @exp10(double)\n" "declare float @exp10f(float)\n" "declare x86_fp80 @exp10l(x86_fp80)\n" @@ -522,52 +519,6 @@ "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) {