#include <math.h>
#include <math_private.h>
#include <float.h>
+#include <libm-alias-finite.h>
double
__ieee754_exp10 (double arg)
replaced sometime (soon?). */
return __ieee754_exp (M_LN10 * arg);
}
-strong_alias (__ieee754_exp10, __exp10_finite)
+libm_alias_finite (__ieee754_exp10, __exp10)
#include <math.h>
#include <math_private.h>
-
+#include <libm-alias-finite.h>
float
__ieee754_exp10f (float arg)
this. */
return __ieee754_exp (M_LN10 * arg);
}
-strong_alias (__ieee754_exp10f, __exp10f_finite)
+libm_alias_finite (__ieee754_exp10f, __exp10f)
#include <math.h>
#include <math_private.h>
#include <float.h>
+#include <libm-alias-finite.h>
long double
__ieee754_exp10l (long double arg)
replaced sometime (soon?). */
return __ieee754_expl (M_LN10l * arg);
}
-strong_alias (__ieee754_exp10l, __exp10l_finite)
+libm_alias_finite (__ieee754_exp10, __exp10)
#include <math.h>
#include <math_private.h>
-
+#include <libm-alias-finite.h>
static double
__attribute__ ((noinline))
return __scalbn (x, (int) fn);
}
-strong_alias (__ieee754_scalb, __scalb_finite)
+libm_alias_finite (__ieee754_scalb, __scalb)
#include <math.h>
#include <math_private.h>
-
+#include <libm-alias-finite.h>
static float
__attribute__ ((noinline))
return __scalbnf (x, (int) fn);
}
-strong_alias (__ieee754_scalbf, __scalbf_finite)
+libm_alias_finite (__ieee754_scalbf, __scalbf)
#include <math.h>
#include <math_private.h>
-
+#include <libm-alias-finite.h>
static long double
__attribute__ ((noinline))
return __scalbnl (x, (int) fn);
}
-strong_alias (__ieee754_scalbl, __scalbl_finite)
+libm_alias_finite (__ieee754_scalbl, __scalbl)
#include <stdlib.h>
#include <soft-fp.h>
#include <quad.h>
+#include <libm-alias-finite.h>
long double
__ieee754_sqrtl (const long double a)
FP_HANDLE_EXCEPTIONS;
return c;
}
-strong_alias (__ieee754_sqrtl, __sqrtl_finite)
+libm_alias_finite (__ieee754_sqrtl, __sqrtl)
<https://www.gnu.org/licenses/>. */
#include <math_private.h>
+#include <libm-alias-finite.h>
double
__ieee754_sqrt (double d)
{
return __builtin_sqrt (d);
}
-strong_alias (__ieee754_sqrt, __sqrt_finite)
+libm_alias_finite (__ieee754_sqrt, __sqrt)
<https://www.gnu.org/licenses/>. */
#include <math_private.h>
+#include <libm-alias-finite.h>
float
__ieee754_sqrtf (float s)
{
return __builtin_sqrtf (s);
}
-strong_alias (__ieee754_sqrtf, __sqrtf_finite)
+libm_alias_finite (__ieee754_sqrtf, __sqrtf)
END(__ieee754_sqrt)
#if SHLIB_COMPAT (libm, GLIBC_2_15, GLIBC_2_18)
-strong_alias(__ieee754_sqrt, __sqrt_finite1)
-compat_symbol(libm, __sqrt_finite1, __sqrt_finite, GLIBC_2_15)
-versioned_symbol(libm, __ieee754_sqrt, __sqrt_finite, GLIBC_2_18)
-#else
-strong_alias(__ieee754_sqrt, __sqrt_finite)
+strong_alias(__ieee754_sqrt, __sqrt_dummy)
+compat_symbol(libm, __sqrt_dummy, __sqrt_finite, GLIBC_2_15)
+#endif
+#if SHLIB_COMPAT (libm, GLIBC_2_18, GLIBC_2_31)
+compat_symbol(libm, __ieee754_sqrt, __sqrt_finite, GLIBC_2_18)
#endif
END(__ieee754_sqrtf)
#if SHLIB_COMPAT (libm, GLIBC_2_15, GLIBC_2_18)
-strong_alias(__ieee754_sqrtf, __sqrtf_finite1)
-compat_symbol(libm, __sqrtf_finite1, __sqrtf_finite, GLIBC_2_15)
-versioned_symbol(libm, __ieee754_sqrtf, __sqrtf_finite, GLIBC_2_18)
-#else
-strong_alias(__ieee754_sqrtf, __sqrtf_finite)
+strong_alias(__ieee754_sqrtf, __sqrtf_dummy)
+compat_symbol(libm, __sqrtf_dummy, __sqrtf_finite, GLIBC_2_15)
+#endif
+#if SHLIB_COMPAT (libm, GLIBC_2_18, GLIBC_2_31)
+compat_symbol(libm, __ieee754_sqrtf, __sqrtf_finite, GLIBC_2_18)
#endif
straight-forward as just adding the alias, since a generic Versions file
includes the 2.15 version and the linker uses the first one it sees. */
#if SHLIB_COMPAT (libm, GLIBC_2_15, GLIBC_2_18)
-versioned_symbol (libm, __ieee754_sqrtl, __sqrtl_finite, GLIBC_2_18);
-#else
-strong_alias(__ieee754_sqrtl, __sqrtl_finite)
+compat_symbol (libm, __ieee754_sqrtl, __sqrtl_finite, GLIBC_2_18);
#endif
\n\
.end __ieee754_sqrt");
-/* Avoid the __sqrt_finite alias that dbl-64/e_sqrt.c would give... */
-#undef strong_alias
-#define strong_alias(a,b)
-
-/* ... defining our own. */
#if SHLIB_COMPAT (libm, GLIBC_2_15, GLIBC_2_18)
-asm (".global __sqrt_finite1; __sqrt_finite1 = __ieee754_sqrt");
+asm (".global __sqrt_dummy; __sqrt_dummy = __ieee754_sqrt");
#else
-asm (".global __sqrt_finite; __sqrt_finite = __ieee754_sqrt");
+asm (".global __sqrt_finite; __sqrt_finite = __ieee754_sqrt");
#endif
static double __full_ieee754_sqrt(double) __attribute_used__;
#define __ieee754_sqrt __full_ieee754_sqrt
#elif SHLIB_COMPAT (libm, GLIBC_2_15, GLIBC_2_18)
-# define __sqrt_finite __sqrt_finite1
+
+strong_alias (__ieee754_sqrt, __sqrt_dummy)
+#define __ieee754_sqrt __ieee754_sqrt
+
#endif /* _IEEE_FP_INEXACT */
#include <sysdeps/ieee754/dbl-64/e_sqrt.c>
+#undef __ieee754_sqrt
/* Work around forgotten symbol in alphaev6 build. */
#if SHLIB_COMPAT (libm, GLIBC_2_15, GLIBC_2_18)
-# undef __sqrt_finite
-# undef __ieee754_sqrt
-compat_symbol (libm, __sqrt_finite1, __sqrt_finite, GLIBC_2_15);
-versioned_symbol (libm, __ieee754_sqrt, __sqrt_finite, GLIBC_2_18);
+compat_symbol (libm, __sqrt_dummy, __sqrt_finite, GLIBC_2_15);
+#endif
+#if SHLIB_COMPAT (libm, GLIBC_2_18, GLIBC_2_31)
+compat_symbol (libm, __ieee754_sqrt, __sqrt_finite, GLIBC_2_18);
#endif
#include <shlib-compat.h>
-#if SHLIB_COMPAT (libm, GLIBC_2_15, GLIBC_2_18)
-# define __sqrtf_finite __sqrtf_finite1
-#endif
-
+#define __ieee754_sqrtf __ieee754_sqrtf
#include <sysdeps/ieee754/flt-32/e_sqrtf.c>
/* Work around forgotten symbol in alphaev6 build. */
#if SHLIB_COMPAT (libm, GLIBC_2_15, GLIBC_2_18)
-# undef __sqrtf_finite
-compat_symbol (libm, __sqrtf_finite1, __sqrtf_finite, GLIBC_2_15);
-versioned_symbol (libm, __ieee754_sqrtf, __sqrtf_finite, GLIBC_2_18);
+strong_alias(__ieee754_sqrtf, __sqrtf_dummy)
+compat_symbol (libm, __sqrtf_dummy, __sqrtf_finite, GLIBC_2_15);
+#endif
+#if SHLIB_COMPAT (libm, GLIBC_2_18, GLIBC_2_31)
+compat_symbol (libm, __ieee754_sqrtf, __sqrtf_finite, GLIBC_2_18);
#endif
/* Use VFP square root instruction. */
# include <math.h>
# include <sysdep.h>
+# include <libm-alias-finite.h>
double
__ieee754_sqrt (double x)
# endif
return ret;
}
-strong_alias (__ieee754_sqrt, __sqrt_finite)
+libm_alias_finite (__ieee754_sqrt, __sqrt)
#endif
/* Use VFP square root instruction. */
# include <math.h>
# include <sysdep.h>
+# include <libm-alias-finite.h>
float
__ieee754_sqrtf (float x)
# endif
return ret;
}
-strong_alias (__ieee754_sqrtf, __sqrtf_finite)
+libm_alias_finite (__ieee754_sqrtf, __sqrtf)
#endif
#endif
#ifndef declare_mgen_finite_alias_x
-#define declare_mgen_finite_alias_x(from, to) \
- strong_alias (from, to ## _finite)
+#define declare_mgen_finite_alias_x(from, to) \
+ libm_alias_finite (from, to)
#endif
#ifndef declare_mgen_finite_alias_s
/* Needed to evaluate M_MANT_DIG below. */
#include <float.h>
+#include <libm-alias-finite.h>
/* Use a special epsilon value for IBM long double
to avoid spurious overflows/underflows. */
*/
#include <machine/asm.h>
+#include <libm-alias-finite.h>
RCSID("$NetBSD: e_acos.S,v 1.4 1995/05/08 23:44:37 jtc Exp $")
fpatan /* atan (sqrt(1 - x^2) / x) */
ret
END (__ieee754_acos)
-strong_alias (__ieee754_acos, __acos_finite)
+libm_alias_finite (__ieee754_acos, __acos)
*/
#include <machine/asm.h>
+#include <libm-alias-finite.h>
RCSID("$NetBSD: $")
fpatan
ret
END (__ieee754_acosf)
-strong_alias (__ieee754_acosf, __acosf_finite)
+libm_alias_finite (__ieee754_acosf, __acosf)
<https://www.gnu.org/licenses/>. */
#include <machine/asm.h>
+#include <libm-alias-finite.h>
.section .rodata.cst8,"aM",@progbits,8
fdiv %st, %st(0)
ret
END(__ieee754_acosh)
-strong_alias (__ieee754_acosh, __acosh_finite)
+libm_alias_finite (__ieee754_acosh, __acosh)
<https://www.gnu.org/licenses/>. */
#include <machine/asm.h>
+#include <libm-alias-finite.h>
.section .rodata.cst8,"aM",@progbits,8
fdiv %st, %st(0)
ret
END(__ieee754_acoshf)
-strong_alias (__ieee754_acoshf, __acoshf_finite)
+libm_alias_finite (__ieee754_acoshf, __acoshf)
<https://www.gnu.org/licenses/>. */
#include <machine/asm.h>
+#include <libm-alias-finite.h>
.section .rodata.cst8,"aM",@progbits,8
fdiv %st, %st(0)
ret
END(__ieee754_acoshl)
-strong_alias (__ieee754_acoshl, __acoshl_finite)
+libm_alias_finite (__ieee754_acoshl, __acoshl)
*/
#include <math_private.h>
+#include <libm-alias-finite.h>
long double
__ieee754_acosl (long double x)
: "=t" (res) : "0" (x) : "st(1)");
return res;
}
-strong_alias (__ieee754_acosl, __acosl_finite)
+libm_alias_finite (__ieee754_acosl, __acosl)
#include <machine/asm.h>
#include <i386-math-asm.h>
+#include <libm-alias-finite.h>
RCSID("$NetBSD: e_asin.S,v 1.4 1995/05/08 23:45:40 jtc Exp $")
DBL_CHECK_FORCE_UFLOW
ret
END (__ieee754_asin)
-strong_alias (__ieee754_asin, __asin_finite)
+libm_alias_finite (__ieee754_asin, __asin)
#include <machine/asm.h>
#include <i386-math-asm.h>
+#include <libm-alias-finite.h>
RCSID("$NetBSD: $")
FLT_CHECK_FORCE_UFLOW
ret
END (__ieee754_asinf)
-strong_alias (__ieee754_asinf, __asinf_finite)
+libm_alias_finite (__ieee754_asinf, __asinf)
#include <machine/asm.h>
#include <i386-math-asm.h>
+#include <libm-alias-finite.h>
RCSID("$NetBSD: e_atan2.S,v 1.4 1995/05/08 23:46:28 jtc Exp $")
DBL_CHECK_FORCE_UFLOW_NARROW
ret
END (__ieee754_atan2)
-strong_alias (__ieee754_atan2, __atan2_finite)
+libm_alias_finite (__ieee754_atan2, __atan2)
#include <machine/asm.h>
#include <i386-math-asm.h>
+#include <libm-alias-finite.h>
RCSID("$NetBSD: e_atan2f.S,v 1.1 1995/05/08 23:35:10 jtc Exp $")
FLT_CHECK_FORCE_UFLOW_NARROW
ret
END (__ieee754_atan2f)
-strong_alias (__ieee754_atan2f, __atan2f_finite)
+libm_alias_finite (__ieee754_atan2f, __atan2f)
*/
#include <math_private.h>
+#include <libm-alias-finite.h>
long double
__ieee754_atan2l (long double y, long double x)
return res;
}
-strong_alias (__ieee754_atan2l, __atan2l_finite)
+libm_alias_finite (__ieee754_atan2l, __atan2l)
#include <machine/asm.h>
#include <i386-math-asm.h>
+#include <libm-alias-finite.h>
.section .rodata
6: fldl 4(%esp)
ret
END(__ieee754_atanh)
-strong_alias (__ieee754_atanh, __atanh_finite)
+libm_alias_finite (__ieee754_atanh, __atanh)
#include <machine/asm.h>
#include <i386-math-asm.h>
+#include <libm-alias-finite.h>
.section .rodata
5: flds 4(%esp)
ret
END(__ieee754_atanhf)
-strong_alias (__ieee754_atanhf, __atanhf_finite)
+libm_alias_finite (__ieee754_atanhf, __atanhf)
<https://www.gnu.org/licenses/>. */
#include <machine/asm.h>
+#include <libm-alias-finite.h>
.section .rodata
fadd %st(0)
ret
END(__ieee754_atanhl)
-strong_alias (__ieee754_atanhl, __atanhl_finite)
+libm_alias_finite (__ieee754_atanhl, __atanhl)
#include <machine/asm.h>
#include <i386-math-asm.h>
+#include <libm-alias-finite.h>
DEFINE_DBL_MIN
DBL_NARROW_EVAL_UFLOW_NONNEG
ret
END(__exp_finite)
+libm_alias_finite (__exp_finite, __exp)
#include <machine/asm.h>
#include <i386-math-asm.h>
+#include <libm-alias-finite.h>
DEFINE_DBL_MIN
fldz /* Set result to 0. */
2: ret
END (__ieee754_exp10)
-strong_alias (__ieee754_exp10, __exp10_finite)
+libm_alias_finite (__ieee754_exp10, __exp10)
#include <machine/asm.h>
#include <i386-math-asm.h>
+#include <libm-alias-finite.h>
DEFINE_FLT_MIN
fldz /* Set result to 0. */
2: ret
END (__ieee754_exp10f)
-strong_alias (__ieee754_exp10f, __exp10f_finite)
+libm_alias_finite (__ieee754_exp10f, __exp10f)
#include <machine/asm.h>
#include <i386-math-asm.h>
+#include <libm-alias-finite.h>
DEFINE_DBL_MIN
fldz /* Set result to 0. */
2: ret
END (__ieee754_exp2)
-strong_alias (__ieee754_exp2, __exp2_finite)
+libm_alias_finite (__ieee754_exp2, __exp2)
#include <machine/asm.h>
#include <i386-math-asm.h>
+#include <libm-alias-finite.h>
DEFINE_LDBL_MIN
fldz /* Set result to 0. */
2: ret
END (__ieee754_exp2l)
-strong_alias (__ieee754_exp2l, __exp2l_finite)
+libm_alias_finite (__ieee754_exp2l, __exp2l)
#include <libm-alias-ldouble.h>
#include <machine/asm.h>
#include <i386-math-asm.h>
+#include <libm-alias-finite.h>
#ifdef USE_AS_EXP10L
# define IEEE754_EXPL __ieee754_exp10l
-# define EXPL_FINITE __exp10l_finite
# define FLDLOG fldl2t
#elif defined USE_AS_EXPM1L
# define IEEE754_EXPL __expm1l
-# undef EXPL_FINITE
# define FLDLOG fldl2e
#else
# define IEEE754_EXPL __ieee754_expl
-# define EXPL_FINITE __expl_finite
# define FLDLOG fldl2e
#endif
fadd %st
ret
END(IEEE754_EXPL)
+
#ifdef USE_AS_EXPM1L
libm_hidden_def (__expm1l)
libm_alias_ldouble (__expm1, expm1)
+#elif defined USE_AS_EXP10L
+libm_alias_finite (__ieee754_exp10l, __exp10l)
#else
-strong_alias (IEEE754_EXPL, EXPL_FINITE)
+libm_alias_finite (__ieee754_expl, __expl)
#endif
*/
#include <machine/asm.h>
+#include <libm-alias-finite.h>
ENTRY(__ieee754_fmod)
fldl 12(%esp)
fstp %st(1)
ret
END (__ieee754_fmod)
-strong_alias (__ieee754_fmod, __fmod_finite)
+libm_alias_finite (__ieee754_fmod, __fmod)
*/
#include <machine/asm.h>
+#include <libm-alias-finite.h>
ENTRY(__ieee754_fmodf)
flds 8(%esp)
fstp %st(1)
ret
END(__ieee754_fmodf)
-strong_alias (__ieee754_fmodf, __fmodf_finite)
+libm_alias_finite (__ieee754_fmodf, __fmodf)
*/
#include <math_private.h>
+#include <libm-alias-finite.h>
long double
__ieee754_fmodl (long double x, long double y)
: "=t" (res) : "0" (x), "u" (y) : "ax", "st(1)");
return res;
}
-strong_alias (__ieee754_fmodl, __fmodl_finite)
+libm_alias_finite (__ieee754_fmodl, __fmodl)
#include <sysdep.h>
#include <i386-math-asm.h>
+#include <libm-alias-finite.h>
DEFINE_DBL_MIN
jmp 2b
END(__ieee754_hypot)
-strong_alias (__ieee754_hypot, __hypot_finite)
+libm_alias_finite (__ieee754_hypot, __hypot)
#include <sysdep.h>
#include <i386-math-asm.h>
+#include <libm-alias-finite.h>
.text
ENTRY(__ieee754_hypotf)
jmp 2b
END(__ieee754_hypotf)
-strong_alias (__ieee754_hypotf, __hypotf_finite)
+libm_alias_finite (__ieee754_hypotf, __hypotf)
*/
#include <machine/asm.h>
+#include <libm-alias-finite.h>
.section .rodata.cst8,"aM",@progbits,8
fyl2xp1 // log(x)
ret
END(__log_finite)
+libm_alias_finite (__log_finite, __log)
*/
#include <machine/asm.h>
+#include <libm-alias-finite.h>
.section .rodata.cst8,"aM",@progbits,8
fstp %st(1)
ret
END (__ieee754_log10)
-strong_alias (__ieee754_log10, __log10_finite)
+libm_alias_finite (__ieee754_log10, __log10)
*/
#include <machine/asm.h>
+#include <libm-alias-finite.h>
.section .rodata.cst8,"aM",@progbits,8
fstp %st(1)
ret
END (__ieee754_log10f)
-strong_alias (__ieee754_log10f, __log10f_finite)
+libm_alias_finite (__ieee754_log10f, __log10f)
*/
#include <machine/asm.h>
+#include <libm-alias-finite.h>
.section .rodata.cst8,"aM",@progbits,8
fadd %st(0)
ret
END(__ieee754_log10l)
-strong_alias (__ieee754_log10l, __log10l_finite)
+libm_alias_finite (__ieee754_log10l, __log10l)
*/
#include <machine/asm.h>
+#include <libm-alias-finite.h>
.section .rodata.cst8,"aM",@progbits,8
fstp %st(1)
ret
END (__ieee754_log2)
-strong_alias (__ieee754_log2, __log2_finite)
+libm_alias_finite (__ieee754_log2, __log2)
*/
#include <machine/asm.h>
+#include <libm-alias-finite.h>
.section .rodata.cst8,"aM",@progbits,8
fadd %st(0)
ret
END (__ieee754_log2l)
-strong_alias (__ieee754_log2l, __log2l_finite)
+libm_alias_finite (__ieee754_log2l, __log2l)
*/
#include <machine/asm.h>
-
+#include <libm-alias-finite.h>
.section .rodata.cst8,"aM",@progbits,8
fyl2xp1 // log(x)
ret
END(__logl_finite)
+libm_alias_finite (__logl_finite, __logl)
#include <machine/asm.h>
#include <i386-math-asm.h>
+#include <libm-alias-finite.h>
.section .rodata.cst8,"aM",@progbits,8
ret
END(__ieee754_pow)
-strong_alias (__ieee754_pow, __pow_finite)
+libm_alias_finite (__ieee754_pow, __pow)
#include <machine/asm.h>
#include <i386-math-asm.h>
+#include <libm-alias-finite.h>
.section .rodata.cst8,"aM",@progbits,8
ret
END(__ieee754_powl)
-strong_alias (__ieee754_powl, __powl_finite)
+libm_alias_finite (__ieee754_powl, __powl)
*/
#include <machine/asm.h>
+#include <libm-alias-finite.h>
ENTRY(__ieee754_remainder)
fldl 12(%esp)
fstp %st(1)
ret
END (__ieee754_remainder)
-strong_alias (__ieee754_remainder, __remainder_finite)
+libm_alias_finite (__ieee754_remainder, __remainder)
*/
#include <machine/asm.h>
+#include <libm-alias-finite.h>
ENTRY(__ieee754_remainderf)
flds 8(%esp)
fstp %st(1)
ret
END (__ieee754_remainderf)
-strong_alias (__ieee754_remainderf, __remainderf_finite)
+libm_alias_finite (__ieee754_remainderf, __remainderf)
*/
#include <machine/asm.h>
+#include <libm-alias-finite.h>
ENTRY(__ieee754_remainderl)
fldt 16(%esp)
fstp %st(1)
ret
END (__ieee754_remainderl)
-strong_alias (__ieee754_remainderl, __remainderl_finite)
+libm_alias_finite (__ieee754_remainderl, __remainderl)
#include <machine/asm.h>
#include <i386-math-asm.h>
+#include <libm-alias-finite.h>
.section .rodata
fdiv %st
ret
END(__ieee754_scalb)
-strong_alias (__ieee754_scalb, __scalb_finite)
+libm_alias_finite (__ieee754_scalb, __scalb)
#include <machine/asm.h>
#include <i386-math-asm.h>
+#include <libm-alias-finite.h>
.section .rodata
fdiv %st
ret
END(__ieee754_scalbf)
-strong_alias (__ieee754_scalbf, __scalbf_finite)
+libm_alias_finite (__ieee754_scalbf, __scalbf)
*/
#include <machine/asm.h>
+#include <libm-alias-finite.h>
.section .rodata
fdiv %st
ret
END(__ieee754_scalbl)
-strong_alias (__ieee754_scalbl, __scalbl_finite)
+libm_alias_finite (__ieee754_scalbl, __scalbl)
*/
#include <machine/asm.h>
+#include <libm-alias-finite.h>
ENTRY(__ieee754_sqrt)
fldl 4(%esp)
cfi_adjust_cfa_offset (-8)
ret
END (__ieee754_sqrt)
-strong_alias (__ieee754_sqrt, __sqrt_finite)
+libm_alias_finite (__ieee754_sqrt, __sqrt)
*/
#include <machine/asm.h>
+#include <libm-alias-finite.h>
ENTRY(__ieee754_sqrtf)
flds 4(%esp)
fsqrt
ret
END (__ieee754_sqrtf)
-strong_alias (__ieee754_sqrtf, __sqrtf_finite)
+libm_alias_finite (__ieee754_sqrtf, __sqrtf)
*/
#include <math_private.h>
+#include <libm-alias-finite.h>
#undef __ieee754_sqrtl
long double
return res;
}
-strong_alias (__ieee754_sqrtl, __sqrtl_finite)
+libm_alias_finite (__ieee754_sqrtl, __sqrtl)
*/
#include <machine/asm.h>
-
+#include <libm-alias-finite.h>
.text
ENTRY(__ieee754_log)
fyl2x // log(x)
ret
END(__log_finite)
+libm_alias_finite (__log_finite, __log)
*/
#include <machine/asm.h>
+#include <libm-alias-finite.h>
.section .rodata.cst8,"aM",@progbits,8
fyl2xp1 // log(x)
ret
END(__logl_finite)
+libm_alias_finite (__logl_finite, __logl)
#define SYMBOL_NAME exp2f
#include "ifunc-sse2.h"
+#include <libm-alias-finite.h>
libc_ifunc_redirected (__redirect_exp2f, __exp2f, IFUNC_SELECTOR ());
#include <libm-alias-float.h>
#ifdef SHARED
-# include <shlib-compat.h>
versioned_symbol (libm, __exp2f, exp2f, GLIBC_2_27);
libm_alias_float_other (__exp2, exp2)
#else
#endif
strong_alias (__exp2f, __ieee754_exp2f)
-strong_alias (__exp2f, __exp2f_finite)
+libm_alias_finite (__ieee754_exp2f, __exp2f)
#define __exp2f __exp2f_ia32
#include <sysdeps/ieee754/flt-32/e_exp2f.c>
#define SYMBOL_NAME expf
#include "ifunc-sse2.h"
+#include <libm-alias-finite.h>
libc_ifunc_redirected (__redirect_expf, __expf, IFUNC_SELECTOR ());
__hidden_ver1 (__expf_ia32, __GI___expf, __redirect_expf)
__attribute__ ((visibility ("hidden"))) __THROW;
-# include <shlib-compat.h>
versioned_symbol (libm, __expf, expf, GLIBC_2_27);
libm_alias_float_other (__exp, exp)
#else
#endif
strong_alias (__expf, __ieee754_expf)
-strong_alias (__expf, __expf_finite)
+libm_alias_finite (__ieee754_expf, __expf)
#define __expf __expf_ia32
#include <sysdeps/ieee754/flt-32/e_expf.c>
#define SYMBOL_NAME log2f
#include "ifunc-sse2.h"
+#include <libm-alias-finite.h>
libc_ifunc_redirected (__redirect_log2f, __log2f, IFUNC_SELECTOR ());
__hidden_ver1 (__log2f_ia32, __GI___log2f, __redirect_log2f)
__attribute__ ((visibility ("hidden"))) __THROW;
-# include <shlib-compat.h>
versioned_symbol (libm, __log2f, log2f, GLIBC_2_27);
libm_alias_float_other (__log2, log2)
#else
#endif
strong_alias (__log2f, __ieee754_log2f)
-strong_alias (__log2f, __log2f_finite)
+libm_alias_finite (__ieee754_log2f, __log2f)
#define __log2f __log2f_ia32
#include <sysdeps/ieee754/flt-32/e_log2f.c>
#define SYMBOL_NAME logf
#include "ifunc-sse2.h"
+#include <libm-alias-finite.h>
libc_ifunc_redirected (__redirect_logf, __logf, IFUNC_SELECTOR ());
__hidden_ver1 (__logf_ia32, __GI___logf, __redirect_logf)
__attribute__ ((visibility ("hidden"))) __THROW;
-# include <shlib-compat.h>
versioned_symbol (libm, __logf, logf, GLIBC_2_27);
libm_alias_float_other (__log, log)
#else
#endif
strong_alias (__logf, __ieee754_logf)
-strong_alias (__logf, __logf_finite)
+libm_alias_finite (__ieee754_logf, __logf)
#define __logf __logf_ia32
#include <sysdeps/ieee754/flt-32/e_logf.c>
#define SYMBOL_NAME powf
#include "ifunc-sse2.h"
+#include <libm-alias-finite.h>
libc_ifunc_redirected (__redirect_powf, __powf, IFUNC_SELECTOR ());
__hidden_ver1 (__powf_ia32, __GI___powf, __redirect_powf)
__attribute__ ((visibility ("hidden")));
-# include <shlib-compat.h>
versioned_symbol (libm, __powf, powf, GLIBC_2_27);
libm_alias_float_other (__pow, pow)
#else
#endif
strong_alias (__powf, __ieee754_powf)
-strong_alias (__powf, __powf_finite)
+libm_alias_finite (__ieee754_powf, __powf)
#define __powf __powf_ia32
#include <sysdeps/ieee754/flt-32/e_powf.c>
#include <math.h>
#include <math_private.h>
+#include <libm-alias-finite.h>
static const double
one = 1.0,
return __log1p (t + sqrt (2.0 * t + t * t));
}
}
-strong_alias (__ieee754_acosh, __acosh_finite)
+libm_alias_finite (__ieee754_acosh, __acosh)
#include <math.h>
#include <math_private.h>
#include <math-underflow.h>
+#include <libm-alias-finite.h>
#ifndef SECTION
# define SECTION
}
}
#ifndef __ieee754_asin
-strong_alias (__ieee754_asin, __asin_finite)
+libm_alias_finite (__ieee754_asin, __asin)
#endif
/*******************************************************************/
}
}
#ifndef __ieee754_acos
-strong_alias (__ieee754_acos, __acos_finite)
+libm_alias_finite (__ieee754_acos, __acos)
#endif
#include <math_private.h>
#include <fenv_private.h>
#include <stap-probe.h>
+#include <libm-alias-finite.h>
#ifndef SECTION
# define SECTION
}
#ifndef __ieee754_atan2
-strong_alias (__ieee754_atan2, __atan2_finite)
+libm_alias_finite (__ieee754_atan2, __atan2)
#endif
/* Treat the Denormalized case */
#include <math-barriers.h>
#include <math_private.h>
#include <math-underflow.h>
+#include <libm-alias-finite.h>
static const double huge = 1e300;
return copysign (t, x);
}
-strong_alias (__ieee754_atanh, __atanh_finite)
+libm_alias_finite (__ieee754_atanh, __atanh)
#include <math.h>
#include <math-narrow-eval.h>
#include <math_private.h>
+#include <libm-alias-finite.h>
static const double one = 1.0, half = 0.5, huge = 1.0e300;
/* |x| > overflowthresold, cosh(x) overflow */
return math_narrow_eval (huge * huge);
}
-strong_alias (__ieee754_cosh, __cosh_finite)
+libm_alias_finite (__ieee754_cosh, __cosh)
#include <math-barriers.h>
#include <math-narrow-eval.h>
#include <math-svid-compat.h>
-#include <shlib-compat.h>
+#include <libm-alias-finite.h>
#include <libm-alias-double.h>
#include "math_config.h"
#ifndef __exp
hidden_def (__exp)
strong_alias (__exp, __ieee754_exp)
-strong_alias (__exp, __exp_finite)
+libm_alias_finite (__ieee754_exp, __exp)
# if LIBM_SVID_COMPAT
versioned_symbol (libm, __exp, exp, GLIBC_2_29);
libm_alias_double_other (__exp, exp)
#include <math.h>
#include <math_private.h>
#include <float.h>
+#include <libm-alias-finite.h>
static const double log10_high = 0x2.4d7637p0;
static const double log10_low = 0x7.6aaa2b05ba95cp-28;
exp_low = arg_high * log10_low + arg_low * M_LN10;
return __ieee754_exp (exp_high) * __ieee754_exp (exp_low);
}
-strong_alias (__ieee754_exp10, __exp10_finite)
+libm_alias_finite (__ieee754_exp10, __exp10)
#include <math-barriers.h>
#include <math-narrow-eval.h>
#include <math-svid-compat.h>
-#include <shlib-compat.h>
+#include <libm-alias-finite.h>
#include <libm-alias-double.h>
#include "math_config.h"
}
#ifndef __exp2
strong_alias (__exp2, __ieee754_exp2)
-strong_alias (__exp2, __exp2_finite)
+libm_alias_finite (__ieee754_exp2, __exp2)
# if LIBM_SVID_COMPAT
versioned_symbol (libm, __exp2, exp2, GLIBC_2_29);
libm_alias_double_other (__exp2, exp2)
#include <math.h>
#include <math_private.h>
+#include <libm-alias-finite.h>
static const double one = 1.0, Zero[] = { 0.0, -0.0, };
}
return x; /* exact output */
}
-strong_alias (__ieee754_fmod, __fmod_finite)
+libm_alias_finite (__ieee754_fmod, __fmod)
#include <fenv_private.h>
#include <math-underflow.h>
#include <float.h>
+#include <libm-alias-finite.h>
/* Coefficients B_2k / 2k(2k-1) of x^-(2k-1) inside exp in Stirling's
approximation to gamma function. */
else
return ret;
}
-strong_alias (__ieee754_gamma_r, __gamma_r_finite)
+libm_alias_finite (__ieee754_gamma_r, __gamma_r)
#include <math.h>
#include <math_private.h>
#include <math-underflow.h>
+#include <libm-alias-finite.h>
double
__ieee754_hypot (double x, double y)
else
return w;
}
-strong_alias (__ieee754_hypot, __hypot_finite)
+#ifndef __ieee754_hypot
+libm_alias_finite (__ieee754_hypot, __hypot)
+#endif
#include <math.h>
#include <math-barriers.h>
#include <math_private.h>
+#include <libm-alias-finite.h>
static double pzero (double), qzero (double);
return ((one + u) * (one - u) + z * (r / s));
}
}
-strong_alias (__ieee754_j0, __j0_finite)
+libm_alias_finite (__ieee754_j0, __j0)
static const double
U[] = { -7.38042951086872317523e-02, /* 0xBFB2E4D6, 0x99CBD01F */
v = v1 + z2 * v2 + z4 * V[3];
return (u / v + tpi * (__ieee754_j0 (x) * __ieee754_log (x)));
}
-strong_alias (__ieee754_y0, __y0_finite)
+libm_alias_finite (__ieee754_y0, __y0)
/* The asymptotic expansions of pzero is
* 1 - 9/128 s^2 + 11025/98304 s^4 - ..., where s = 1/x.
#include <math-narrow-eval.h>
#include <math_private.h>
#include <math-underflow.h>
+#include <libm-alias-finite.h>
static double pone (double), qone (double);
s = s1 + z2 * s2 + z4 * s3;
return (x * 0.5 + r / s);
}
-strong_alias (__ieee754_j1, __j1_finite)
+libm_alias_finite (__ieee754_j1, __j1)
static const double U0[5] = {
-1.96057090646238940668e-01, /* 0xBFC91866, 0x143CBC8A */
v = v1 + z2 * v2 + z4 * v3;
return (x * (u / v) + tpi * (__ieee754_j1 (x) * __ieee754_log (x) - one / x));
}
-strong_alias (__ieee754_y1, __y1_finite)
+libm_alias_finite (__ieee754_y1, __y1)
/* For x >= 8, the asymptotic expansions of pone is
* 1 + 15/128 s^2 - 4725/2^15 s^4 - ..., where s = 1/x.
#include <math_private.h>
#include <fenv_private.h>
#include <math-underflow.h>
+#include <libm-alias-finite.h>
static const double
invsqrtpi = 5.64189583547756279280e-01, /* 0x3FE20DD7, 0x50429B6D */
math_check_force_underflow (ret);
return ret;
}
-strong_alias (__ieee754_jn, __jn_finite)
+libm_alias_finite (__ieee754_jn, __jn)
double
__ieee754_yn (int n, double x)
ret = copysign (DBL_MAX, ret) * DBL_MAX;
return ret;
}
-strong_alias (__ieee754_yn, __yn_finite)
+libm_alias_finite (__ieee754_yn, __yn)
#include <math-narrow-eval.h>
#include <math_private.h>
#include <libc-diag.h>
+#include <libm-alias-finite.h>
static const double
two52= 4.50359962737049600000e+15, /* 0x43300000, 0x00000000 */
DIAG_POP_NEEDS_COMMENT;
return r;
}
-strong_alias (__ieee754_lgamma_r, __lgamma_r_finite)
+libm_alias_finite (__ieee754_lgamma_r, __lgamma_r)
#include <math.h>
#include <stdint.h>
#include <math-svid-compat.h>
-#include <shlib-compat.h>
+#include <libm-alias-finite.h>
#include <libm-alias-double.h>
#include "math_config.h"
}
#ifndef __log
strong_alias (__log, __ieee754_log)
-strong_alias (__log, __log_finite)
+libm_alias_finite (__ieee754_log, __log)
# if LIBM_SVID_COMPAT
versioned_symbol (libm, __log, log, GLIBC_2_29);
libm_alias_double_other (__log, log)
#include <math.h>
#include <math_private.h>
#include <fix-int-fp-convert-zero.h>
+#include <libm-alias-finite.h>
static const double two54 = 1.80143985094819840000e+16; /* 0x43500000, 0x00000000 */
static const double ivln10 = 4.34294481903251816668e-01; /* 0x3FDBCB7B, 0x1526E50E */
z = y * log10_2lo + ivln10 * __ieee754_log (x);
return z + y * log10_2hi;
}
-
-strong_alias (__ieee754_log10, __log10_finite)
+libm_alias_finite (__ieee754_log10, __log10)
#include <math.h>
#include <stdint.h>
#include <math-svid-compat.h>
-#include <shlib-compat.h>
+#include <libm-alias-finite.h>
#include <libm-alias-double.h>
#include "math_config.h"
}
#ifndef __log2
strong_alias (__log2, __ieee754_log2)
-strong_alias (__log2, __log2_finite)
+libm_alias_finite (__ieee754_log2, __log2)
# if LIBM_SVID_COMPAT
versioned_symbol (libm, __log2, log2, GLIBC_2_29);
libm_alias_double_other (__log2, log2)
#include <math-barriers.h>
#include <math-narrow-eval.h>
#include <math-svid-compat.h>
-#include <shlib-compat.h>
+#include <libm-alias-finite.h>
#include <libm-alias-double.h>
#include "math_config.h"
}
#ifndef __pow
strong_alias (__pow, __ieee754_pow)
-strong_alias (__pow, __pow_finite)
+libm_alias_finite (__ieee754_pow, __pow)
# if LIBM_SVID_COMPAT
versioned_symbol (libm, __pow, pow, GLIBC_2_29);
libm_alias_double_other (__pow, pow)
#include <math.h>
#include <math_private.h>
#include <fenv_private.h>
+#include <libm-alias-finite.h>
/**************************************************************************/
/* An ultimate remainder routine. Given two IEEE double machine numbers x */
}
}
}
-strong_alias (__ieee754_remainder, __remainder_finite)
+libm_alias_finite (__ieee754_remainder, __remainder)
#include <math-narrow-eval.h>
#include <math_private.h>
#include <math-underflow.h>
+#include <libm-alias-finite.h>
static const double one = 1.0, shuge = 1.0e307;
/* |x| > overflowthresold, sinh(x) overflow */
return math_narrow_eval (x * shuge);
}
-strong_alias (__ieee754_sinh, __sinh_finite)
+libm_alias_finite (__ieee754_sinh, __sinh)
#include <math-barriers.h>
#include <math_private.h>
#include <fenv_private.h>
+#include <libm-alias-finite.h>
/*********************************************************************/
/* An ultimate sqrt routine. Given an IEEE double machine number x */
return 0x1p-256 * __ieee754_sqrt (x * 0x1p512);
}
}
-strong_alias (__ieee754_sqrt, __sqrt_finite)
+#ifndef __ieee754_sqrt
+libm_alias_finite (__ieee754_sqrt, __sqrt)
+#endif
#include <math.h>
#include <math_private.h>
+#include <libm-alias-finite.h>
static const double
one = 1.0,
else /* x < 1 */
return (x - x) / (x - x);
}
-strong_alias (__ieee754_acosh, __acosh_finite)
+libm_alias_finite (__ieee754_acosh, __acosh)
#include <math.h>
#include <math_private.h>
+#include <libm-alias-finite.h>
static const double one = 1.0, half=0.5, huge = 1.0e300;
/* |x| > overflowthresold, cosh(x) overflow */
return huge*huge;
}
-strong_alias (__ieee754_cosh, __cosh_finite)
+libm_alias_finite (__ieee754_cosh, __cosh)
#include <math.h>
#include <math_private.h>
#include <stdint.h>
+#include <libm-alias-finite.h>
static const double one = 1.0, Zero[] = {0.0, -0.0,};
}
return x; /* exact output */
}
-strong_alias (__ieee754_fmod, __fmod_finite)
+libm_alias_finite (__ieee754_fmod, __fmod)
#include <math.h>
#include <math_private.h>
#include <stdint.h>
+#include <libm-alias-finite.h>
static const double two54 = 1.80143985094819840000e+16; /* 0x4350000000000000 */
static const double ivln10 = 4.34294481903251816668e-01; /* 0x3FDBCB7B1526E50E */
z = y * log10_2lo + ivln10 * __ieee754_log (x);
return z + y * log10_2hi;
}
-
-strong_alias (__ieee754_log10, __log10_finite)
+libm_alias_finite (__ieee754_log10, __log10)
#define __fsubl __f32subf128
#define __dsubl __f64subf128
+/* Used on __finite compat alias. */
+#define __acosl __acosf128
+#define __acoshl __acoshf128
+#define __asinl __asinf128
+#define __atan2l __atan2f128
+#define __atanhl __atanhf128
+#define __coshl __coshf128
+#define __exp10l __exp10f128
+#define __expl __expf128
+#define __fmodl __fmodf128
+#define __gammal_r __gammaf128_r
+#define __hypotl __hypotf128
+#define __j0l __j0f128
+#define __j1l __j1f128
+#define __jnl __jnf128
+#define __lgammal_r __lgammaf128_r
+#define __log10l __log10f128
+#define __log2l __log2f128
+#define __logl __logf128
+#define __powl __powf128
+#define __remainderl __remainderf128
+#define __sinhl __sinhf128
+#define __y0l __y0f128
+#define __y1l __y1f128
+#define __ynl __ynf128
+
/* __nexttowardf128 is not _Float128 API. */
#define __nexttowardl __nexttowardf128_do_not_use
#define nexttowardl nexttowardf128_do_not_use
#include <math.h>
#include <math_private.h>
+#include <libm-alias-finite.h>
static const float
one = 1.0000000000e+00, /* 0x3F800000 */
return (float)2.0*(df+w);
}
}
-strong_alias (__ieee754_acosf, __acosf_finite)
+libm_alias_finite (__ieee754_acosf, __acosf)
#include <math.h>
#include <math_private.h>
+#include <libm-alias-finite.h>
static const float
one = 1.0,
return __log1pf(t+sqrtf((float)2.0*t+t*t));
}
}
-strong_alias (__ieee754_acoshf, __acoshf_finite)
+libm_alias_finite (__ieee754_acoshf, __acoshf)
#include <math.h>
#include <math_private.h>
#include <math-underflow.h>
+#include <libm-alias-finite.h>
static const float
one = 1.0000000000e+00, /* 0x3F800000 */
}
if(hx>0) return t; else return -t;
}
-strong_alias (__ieee754_asinf, __asinf_finite)
+libm_alias_finite (__ieee754_asinf, __asinf)
#include <math.h>
#include <math_private.h>
+#include <libm-alias-finite.h>
static const float
tiny = 1.0e-30,
return (z-pi_lo)-pi;/* atan(-,-) */
}
}
-strong_alias (__ieee754_atan2f, __atan2f_finite)
+libm_alias_finite (__ieee754_atan2f, __atan2f)
#include <math-barriers.h>
#include <math_private.h>
#include <math-underflow.h>
+#include <libm-alias-finite.h>
static const float huge = 1e30;
return copysignf (t, x);
}
-strong_alias (__ieee754_atanhf, __atanhf_finite)
+libm_alias_finite (__ieee754_atanhf, __atanhf)
#include <math.h>
#include <math-narrow-eval.h>
#include <math_private.h>
+#include <libm-alias-finite.h>
static const float huge = 1.0e30;
static const float one = 1.0, half=0.5;
/* |x| > overflowthresold, cosh(x) overflow */
return math_narrow_eval (huge*huge);
}
-strong_alias (__ieee754_coshf, __coshf_finite)
+libm_alias_finite (__ieee754_coshf, __coshf)
#include <math.h>
#include <math-narrow-eval.h>
#include <stdint.h>
-#include <shlib-compat.h>
+#include <libm-alias-finite.h>
#include <libm-alias-float.h>
#include "math_config.h"
}
#ifndef __exp2f
strong_alias (__exp2f, __ieee754_exp2f)
-strong_alias (__exp2f, __exp2f_finite)
+libm_alias_finite (__ieee754_exp2f, __exp2f)
versioned_symbol (libm, __exp2f, exp2f, GLIBC_2_27);
libm_alias_float_other (__exp2, exp2)
#endif
#include <math.h>
#include <math-narrow-eval.h>
#include <stdint.h>
-#include <shlib-compat.h>
+#include <libm-alias-finite.h>
#include <libm-alias-float.h>
#include "math_config.h"
#ifndef __expf
hidden_def (__expf)
strong_alias (__expf, __ieee754_expf)
-strong_alias (__expf, __expf_finite)
+libm_alias_finite (__ieee754_expf, __expf)
versioned_symbol (libm, __expf, expf, GLIBC_2_27);
libm_alias_float_other (__exp, exp)
#endif
#include <math.h>
#include <math_private.h>
+#include <libm-alias-finite.h>
static const float one = 1.0, Zero[] = {0.0, -0.0,};
}
return x; /* exact output */
}
-strong_alias (__ieee754_fmodf, __fmodf_finite)
+libm_alias_finite (__ieee754_fmodf, __fmodf)
#include <fenv_private.h>
#include <math-underflow.h>
#include <float.h>
+#include <libm-alias-finite.h>
/* Coefficients B_2k / 2k(2k-1) of x^-(2k-1) inside exp in Stirling's
approximation to gamma function. */
else
return ret;
}
-strong_alias (__ieee754_gammaf_r, __gammaf_r_finite)
+libm_alias_finite (__ieee754_gammaf_r, __gammaf_r)
#include <math.h>
#include <math_private.h>
+#include <libm-alias-finite.h>
float
__ieee754_hypotf(float x, float y)
return (float) sqrt(d_x * d_x + d_y * d_y);
}
-strong_alias (__ieee754_hypotf, __hypotf_finite)
+#ifndef __ieee754_hypotf
+libm_alias_finite (__ieee754_hypotf, __hypotf)
+#endif
#include <math.h>
#include <math-barriers.h>
#include <math_private.h>
+#include <libm-alias-finite.h>
static float pzerof(float), qzerof(float);
return((one+u)*(one-u)+z*(r/s));
}
}
-strong_alias (__ieee754_j0f, __j0f_finite)
+libm_alias_finite (__ieee754_j0f, __j0f)
static const float
u00 = -7.3804296553e-02, /* 0xbd9726b5 */
v = one+z*(v01+z*(v02+z*(v03+z*v04)));
return(u/v + tpi*(__ieee754_j0f(x)*__ieee754_logf(x)));
}
-strong_alias (__ieee754_y0f, __y0f_finite)
+libm_alias_finite (__ieee754_y0f, __y0f)
/* The asymptotic expansions of pzero is
* 1 - 9/128 s^2 + 11025/98304 s^4 - ..., where s = 1/x.
#include <math_private.h>
#include <fenv_private.h>
#include <math-underflow.h>
+#include <libm-alias-finite.h>
static float ponef(float), qonef(float);
r *= x;
return(x*(float)0.5+r/s);
}
-strong_alias (__ieee754_j1f, __j1f_finite)
+libm_alias_finite (__ieee754_j1f, __j1f)
static const float U0[5] = {
-1.9605709612e-01, /* 0xbe48c331 */
v = one+z*(V0[0]+z*(V0[1]+z*(V0[2]+z*(V0[3]+z*V0[4]))));
return(x*(u/v) + tpi*(__ieee754_j1f(x)*__ieee754_logf(x)-one/x));
}
-strong_alias (__ieee754_y1f, __y1f_finite)
+libm_alias_finite (__ieee754_y1f, __y1f)
/* For x >= 8, the asymptotic expansions of pone is
* 1 + 15/128 s^2 - 4725/2^15 s^4 - ..., where s = 1/x.
#include <math_private.h>
#include <fenv_private.h>
#include <math-underflow.h>
+#include <libm-alias-finite.h>
static const float
two = 2.0000000000e+00, /* 0x40000000 */
math_check_force_underflow (ret);
return ret;
}
-strong_alias (__ieee754_jnf, __jnf_finite)
+libm_alias_finite (__ieee754_jnf, __jnf)
float
__ieee754_ynf(int n, float x)
ret = copysignf (FLT_MAX, ret) * FLT_MAX;
return ret;
}
-strong_alias (__ieee754_ynf, __ynf_finite)
+libm_alias_finite (__ieee754_ynf, __ynf)
#include <math-narrow-eval.h>
#include <math_private.h>
#include <libc-diag.h>
+#include <libm-alias-finite.h>
static const float
two23= 8.3886080000e+06, /* 0x4b000000 */
DIAG_POP_NEEDS_COMMENT;
return r;
}
-strong_alias (__ieee754_lgammaf_r, __lgammaf_r_finite)
+libm_alias_finite (__ieee754_lgammaf_r, __lgammaf_r)
#include <math.h>
#include <math_private.h>
#include <fix-int-fp-convert-zero.h>
+#include <libm-alias-finite.h>
static const float
two25 = 3.3554432000e+07, /* 0x4c000000 */
z = y*log10_2lo + ivln10*__ieee754_logf(x);
return z+y*log10_2hi;
}
-strong_alias (__ieee754_log10f, __log10f_finite)
+libm_alias_finite (__ieee754_log10f, __log10f)
#include <math.h>
#include <stdint.h>
-#include <shlib-compat.h>
+#include <libm-alias-finite.h>
#include <libm-alias-float.h>
#include "math_config.h"
}
#ifndef __log2f
strong_alias (__log2f, __ieee754_log2f)
-strong_alias (__log2f, __log2f_finite)
+libm_alias_finite (__ieee754_log2f, __log2f)
versioned_symbol (libm, __log2f, log2f, GLIBC_2_27);
libm_alias_float_other (__log2, log2)
#endif
#include <math.h>
#include <stdint.h>
-#include <shlib-compat.h>
+#include <libm-alias-finite.h>
#include <libm-alias-float.h>
#include "math_config.h"
}
#ifndef __logf
strong_alias (__logf, __ieee754_logf)
-strong_alias (__logf, __logf_finite)
+libm_alias_finite (__ieee754_logf, __logf)
versioned_symbol (libm, __logf, logf, GLIBC_2_27);
libm_alias_float_other (__log, log)
#endif
#include <math-barriers.h>
#include <math-narrow-eval.h>
#include <stdint.h>
-#include <shlib-compat.h>
+#include <libm-alias-finite.h>
#include <libm-alias-float.h>
#include "math_config.h"
}
#ifndef __powf
strong_alias (__powf, __ieee754_powf)
-strong_alias (__powf, __powf_finite)
+libm_alias_finite (__ieee754_powf, __powf)
versioned_symbol (libm, __powf, powf, GLIBC_2_27);
libm_alias_float_other (__pow, pow)
#endif
#include <math.h>
#include <math_private.h>
+#include <libm-alias-finite.h>
static const float zero = 0.0;
SET_FLOAT_WORD(x,hx^sx);
return x;
}
-strong_alias (__ieee754_remainderf, __remainderf_finite)
+libm_alias_finite (__ieee754_remainderf, __remainderf)
#include <math-narrow-eval.h>
#include <math_private.h>
#include <math-underflow.h>
+#include <libm-alias-finite.h>
static const float one = 1.0, shuge = 1.0e37;
/* |x| > overflowthresold, sinh(x) overflow */
return math_narrow_eval (x*shuge);
}
-strong_alias (__ieee754_sinhf, __sinhf_finite)
+libm_alias_finite (__ieee754_sinhf, __sinhf)
#include <math.h>
#include <math_private.h>
+#include <libm-alias-finite.h>
static const float one = 1.0, tiny=1.0e-30;
SET_FLOAT_WORD(z,ix);
return z;
}
-strong_alias (__ieee754_sqrtf, __sqrtf_finite)
+#ifndef __ieee754_sqrtf
+libm_alias_finite (__ieee754_sqrtf, __sqrtf)
+#endif
#include <math.h>
#include <math_private.h>
+#include <libm-alias-finite.h>
static const _Float128
one = 1.0,
return __log1pl(t+sqrtl(2*t+t*t));
}
}
-strong_alias (__ieee754_acoshl, __acoshl_finite)
+libm_alias_finite (__ieee754_acoshl, __acoshl)
#include <math.h>
#include <math_private.h>
+#include <libm-alias-finite.h>
static const _Float128
one = 1,
return 2.0 * w;
}
}
-strong_alias (__ieee754_acosl, __acosl_finite)
+libm_alias_finite (__ieee754_acosl, __acosl)
#include <math-barriers.h>
#include <math_private.h>
#include <math-underflow.h>
+#include <libm-alias-finite.h>
static const _Float128
one = 1,
else
return -t;
}
-strong_alias (__ieee754_asinl, __asinl_finite)
+libm_alias_finite (__ieee754_asinl, __asinl)
#include <math.h>
#include <math_private.h>
+#include <libm-alias-finite.h>
static const _Float128
tiny = L(1.0e-4900),
return (z-pi_lo)-pi;/* atan(-,-) */
}
}
-strong_alias (__ieee754_atan2l, __atan2l_finite)
+libm_alias_finite (__ieee754_atan2l, __atan2l)
#include <math.h>
#include <math_private.h>
#include <math-underflow.h>
+#include <libm-alias-finite.h>
static const _Float128 one = 1, huge = L(1e4900);
t = 0.5*__log1pl((u.value+u.value)/(one-u.value));
if(jx & 0x80000000) return -t; else return t;
}
-strong_alias (__ieee754_atanhl, __atanhl_finite)
+libm_alias_finite (__ieee754_atanhl, __atanhl)
#include <math.h>
#include <math_private.h>
+#include <libm-alias-finite.h>
static const _Float128 one = 1.0, half = 0.5, huge = L(1.0e4900),
ovf_thresh = L(1.1357216553474703894801348310092223067821E4);
/* |x| > overflowthresold, cosh(x) overflow */
return huge * huge;
}
-strong_alias (__ieee754_coshl, __coshl_finite)
+libm_alias_finite (__ieee754_coshl, __coshl)
#include <math.h>
#include <math_private.h>
#include <float.h>
+#include <libm-alias-finite.h>
static const _Float128 log10_high = L(0x2.4d763776aaa2bp0);
static const _Float128 log10_low = L(0x5.ba95b58ae0b4c28a38a3fb3e7698p-60);
exp_low = arg_high * log10_low + arg_low * M_LN10l;
return __ieee754_expl (exp_high) * __ieee754_expl (exp_low);
}
-strong_alias (__ieee754_exp10l, __exp10l_finite)
+libm_alias_finite (__ieee754_exp10l, __exp10l)
#include <math-underflow.h>
#include <stdlib.h>
#include "t_expl.h"
+#include <libm-alias-finite.h>
static const _Float128 C[] = {
/* Smallest integer x for which e^x overflows. */
/* Return x, if x is a NaN or Inf; or overflow, otherwise. */
return TWO16383*x;
}
-strong_alias (__ieee754_expl, __expl_finite)
+libm_alias_finite (__ieee754_expl, __expl)
#include <math.h>
#include <math_private.h>
+#include <libm-alias-finite.h>
static const _Float128 one = 1.0, Zero[] = {0.0, -0.0,};
}
return x; /* exact output */
}
-strong_alias (__ieee754_fmodl, __fmodl_finite)
+libm_alias_finite (__ieee754_fmodl, __fmodl)
#include <fenv_private.h>
#include <math-underflow.h>
#include <float.h>
+#include <libm-alias-finite.h>
/* Coefficients B_2k / 2k(2k-1) of x^-(2k-1) inside exp in Stirling's
approximation to gamma function. */
else
return ret;
}
-strong_alias (__ieee754_gammal_r, __gammal_r_finite)
+libm_alias_finite (__ieee754_gammal_r, __gammal_r)
#include <math.h>
#include <math_private.h>
#include <math-underflow.h>
+#include <libm-alias-finite.h>
_Float128
__ieee754_hypotl(_Float128 x, _Float128 y)
return w;
} else return w;
}
-strong_alias (__ieee754_hypotl, __hypotl_finite)
+libm_alias_finite (__ieee754_hypotl, __hypotl)
#include <math.h>
#include <math_private.h>
#include <float.h>
+#include <libm-alias-finite.h>
/* 1 / sqrt(pi) */
static const _Float128 ONEOSQPI = L(5.6418958354775628694807945156077258584405E-1);
z = ONEOSQPI * (p * cc - q * ss) / sqrtl (xx);
return z;
}
-strong_alias (__ieee754_j0l, __j0l_finite)
+libm_alias_finite (__ieee754_j0l, __j0l)
/* Y0(x) = 2/pi * log(x) * J0(x) + R(x^2)
z = ONEOSQPI * (p * ss + q * cc) / sqrtl (x);
return z;
}
-strong_alias (__ieee754_y0l, __y0l_finite)
+libm_alias_finite (__ieee754_y0l, __y0l)
#include <fenv_private.h>
#include <math-underflow.h>
#include <float.h>
+#include <libm-alias-finite.h>
/* 1 / sqrt(pi) */
static const _Float128 ONEOSQPI = L(5.6418958354775628694807945156077258584405E-1);
z = -z;
return z;
}
-strong_alias (__ieee754_j1l, __j1l_finite)
+libm_alias_finite (__ieee754_j1l, __j1l)
/* Y1(x) = 2/pi * (log(x) * J1(x) - 1/x) + x R(x^2)
z = ONEOSQPI * (p * ss + q * cc) / sqrtl (xx);
return z;
}
-strong_alias (__ieee754_y1l, __y1l_finite)
+libm_alias_finite (__ieee754_y1l, __y1l)
#include <math_private.h>
#include <fenv_private.h>
#include <math-underflow.h>
+#include <libm-alias-finite.h>
static const _Float128
invsqrtpi = L(5.6418958354775628694807945156077258584405E-1),
math_check_force_underflow (ret);
return ret;
}
-strong_alias (__ieee754_jnl, __jnl_finite)
+libm_alias_finite (__ieee754_jnl, __jnl)
_Float128
__ieee754_ynl (int n, _Float128 x)
ret = copysignl (LDBL_MAX, ret) * LDBL_MAX;
return ret;
}
-strong_alias (__ieee754_ynl, __ynl_finite)
+libm_alias_finite (__ieee754_ynl, __ynl)
#include <math.h>
#include <math_private.h>
#include <float.h>
+#include <libm-alias-finite.h>
static const _Float128 PIL = L(3.1415926535897932384626433832795028841972E0);
static const _Float128 MAXLGM = L(1.0485738685148938358098967157129705071571E4928);
q += neval (p, RASY, NRASY) / x;
return (q);
}
-strong_alias (__ieee754_lgammal_r, __lgammal_r_finite)
+libm_alias_finite (__ieee754_lgammal_r, __lgammal_r)
#include <math.h>
#include <math_private.h>
+#include <libm-alias-finite.h>
/* Coefficients for ln(1+x) = x - x**2/2 + x**3 P(x)/Q(x)
* 1/sqrt(2) <= x < sqrt(2)
z += e * L102A;
return (z);
}
-strong_alias (__ieee754_log10l, __log10l_finite)
+libm_alias_finite (__ieee754_log10l, __log10l)
#include <math.h>
#include <math_private.h>
+#include <libm-alias-finite.h>
/* Coefficients for ln(1+x) = x - x**2/2 + x**3 P(x)/Q(x)
* 1/sqrt(2) <= x < sqrt(2)
z += e;
return (z);
}
-strong_alias (__ieee754_log2l, __log2l_finite)
+libm_alias_finite (__ieee754_log2l, __log2l)
#include <math.h>
#include <math_private.h>
+#include <libm-alias-finite.h>
/* log(1+x) = x - .5 x^2 + x^3 l(x)
-.0078125 <= x <= +.0078125
y += e * ln2a;
return y;
}
-strong_alias (__ieee754_logl, __logl_finite)
+libm_alias_finite (__ieee754_logl, __logl)
#include <math.h>
#include <math-barriers.h>
#include <math_private.h>
+#include <libm-alias-finite.h>
static const _Float128 bp[] = {
1,
}
return sgn * z;
}
-strong_alias (__ieee754_powl, __powl_finite)
+libm_alias_finite (__ieee754_powl, __powl)
#include <math.h>
#include <math_private.h>
+#include <libm-alias-finite.h>
static const _Float128 zero = 0;
SET_LDOUBLE_MSW64(x,hx^sx);
return x;
}
-strong_alias (__ieee754_remainderl, __remainderl_finite)
+libm_alias_finite (__ieee754_remainderl, __remainderl)
#include <math.h>
#include <math_private.h>
#include <math-underflow.h>
+#include <libm-alias-finite.h>
static const _Float128 one = 1.0, shuge = L(1.0e4931),
ovf_thresh = L(1.1357216553474703894801348310092223067821E4);
/* |x| > overflowthreshold, sinhl(x) overflow */
return x * shuge;
}
-strong_alias (__ieee754_sinhl, __sinhl_finite)
+libm_alias_finite (__ieee754_sinhl, __sinhl)
#include <math.h>
#include <math_private.h>
+#include <libm-alias-finite.h>
static const long double
one = 1.0L,
return __log1pl(t+sqrtl(2.0*t+t*t));
}
}
-strong_alias (__ieee754_acoshl, __acoshl_finite)
+libm_alias_finite (__ieee754_acoshl, __acoshl)
#include <math.h>
#include <math_private.h>
+#include <libm-alias-finite.h>
static const long double
one = 1.0L,
return 2.0 * w;
}
}
-strong_alias (__ieee754_acosl, __acosl_finite)
+libm_alias_finite (__ieee754_acosl, __acosl)
#include <math-barriers.h>
#include <math_private.h>
#include <math-underflow.h>
+#include <libm-alias-finite.h>
static const long double
one = 1.0L,
else
return -t;
}
-strong_alias (__ieee754_asinl, __asinl_finite)
+libm_alias_finite (__ieee754_asinl, __asinl)
#include <math.h>
#include <math_private.h>
+#include <libm-alias-finite.h>
static const long double
tiny = 1.0e-300L,
return (z-pi_lo)-pi;/* atan(-,-) */
}
}
-strong_alias (__ieee754_atan2l, __atan2l_finite)
+libm_alias_finite (__ieee754_atan2l, __atan2l)
#include <math.h>
#include <math_private.h>
#include <math-underflow.h>
+#include <libm-alias-finite.h>
static const long double one = 1.0L, huge = 1e300L;
t = 0.5*__log1pl((x+x)/(one-x));
if(hx>=0) return t; else return -t;
}
-strong_alias (__ieee754_atanhl, __atanhl_finite)
+libm_alias_finite (__ieee754_atanhl, __atanhl)
#include <math.h>
#include <math_private.h>
+#include <libm-alias-finite.h>
static const long double one = 1.0L, half=0.5L, huge = 1.0e300L;
/* |x| > overflowthresold, cosh(x) overflow */
return huge*huge;
}
-strong_alias (__ieee754_coshl, __coshl_finite)
+libm_alias_finite (__ieee754_coshl, __coshl)
#include <math.h>
#include <math_private.h>
#include <float.h>
+#include <libm-alias-finite.h>
static const long double log10_high = 0x2.4d763776aaap+0L;
static const long double log10_low = 0x2.b05ba95b58ae0b4c28a38a3fb4p-48L;
exp_low = arg_high * log10_low + arg_low * M_LN10l;
return __ieee754_expl (exp_high) * __ieee754_expl (exp_low);
}
-strong_alias (__ieee754_exp10l, __exp10l_finite)
+libm_alias_finite (__ieee754_exp10l, __exp10l)
#include <inttypes.h>
#include <math_private.h>
#include <fenv_private.h>
-
+#include <libm-alias-finite.h>
#include "t_expl.h"
return result;
return result * scale_u.ld;
}
-strong_alias (__ieee754_expl, __expl_finite)
+libm_alias_finite (__ieee754_expl, __expl)
#include <math.h>
#include <math_private.h>
#include <ieee754.h>
+#include <libm-alias-finite.h>
static const long double one = 1.0, Zero[] = {0.0, -0.0,};
}
return x; /* exact output */
}
-strong_alias (__ieee754_fmodl, __fmodl_finite)
+libm_alias_finite (__ieee754_fmodl, __fmodl)
#include <fenv_private.h>
#include <math-underflow.h>
#include <float.h>
+#include <libm-alias-finite.h>
/* Coefficients B_2k / 2k(2k-1) of x^-(2k-1) inside exp in Stirling's
approximation to gamma function. */
else
return ret;
}
-strong_alias (__ieee754_gammal_r, __gammal_r_finite)
+libm_alias_finite (__ieee754_gammal_r, __gammal_r)
#include <math.h>
#include <math_private.h>
#include <math-underflow.h>
+#include <libm-alias-finite.h>
long double
__ieee754_hypotl(long double x, long double y)
else
return w;
}
-strong_alias (__ieee754_hypotl, __hypotl_finite)
+libm_alias_finite (__ieee754_hypotl, __hypotl)
#include <math.h>
#include <math_private.h>
#include <float.h>
+#include <libm-alias-finite.h>
/* 1 / sqrt(pi) */
static const long double ONEOSQPI = 5.6418958354775628694807945156077258584405E-1L;
z = ONEOSQPI * (p * cc - q * ss) / sqrtl (xx);
return z;
}
-strong_alias (__ieee754_j0l, __j0l_finite)
+libm_alias_finite (__ieee754_j0l, __j0l)
/* Y0(x) = 2/pi * log(x) * J0(x) + R(x^2)
z = ONEOSQPI * (p * ss + q * cc) / sqrtl (x);
return z;
}
-strong_alias (__ieee754_y0l, __y0l_finite)
+libm_alias_finite (__ieee754_y0l, __y0l)
#include <fenv_private.h>
#include <math-underflow.h>
#include <float.h>
+#include <libm-alias-finite.h>
/* 1 / sqrt(pi) */
static const long double ONEOSQPI = 5.6418958354775628694807945156077258584405E-1L;
z = -z;
return z;
}
-strong_alias (__ieee754_j1l, __j1l_finite)
+libm_alias_finite (__ieee754_j1l, __j1l)
/* Y1(x) = 2/pi * (log(x) * J1(x) - 1/x) + x R(x^2)
z = ONEOSQPI * (p * ss + q * cc) / sqrtl (xx);
return z;
}
-strong_alias (__ieee754_y1l, __y1l_finite)
+libm_alias_finite (__ieee754_y1l, __y1l)
#include <math_private.h>
#include <fenv_private.h>
#include <math-underflow.h>
+#include <libm-alias-finite.h>
static const long double
invsqrtpi = 5.6418958354775628694807945156077258584405E-1L,
math_check_force_underflow (ret);
return ret;
}
-strong_alias (__ieee754_jnl, __jnl_finite)
+libm_alias_finite (__ieee754_jnl, __jnl)
long double
__ieee754_ynl (int n, long double x)
ret = copysignl (LDBL_MAX, ret) * LDBL_MAX;
return ret;
}
-strong_alias (__ieee754_ynl, __ynl_finite)
+libm_alias_finite (__ieee754_ynl, __ynl)
#include <math.h>
#include <math_private.h>
#include <float.h>
+#include <libm-alias-finite.h>
static const long double PIL = 3.1415926535897932384626433832795028841972E0L;
static const long double MAXLGM = 0x5.d53649e2d469dbc1f01e99fd66p+1012L;
q += neval (p, RASY, NRASY) / x;
return (q);
}
-strong_alias (__ieee754_lgammal_r, __lgammal_r_finite)
+libm_alias_finite (__ieee754_lgammal_r, __lgammal_r)
#include <math.h>
#include <math_private.h>
+#include <libm-alias-finite.h>
/* Coefficients for ln(1+x) = x - x**2/2 + x**3 P(x)/Q(x)
* 1/sqrt(2) <= x < sqrt(2)
z += e * L102A;
return (z);
}
-strong_alias (__ieee754_log10l, __log10l_finite)
+libm_alias_finite (__ieee754_log10l, __log10l)
#include <math.h>
#include <math_private.h>
+#include <libm-alias-finite.h>
/* Coefficients for ln(1+x) = x - x**2/2 + x**3 P(x)/Q(x)
* 1/sqrt(2) <= x < sqrt(2)
z += e;
return (z);
}
-strong_alias (__ieee754_log2l, __log2l_finite)
+libm_alias_finite (__ieee754_log2l, __log2l)
#include <math.h>
#include <math_private.h>
+#include <libm-alias-finite.h>
/* log(1+x) = x - .5 x^2 + x^3 l(x)
-.0078125 <= x <= +.0078125
y += e * ln2a;
return y;
}
-strong_alias (__ieee754_logl, __logl_finite)
+libm_alias_finite (__ieee754_logl, __logl)
#include <math.h>
#include <math_private.h>
#include <math-underflow.h>
+#include <libm-alias-finite.h>
static const long double bp[] = {
1.0L,
math_check_force_underflow (z);
return z;
}
-strong_alias (__ieee754_powl, __powl_finite)
+libm_alias_finite (__ieee754_powl, __powl)
#include <math.h>
#include <math_private.h>
+#include <libm-alias-finite.h>
static const long double zero = 0.0L;
x = -x;
return x;
}
-strong_alias (__ieee754_remainderl, __remainderl_finite)
+libm_alias_finite (__ieee754_remainderl, __remainderl)
#include <math.h>
#include <math_private.h>
#include <math-underflow.h>
+#include <libm-alias-finite.h>
static const long double one = 1.0, shuge = 1.0e307;
/* |x| > overflowthresold, sinh(x) overflow */
return x*shuge;
}
-strong_alias (__ieee754_sinhl, __sinhl_finite)
+libm_alias_finite (__ieee754_sinhl, __sinhl)
/*********************************************************************/
#include <math_private.h>
+#include <libm-alias-finite.h>
typedef union {int64_t i[2]; long double x; double d[2]; } mynumber;
return tm256*__ieee754_sqrtl(x*t512);
}
}
-strong_alias (__ieee754_sqrtl, __sqrtl_finite)
+libm_alias_finite (__ieee754_sqrtl, __sqrtl)
#include <math.h>
#include <math_private.h>
+#include <libm-alias-finite.h>
static const long double
one = 1.0,
return __log1pl(t+sqrtl(2.0*t+t*t));
}
}
-strong_alias (__ieee754_acoshl, __acoshl_finite)
+libm_alias_finite (__ieee754_acoshl, __acoshl)
#include <math.h>
#include <math_private.h>
#include <math-underflow.h>
+#include <libm-alias-finite.h>
static const long double
one = 1.0L,
else
return -t;
}
-strong_alias (__ieee754_asinl, __asinl_finite)
+libm_alias_finite (__ieee754_asinl, __asinl)
#include <math-barriers.h>
#include <math_private.h>
#include <math-underflow.h>
+#include <libm-alias-finite.h>
static const long double one = 1.0, huge = 1e4900L;
t = 0.5*__log1pl((x+x)/(one-x));
if(se<=0x7fff) return t; else return -t;
}
-strong_alias (__ieee754_atanhl, __atanhl_finite)
+libm_alias_finite (__ieee754_atanhl, __atanhl)
#include <math.h>
#include <math_private.h>
+#include <libm-alias-finite.h>
static const long double one = 1.0, half=0.5, huge = 1.0e4900L;
/* |x| >= log(2*maxdouble), cosh(x) overflow */
return huge*huge;
}
-strong_alias (__ieee754_coshl, __coshl_finite)
+libm_alias_finite (__ieee754_coshl, __coshl)
#include <fenv_private.h>
#include <math-underflow.h>
#include <float.h>
+#include <libm-alias-finite.h>
/* Coefficients B_2k / 2k(2k-1) of x^-(2k-1) inside exp in Stirling's
approximation to gamma function. */
else
return ret;
}
-strong_alias (__ieee754_gammal_r, __gammal_r_finite)
+libm_alias_finite (__ieee754_gammal_r, __gammal_r)
#include <math.h>
#include <math_private.h>
#include <math-underflow.h>
+#include <libm-alias-finite.h>
long double __ieee754_hypotl(long double x, long double y)
{
return w;
} else return w;
}
-strong_alias (__ieee754_hypotl, __hypotl_finite)
+libm_alias_finite (__ieee754_hypotl, __hypotl)
#include <math.h>
#include <math-barriers.h>
#include <math_private.h>
+#include <libm-alias-finite.h>
static long double pzero (long double), qzero (long double);
return ((one + u) * (one - u) + z * (r / s));
}
}
-strong_alias (__ieee754_j0l, __j0l_finite)
+libm_alias_finite (__ieee754_j0l, __j0l)
/* y0(x) = 2/pi ln(x) J0(x) + U(x^2)/V(x^2)
v = V[0] + z * (V[1] + z * (V[2] + z * (V[3] + z * (V[4] + z))));
return (u / v + tpi * (__ieee754_j0l (x) * __ieee754_logl (x)));
}
-strong_alias (__ieee754_y0l, __y0l_finite)
+libm_alias_finite (__ieee754_y0l, __y0l)
/* The asymptotic expansions of pzero is
* 1 - 9/128 s^2 + 11025/98304 s^4 - ..., where s = 1/x.
#include <math.h>
#include <math_private.h>
#include <math-underflow.h>
+#include <libm-alias-finite.h>
static long double pone (long double), qone (long double);
r *= x;
return (x * 0.5 + r / s);
}
-strong_alias (__ieee754_j1l, __j1l_finite)
+libm_alias_finite (__ieee754_j1l, __j1l)
/* Y1(x) = 2/pi * (log(x) * j1(x) - 1/x) + x R(x^2)
return (x * (u / v) +
tpi * (__ieee754_j1l (x) * __ieee754_logl (x) - one / x));
}
-strong_alias (__ieee754_y1l, __y1l_finite)
+libm_alias_finite (__ieee754_y1l, __y1l)
/* For x >= 8, the asymptotic expansions of pone is
#include <math_private.h>
#include <fenv_private.h>
#include <math-underflow.h>
+#include <libm-alias-finite.h>
static const long double
invsqrtpi = 5.64189583547756286948079e-1L, two = 2.0e0L, one = 1.0e0L;
math_check_force_underflow (ret);
return ret;
}
-strong_alias (__ieee754_jnl, __jnl_finite)
+libm_alias_finite (__ieee754_jnl, __jnl)
long double
__ieee754_ynl (int n, long double x)
ret = copysignl (LDBL_MAX, ret) * LDBL_MAX;
return ret;
}
-strong_alias (__ieee754_ynl, __ynl_finite)
+libm_alias_finite (__ieee754_ynl, __ynl)
#include <math.h>
#include <math_private.h>
#include <libc-diag.h>
+#include <libm-alias-finite.h>
static const long double
half = 0.5L,
DIAG_POP_NEEDS_COMMENT;
return r;
}
-strong_alias (__ieee754_lgammal_r, __lgammal_r_finite)
+libm_alias_finite (__ieee754_lgammal_r, __lgammal_r)
#include <math.h>
#include <math_private.h>
#include <math-underflow.h>
+#include <libm-alias-finite.h>
static const long double one = 1.0, shuge = 1.0e4931L;
/* |x| > overflowthreshold, sinhl(x) overflow */
return x*shuge;
}
-strong_alias (__ieee754_sinhl, __sinhl_finite)
+libm_alias_finite (__ieee754_sinhl, __sinhl)
--- /dev/null
+/* Finite math compatibility macros.
+ Copyright (C) 2020 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, see
+ <http://www.gnu.org/licenses/>. */
+
+#ifndef _LIBM_ALIAS_FINITE_H
+#define _LIBM_ALIAS_FINITE_H
+
+#include <first-versions.h>
+#include <shlib-compat.h>
+
+/* The -ffinite-math symbols were added on GLIBC 2.15 and moved to compat
+ symbol so newer architectures do not require to support it. */
+#if SHLIB_COMPAT (libm, GLIBC_2_15, GLIBC_2_31)
+# define libm_alias_finite(from, to) \
+ libm_alias_finite1(from, to)
+# define libm_alias_finite1(from, to) \
+compat_symbol (libm, \
+ from, \
+ to ## _finite, \
+ FIRST_VERSION_libm_ ## to ## _finite);
+#else
+# define libm_alias_finite(from, to)
+#endif
+
+#endif
License along with the GNU C Library. If not, see
<https://www.gnu.org/licenses/>. */
+#include <libm-alias-finite.h>
+
double
__ieee754_sqrt (double x)
{
asm ("fdsqrt.d %1,%0" : "=f" (x) : "fm" (x));
return x;
}
-strong_alias (__ieee754_sqrt, __sqrt_finite)
+libm_alias_finite (__ieee754_sqrt, __sqrt)
License along with the GNU C Library. If not, see
<https://www.gnu.org/licenses/>. */
+#include <libm-alias-finite.h>
+
float
__ieee754_sqrtf (float x)
{
asm ("fssqrt.s %1,%0" : "=f" (result) : "dm" (x));
return result;
}
-strong_alias (__ieee754_sqrtf, __sqrtf_finite)
+libm_alias_finite (__ieee754_sqrtf, __sqrtf)
#include <math.h>
#include <math_private.h>
#include "mathimpl.h"
+#include <libm-alias-finite.h>
#ifndef FUNC
# define FUNC __ieee754_acos
-# define FUNC_FINITE __acos_finite
+# define FUNC_FINITE __acos
#endif
#ifndef float_type
# define float_type double
return __m81_u(FUNC)(x);
}
#ifdef FUNC_FINITE
-strong_alias (FUNC, FUNC_FINITE)
+libm_alias_finite (FUNC, FUNC_FINITE)
#endif
#ifndef FUNC
# define FUNC __ieee754_acosf
-# define FUNC_FINITE __acosf_finite
+# define FUNC_FINITE __acosf
#endif
#define float_type float
#include <e_acos.c>
#ifndef FUNC
# define FUNC __ieee754_acosl
-# define FUNC_FINITE __acosl_finite
+# define FUNC_FINITE __acosl
#endif
#define float_type long double
#include <e_acos.c>
#define FUNC __ieee754_asin
-#define FUNC_FINITE __asin_finite
+#define FUNC_FINITE __asin
#include <e_acos.c>
#define FUNC __ieee754_asinf
-#define FUNC_FINITE __asinf_finite
+#define FUNC_FINITE __asinf
#include <e_acosf.c>
#define FUNC __ieee754_asinl
-#define FUNC_FINITE __asinl_finite
+#define FUNC_FINITE __asinl
#include <e_acosl.c>
#include <math.h>
#include <math_private.h>
#include "mathimpl.h"
+#include <libm-alias-finite.h>
#ifndef SUFF
#define SUFF
}
return z;
}
-strong_alias (s(__ieee754_atan2), CONCATX (s (__atan2), _finite))
+libm_alias_finite (s(__ieee754_atan2), s (__atan2))
#define FUNC __ieee754_atanh
-#define FUNC_FINITE __atanh_finite
+#define FUNC_FINITE __atanh
#include <e_acos.c>
#define FUNC __ieee754_atanhf
-#define FUNC_FINITE __atanhf_finite
+#define FUNC_FINITE __atanhf
#include <e_acosf.c>
#define FUNC __ieee754_atanhl
-#define FUNC_FINITE __atanhl_finite
+#define FUNC_FINITE __atanhl
#include <e_acosl.c>
#define FUNC __ieee754_cosh
-#define FUNC_FINITE __cosh_finite
+#define FUNC_FINITE __cosh
#include <e_acos.c>
#define FUNC __ieee754_coshf
-#define FUNC_FINITE __coshf_finite
+#define FUNC_FINITE __coshf
#include <e_acosf.c>
#define FUNC __ieee754_coshl
-#define FUNC_FINITE __coshl_finite
+#define FUNC_FINITE __coshl
#include <e_acosl.c>
#define FUNC __ieee754_exp
-#define FUNC_FINITE __exp_finite
+#define FUNC_FINITE __exp
#include <e_acos.c>
#define FUNC __ieee754_exp10
-#define FUNC_FINITE __exp10_finite
+#define FUNC_FINITE __exp10
#include <e_acos.c>
#define FUNC __ieee754_exp10f
-#define FUNC_FINITE __exp10f_finite
+#define FUNC_FINITE __exp10f
#include <e_acosf.c>
#define FUNC __ieee754_exp10l
-#define FUNC_FINITE __exp10l_finite
+#define FUNC_FINITE __exp10l
#include <e_acosl.c>
#define FUNC __ieee754_exp2
-#define FUNC_FINITE __exp2_finite
+#define FUNC_FINITE __exp2
#include <e_acos.c>
#define FUNC __ieee754_exp2f
-#define FUNC_FINITE __exp2f_finite
+#define FUNC_FINITE __exp2f
#include <e_acosf.c>
#define FUNC __ieee754_exp2l
-#define FUNC_FINITE __exp2l_finite
+#define FUNC_FINITE __exp2l
#include <e_acosl.c>
#define FUNC __ieee754_expf
-#define FUNC_FINITE __expf_finite
+#define FUNC_FINITE __expf
#include <e_acosf.c>
#define FUNC __ieee754_expl
-#define FUNC_FINITE __expl_finite
+#define FUNC_FINITE __expl
#include <e_acosl.c>
#include <math.h>
#include <math_private.h>
#include "mathimpl.h"
+#include <libm-alias-finite.h>
#ifndef FUNC
# define FUNC __ieee754_fmod
-# define FUNC_FINITE __fmod_finite
+# define FUNC_FINITE __fmod
#endif
#ifndef float_type
# define float_type double
return __m81_u(FUNC)(x, y);
}
#ifdef FUNC_FINITE
-strong_alias (FUNC, FUNC_FINITE)
+libm_alias_finite (FUNC, FUNC_FINITE)
#endif
#ifndef FUNC
# define FUNC __ieee754_fmodf
-# define FUNC_FINITE __fmodf_finite
+# define FUNC_FINITE __fmodf
#endif
#define float_type float
#include <e_fmod.c>
#ifndef FUNC
# define FUNC __ieee754_fmodl
-# define FUNC_FINITE __fmodl_finite
+# define FUNC_FINITE __fmodl
#endif
#define float_type long double
#include <e_fmod.c>
#define FUNC __ieee754_log
-#define FUNC_FINITE __log_finite
+#define FUNC_FINITE __log
#include <e_acos.c>
#define FUNC __ieee754_log10
-#define FUNC_FINITE __log10_finite
+#define FUNC_FINITE __log10
#include <e_acos.c>
#define FUNC __ieee754_log10f
-#define FUNC_FINITE __log10f_finite
+#define FUNC_FINITE __log10f
#include <e_acosf.c>
#define FUNC __ieee754_log10l
-#define FUNC_FINITE __log10l_finite
+#define FUNC_FINITE __log10l
#include <e_acosl.c>
#define FUNC __ieee754_log2
-#define FUNC_FINITE __log2_finite
+#define FUNC_FINITE __log2
#include <e_acos.c>
#define FUNC __ieee754_log2f
-#define FUNC_FINITE __log2f_finite
+#define FUNC_FINITE __log2f
#include <e_acosf.c>
#define FUNC __ieee754_log2l
-#define FUNC_FINITE __log2l_finite
+#define FUNC_FINITE __log2l
#include <e_acosl.c>
#define FUNC __ieee754_logf
-#define FUNC_FINITE __logf_finite
+#define FUNC_FINITE __logf
#include <e_acosf.c>
#define FUNC __ieee754_logl
-#define FUNC_FINITE __logl_finite
+#define FUNC_FINITE __logl
#include <e_acosl.c>
#include <math.h>
#include <math_private.h>
#include "mathimpl.h"
+#include <libm-alias-finite.h>
#ifndef SUFF
#define SUFF
z = m81(__ieee754_exp) (y * m81(__ieee754_log) (x));
return z;
}
-strong_alias (s(__ieee754_pow), CONCATX (s(__pow), _finite))
+libm_alias_finite (s(__ieee754_pow), s (__pow))
#define FUNC __ieee754_remainder
-#define FUNC_FINITE __remainder_finite
+#define FUNC_FINITE __remainder
#include <e_fmod.c>
#define FUNC __ieee754_remainderf
-#define FUNC_FINITE __remainderf_finite
+#define FUNC_FINITE __remainderf
#include <e_fmodf.c>
#define FUNC __ieee754_remainderl
-#define FUNC_FINITE __remainderl_finite
+#define FUNC_FINITE __remainderl
#include <e_fmodl.c>
#include <math.h>
#include <math_private.h>
#include "mathimpl.h"
+#include <libm-alias-finite.h>
#ifndef SUFF
#define SUFF
__asm ("fscale%.x %1, %0" : "=f" (retval) : "f" (fn), "0" (x));
return retval;
}
-strong_alias (s(__ieee754_scalb), CONCATX (s(__scalb), _finite))
+libm_alias_finite (s(__ieee754_scalb), s (__scalb))
#define FUNC __ieee754_sinh
-#define FUNC_FINITE __sinh_finite
+#define FUNC_FINITE __sinh
#include <e_acos.c>
#define FUNC __ieee754_sinhf
-#define FUNC_FINITE __sinhf_finite
+#define FUNC_FINITE __sinhf
#include <e_acosf.c>
#define FUNC __ieee754_sinhl
-#define FUNC_FINITE __sinhl_finite
+#define FUNC_FINITE __sinhl
#include <e_acosl.c>
#define FUNC __ieee754_sqrt
-#define FUNC_FINITE __sqrt_finite
+#define FUNC_FINITE __sqrt
#include <e_acos.c>
#define FUNC __ieee754_sqrtf
-#define FUNC_FINITE __sqrtf_finite
+#define FUNC_FINITE __sqrtf
#include <e_acosf.c>
#define FUNC __ieee754_sqrtl
-#define FUNC_FINITE __sqrtl_finite
+#define FUNC_FINITE __sqrtl
#include <e_acosl.c>
#include <sgidefs.h>
-
+#include <libm-alias-finite.h>
#if (_MIPS_ISA >= _MIPS_ISA_MIPS2)
__asm__ ("sqrt.d %0,%1" : "=f" (z) : "f" (x));
return z;
}
-strong_alias (__ieee754_sqrt, __sqrt_finite)
+libm_alias_finite (__ieee754_sqrt, __sqrt)
#else
#include <sgidefs.h>
-
+#include <libm-alias-finite.h>
#if (_MIPS_ISA >= _MIPS_ISA_MIPS2)
__asm__ ("sqrt.s %0,%1" : "=f" (z) : "f" (x));
return z;
}
-strong_alias (__ieee754_sqrtf, __sqrtf_finite)
+libm_alias_finite (__ieee754_sqrtf, __sqrtf)
#else
#include <stdlib.h>
#include <soft-fp.h>
#include <quad.h>
+#include <libm-alias-finite.h>
long double
__ieee754_sqrtl (const long double a)
FP_HANDLE_EXCEPTIONS;
return c;
}
-strong_alias (__ieee754_sqrtl, __sqrtl_finite)
+libm_alias_finite (__ieee754_sqrtl, __sqrtl)
#include <math_private.h>
#include <math-underflow.h>
#include <stdint.h>
+#include <libm-alias-finite.h>
/* __ieee754_hypot(x,y)
*
}
return sqrt (x * x + y * y);
}
-strong_alias (__ieee754_hypot, __hypot_finite)
+#ifndef __ieee754_hypot
+libm_alias_finite (__ieee754_hypot, __hypot)
+#endif
#include <math.h>
#include <math_private.h>
#include <stdint.h>
+#include <libm-alias-finite.h>
/* __ieee754_hypotf(x,y)
return sqrt ((double) x * x + (double) y * y);
}
-strong_alias (__ieee754_hypotf, __hypotf_finite)
+#ifndef __ieee754_hypotf
+libm_alias_finite (__ieee754_hypotf, __hypotf)
+#endif
#include <stdint.h>
#include <sysdep.h>
#include <ldsodefs.h>
+#include <libm-alias-finite.h>
#ifndef _ARCH_PPCSQ
static const double almost_half = 0.5000000000000001; /* 0.5 + 2^-53 */
return z;
}
-strong_alias (__ieee754_sqrt, __sqrt_finite)
+libm_alias_finite (__ieee754_sqrt, __sqrt)
#include <stdint.h>
#include <sysdep.h>
#include <ldsodefs.h>
+#include <libm-alias-finite.h>
#ifndef _ARCH_PPCSQ
static const float almost_half = 0.50000006; /* 0.5 + 2^-24 */
return z;
}
-strong_alias (__ieee754_sqrtf, __sqrtf_finite)
+libm_alias_finite (__ieee754_sqrtf, __sqrtf)
#include <math.h>
-#undef strong_alias
-#define strong_alias(a, b)
-
#define __ieee754_hypot __ieee754_hypot_power7
#include <sysdeps/powerpc/fpu/e_hypot.c>
#include <math.h>
-#undef strong_alias
-#define strong_alias(a, b)
-
#define __ieee754_hypot __ieee754_hypot_ppc32
#include <sysdeps/powerpc/fpu/e_hypot.c>
#include <math.h>
#include <math_private.h>
#include <math_ldbl_opt.h>
-#include <shlib-compat.h>
+#include <libm-alias-finite.h>
#include "init-arch.h"
extern __typeof (__ieee754_hypot) __ieee754_hypot_ppc32 attribute_hidden;
? __ieee754_hypot_power7
: __ieee754_hypot_ppc32);
-strong_alias (__ieee754_hypot, __hypot_finite)
+libm_alias_finite (__ieee754_hypot, __hypot)
#include <math.h>
-#undef strong_alias
-#define strong_alias(a, b)
-
#define __ieee754_hypotf __ieee754_hypotf_power7
#include <sysdeps/powerpc/fpu/e_hypotf.c>
#include <math.h>
-#undef strong_alias
-#define strong_alias(a, b)
-
#define __ieee754_hypotf __ieee754_hypotf_ppc32
#include <sysdeps/ieee754/flt-32/e_hypotf.c>
#include <math.h>
#include <math_private.h>
#include <math_ldbl_opt.h>
-#include <shlib-compat.h>
+#include <libm-alias-finite.h>
#include "init-arch.h"
extern __typeof (__ieee754_hypotf) __ieee754_hypotf_ppc32 attribute_hidden;
? __ieee754_hypotf_power7
: __ieee754_hypotf_ppc32);
-strong_alias (__ieee754_hypotf, __hypotf_finite)
+libm_alias_finite (__ieee754_hypotf, __hypotf)
<https://www.gnu.org/licenses/>. */
#include <math.h>
+#include <libm-alias-finite.h>
/* Unavoidable hacks since TFmode is assumed to be binary128 when
-mabi=ibmlongdouble is used. */
FP_HANDLE_EXCEPTIONS;
return r;
}
-strong_alias (__ieee754_sqrtf128, __sqrtf128_finite)
+libm_alias_finite (__ieee754_sqrtf128, __sqrtf128)
License along with the GNU C Library; if not, see
<https://www.gnu.org/licenses/>. */
+#include <libm-alias-finite.h>
+
__float128
__ieee754_sqrtf128 (__float128 a)
{
asm ("xssqrtqp %0,%1" : "=v" (z) : "v" (a));
return z;
}
-strong_alias (__ieee754_sqrtf128, __sqrtf128_finite)
+libm_alias_finite (__ieee754_sqrtf128, __sqrtf128)
#include <stdlib.h>
#include <soft-fp/soft-fp.h>
#include <soft-fp/quad.h>
+#include <libm-alias-finite.h>
long double
__ieee754_sqrtl (const long double a)
FP_HANDLE_EXCEPTIONS;
return c;
}
-strong_alias (__ieee754_sqrtl, __sqrtl_finite)
+libm_alias_finite (__ieee754_sqrtl, __sqrtl)
<https://www.gnu.org/licenses/>. */
#include <math.h>
+#include <libm-alias-finite.h>
double
__ieee754_sqrt (double x)
asm ("fsqrt.d %0, %1" : "=f" (x) : "f" (x));
return x;
}
-strong_alias (__ieee754_sqrt, __sqrt_finite)
+libm_alias_finite (__ieee754_sqrt, __sqrt)
<https://www.gnu.org/licenses/>. */
#include <math.h>
+#include <libm-alias-finite.h>
float
__ieee754_sqrtf (float x)
asm ("fsqrt.s %0, %1" : "=f" (x) : "f" (x));
return x;
}
-strong_alias (__ieee754_sqrtf, __sqrtf_finite)
+libm_alias_finite (__ieee754_sqrtf, __sqrtf)
<https://www.gnu.org/licenses/>. */
#include <math_private.h>
+#include <libm-alias-finite.h>
double
__ieee754_sqrt (double x)
__asm__ ( "sqdbr %0,%1" : "=f" (res) : "f" (x) );
return res;
}
-strong_alias (__ieee754_sqrt, __sqrt_finite)
+libm_alias_finite (__ieee754_sqrt, __sqrt)
<https://www.gnu.org/licenses/>. */
#include <math_private.h>
+#include <libm-alias-finite.h>
float
__ieee754_sqrtf (float x)
__asm__ ( "sqebr %0,%1" : "=f" (res) : "f" (x) );
return res;
}
-strong_alias (__ieee754_sqrtf, __sqrtf_finite)
+libm_alias_finite (__ieee754_sqrtf, __sqrtf)
<https://www.gnu.org/licenses/>. */
#include <math_private.h>
+#include <libm-alias-finite.h>
long double
__ieee754_sqrtl (long double x)
__asm__ ( "sqxbr %0,%1" : "=f" (res) : "f" (x) );
return res;
}
-strong_alias (__ieee754_sqrtl, __sqrtl_finite)
+libm_alias_finite (__ieee754_sqrtl, __sqrtl)
#include <errno.h>
#include <math.h>
+#include <libm-alias-finite.h>
#ifndef __GNUC__
#error This file uses GNU C extensions; you must compile with GCC.
asm ("fsqrtd %1, %0" : "=f" (result) : "f" (x));
return result;
}
-strong_alias (__ieee754_sqrt, __sqrt_finite)
+libm_alias_finite (__ieee754_sqrt, __sqrt)
<https://www.gnu.org/licenses/>. */
#include <math.h>
+#include <libm-alias-finite.h>
extern void _Qp_sqrt(long double *, const long double *);
_Qp_sqrt (&ret, &x);
return ret;
}
-strong_alias (__ieee754_sqrtl, __sqrtl_finite)
+libm_alias_finite (__ieee754_sqrtl, __sqrtl)
#include <soft-fp.h>
#include <quad.h>
+#include <libm-alias-finite.h>
__float128
__ieee754_sqrtf128 (__float128 a)
FP_HANDLE_EXCEPTIONS;
return r;
}
-strong_alias (__ieee754_sqrtf128, __sqrtf128_finite)
+libm_alias_finite (__ieee754_sqrtf128, __sqrtf128)
#include <machine/asm.h>
#include <x86_64-math-asm.h>
+#include <libm-alias-finite.h>
DEFINE_LDBL_MIN
fldz /* Set result to 0. */
2: ret
END (__ieee754_exp2l)
-strong_alias (__ieee754_exp2l, __exp2l_finite)
+libm_alias_finite (__ieee754_exp2l, __exp2l)
#include <libm-alias-ldouble.h>
#include <machine/asm.h>
#include <x86_64-math-asm.h>
+#include <libm-alias-finite.h>
#ifdef USE_AS_EXP10L
# define IEEE754_EXPL __ieee754_exp10l
fadd %st
ret
END(IEEE754_EXPL)
+
#ifdef USE_AS_EXPM1L
libm_hidden_def (__expm1l)
libm_alias_ldouble (__expm1, expm1)
+#elif defined USE_AS_EXP10L
+libm_alias_finite (__ieee754_exp10l, __exp10l)
#else
-strong_alias (IEEE754_EXPL, EXPL_FINITE)
+libm_alias_finite (__ieee754_expl, __expl)
#endif
*/
#include <machine/asm.h>
+#include <libm-alias-finite.h>
RCSID("$NetBSD: $")
fstp %st(1)
ret
END (__ieee754_fmodl)
-strong_alias (__ieee754_fmodl, __fmodl_finite)
+libm_alias_finite (__ieee754_fmodl, __fmodl)
*/
#include <machine/asm.h>
+#include <libm-alias-finite.h>
.section .rodata.cst8,"aM",@progbits,8
fyl2xp1 // log10(x)
ret
END(__log10l_finite)
+libm_alias_finite (__log10l_finite, __log10l)
*/
#include <machine/asm.h>
+#include <libm-alias-finite.h>
.section .rodata.cst8,"aM",@progbits,8
fyl2xp1 // log(x)
ret
END (__log2l_finite)
+libm_alias_finite (__log2l_finite, __log2l)
*/
#include <machine/asm.h>
-
+#include <libm-alias-finite.h>
.section .rodata.cst8,"aM",@progbits,8
fyl2xp1 // log(x)
ret
END (__logl_finite)
+libm_alias_finite (__logl_finite, __logl)
#include <machine/asm.h>
#include <x86_64-math-asm.h>
+#include <libm-alias-finite.h>
.section .rodata.cst8,"aM",@progbits,8
ret
END(__ieee754_powl)
-strong_alias (__ieee754_powl, __powl_finite)
+libm_alias_finite (__ieee754_powl, __powl)
*/
#include <machine/asm.h>
+#include <libm-alias-finite.h>
ENTRY(__ieee754_remainderl)
fldt 24(%rsp)
fstp %st(1)
ret
END (__ieee754_remainderl)
-strong_alias (__ieee754_remainderl, __remainderl_finite)
+libm_alias_finite (__ieee754_remainderl, __remainderl)
*/
#include <machine/asm.h>
+#include <libm-alias-finite.h>
.section .rodata
fdiv %st
ret
END(__ieee754_scalbl)
-strong_alias (__ieee754_scalbl, __scalbl_finite)
+libm_alias_finite (__ieee754_scalbl, __scalbl)
<https://www.gnu.org/licenses/>. */
#include <math_private.h>
+#include <libm-alias-finite.h>
#undef __ieee754_sqrt
double
return res;
}
-strong_alias (__ieee754_sqrt, __sqrt_finite)
+libm_alias_finite (__ieee754_sqrt, __sqrt)
<https://www.gnu.org/licenses/>. */
#include <math_private.h>
+#include <libm-alias-finite.h>
#undef __ieee754_sqrtf
float
return res;
}
-strong_alias (__ieee754_sqrtf, __sqrtf_finite)
+libm_alias_finite (__ieee754_sqrtf, __sqrtf)
License along with the GNU C Library; if not, see
<https://www.gnu.org/licenses/>. */
+#include <libm-alias-finite.h>
+
extern double __redirect_ieee754_asin (double);
extern double __redirect_ieee754_acos (double);
libc_ifunc_redirected (__redirect_ieee754_asin, __ieee754_asin,
IFUNC_SELECTOR ());
-strong_alias (__ieee754_asin, __asin_finite)
+libm_alias_finite (__ieee754_asin, __asin)
#undef SYMBOL_NAME
#define SYMBOL_NAME ieee754_acos
libc_ifunc_redirected (__redirect_ieee754_acos, __ieee754_acos,
IFUNC_SELECTOR ());
-strong_alias (__ieee754_acos, __acos_finite)
-
+libm_alias_finite (__ieee754_acos, __acos)
#define __ieee754_acos __ieee754_acos_sse2
#define __ieee754_asin __ieee754_asin_sse2
License along with the GNU C Library; if not, see
<https://www.gnu.org/licenses/>. */
+#include <libm-alias-finite.h>
+
extern double __redirect_ieee754_atan2 (double, double);
#define SYMBOL_NAME ieee754_atan2
libc_ifunc_redirected (__redirect_ieee754_atan2,
__ieee754_atan2, IFUNC_SELECTOR ());
-strong_alias (__ieee754_atan2, __atan2_finite)
+libm_alias_finite (__ieee754_atan2, __atan2)
#define __ieee754_atan2 __ieee754_atan2_sse2
#include <sysdeps/ieee754/dbl-64/e_atan2.c>
<https://www.gnu.org/licenses/>. */
#include <math.h>
+#include <libm-alias-finite.h>
extern double __redirect_ieee754_exp (double);
libc_ifunc_redirected (__redirect_ieee754_exp, __ieee754_exp,
IFUNC_SELECTOR ());
-strong_alias (__ieee754_exp, __exp_finite)
+libm_alias_finite (__ieee754_exp, __exp)
#define __exp __ieee754_exp_sse2
#include <sysdeps/ieee754/dbl-64/e_exp.c>
<https://www.gnu.org/licenses/>. */
#include <libm-alias-float.h>
+#include <libm-alias-finite.h>
extern float __redirect_exp2f (float);
libc_ifunc_redirected (__redirect_exp2f, __exp2f, IFUNC_SELECTOR ());
#ifdef SHARED
-# include <shlib-compat.h>
-versioned_symbol (libm, __exp2f, exp2f, GLIBC_2_27);
+versioned_symbol (libm, __ieee754_exp2f, exp2f, GLIBC_2_27);
libm_alias_float_other (__exp2, exp2)
#else
libm_alias_float (__exp2, exp2)
#endif
strong_alias (__exp2f, __ieee754_exp2f)
-strong_alias (__exp2f, __exp2f_finite)
+libm_alias_finite (__exp2f, __exp2f)
#define __exp2f __exp2f_sse2
#include <sysdeps/ieee754/flt-32/e_exp2f.c>
<https://www.gnu.org/licenses/>. */
#include <libm-alias-float.h>
+#include <libm-alias-finite.h>
extern float __redirect_expf (float);
__hidden_ver1 (__expf, __GI___expf, __redirect_expf)
__attribute__ ((visibility ("hidden")));
-# include <shlib-compat.h>
-versioned_symbol (libm, __expf, expf, GLIBC_2_27);
+versioned_symbol (libm, __ieee754_expf, expf, GLIBC_2_27);
libm_alias_float_other (__exp, exp)
#else
libm_alias_float (__exp, exp)
#endif
strong_alias (__expf, __ieee754_expf)
-strong_alias (__expf, __expf_finite)
+libm_alias_finite (__expf, __expf)
#define __expf __expf_sse2
#include <sysdeps/ieee754/flt-32/e_expf.c>
<https://www.gnu.org/licenses/>. */
#include <math.h>
+#include <libm-alias-finite.h>
extern double __redirect_ieee754_log (double);
libc_ifunc_redirected (__redirect_ieee754_log, __ieee754_log,
IFUNC_SELECTOR ());
-strong_alias (__ieee754_log, __log_finite)
+libm_alias_finite (__ieee754_log, __log)
#define __log __ieee754_log_sse2
#include <sysdeps/ieee754/dbl-64/e_log.c>
<https://www.gnu.org/licenses/>. */
#include <libm-alias-float.h>
+#include <libm-alias-finite.h>
extern float __redirect_log2f (float);
__hidden_ver1 (__log2f, __GI___log2f, __redirect_log2f)
__attribute__ ((visibility ("hidden")));
-# include <shlib-compat.h>
-versioned_symbol (libm, __log2f, log2f, GLIBC_2_27);
+versioned_symbol (libm, __ieee754_log2f, log2f, GLIBC_2_27);
libm_alias_float_other (__log2, log2)
#else
libm_alias_float (__log2, log2)
#endif
strong_alias (__log2f, __ieee754_log2f)
-strong_alias (__log2f, __log2f_finite)
+libm_alias_finite (__log2f, __log2f)
#define __log2f __log2f_sse2
#include <sysdeps/ieee754/flt-32/e_log2f.c>
<https://www.gnu.org/licenses/>. */
#include <libm-alias-float.h>
+#include <libm-alias-finite.h>
extern float __redirect_logf (float);
__hidden_ver1 (__logf, __GI___logf, __redirect_logf)
__attribute__ ((visibility ("hidden")));
-# include <shlib-compat.h>
-versioned_symbol (libm, __logf, logf, GLIBC_2_27);
+versioned_symbol (libm, __ieee754_logf, logf, GLIBC_2_27);
libm_alias_float_other (__log, log)
#else
libm_alias_float (__log, log)
#endif
strong_alias (__logf, __ieee754_logf)
-strong_alias (__logf, __logf_finite)
+libm_alias_finite (__logf, __logf)
#define __logf __logf_sse2
#include <sysdeps/ieee754/flt-32/e_logf.c>
<https://www.gnu.org/licenses/>. */
#include <math.h>
+#include <libm-alias-finite.h>
extern double __redirect_ieee754_pow (double, double);
libc_ifunc_redirected (__redirect_ieee754_pow,
__ieee754_pow, IFUNC_SELECTOR ());
-strong_alias (__ieee754_pow, __pow_finite)
+libm_alias_finite (__ieee754_pow, __pow)
#define __pow __ieee754_pow_sse2
#include <sysdeps/ieee754/dbl-64/e_pow.c>
<https://www.gnu.org/licenses/>. */
#include <libm-alias-float.h>
+#include <libm-alias-finite.h>
#define powf __redirect_powf
#define __DECL_SIMD___redirect_powf
__hidden_ver1 (__powf, __GI___powf, __redirect_powf)
__attribute__ ((visibility ("hidden")));
-# include <shlib-compat.h>
-versioned_symbol (libm, __powf, powf, GLIBC_2_27);
+versioned_symbol (libm, __ieee754_powf, powf, GLIBC_2_27);
libm_alias_float_other (__pow, pow)
#else
libm_alias_float (__pow, pow)
#endif
strong_alias (__powf, __ieee754_powf)
-strong_alias (__powf, __powf_finite)
+libm_alias_finite (__powf, __powf)
#define __powf __powf_sse2
#include <sysdeps/ieee754/flt-32/e_powf.c>
projects / thirdparty / glibc.git / commitdiff
