2018-09-27 Joseph Myers <joseph@codesourcery.com>
+ * include/math.h [!_ISOMAC && !(__FINITE_MATH_ONLY__ &&
+ __FINITE_MATH_ONLY__ > 0) && !NO_MATH_REDIRECT]
+ (MATH_REDIRECT_BINARY_ARGS): New macro.
+ [!_ISOMAC && !(__FINITE_MATH_ONLY__ && __FINITE_MATH_ONLY__ > 0)
+ && !NO_MATH_REDIRECT] (copysign): Redirect using MATH_REDIRECT.
+ * sysdeps/alpha/fpu/s_copysign.c: Define NO_MATH_REDIRECT before
+ header inclusion.
+ * sysdeps/alpha/fpu/s_copysignf.c: Likewise.
+ * sysdeps/ieee754/dbl-64/s_copysign.c: Likewise.
+ * sysdeps/ieee754/float128/s_copysignf128.c: Likewise.
+ * sysdeps/ieee754/flt-32/s_copysignf.c: Likewise.
+ * sysdeps/ieee754/ldbl-128/s_copysignl.c: Likewise.
+ * sysdeps/ieee754/ldbl-128ibm/s_copysignl.c: Likewise.
+ * sysdeps/ieee754/ldbl-96/s_copysignl.c: Likewise.
+ * sysdeps/powerpc/powerpc32/power4/fpu/multiarch/s_copysign.c:
+ Likewise.
+ * sysdeps/powerpc/powerpc32/power4/fpu/multiarch/s_copysignf.c:
+ Likewise.
+ * sysdeps/powerpc/powerpc64/fpu/multiarch/s_copysign.c: Likewise.
+ * sysdeps/powerpc/powerpc64/fpu/multiarch/s_copysignf.c: Likewise.
+ * sysdeps/riscv/rvd/s_copysign.c: Likewise.
+ * sysdeps/riscv/rvf/s_copysignf.c: Likewise.
+ * sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_copysign.c:
+ Likewise.
+ * sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_copysignf.c:
+ Likewise.
+ * sysdeps/generic/math_private_calls.h
+ [!__MATH_DECLARING_LONG_DOUBLE || !NO_LONG_DOUBLE] (__copysign):
+ Do not declare and define as an inline function.
+ * math/divtc3.c (__divtc3): Use copysign functions instead of
+ __copysign variants.
+ * math/multc3.c (__multc3): Likewise.
+ * sysdeps/generic/math-type-macros.h (M_COPYSIGN): Likewise.
+ * sysdeps/ieee754/dbl-64/e_atan2.c (signArctan2): Likewise.
+ * sysdeps/ieee754/dbl-64/e_atanh.c (__ieee754_atanh): Likewise.
+ * sysdeps/ieee754/dbl-64/e_gamma_r.c (__ieee754_gamma_r):
+ Likewise.
+ * sysdeps/ieee754/dbl-64/e_jn.c (__ieee754_jn): Likewise.
+ (__ieee754_yn): Likewise.
+ * sysdeps/ieee754/dbl-64/s_asinh.c (__asinh): Likewise.
+ * sysdeps/ieee754/dbl-64/s_atan.c (__signArctan): Likewise.
+ * sysdeps/ieee754/dbl-64/s_scalbln.c (__scalbln): Likewise.
+ * sysdeps/ieee754/dbl-64/s_scalbn.c (__scalbn): Likewise.
+ * sysdeps/ieee754/dbl-64/s_sin.c (do_sin): Likewise.
+ (__sin): Likewise.
+ * sysdeps/ieee754/dbl-64/s_sincos.c (__sincos): Likewise.
+ * sysdeps/ieee754/dbl-64/wordsize-64/s_nearbyint.c (__nearbyint):
+ Likewise.
+ * sysdeps/ieee754/dbl-64/wordsize-64/s_scalbln.c (__scalbln):
+ Likewise.
+ * sysdeps/ieee754/dbl-64/wordsize-64/s_scalbn.c (__scalbn):
+ Likewise.
+ * sysdeps/ieee754/flt-32/e_atanhf.c (__ieee754_atanhf): Likewise.
+ * sysdeps/ieee754/flt-32/e_gammaf_r.c (__ieee754_gammaf_r):
+ Likewise.
+ * sysdeps/ieee754/flt-32/e_jnf.c (__ieee754_jnf): Likewise.
+ (__ieee754_ynf): Likewise.
+ * sysdeps/ieee754/flt-32/s_asinhf.c (__asinhf): Likewise.
+ * sysdeps/ieee754/flt-32/s_scalbnf.c (__scalbnf): Likewise.
+ * sysdeps/ieee754/k_standard.c (__kernel_standard): Likewise.
+ * sysdeps/ieee754/ldbl-128/e_gammal_r.c (__ieee754_gammal_r):
+ Likewise.
+ * sysdeps/ieee754/ldbl-128/e_jnl.c (__ieee754_jnl): Likewise.
+ (__ieee754_ynl): Likewise.
+ * sysdeps/ieee754/ldbl-128/s_scalblnl.c (__scalblnl): Likewise.
+ * sysdeps/ieee754/ldbl-128/s_scalbnl.c (__scalbnl): Likewise.
+ * sysdeps/ieee754/ldbl-128ibm/e_gammal_r.c (__ieee754_gammal_r):
+ Likewise.
+ * sysdeps/ieee754/ldbl-128ibm/e_jnl.c (__ieee754_jnl): Likewise.
+ (__ieee754_ynl): Likewise.
+ * sysdeps/ieee754/ldbl-128ibm/s_fmal.c (__fmal): Likewise.
+ * sysdeps/ieee754/ldbl-128ibm/s_scalblnl.c (__scalblnl): Likewise.
+ * sysdeps/ieee754/ldbl-128ibm/s_scalbnl.c (__scalbnl): Likewise.
+ * sysdeps/ieee754/ldbl-96/e_gammal_r.c (__ieee754_gammal_r):
+ Likewise.
+ * sysdeps/ieee754/ldbl-96/e_jnl.c (__ieee754_jnl): Likewise.
+ (__ieee754_ynl)
+ * sysdeps/ieee754/ldbl-96/s_asinhl.c (__asinhl): Likewise.
+ * sysdeps/ieee754/ldbl-96/s_scalblnl.c (__scalblnl): Likewise.
+ * sysdeps/ieee754/ldbl-opt/nldbl-copysign.c (copysignl): Likewise.
+ * sysdeps/powerpc/power5+/fpu/s_modf.c (__modf): Likewise.
+ * sysdeps/powerpc/power5+/fpu/s_modff.c (__modff): Likewise.
+
* include/math.h [!_ISOMAC && !(__FINITE_MATH_ONLY__ &&
__FINITE_MATH_ONLY__ > 0) && !NO_MATH_REDIRECT] (round): Redirect
using MATH_REDIRECT.
# define MATH_REDIRECT_F128(FUNC, PREFIX, ARGS)
# endif
# define MATH_REDIRECT_UNARY_ARGS(TYPE) TYPE
+# define MATH_REDIRECT_BINARY_ARGS(TYPE) TYPE, TYPE
MATH_REDIRECT (sqrt, "__ieee754_", MATH_REDIRECT_UNARY_ARGS)
MATH_REDIRECT (ceil, "__", MATH_REDIRECT_UNARY_ARGS)
MATH_REDIRECT (floor, "__", MATH_REDIRECT_UNARY_ARGS)
MATH_REDIRECT (rint, "__", MATH_REDIRECT_UNARY_ARGS)
MATH_REDIRECT (trunc, "__", MATH_REDIRECT_UNARY_ARGS)
MATH_REDIRECT (round, "__", MATH_REDIRECT_UNARY_ARGS)
+MATH_REDIRECT (copysign, "__", MATH_REDIRECT_BINARY_ARGS)
# endif
# endif
{
if (denom == 0.0 && (!isnan (a) || !isnan (b)))
{
- x = __copysignl (INFINITY, c) * a;
- y = __copysignl (INFINITY, c) * b;
+ x = copysignl (INFINITY, c) * a;
+ y = copysignl (INFINITY, c) * b;
}
else if ((isinf (a) || isinf (b))
&& isfinite (c) && isfinite (d))
{
- a = __copysignl (isinf (a) ? 1 : 0, a);
- b = __copysignl (isinf (b) ? 1 : 0, b);
+ a = copysignl (isinf (a) ? 1 : 0, a);
+ b = copysignl (isinf (b) ? 1 : 0, b);
x = INFINITY * (a * c + b * d);
y = INFINITY * (b * c - a * d);
}
else if ((isinf (c) || isinf (d))
&& isfinite (a) && isfinite (b))
{
- c = __copysignl (isinf (c) ? 1 : 0, c);
- d = __copysignl (isinf (d) ? 1 : 0, d);
+ c = copysignl (isinf (c) ? 1 : 0, c);
+ d = copysignl (isinf (d) ? 1 : 0, d);
x = 0.0 * (a * c + b * d);
y = 0.0 * (b * c - a * d);
}
{
/* z is infinite. "Box" the infinity and change NaNs in
the other factor to 0. */
- a = __copysignl (isinf (a) ? 1 : 0, a);
- b = __copysignl (isinf (b) ? 1 : 0, b);
- if (isnan (c)) c = __copysignl (0, c);
- if (isnan (d)) d = __copysignl (0, d);
+ a = copysignl (isinf (a) ? 1 : 0, a);
+ b = copysignl (isinf (b) ? 1 : 0, b);
+ if (isnan (c)) c = copysignl (0, c);
+ if (isnan (d)) d = copysignl (0, d);
recalc = 1;
}
if (isinf (c) || isinf (d))
{
/* w is infinite. "Box" the infinity and change NaNs in
the other factor to 0. */
- c = __copysignl (isinf (c) ? 1 : 0, c);
- d = __copysignl (isinf (d) ? 1 : 0, d);
- if (isnan (a)) a = __copysignl (0, a);
- if (isnan (b)) b = __copysignl (0, b);
+ c = copysignl (isinf (c) ? 1 : 0, c);
+ d = copysignl (isinf (d) ? 1 : 0, d);
+ if (isnan (a)) a = copysignl (0, a);
+ if (isnan (b)) b = copysignl (0, b);
recalc = 1;
}
if (!recalc
|| isinf (ad) || isinf (bc)))
{
/* Recover infinities from overflow by changing NaNs to 0. */
- if (isnan (a)) a = __copysignl (0, a);
- if (isnan (b)) b = __copysignl (0, b);
- if (isnan (c)) c = __copysignl (0, c);
- if (isnan (d)) d = __copysignl (0, d);
+ if (isnan (a)) a = copysignl (0, a);
+ if (isnan (b)) b = copysignl (0, b);
+ if (isnan (c)) c = copysignl (0, c);
+ if (isnan (d)) d = copysignl (0, d);
recalc = 1;
}
if (recalc)
License along with the GNU C Library. If not, see
<http://www.gnu.org/licenses/>. */
+#define NO_MATH_REDIRECT
#include <math.h>
#include <math_ldbl_opt.h>
#include <libm-alias-double.h>
License along with the GNU C Library. If not, see
<http://www.gnu.org/licenses/>. */
+#define NO_MATH_REDIRECT
#include <math.h>
#include <libm-alias-float.h>
#define M_HUGE_VAL (M_SUF (__builtin_huge_val) ())
/* Helper macros for commonly used functions. */
-#define M_COPYSIGN M_SUF (__copysign)
+#define M_COPYSIGN M_SUF (copysign)
#define M_FABS M_SUF (fabs)
#define M_SINCOS M_SUF (__sincos)
#define M_SCALBN M_SUF (__scalbn)
#endif
/* Internal functions. */
-#if !defined __MATH_DECLARING_LONG_DOUBLE || !defined NO_LONG_DOUBLE
-extern _Mdouble_ __MSUF (__copysign) (_Mdouble_ x, _Mdouble_ __y);
-
-extern inline _Mdouble_
-__MSUF (__copysign) (_Mdouble_ x, _Mdouble_ __y)
-{
- return __MSUF (__builtin_copysign) (x, __y);
-}
-#endif
/* Return X^2 + Y^2 - 1, computed without large cancellation error.
It is given that 1 > X >= Y >= epsilon / 2, and that X^2 + Y^2 >=
static double
signArctan2 (double y, double z)
{
- return __copysign (z, y);
+ return copysign (z, y);
}
static double normalized (double, double, double, double);
return x / 0.0;
}
- return __copysign (t, x);
+ return copysign (t, x);
}
strong_alias (__ieee754_atanh, __atanh_finite)
{
if (*signgamp < 0)
{
- ret = math_narrow_eval (-__copysign (DBL_MAX, ret) * DBL_MAX);
+ ret = math_narrow_eval (-copysign (DBL_MAX, ret) * DBL_MAX);
ret = -ret;
}
else
- ret = math_narrow_eval (__copysign (DBL_MAX, ret) * DBL_MAX);
+ ret = math_narrow_eval (copysign (DBL_MAX, ret) * DBL_MAX);
return ret;
}
else if (ret == 0)
{
if (*signgamp < 0)
{
- ret = math_narrow_eval (-__copysign (DBL_MIN, ret) * DBL_MIN);
+ ret = math_narrow_eval (-copysign (DBL_MIN, ret) * DBL_MIN);
ret = -ret;
}
else
- ret = math_narrow_eval (__copysign (DBL_MIN, ret) * DBL_MIN);
+ ret = math_narrow_eval (copysign (DBL_MIN, ret) * DBL_MIN);
return ret;
}
else
}
if (ret == 0)
{
- ret = math_narrow_eval (__copysign (DBL_MIN, ret) * DBL_MIN);
+ ret = math_narrow_eval (copysign (DBL_MIN, ret) * DBL_MIN);
__set_errno (ERANGE);
}
else
}
out:
if (isinf (ret))
- ret = __copysign (DBL_MAX, ret) * DBL_MAX;
+ ret = copysign (DBL_MAX, ret) * DBL_MAX;
return ret;
}
strong_alias (__ieee754_yn, __yn_finite)
w = __log1p (xa + t / (one + sqrt (one + t)));
}
}
- return __copysign (w, x);
+ return copysign (w, x);
}
libm_alias_double (__asinh, asinh)
static double
__signArctan (double x, double y)
{
- return __copysign (y, x);
+ return copysign (y, x);
}
* with the sign bit of y.
*/
+#define NO_MATH_REDIRECT
#include <math.h>
#include <math_private.h>
#include <libm-alias-double.h>
if (__glibc_unlikely (k == 0x7ff))
return x + x; /* NaN or Inf */
if (__glibc_unlikely (n < -50000))
- return tiny * __copysign (tiny, x); /*underflow*/
+ return tiny * copysign (tiny, x); /*underflow*/
if (__glibc_unlikely (n > 50000 || k + n > 0x7fe))
- return huge * __copysign (huge, x); /* overflow */
+ return huge * copysign (huge, x); /* overflow */
/* Now k and n are bounded we know that k = k+n does not
overflow. */
k = k + n;
SET_HIGH_WORD (x, (hx & 0x800fffff) | (k << 20)); return x;
}
if (k <= -54)
- return tiny * __copysign (tiny, x); /*underflow*/
+ return tiny * copysign (tiny, x); /*underflow*/
k += 54; /* subnormal result */
SET_HIGH_WORD (x, (hx & 0x800fffff) | (k << 20));
return x * twom54;
if (__glibc_unlikely (k == 0x7ff))
return x + x; /* NaN or Inf */
if (__glibc_unlikely (n < -50000))
- return tiny * __copysign (tiny, x); /*underflow*/
+ return tiny * copysign (tiny, x); /*underflow*/
if (__glibc_unlikely (n > 50000 || k + n > 0x7fe))
- return huge * __copysign (huge, x); /* overflow */
+ return huge * copysign (huge, x); /* overflow */
/* Now k and n are bounded we know that k = k+n does not
overflow. */
k = k + n;
SET_HIGH_WORD (x, (hx & 0x800fffff) | (k << 20)); return x;
}
if (k <= -54)
- return tiny * __copysign (tiny, x); /*underflow*/
+ return tiny * copysign (tiny, x); /*underflow*/
k += 54; /* subnormal result */
SET_HIGH_WORD (x, (hx & 0x800fffff) | (k << 20));
return x * twom54;
c = x * dx + xx * (cs2 + xx * (cs4 + xx * cs6));
SINCOS_TABLE_LOOKUP (u, sn, ssn, cs, ccs);
cor = (ssn + s * ccs - sn * c) + cs * s;
- return __copysign (sn + cor, xold);
+ return copysign (sn + cor, xold);
}
/* Reduce range of x to within PI/2 with abs (x) < 105414350. The high part
{
t = hp0 - fabs (x);
/* Max ULP is 0.51. */
- retval = __copysign (do_cos (t, hp1), x);
+ retval = copysign (do_cos (t, hp1), x);
} /* else if (k < 0x400368fd) */
/*-------------------------- 2.426265<|x|< 105414350 ----------------------*/
y = hp0 - fabs (x);
a = y + hp1;
da = (y - a) + hp1;
- *sinx = __copysign (do_cos (a, da), x);
+ *sinx = copysign (do_cos (a, da), x);
*cosx = do_sin (a, da);
return;
}
double t = w-TWO52[sx];
math_force_eval (t);
libc_fesetenv (&env);
- return __copysign (t, x);
+ return copysign (t, x);
}
} else {
if(j0==0x400) return x+x; /* inf or NaN */
}
if (__builtin_expect(k==0x7ff, 0)) return x+x; /* NaN or Inf */
if (__builtin_expect(n< -50000, 0))
- return tiny*__copysign(tiny,x); /*underflow*/
+ return tiny*copysign(tiny,x); /*underflow*/
if (__builtin_expect(n> 50000 || k+n > 0x7fe, 0))
- return huge*__copysign(huge,x); /* overflow */
+ return huge*copysign(huge,x); /* overflow */
/* Now k and n are bounded we know that k = k+n does not
overflow. */
k = k+n;
{INSERT_WORDS64(x,(ix&UINT64_C(0x800fffffffffffff))|(k<<52));
return x;}
if (k <= -54)
- return tiny*__copysign(tiny,x); /*underflow*/
+ return tiny*copysign(tiny,x); /*underflow*/
k += 54; /* subnormal result */
INSERT_WORDS64(x,(ix&INT64_C(0x800fffffffffffff))|(k<<52));
return x*twom54;
}
if (__builtin_expect(k==0x7ff, 0)) return x+x; /* NaN or Inf */
if (__builtin_expect(n< -50000, 0))
- return tiny*__copysign(tiny,x); /*underflow*/
+ return tiny*copysign(tiny,x); /*underflow*/
if (__builtin_expect(n> 50000 || k+n > 0x7fe, 0))
- return huge*__copysign(huge,x); /* overflow */
+ return huge*copysign(huge,x); /* overflow */
/* Now k and n are bounded we know that k = k+n does not
overflow. */
k = k+n;
{INSERT_WORDS64(x,(ix&UINT64_C(0x800fffffffffffff))|(k<<52));
return x;}
if (k <= -54)
- return tiny*__copysign(tiny,x); /*underflow*/
+ return tiny*copysign(tiny,x); /*underflow*/
k += 54; /* subnormal result */
INSERT_WORDS64(x,(ix&INT64_C(0x800fffffffffffff))|(k<<52));
return x*twom54;
+#define NO_MATH_REDIRECT
#include <float128_private.h>
#include "../ldbl-128/s_copysignl.c"
return x / 0.0f;
}
- return __copysignf (t, x);
+ return copysignf (t, x);
}
strong_alias (__ieee754_atanhf, __atanhf_finite)
{
if (*signgamp < 0)
{
- ret = math_narrow_eval (-__copysignf (FLT_MAX, ret) * FLT_MAX);
+ ret = math_narrow_eval (-copysignf (FLT_MAX, ret) * FLT_MAX);
ret = -ret;
}
else
- ret = math_narrow_eval (__copysignf (FLT_MAX, ret) * FLT_MAX);
+ ret = math_narrow_eval (copysignf (FLT_MAX, ret) * FLT_MAX);
return ret;
}
else if (ret == 0)
{
if (*signgamp < 0)
{
- ret = math_narrow_eval (-__copysignf (FLT_MIN, ret) * FLT_MIN);
+ ret = math_narrow_eval (-copysignf (FLT_MIN, ret) * FLT_MIN);
ret = -ret;
}
else
- ret = math_narrow_eval (__copysignf (FLT_MIN, ret) * FLT_MIN);
+ ret = math_narrow_eval (copysignf (FLT_MIN, ret) * FLT_MIN);
return ret;
}
else
}
if (ret == 0)
{
- ret = math_narrow_eval (__copysignf (FLT_MIN, ret) * FLT_MIN);
+ ret = math_narrow_eval (copysignf (FLT_MIN, ret) * FLT_MIN);
__set_errno (ERANGE);
}
else
}
out:
if (isinf (ret))
- ret = __copysignf (FLT_MAX, ret) * FLT_MAX;
+ ret = copysignf (FLT_MAX, ret) * FLT_MAX;
return ret;
}
strong_alias (__ieee754_ynf, __ynf_finite)
w =__log1pf(xa+t/(one+sqrtf(one+t)));
}
}
- return __copysignf(w, x);
+ return copysignf(w, x);
}
libm_alias_float (__asinh, asinh)
* with the sign bit of y.
*/
+#define NO_MATH_REDIRECT
#include <math.h>
#include <math_private.h>
#include <libm-alias-float.h>
}
if (__builtin_expect(k==0xff, 0)) return x+x; /* NaN or Inf */
if (__builtin_expect(n< -50000, 0))
- return tiny*__copysignf(tiny,x); /*underflow*/
+ return tiny*copysignf(tiny,x); /*underflow*/
if (__builtin_expect(n> 50000 || k+n > 0xfe, 0))
- return huge*__copysignf(huge,x); /* overflow */
+ return huge*copysignf(huge,x); /* overflow */
/* Now k and n are bounded we know that k = k+n does not
overflow. */
k = k+n;
if (__builtin_expect(k > 0, 1)) /* normal result */
{SET_FLOAT_WORD(x,(ix&0x807fffff)|(k<<23)); return x;}
if (k <= -25)
- return tiny*__copysignf(tiny,x); /*underflow*/
+ return tiny*copysignf(tiny,x); /*underflow*/
k += 25; /* subnormal result */
SET_FLOAT_WORD(x,(ix&0x807fffff)|(k<<23));
return x*twom25;
/* scalb underflow */
exc.type = UNDERFLOW;
exc.name = CSTR ("scalb");
- exc.retval = __copysign(zero,x);
+ exc.retval = copysign(zero,x);
if (_LIB_VERSION == _POSIX_)
__set_errno (ERANGE);
else if (!matherr(&exc)) {
/* tgamma(finite) overflow */
exc.type = OVERFLOW;
exc.name = CSTR ("tgamma");
- exc.retval = __copysign (HUGE_VAL, x);
+ exc.retval = copysign (HUGE_VAL, x);
if (_LIB_VERSION == _POSIX_)
__set_errno (ERANGE);
else if (!matherr(&exc)) {
/* tgamma(+-0) */
exc.type = SING;
exc.name = CSTR ("tgamma");
- exc.retval = __copysign (HUGE_VAL, x);
+ exc.retval = copysign (HUGE_VAL, x);
if (_LIB_VERSION == _POSIX_)
__set_errno (ERANGE);
else if (!matherr(&exc)) {
if (isinf (ret) && x != 0)
{
if (*signgamp < 0)
- return -(-__copysignl (LDBL_MAX, ret) * LDBL_MAX);
+ return -(-copysignl (LDBL_MAX, ret) * LDBL_MAX);
else
- return __copysignl (LDBL_MAX, ret) * LDBL_MAX;
+ return copysignl (LDBL_MAX, ret) * LDBL_MAX;
}
else if (ret == 0)
{
if (*signgamp < 0)
- return -(-__copysignl (LDBL_MIN, ret) * LDBL_MIN);
+ return -(-copysignl (LDBL_MIN, ret) * LDBL_MIN);
else
- return __copysignl (LDBL_MIN, ret) * LDBL_MIN;
+ return copysignl (LDBL_MIN, ret) * LDBL_MIN;
}
else
return ret;
}
if (ret == 0)
{
- ret = __copysignl (LDBL_MIN, ret) * LDBL_MIN;
+ ret = copysignl (LDBL_MIN, ret) * LDBL_MIN;
__set_errno (ERANGE);
}
else
}
out:
if (isinf (ret))
- ret = __copysignl (LDBL_MAX, ret) * LDBL_MAX;
+ ret = copysignl (LDBL_MAX, ret) * LDBL_MAX;
return ret;
}
strong_alias (__ieee754_ynl, __ynl_finite)
* with the sign bit of y.
*/
+#define NO_MATH_REDIRECT
#include <math.h>
#include <math_private.h>
#include <libm-alias-ldouble.h>
k = ((hx>>48)&0x7fff) - 114;
}
if (k==0x7fff) return x+x; /* NaN or Inf */
- if (n< -50000) return tiny*__copysignl(tiny,x); /*underflow*/
+ if (n< -50000) return tiny*copysignl(tiny,x); /*underflow*/
if (n> 50000 || k+n > 0x7ffe)
- return huge*__copysignl(huge,x); /* overflow */
+ return huge*copysignl(huge,x); /* overflow */
/* Now k and n are bounded we know that k = k+n does not
overflow. */
k = k+n;
if (k > 0) /* normal result */
{SET_LDOUBLE_MSW64(x,(hx&0x8000ffffffffffffULL)|(k<<48)); return x;}
if (k <= -114)
- return tiny*__copysignl(tiny,x); /*underflow*/
+ return tiny*copysignl(tiny,x); /*underflow*/
k += 114; /* subnormal result */
SET_LDOUBLE_MSW64(x,(hx&0x8000ffffffffffffULL)|(k<<48));
return x*twom114;
k = ((hx>>48)&0x7fff) - 114;
}
if (k==0x7fff) return x+x; /* NaN or Inf */
- if (n< -50000) return tiny*__copysignl(tiny,x); /*underflow*/
+ if (n< -50000) return tiny*copysignl(tiny,x); /*underflow*/
if (n> 50000 || k+n > 0x7ffe)
- return huge*__copysignl(huge,x); /* overflow */
+ return huge*copysignl(huge,x); /* overflow */
/* Now k and n are bounded we know that k = k+n does not
overflow. */
k = k+n;
if (k > 0) /* normal result */
{SET_LDOUBLE_MSW64(x,(hx&0x8000ffffffffffffULL)|(k<<48)); return x;}
if (k <= -114)
- return tiny*__copysignl(tiny,x); /*underflow*/
+ return tiny*copysignl(tiny,x); /*underflow*/
k += 114; /* subnormal result */
SET_LDOUBLE_MSW64(x,(hx&0x8000ffffffffffffULL)|(k<<48));
return x*twom114;
if (isinf (ret) && x != 0)
{
if (*signgamp < 0)
- return -(-__copysignl (LDBL_MAX, ret) * LDBL_MAX);
+ return -(-copysignl (LDBL_MAX, ret) * LDBL_MAX);
else
- return __copysignl (LDBL_MAX, ret) * LDBL_MAX;
+ return copysignl (LDBL_MAX, ret) * LDBL_MAX;
}
else if (ret == 0)
{
if (*signgamp < 0)
- return -(-__copysignl (LDBL_MIN, ret) * LDBL_MIN);
+ return -(-copysignl (LDBL_MIN, ret) * LDBL_MIN);
else
- return __copysignl (LDBL_MIN, ret) * LDBL_MIN;
+ return copysignl (LDBL_MIN, ret) * LDBL_MIN;
}
else
return ret;
}
if (ret == 0)
{
- ret = __copysignl (LDBL_MIN, ret) * LDBL_MIN;
+ ret = copysignl (LDBL_MIN, ret) * LDBL_MIN;
__set_errno (ERANGE);
}
else
}
out:
if (isinf (ret))
- ret = __copysignl (LDBL_MAX, ret) * LDBL_MAX;
+ ret = copysignl (LDBL_MAX, ret) * LDBL_MAX;
return ret;
}
strong_alias (__ieee754_ynl, __ynl_finite)
* with the sign bit of y.
*/
+#define NO_MATH_REDIRECT
#include <math.h>
#include <math_private.h>
#include <math_ldbl_opt.h>
scale_val = math_opt_barrier (scale_val);
scale_val = __scalbn (scale_val, scale_exp);
if (fabs (scale_val) == DBL_MAX)
- return __copysignl (LDBL_MAX, scale_val);
+ return copysignl (LDBL_MAX, scale_val);
math_check_force_underflow (scale_val);
return scale_val;
k = ((hx>>52)&0x7ff) - 54;
}
else if (k==0x7ff) return x+x; /* NaN or Inf */
- if (n< -50000) return tiny*__copysignl(tiny,x); /*underflow */
+ if (n< -50000) return tiny*copysignl(tiny,x); /*underflow */
if (n> 50000 || k+n > 0x7fe)
- return huge*__copysignl(huge,x); /* overflow */
+ return huge*copysignl(huge,x); /* overflow */
/* Now k and n are bounded we know that k = k+n does not
overflow. */
k = k+n;
return x;
}
if (k <= -54)
- return tiny*__copysignl(tiny,x); /*underflow*/
+ return tiny*copysignl(tiny,x); /*underflow*/
k += 54; /* subnormal result */
lx &= 0x8000000000000000ULL;
hx &= 0x800fffffffffffffULL;
k = ((hx>>52)&0x7ff) - 54;
}
else if (k==0x7ff) return x+x; /* NaN or Inf */
- if (n< -50000) return tiny*__copysignl(tiny,x); /*underflow */
+ if (n< -50000) return tiny*copysignl(tiny,x); /*underflow */
if (n> 50000 || k+n > 0x7fe)
- return huge*__copysignl(huge,x); /* overflow */
+ return huge*copysignl(huge,x); /* overflow */
/* Now k and n are bounded we know that k = k+n does not
overflow. */
k = k+n;
return x;
}
if (k <= -54)
- return tiny*__copysignl(tiny,x); /*underflow*/
+ return tiny*copysignl(tiny,x); /*underflow*/
k += 54; /* subnormal result */
lx &= 0x8000000000000000ULL;
hx &= 0x800fffffffffffffULL;
if (isinf (ret) && x != 0)
{
if (*signgamp < 0)
- return -(-__copysignl (LDBL_MAX, ret) * LDBL_MAX);
+ return -(-copysignl (LDBL_MAX, ret) * LDBL_MAX);
else
- return __copysignl (LDBL_MAX, ret) * LDBL_MAX;
+ return copysignl (LDBL_MAX, ret) * LDBL_MAX;
}
else if (ret == 0)
{
if (*signgamp < 0)
- return -(-__copysignl (LDBL_MIN, ret) * LDBL_MIN);
+ return -(-copysignl (LDBL_MIN, ret) * LDBL_MIN);
else
- return __copysignl (LDBL_MIN, ret) * LDBL_MIN;
+ return copysignl (LDBL_MIN, ret) * LDBL_MIN;
}
else
return ret;
}
if (ret == 0)
{
- ret = __copysignl (LDBL_MIN, ret) * LDBL_MIN;
+ ret = copysignl (LDBL_MIN, ret) * LDBL_MIN;
__set_errno (ERANGE);
}
else
}
out:
if (isinf (ret))
- ret = __copysignl (LDBL_MAX, ret) * LDBL_MAX;
+ ret = copysignl (LDBL_MAX, ret) * LDBL_MAX;
return ret;
}
strong_alias (__ieee754_ynl, __ynl_finite)
w =__log1pl(xa+t/(one+sqrtl(one+t)));
}
}
- return __copysignl(w, x);
+ return copysignl(w, x);
}
libm_alias_ldouble (__asinh, asinh)
* with the sign bit of y.
*/
+#define NO_MATH_REDIRECT
#include <math.h>
#include <math_private.h>
#include <libm-alias-ldouble.h>
}
if (__builtin_expect(k==0x7fff, 0)) return x+x; /* NaN or Inf */
if (__builtin_expect(n< -50000, 0))
- return tiny*__copysignl(tiny,x);
+ return tiny*copysignl(tiny,x);
if (__builtin_expect(n> 50000 || k+n > 0x7ffe, 0))
- return huge*__copysignl(huge,x); /* overflow */
+ return huge*copysignl(huge,x); /* overflow */
/* Now k and n are bounded we know that k = k+n does not
overflow. */
k = k+n;
if (__builtin_expect(k > 0, 1)) /* normal result */
{SET_LDOUBLE_EXP(x,(es&0x8000)|k); return x;}
if (k <= -64)
- return tiny*__copysignl(tiny,x); /*underflow*/
+ return tiny*copysignl(tiny,x); /*underflow*/
k += 64; /* subnormal result */
SET_LDOUBLE_EXP(x,(es&0x8000)|k);
return x*twom64;
attribute_hidden
copysignl (double x, double y)
{
- return __copysign (x, y);
+ return copysign (x, y);
}
if (__builtin_isinf (x))
{
*iptr = x;
- return __copysign (0.0, x);
+ return copysign (0.0, x);
}
else if (__builtin_isnan (x))
{
if (x >= 0.0)
{
*iptr = floor (x);
- return __copysign (x - *iptr, x);
+ return copysign (x - *iptr, x);
}
else
{
*iptr = ceil (x);
- return __copysign (x - *iptr, x);
+ return copysign (x - *iptr, x);
}
}
libm_alias_double (__modf, modf)
if (__builtin_isinff (x))
{
*iptr = x;
- return __copysignf (0.0, x);
+ return copysignf (0.0, x);
}
else if (__builtin_isnanf (x))
{
if (x >= 0.0)
{
*iptr = floorf (x);
- return __copysignf (x - *iptr, x);
+ return copysignf (x - *iptr, x);
}
else
{
*iptr = ceilf (x);
- return __copysignf (x - *iptr, x);
+ return copysignf (x - *iptr, x);
}
}
libm_alias_float (__modf, modf)
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
+#define NO_MATH_REDIRECT
/* Redefine copysign so that the compiler won't complain about the type
mismatch with the IFUNC selector in strong_alias below. */
#undef __copysign
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
+#define NO_MATH_REDIRECT
#include <math.h>
#include <shlib-compat.h>
#include "init-arch.h"
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
+#define NO_MATH_REDIRECT
/* Redefine copysign so that the compiler won't complain about the type
mismatch with the IFUNC selector in strong_alias below. */
#undef __copysign
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
+#define NO_MATH_REDIRECT
#include <math.h>
#include <shlib-compat.h>
#include "init-arch.h"
License along with the GNU C Library. If not, see
<http://www.gnu.org/licenses/>. */
+#define NO_MATH_REDIRECT
#include <math.h>
#include <libm-alias-double.h>
License along with the GNU C Library. If not, see
<http://www.gnu.org/licenses/>. */
+#define NO_MATH_REDIRECT
#include <math.h>
#include <libm-alias-float.h>
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
+#define NO_MATH_REDIRECT
#define __copysign __redirect_copysign
#include <math.h>
#include <math_ldbl_opt.h>
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
+#define NO_MATH_REDIRECT
#include <math.h>
#include <sparc-ifunc.h>
#include <libm-alias-float.h>
projects / thirdparty / glibc.git / commitdiff
