Use copysign functions not __copysign functions in glibc libm [committed]

diff --git a/include/math.h b/include/math.h
index ca9a1f0cd6..79ebbae359 100644
--- a/include/math.h
+++ b/include/math.h
@@ -100,12 +100,14 @@  fabsf128 (_Float128 x)
 #    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
 
diff --git a/math/divtc3.c b/math/divtc3.c
index b1df88bdb7..e83feca837 100644
--- a/math/divtc3.c
+++ b/math/divtc3.c
@@ -51,22 +51,22 @@  __divtc3 (long double a, long double b, long double c, long double d)
     {
       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);
 	}
diff --git a/math/multc3.c b/math/multc3.c
index 9943d705fd..775cbfbcce 100644
--- a/math/multc3.c
+++ b/math/multc3.c
@@ -42,20 +42,20 @@  __multc3 (long double a, long double b, long double c, long double 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
@@ -63,10 +63,10 @@  __multc3 (long double a, long double b, long double c, long double d)
 	      || 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)
diff --git a/sysdeps/alpha/fpu/s_copysign.c b/sysdeps/alpha/fpu/s_copysign.c
index 493615a896..96c294a6af 100644
--- a/sysdeps/alpha/fpu/s_copysign.c
+++ b/sysdeps/alpha/fpu/s_copysign.c
@@ -16,6 +16,7 @@ 
    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>
diff --git a/sysdeps/alpha/fpu/s_copysignf.c b/sysdeps/alpha/fpu/s_copysignf.c
index b92b6d4d77..e814a92c68 100644
--- a/sysdeps/alpha/fpu/s_copysignf.c
+++ b/sysdeps/alpha/fpu/s_copysignf.c
@@ -16,6 +16,7 @@ 
    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>
 
diff --git a/sysdeps/generic/math-type-macros.h b/sysdeps/generic/math-type-macros.h
index 5250815253..40251d595b 100644
--- a/sysdeps/generic/math-type-macros.h
+++ b/sysdeps/generic/math-type-macros.h
@@ -101,7 +101,7 @@ 
 #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)
diff --git a/sysdeps/generic/math_private_calls.h b/sysdeps/generic/math_private_calls.h
index 16b4ea3736..1fd56b8081 100644
--- a/sysdeps/generic/math_private_calls.h
+++ b/sysdeps/generic/math_private_calls.h
@@ -75,15 +75,6 @@  extern int __MSUF (__kernel_rem_pio2) (_Mdouble_ *, _Mdouble_ *, int,
 #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 >=
diff --git a/sysdeps/ieee754/dbl-64/e_atan2.c b/sysdeps/ieee754/dbl-64/e_atan2.c
index c3e1b2218c..741ba9b42c 100644
--- a/sysdeps/ieee754/dbl-64/e_atan2.c
+++ b/sysdeps/ieee754/dbl-64/e_atan2.c
@@ -64,7 +64,7 @@  static double atan2Mp (double, double, const int[]);
 static double
 signArctan2 (double y, double z)
 {
-  return __copysign (z, y);
+  return copysign (z, y);
 }
 
 static double normalized (double, double, double, double);
diff --git a/sysdeps/ieee754/dbl-64/e_atanh.c b/sysdeps/ieee754/dbl-64/e_atanh.c
index da4da8270c..d145b2b923 100644
--- a/sysdeps/ieee754/dbl-64/e_atanh.c
+++ b/sysdeps/ieee754/dbl-64/e_atanh.c
@@ -71,6 +71,6 @@  __ieee754_atanh (double x)
       return x / 0.0;
     }
 
-  return __copysign (t, x);
+  return copysign (t, x);
 }
 strong_alias (__ieee754_atanh, __atanh_finite)
diff --git a/sysdeps/ieee754/dbl-64/e_gamma_r.c b/sysdeps/ieee754/dbl-64/e_gamma_r.c
index 7707c062cb..9692b733e1 100644
--- a/sysdeps/ieee754/dbl-64/e_gamma_r.c
+++ b/sysdeps/ieee754/dbl-64/e_gamma_r.c
@@ -199,22 +199,22 @@  __ieee754_gamma_r (double x, int *signgamp)
     {
       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
diff --git a/sysdeps/ieee754/dbl-64/e_jn.c b/sysdeps/ieee754/dbl-64/e_jn.c
index cb7c6cf266..aff06ead16 100644
--- a/sysdeps/ieee754/dbl-64/e_jn.c
+++ b/sysdeps/ieee754/dbl-64/e_jn.c
@@ -250,7 +250,7 @@  __ieee754_jn (int n, double x)
   }
   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
@@ -344,7 +344,7 @@  __ieee754_yn (int n, double x)
   }
  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)
diff --git a/sysdeps/ieee754/dbl-64/s_asinh.c b/sysdeps/ieee754/dbl-64/s_asinh.c
index 192ff8594d..7fd281d791 100644
--- a/sysdeps/ieee754/dbl-64/s_asinh.c
+++ b/sysdeps/ieee754/dbl-64/s_asinh.c
@@ -65,6 +65,6 @@  __asinh (double x)
 	  w = __log1p (xa + t / (one + sqrt (one + t)));
 	}
     }
-  return __copysign (w, x);
+  return copysign (w, x);
 }
 libm_alias_double (__asinh, asinh)
diff --git a/sysdeps/ieee754/dbl-64/s_atan.c b/sysdeps/ieee754/dbl-64/s_atan.c
index 311c28fe13..e346581fb6 100644
--- a/sysdeps/ieee754/dbl-64/s_atan.c
+++ b/sysdeps/ieee754/dbl-64/s_atan.c
@@ -57,7 +57,7 @@  static double atanMp (double, const int[]);
 static double
 __signArctan (double x, double y)
 {
-  return __copysign (y, x);
+  return copysign (y, x);
 }
 
 
diff --git a/sysdeps/ieee754/dbl-64/s_copysign.c b/sysdeps/ieee754/dbl-64/s_copysign.c
index ab81d732ab..589b088c95 100644
--- a/sysdeps/ieee754/dbl-64/s_copysign.c
+++ b/sysdeps/ieee754/dbl-64/s_copysign.c
@@ -20,6 +20,7 @@  static char rcsid[] = "$NetBSD: s_copysign.c,v 1.8 1995/05/10 20:46:57 jtc Exp $
  * with the sign bit of y.
  */
 
+#define NO_MATH_REDIRECT
 #include <math.h>
 #include <math_private.h>
 #include <libm-alias-double.h>
diff --git a/sysdeps/ieee754/dbl-64/s_scalbln.c b/sysdeps/ieee754/dbl-64/s_scalbln.c
index 32cd12e3b0..0e3d732e48 100644
--- a/sysdeps/ieee754/dbl-64/s_scalbln.c
+++ b/sysdeps/ieee754/dbl-64/s_scalbln.c
@@ -42,9 +42,9 @@  __scalbln (double x, long int n)
   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;
@@ -53,7 +53,7 @@  __scalbln (double x, long int 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;
diff --git a/sysdeps/ieee754/dbl-64/s_scalbn.c b/sysdeps/ieee754/dbl-64/s_scalbn.c
index 58c7e1b33a..cf4d6846ee 100644
--- a/sysdeps/ieee754/dbl-64/s_scalbn.c
+++ b/sysdeps/ieee754/dbl-64/s_scalbn.c
@@ -42,9 +42,9 @@  __scalbn (double x, int n)
   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;
@@ -53,7 +53,7 @@  __scalbn (double x, int 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;
diff --git a/sysdeps/ieee754/dbl-64/s_sin.c b/sysdeps/ieee754/dbl-64/s_sin.c
index db1687edd5..212f83c904 100644
--- a/sysdeps/ieee754/dbl-64/s_sin.c
+++ b/sysdeps/ieee754/dbl-64/s_sin.c
@@ -144,7 +144,7 @@  do_sin (double x, double dx)
   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
@@ -231,7 +231,7 @@  __sin (double x)
     {
       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 ----------------------*/
diff --git a/sysdeps/ieee754/dbl-64/s_sincos.c b/sysdeps/ieee754/dbl-64/s_sincos.c
index 6dc1609fa4..41664c1bd4 100644
--- a/sysdeps/ieee754/dbl-64/s_sincos.c
+++ b/sysdeps/ieee754/dbl-64/s_sincos.c
@@ -63,7 +63,7 @@  __sincos (double x, double *sinx, double *cosx)
       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;
     }
diff --git a/sysdeps/ieee754/dbl-64/wordsize-64/s_nearbyint.c b/sysdeps/ieee754/dbl-64/wordsize-64/s_nearbyint.c
index 2bb59de30b..92fa72af59 100644
--- a/sysdeps/ieee754/dbl-64/wordsize-64/s_nearbyint.c
+++ b/sysdeps/ieee754/dbl-64/wordsize-64/s_nearbyint.c
@@ -49,7 +49,7 @@  __nearbyint(double x)
 		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 */
diff --git a/sysdeps/ieee754/dbl-64/wordsize-64/s_scalbln.c b/sysdeps/ieee754/dbl-64/wordsize-64/s_scalbln.c
index 8dce51e928..071c9d7794 100644
--- a/sysdeps/ieee754/dbl-64/wordsize-64/s_scalbln.c
+++ b/sysdeps/ieee754/dbl-64/wordsize-64/s_scalbln.c
@@ -40,9 +40,9 @@  __scalbln (double x, long int n)
 	    }
 	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;
@@ -50,7 +50,7 @@  __scalbln (double x, long int 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;
diff --git a/sysdeps/ieee754/dbl-64/wordsize-64/s_scalbn.c b/sysdeps/ieee754/dbl-64/wordsize-64/s_scalbn.c
index d517a919c8..4491227f3e 100644
--- a/sysdeps/ieee754/dbl-64/wordsize-64/s_scalbn.c
+++ b/sysdeps/ieee754/dbl-64/wordsize-64/s_scalbn.c
@@ -40,9 +40,9 @@  __scalbn (double x, int n)
 	    }
 	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;
@@ -50,7 +50,7 @@  __scalbn (double x, int 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;
diff --git a/sysdeps/ieee754/float128/s_copysignf128.c b/sysdeps/ieee754/float128/s_copysignf128.c
index 808f7abbc0..fcb5162c66 100644
--- a/sysdeps/ieee754/float128/s_copysignf128.c
+++ b/sysdeps/ieee754/float128/s_copysignf128.c
@@ -1,2 +1,3 @@ 
+#define NO_MATH_REDIRECT
 #include <float128_private.h>
 #include "../ldbl-128/s_copysignl.c"
diff --git a/sysdeps/ieee754/flt-32/e_atanhf.c b/sysdeps/ieee754/flt-32/e_atanhf.c
index 207d759362..db2462ed5a 100644
--- a/sysdeps/ieee754/flt-32/e_atanhf.c
+++ b/sysdeps/ieee754/flt-32/e_atanhf.c
@@ -71,6 +71,6 @@  __ieee754_atanhf (float x)
       return x / 0.0f;
     }
 
-  return __copysignf (t, x);
+  return copysignf (t, x);
 }
 strong_alias (__ieee754_atanhf, __atanhf_finite)
diff --git a/sysdeps/ieee754/flt-32/e_gammaf_r.c b/sysdeps/ieee754/flt-32/e_gammaf_r.c
index 6a9e28a309..af37abbfe7 100644
--- a/sysdeps/ieee754/flt-32/e_gammaf_r.c
+++ b/sysdeps/ieee754/flt-32/e_gammaf_r.c
@@ -191,22 +191,22 @@  __ieee754_gammaf_r (float x, int *signgamp)
     {
       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
diff --git a/sysdeps/ieee754/flt-32/e_jnf.c b/sysdeps/ieee754/flt-32/e_jnf.c
index e8b9425ee0..ae29015424 100644
--- a/sysdeps/ieee754/flt-32/e_jnf.c
+++ b/sysdeps/ieee754/flt-32/e_jnf.c
@@ -174,7 +174,7 @@  __ieee754_jnf(int n, float x)
     }
     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
@@ -230,7 +230,7 @@  __ieee754_ynf(int n, float x)
     }
  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)
diff --git a/sysdeps/ieee754/flt-32/s_asinhf.c b/sysdeps/ieee754/flt-32/s_asinhf.c
index 0812b54dca..13af5db1eb 100644
--- a/sysdeps/ieee754/flt-32/s_asinhf.c
+++ b/sysdeps/ieee754/flt-32/s_asinhf.c
@@ -47,6 +47,6 @@  __asinhf(float x)
 		w =__log1pf(xa+t/(one+sqrtf(one+t)));
 	    }
 	}
-	return __copysignf(w, x);
+	return copysignf(w, x);
 }
 libm_alias_float (__asinh, asinh)
diff --git a/sysdeps/ieee754/flt-32/s_copysignf.c b/sysdeps/ieee754/flt-32/s_copysignf.c
index 3c4ac7ce68..77d1d90e92 100644
--- a/sysdeps/ieee754/flt-32/s_copysignf.c
+++ b/sysdeps/ieee754/flt-32/s_copysignf.c
@@ -23,6 +23,7 @@  static char rcsid[] = "$NetBSD: s_copysignf.c,v 1.4 1995/05/10 20:46:59 jtc Exp
  * with the sign bit of y.
  */
 
+#define NO_MATH_REDIRECT
 #include <math.h>
 #include <math_private.h>
 #include <libm-alias-float.h>
diff --git a/sysdeps/ieee754/flt-32/s_scalbnf.c b/sysdeps/ieee754/flt-32/s_scalbnf.c
index f36ae241b2..1a760f767a 100644
--- a/sysdeps/ieee754/flt-32/s_scalbnf.c
+++ b/sysdeps/ieee754/flt-32/s_scalbnf.c
@@ -36,16 +36,16 @@  __scalbnf (float x, int n)
 	    }
 	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;
diff --git a/sysdeps/ieee754/k_standard.c b/sysdeps/ieee754/k_standard.c
index f71a837980..826f19785a 100644
--- a/sysdeps/ieee754/k_standard.c
+++ b/sysdeps/ieee754/k_standard.c
@@ -693,7 +693,7 @@  __kernel_standard(double x, double y, int type)
 		/* 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)) {
@@ -808,7 +808,7 @@  __kernel_standard(double x, double y, int type)
 		/* 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)) {
@@ -930,7 +930,7 @@  __kernel_standard(double x, double y, int type)
 		/* 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)) {
diff --git a/sysdeps/ieee754/ldbl-128/e_gammal_r.c b/sysdeps/ieee754/ldbl-128/e_gammal_r.c
index 837395e1fd..b8690b0c96 100644
--- a/sysdeps/ieee754/ldbl-128/e_gammal_r.c
+++ b/sysdeps/ieee754/ldbl-128/e_gammal_r.c
@@ -203,16 +203,16 @@  __ieee754_gammal_r (_Float128 x, int *signgamp)
   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;
diff --git a/sysdeps/ieee754/ldbl-128/e_jnl.c b/sysdeps/ieee754/ldbl-128/e_jnl.c
index 540b95ca58..7610d18c67 100644
--- a/sysdeps/ieee754/ldbl-128/e_jnl.c
+++ b/sysdeps/ieee754/ldbl-128/e_jnl.c
@@ -299,7 +299,7 @@  __ieee754_jnl (int n, _Float128 x)
   }
   if (ret == 0)
     {
-      ret = __copysignl (LDBL_MIN, ret) * LDBL_MIN;
+      ret = copysignl (LDBL_MIN, ret) * LDBL_MIN;
       __set_errno (ERANGE);
     }
   else
@@ -415,7 +415,7 @@  __ieee754_ynl (int n, _Float128 x)
   }
  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)
diff --git a/sysdeps/ieee754/ldbl-128/s_copysignl.c b/sysdeps/ieee754/ldbl-128/s_copysignl.c
index d23e0f72ea..a501139f71 100644
--- a/sysdeps/ieee754/ldbl-128/s_copysignl.c
+++ b/sysdeps/ieee754/ldbl-128/s_copysignl.c
@@ -23,6 +23,7 @@  static char rcsid[] = "$NetBSD: $";
  * with the sign bit of y.
  */
 
+#define NO_MATH_REDIRECT
 #include <math.h>
 #include <math_private.h>
 #include <libm-alias-ldouble.h>
diff --git a/sysdeps/ieee754/ldbl-128/s_scalblnl.c b/sysdeps/ieee754/ldbl-128/s_scalblnl.c
index 5864eaf93c..590b2ca023 100644
--- a/sysdeps/ieee754/ldbl-128/s_scalblnl.c
+++ b/sysdeps/ieee754/ldbl-128/s_scalblnl.c
@@ -46,16 +46,16 @@  _Float128 __scalblnl (_Float128 x, long int n)
 	    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;
diff --git a/sysdeps/ieee754/ldbl-128/s_scalbnl.c b/sysdeps/ieee754/ldbl-128/s_scalbnl.c
index e6fe796079..ad9a0b105a 100644
--- a/sysdeps/ieee754/ldbl-128/s_scalbnl.c
+++ b/sysdeps/ieee754/ldbl-128/s_scalbnl.c
@@ -46,16 +46,16 @@  _Float128 __scalbnl (_Float128 x, int n)
 	    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;
diff --git a/sysdeps/ieee754/ldbl-128ibm/e_gammal_r.c b/sysdeps/ieee754/ldbl-128ibm/e_gammal_r.c
index 6361d35428..e648ca1a27 100644
--- a/sysdeps/ieee754/ldbl-128ibm/e_gammal_r.c
+++ b/sysdeps/ieee754/ldbl-128ibm/e_gammal_r.c
@@ -203,16 +203,16 @@  __ieee754_gammal_r (long double x, int *signgamp)
   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;
diff --git a/sysdeps/ieee754/ldbl-128ibm/e_jnl.c b/sysdeps/ieee754/ldbl-128ibm/e_jnl.c
index 208def09c9..50b4558e74 100644
--- a/sysdeps/ieee754/ldbl-128ibm/e_jnl.c
+++ b/sysdeps/ieee754/ldbl-128ibm/e_jnl.c
@@ -299,7 +299,7 @@  __ieee754_jnl (int n, long double x)
   }
   if (ret == 0)
     {
-      ret = __copysignl (LDBL_MIN, ret) * LDBL_MIN;
+      ret = copysignl (LDBL_MIN, ret) * LDBL_MIN;
       __set_errno (ERANGE);
     }
   else
@@ -417,7 +417,7 @@  __ieee754_ynl (int n, long double x)
   }
  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)
diff --git a/sysdeps/ieee754/ldbl-128ibm/s_copysignl.c b/sysdeps/ieee754/ldbl-128ibm/s_copysignl.c
index 3b8ec1a74d..4214853fed 100644
--- a/sysdeps/ieee754/ldbl-128ibm/s_copysignl.c
+++ b/sysdeps/ieee754/ldbl-128ibm/s_copysignl.c
@@ -23,6 +23,7 @@  static char rcsid[] = "$NetBSD: $";
  * with the sign bit of y.
  */
 
+#define NO_MATH_REDIRECT
 #include <math.h>
 #include <math_private.h>
 #include <math_ldbl_opt.h>
diff --git a/sysdeps/ieee754/ldbl-128ibm/s_fmal.c b/sysdeps/ieee754/ldbl-128ibm/s_fmal.c
index bc61e9049c..5b55268c21 100644
--- a/sysdeps/ieee754/ldbl-128ibm/s_fmal.c
+++ b/sysdeps/ieee754/ldbl-128ibm/s_fmal.c
@@ -244,7 +244,7 @@  __fmal (long double x, long double y, long double z)
   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;
 
diff --git a/sysdeps/ieee754/ldbl-128ibm/s_scalblnl.c b/sysdeps/ieee754/ldbl-128ibm/s_scalblnl.c
index 031635267f..b6a2d30736 100644
--- a/sysdeps/ieee754/ldbl-128ibm/s_scalblnl.c
+++ b/sysdeps/ieee754/ldbl-128ibm/s_scalblnl.c
@@ -56,9 +56,9 @@  long double __scalblnl (long double x, long int n)
 	    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;
@@ -93,7 +93,7 @@  long double __scalblnl (long double x, long int 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;
diff --git a/sysdeps/ieee754/ldbl-128ibm/s_scalbnl.c b/sysdeps/ieee754/ldbl-128ibm/s_scalbnl.c
index 0c4508835e..bbefa86661 100644
--- a/sysdeps/ieee754/ldbl-128ibm/s_scalbnl.c
+++ b/sysdeps/ieee754/ldbl-128ibm/s_scalbnl.c
@@ -56,9 +56,9 @@  long double __scalbnl (long double x, int n)
 	    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;
@@ -93,7 +93,7 @@  long double __scalbnl (long double x, int 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;
diff --git a/sysdeps/ieee754/ldbl-96/e_gammal_r.c b/sysdeps/ieee754/ldbl-96/e_gammal_r.c
index 49428eba44..c4a166db2d 100644
--- a/sysdeps/ieee754/ldbl-96/e_gammal_r.c
+++ b/sysdeps/ieee754/ldbl-96/e_gammal_r.c
@@ -195,16 +195,16 @@  __ieee754_gammal_r (long double x, int *signgamp)
   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;
diff --git a/sysdeps/ieee754/ldbl-96/e_jnl.c b/sysdeps/ieee754/ldbl-96/e_jnl.c
index fd28f6ae91..855190841b 100644
--- a/sysdeps/ieee754/ldbl-96/e_jnl.c
+++ b/sysdeps/ieee754/ldbl-96/e_jnl.c
@@ -292,7 +292,7 @@  __ieee754_jnl (int n, long double x)
   }
   if (ret == 0)
     {
-      ret = __copysignl (LDBL_MIN, ret) * LDBL_MIN;
+      ret = copysignl (LDBL_MIN, ret) * LDBL_MIN;
       __set_errno (ERANGE);
     }
   else
@@ -400,7 +400,7 @@  __ieee754_ynl (int n, long double x)
   }
  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)
diff --git a/sysdeps/ieee754/ldbl-96/s_asinhl.c b/sysdeps/ieee754/ldbl-96/s_asinhl.c
index 2b9ae1f677..0edd332150 100644
--- a/sysdeps/ieee754/ldbl-96/s_asinhl.c
+++ b/sysdeps/ieee754/ldbl-96/s_asinhl.c
@@ -62,6 +62,6 @@  long double __asinhl(long double x)
 		w =__log1pl(xa+t/(one+sqrtl(one+t)));
 	    }
 	}
-	return __copysignl(w, x);
+	return copysignl(w, x);
 }
 libm_alias_ldouble (__asinh, asinh)
diff --git a/sysdeps/ieee754/ldbl-96/s_copysignl.c b/sysdeps/ieee754/ldbl-96/s_copysignl.c
index 3c16d54783..d0a6dc163a 100644
--- a/sysdeps/ieee754/ldbl-96/s_copysignl.c
+++ b/sysdeps/ieee754/ldbl-96/s_copysignl.c
@@ -24,6 +24,7 @@  static char rcsid[] = "$NetBSD: $";
  * with the sign bit of y.
  */
 
+#define NO_MATH_REDIRECT
 #include <math.h>
 #include <math_private.h>
 #include <libm-alias-ldouble.h>
diff --git a/sysdeps/ieee754/ldbl-96/s_scalblnl.c b/sysdeps/ieee754/ldbl-96/s_scalblnl.c
index 457e999c6c..d752248037 100644
--- a/sysdeps/ieee754/ldbl-96/s_scalblnl.c
+++ b/sysdeps/ieee754/ldbl-96/s_scalblnl.c
@@ -44,16 +44,16 @@  __scalblnl (long double x, long int n)
 	    }
 	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;
diff --git a/sysdeps/ieee754/ldbl-opt/nldbl-copysign.c b/sysdeps/ieee754/ldbl-opt/nldbl-copysign.c
index 045f00dda8..ef23badecc 100644
--- a/sysdeps/ieee754/ldbl-opt/nldbl-copysign.c
+++ b/sysdeps/ieee754/ldbl-opt/nldbl-copysign.c
@@ -4,5 +4,5 @@  double
 attribute_hidden
 copysignl (double x, double y)
 {
-  return __copysign (x, y);
+  return copysign (x, y);
 }
diff --git a/sysdeps/powerpc/power5+/fpu/s_modf.c b/sysdeps/powerpc/power5+/fpu/s_modf.c
index 20c828c778..b8ff8dbdb3 100644
--- a/sysdeps/powerpc/power5+/fpu/s_modf.c
+++ b/sysdeps/powerpc/power5+/fpu/s_modf.c
@@ -26,7 +26,7 @@  __modf (double x, double *iptr)
   if (__builtin_isinf (x))
     {
       *iptr = x;
-      return __copysign (0.0, x);
+      return copysign (0.0, x);
     }
   else if (__builtin_isnan (x))
     {
@@ -37,12 +37,12 @@  __modf (double x, double *iptr)
   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)
diff --git a/sysdeps/powerpc/power5+/fpu/s_modff.c b/sysdeps/powerpc/power5+/fpu/s_modff.c
index 807bfe1e03..9f11116691 100644
--- a/sysdeps/powerpc/power5+/fpu/s_modff.c
+++ b/sysdeps/powerpc/power5+/fpu/s_modff.c
@@ -25,7 +25,7 @@  __modff (float x, float *iptr)
   if (__builtin_isinff (x))
     {
       *iptr = x;
-      return __copysignf (0.0, x);
+      return copysignf (0.0, x);
     }
   else if (__builtin_isnanf (x))
     {
@@ -36,12 +36,12 @@  __modff (float x, float *iptr)
   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)
diff --git a/sysdeps/powerpc/powerpc32/power4/fpu/multiarch/s_copysign.c b/sysdeps/powerpc/powerpc32/power4/fpu/multiarch/s_copysign.c
index 86df7d6bc2..f2a6f9b23b 100644
--- a/sysdeps/powerpc/powerpc32/power4/fpu/multiarch/s_copysign.c
+++ b/sysdeps/powerpc/powerpc32/power4/fpu/multiarch/s_copysign.c
@@ -16,6 +16,7 @@ 
    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
diff --git a/sysdeps/powerpc/powerpc32/power4/fpu/multiarch/s_copysignf.c b/sysdeps/powerpc/powerpc32/power4/fpu/multiarch/s_copysignf.c
index d2900b3287..6dd869bfcd 100644
--- a/sysdeps/powerpc/powerpc32/power4/fpu/multiarch/s_copysignf.c
+++ b/sysdeps/powerpc/powerpc32/power4/fpu/multiarch/s_copysignf.c
@@ -16,6 +16,7 @@ 
    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"
diff --git a/sysdeps/powerpc/powerpc64/fpu/multiarch/s_copysign.c b/sysdeps/powerpc/powerpc64/fpu/multiarch/s_copysign.c
index 74ce097397..9cb5e39c3c 100644
--- a/sysdeps/powerpc/powerpc64/fpu/multiarch/s_copysign.c
+++ b/sysdeps/powerpc/powerpc64/fpu/multiarch/s_copysign.c
@@ -16,6 +16,7 @@ 
    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
diff --git a/sysdeps/powerpc/powerpc64/fpu/multiarch/s_copysignf.c b/sysdeps/powerpc/powerpc64/fpu/multiarch/s_copysignf.c
index 377a3f814c..c76c3f6877 100644
--- a/sysdeps/powerpc/powerpc64/fpu/multiarch/s_copysignf.c
+++ b/sysdeps/powerpc/powerpc64/fpu/multiarch/s_copysignf.c
@@ -16,6 +16,7 @@ 
    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"
diff --git a/sysdeps/riscv/rvd/s_copysign.c b/sysdeps/riscv/rvd/s_copysign.c
index 36fef55aa2..b3f52aa77b 100644
--- a/sysdeps/riscv/rvd/s_copysign.c
+++ b/sysdeps/riscv/rvd/s_copysign.c
@@ -16,6 +16,7 @@ 
    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>
 
diff --git a/sysdeps/riscv/rvf/s_copysignf.c b/sysdeps/riscv/rvf/s_copysignf.c
index 4d1c122f7e..60473b0cbf 100644
--- a/sysdeps/riscv/rvf/s_copysignf.c
+++ b/sysdeps/riscv/rvf/s_copysignf.c
@@ -16,6 +16,7 @@ 
    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>
 
diff --git a/sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_copysign.c b/sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_copysign.c
index 291e697d99..fe7c3eb62b 100644
--- a/sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_copysign.c
+++ b/sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_copysign.c
@@ -16,6 +16,7 @@ 
    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>
diff --git a/sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_copysignf.c b/sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_copysignf.c
index c051167b48..b8a9855214 100644
--- a/sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_copysignf.c
+++ b/sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_copysignf.c
@@ -16,6 +16,7 @@ 
    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>