+2018-09-14 Joseph Myers <joseph@codesourcery.com>
+
+ * include/math.h [!_ISOMAC && !(__FINITE_MATH_ONLY__ &&
+ __FINITE_MATH_ONLY__ > 0) && !NO_MATH_REDIRECT] (MATH_REDIRECT):
+ New macro.
+ [!_ISOMAC && !(__FINITE_MATH_ONLY__ && __FINITE_MATH_ONLY__ > 0)
+ && !NO_MATH_REDIRECT] (MATH_REDIRECT_LDBL): Likewise.
+ [!_ISOMAC && !(__FINITE_MATH_ONLY__ && __FINITE_MATH_ONLY__ > 0)
+ && !NO_MATH_REDIRECT] (MATH_REDIRECT_F128): Likewise.
+ [!_ISOMAC && !(__FINITE_MATH_ONLY__ && __FINITE_MATH_ONLY__ > 0)
+ && !NO_MATH_REDIRECT] (MATH_REDIRECT_UNARY_ARGS): Likewise.
+ [!_ISOMAC && !(__FINITE_MATH_ONLY__ && __FINITE_MATH_ONLY__ > 0)
+ && !NO_MATH_REDIRECT] (sqrt): Redirect using MATH_REDIRECT.
+ [!_ISOMAC && !(__FINITE_MATH_ONLY__ && __FINITE_MATH_ONLY__ > 0)
+ && !NO_MATH_REDIRECT] (floor): Likewise.
+ * sysdeps/aarch64/fpu/s_floor.c: Define NO_MATH_REDIRECT before
+ header inclusion.
+ * sysdeps/aarch64/fpu/s_floorf.c: Likewise.
+ * sysdeps/ieee754/dbl-64/s_floor.c: Likewise.
+ * sysdeps/ieee754/dbl-64/wordsize-64/s_floor.c: Likewise.
+ * sysdeps/ieee754/float128/s_floorf128.c: Likewise.
+ * sysdeps/ieee754/flt-32/s_floorf.c: Likewise.
+ * sysdeps/ieee754/ldbl-128/s_floorl.c: Likewise.
+ * sysdeps/ieee754/ldbl-128ibm/s_floorl.c: Likewise.
+ * sysdeps/m68k/m680x0/fpu/s_floor_template.c: Likewise.
+ * sysdeps/powerpc/powerpc32/power4/fpu/multiarch/s_floor.c: Likewise.
+ * sysdeps/powerpc/powerpc32/power4/fpu/multiarch/s_floorf.c: Likewise.
+ * sysdeps/powerpc/powerpc64/fpu/multiarch/s_floor.c: Likewise.
+ * sysdeps/powerpc/powerpc64/fpu/multiarch/s_floorf.c: Likewise.
+ * sysdeps/riscv/rv64/rvd/s_floor.c: Likewise.
+ * sysdeps/riscv/rvf/s_floorf.c: Likewise.
+ * sysdeps/sparc/sparc64/fpu/multiarch/s_floor.c: Likewise.
+ * sysdeps/sparc/sparc64/fpu/multiarch/s_floorf.c: Likewise.
+ * sysdeps/x86_64/fpu/multiarch/s_floor.c: Likewise.
+ * sysdeps/x86_64/fpu/multiarch/s_floorf.c: Likewise.
+ * sysdeps/powerpc/fpu/math_private.h [_ARCH_PWR5X] (__floor):
+ Remove macro.
+ [_ARCH_PWR5X] (__floorf): Likewise.
+ * sysdeps/x86_64/fpu/math_private.h [__SSE4_1__] (__floor): Remove
+ inline function.
+ [__SSE4_1__] (__floorf): Likewise.
+ * math/w_lgamma_main.c (LGFUNC (__lgamma)): Use floor functions
+ instead of __floor variants.
+ * math/w_lgamma_r_compat.c (__lgamma_r): Likewise.
+ * math/w_lgammaf_main.c (LGFUNC (__lgammaf)): Likewise.
+ * math/w_lgammaf_r_compat.c (__lgammaf_r): Likewise.
+ * math/w_lgammal_main.c (LGFUNC (__lgammal)): Likewise.
+ * math/w_lgammal_r_compat.c (__lgammal_r): Likewise.
+ * math/w_tgamma_compat.c (__tgamma): Likewise.
+ * math/w_tgamma_template.c (M_DECL_FUNC (__tgamma)): Likewise.
+ * math/w_tgammaf_compat.c (__tgammaf): Likewise.
+ * math/w_tgammal_compat.c (__tgammal): Likewise.
+ * sysdeps/ieee754/dbl-64/e_lgamma_r.c (sin_pi): Likewise.
+ * sysdeps/ieee754/dbl-64/k_rem_pio2.c (__kernel_rem_pio2):
+ Likewise.
+ * sysdeps/ieee754/dbl-64/lgamma_neg.c (__lgamma_neg): Likewise.
+ * sysdeps/ieee754/flt-32/e_lgammaf_r.c (sin_pif): Likewise.
+ * sysdeps/ieee754/flt-32/lgamma_negf.c (__lgamma_negf): Likewise.
+ * sysdeps/ieee754/ldbl-128/e_lgammal_r.c (__ieee754_lgammal_r):
+ Likewise.
+ * sysdeps/ieee754/ldbl-128/e_powl.c (__ieee754_powl): Likewise.
+ * sysdeps/ieee754/ldbl-128/lgamma_negl.c (__lgamma_negl):
+ Likewise.
+ * sysdeps/ieee754/ldbl-128/s_expm1l.c (__expm1l): Likewise.
+ * sysdeps/ieee754/ldbl-128ibm/e_lgammal_r.c (__ieee754_lgammal_r):
+ Likewise.
+ * sysdeps/ieee754/ldbl-128ibm/e_powl.c (__ieee754_powl): Likewise.
+ * sysdeps/ieee754/ldbl-128ibm/lgamma_negl.c (__lgamma_negl):
+ Likewise.
+ * sysdeps/ieee754/ldbl-128ibm/s_expm1l.c (__expm1l): Likewise.
+ * sysdeps/ieee754/ldbl-128ibm/s_truncl.c (__truncl): Likewise.
+ * sysdeps/ieee754/ldbl-96/e_lgammal_r.c (sin_pi): Likewise.
+ * sysdeps/ieee754/ldbl-96/lgamma_negl.c (__lgamma_negl): Likewise.
+ * sysdeps/powerpc/power5+/fpu/s_modf.c (__modf): Likewise.
+ * sysdeps/powerpc/power5+/fpu/s_modff.c (__modff): Likewise.
+
2018-09-12 Joseph Myers <joseph@codesourcery.com>
* elf/Makefile (modules-names-tests): New variable.
# if !(defined __FINITE_MATH_ONLY__ && __FINITE_MATH_ONLY__ > 0)
# ifndef NO_MATH_REDIRECT
-/* Declare sqrt for use within GLIBC. Compilers typically inline sqrt as a
- single instruction. Use an asm to avoid use of PLTs if it doesn't. */
-float (sqrtf) (float) asm ("__ieee754_sqrtf");
-double (sqrt) (double) asm ("__ieee754_sqrt");
-# ifndef __NO_LONG_DOUBLE_MATH
-long double (sqrtl) (long double) asm ("__ieee754_sqrtl");
+/* Declare some functions for use within GLIBC. Compilers typically
+ inline those functions as a single instruction. Use an asm to
+ avoid use of PLTs if it doesn't. */
+# define MATH_REDIRECT(FUNC, PREFIX, ARGS) \
+ float (FUNC ## f) (ARGS (float)) asm (PREFIX #FUNC "f"); \
+ double (FUNC) (ARGS (double)) asm (PREFIX #FUNC ); \
+ MATH_REDIRECT_LDBL (FUNC, PREFIX, ARGS) \
+ MATH_REDIRECT_F128 (FUNC, PREFIX, ARGS)
+# ifdef __NO_LONG_DOUBLE_MATH
+# define MATH_REDIRECT_LDBL(FUNC, PREFIX, ARGS)
+# else
+# define MATH_REDIRECT_LDBL(FUNC, PREFIX, ARGS) \
+ long double (FUNC ## l) (ARGS (long double)) asm (PREFIX #FUNC "l");
# endif
-# if __HAVE_DISTINCT_FLOAT128 > 0
-_Float128 (sqrtf128) (_Float128) asm ("__ieee754_sqrtf128");
+# if __HAVE_DISTINCT_FLOAT128
+# define MATH_REDIRECT_F128(FUNC, PREFIX, ARGS) \
+ _Float128 (FUNC ## f128) (ARGS (_Float128)) asm (PREFIX #FUNC "f128");
+# else
+# define MATH_REDIRECT_F128(FUNC, PREFIX, ARGS)
# endif
+# define MATH_REDIRECT_UNARY_ARGS(TYPE) TYPE
+MATH_REDIRECT (sqrt, "__ieee754_", MATH_REDIRECT_UNARY_ARGS)
+MATH_REDIRECT (floor, "__", MATH_REDIRECT_UNARY_ARGS)
# endif
# endif
if(__builtin_expect(!isfinite(y), 0)
&& isfinite(x) && _LIB_VERSION != _IEEE_)
return __kernel_standard(x, x,
- __floor(x)==x&&x<=0.0
+ floor(x)==x&&x<=0.0
? 15 /* lgamma pole */
: 14); /* lgamma overflow */
if(__builtin_expect(!isfinite(y), 0)
&& isfinite(x) && _LIB_VERSION != _IEEE_)
return __kernel_standard(x, x,
- __floor(x)==x&&x<=0.0
+ floor(x)==x&&x<=0.0
? 15 /* lgamma pole */
: 14); /* lgamma overflow */
if(__builtin_expect(!isfinite(y), 0)
&& isfinite(x) && _LIB_VERSION != _IEEE_)
return __kernel_standard_f(x, x,
- __floorf(x)==x&&x<=0.0f
+ floorf(x)==x&&x<=0.0f
? 115 /* lgamma pole */
: 114); /* lgamma overflow */
if(__builtin_expect(!isfinite(y), 0)
&& isfinite(x) && _LIB_VERSION != _IEEE_)
return __kernel_standard_f(x, x,
- __floorf(x)==x&&x<=0.0f
+ floorf(x)==x&&x<=0.0f
? 115 /* lgamma pole */
: 114); /* lgamma overflow */
if(__builtin_expect(!isfinite(y), 0)
&& isfinite(x) && _LIB_VERSION != _IEEE_)
return __kernel_standard_l(x, x,
- __floorl(x)==x&&x<=0.0L
+ floorl(x)==x&&x<=0.0L
? 215 /* lgamma pole */
: 214); /* lgamma overflow */
if(__builtin_expect(!isfinite(y), 0)
&& isfinite(x) && _LIB_VERSION != _IEEE_)
return __kernel_standard(x, x,
- __floorl(x)==x&&x<=0.0
+ floorl(x)==x&&x<=0.0
? 215 /* lgamma pole */
: 214); /* lgamma overflow */
&& _LIB_VERSION != _IEEE_) {
if (x == 0.0)
return __kernel_standard(x,x,50); /* tgamma pole */
- else if(__floor(x)==x&&x<0.0)
+ else if(floor(x)==x&&x<0.0)
return __kernel_standard(x,x,41); /* tgamma domain */
else if (y == 0)
__set_errno (ERANGE); /* tgamma underflow */
if (x == 0)
/* Pole error: tgamma(x=0). */
__set_errno (ERANGE);
- else if (M_SUF (__floor) (x) == x && x < 0)
+ else if (M_SUF (floor) (x) == x && x < 0)
/* Domain error: tgamma(integer x<0). */
__set_errno (EDOM);
else
if (x == (float)0.0)
/* tgammaf pole */
return __kernel_standard_f(x, x, 150);
- else if(__floorf(x)==x&&x<0.0f)
+ else if(floorf(x)==x&&x<0.0f)
/* tgammaf domain */
return __kernel_standard_f(x, x, 141);
else if (y == 0)
&& _LIB_VERSION != _IEEE_) {
if(x==0.0)
return __kernel_standard_l(x,x,250); /* tgamma pole */
- else if(__floorl(x)==x&&x<0.0L)
+ else if(floorl(x)==x&&x<0.0L)
return __kernel_standard_l(x,x,241); /* tgamma domain */
else if (y == 0)
__set_errno (ERANGE); /* tgamma underflow */
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>
* argument reduction, make sure inexact flag not raised if input
* is an integer
*/
- z = __floor(y);
+ z = floor(y);
if(z!=y) { /* inexact anyway */
y *= 0.5;
- y = 2.0*(y - __floor(y)); /* y = |x| mod 2.0 */
+ y = 2.0*(y - floor(y)); /* y = |x| mod 2.0 */
n = (int) (y*4.0);
} else {
if(ix>=0x43400000) {
/* compute n */
z = __scalbn (z, q0); /* actual value of z */
- z -= 8.0 * __floor (z * 0.125); /* trim off integer >= 8 */
+ z -= 8.0 * floor (z * 0.125); /* trim off integer >= 8 */
n = (int32_t) z;
z -= (double) n;
ih = 0;
{
/* Determine the half-integer region X lies in, handle exact
integers and determine the sign of the result. */
- int i = __floor (-2 * x);
+ int i = floor (-2 * x);
if ((i & 1) == 0 && i == -2 * x)
return 1.0 / 0.0;
double xn = ((i & 1) == 0 ? -i / 2 : (-i - 1) / 2);
approximations to an adjusted version of the gamma function. */
if (i < 2)
{
- int j = __floor (-8 * x) - 16;
+ int j = floor (-8 * x) - 16;
double xm = (-33 - 2 * j) * 0.0625;
double x_adj = x - xm;
size_t deg = poly_deg[j];
* Bit twiddling.
*/
+#define NO_MATH_REDIRECT
#include <math.h>
#include <math_private.h>
#include <libm-alias-double.h>
* ====================================================
*/
+#define NO_MATH_REDIRECT
#include <math.h>
#include <math_private.h>
#include <stdint.h>
+#define NO_MATH_REDIRECT
#include <float128_private.h>
#include "../ldbl-128/s_floorl.c"
* argument reduction, make sure inexact flag not raised if input
* is an integer
*/
- z = __floorf(y);
+ z = floorf(y);
if(z!=y) { /* inexact anyway */
y *= (float)0.5;
- y = (float)2.0*(y - __floorf(y)); /* y = |x| mod 2.0 */
+ y = (float)2.0*(y - floorf(y)); /* y = |x| mod 2.0 */
n = (int) (y*(float)4.0);
} else {
if(ix>=0x4b800000) {
{
/* Determine the half-integer region X lies in, handle exact
integers and determine the sign of the result. */
- int i = __floorf (-2 * x);
+ int i = floorf (-2 * x);
if ((i & 1) == 0 && i == -2 * x)
return 1.0f / 0.0f;
float xn = ((i & 1) == 0 ? -i / 2 : (-i - 1) / 2);
approximations to an adjusted version of the gamma function. */
if (i < 2)
{
- int j = __floorf (-8 * x) - 16;
+ int j = floorf (-8 * x) - 16;
float xm = (-33 - 2 * j) * 0.0625f;
float x_adj = x - xm;
size_t deg = poly_deg[j];
* Bit twiddling.
*/
+#define NO_MATH_REDIRECT
#include <math.h>
#include <math_private.h>
#include <libm-alias-float.h>
if (x < -2 && x > -50)
return __lgamma_negl (x, signgamp);
q = -x;
- p = __floorl (q);
+ p = floorl (q);
if (p == q)
return (one / fabsl (p - p));
_Float128 halfp = p * L(0.5);
- if (halfp == __floorl (halfp))
+ if (halfp == floorl (halfp))
*signgamp = -1;
else
*signgamp = 1;
if (x < L(13.5))
{
p = 0;
- nx = __floorl (x + L(0.5));
+ nx = floorl (x + L(0.5));
nn = nx;
switch (nn)
{
yisint = 2; /* even integer y */
else if (iy >= 0x3fff0000) /* 1.0 */
{
- if (__floorl (y) == y)
+ if (floorl (y) == y)
{
z = 0.5 * y;
- if (__floorl (z) == z)
+ if (floorl (z) == z)
yisint = 2;
else
yisint = 1;
n = 0;
if (i > 0x3ffe0000)
{ /* if |z| > 0.5, set n = [z+0.5] */
- n = __floorl (z + L(0.5));
+ n = floorl (z + L(0.5));
t = n;
p_h -= t;
}
{
/* Determine the half-integer region X lies in, handle exact
integers and determine the sign of the result. */
- int i = __floorl (-2 * x);
+ int i = floorl (-2 * x);
if ((i & 1) == 0 && i == -2 * x)
return L(1.0) / L(0.0);
_Float128 xn = ((i & 1) == 0 ? -i / 2 : (-i - 1) / 2);
approximations to an adjusted version of the gamma function. */
if (i < 2)
{
- int j = __floorl (-8 * x) - 16;
+ int j = floorl (-8 * x) - 16;
_Float128 xm = (-33 - 2 * j) * L(0.0625);
_Float128 x_adj = x - xm;
size_t deg = poly_deg[j];
/* Express x = ln 2 (k + remainder), remainder not exceeding 1/2. */
xx = C1 + C2; /* ln 2. */
- px = __floorl (0.5 + x / xx);
+ px = floorl (0.5 + x / xx);
k = px;
/* remainder times ln 2 */
x -= px * C1;
* Bit twiddling.
*/
+#define NO_MATH_REDIRECT
#include <math.h>
#include <math_private.h>
#include <libm-alias-ldouble.h>
if (x < -2 && x > -48)
return __lgamma_negl (x, signgamp);
q = -x;
- p = __floorl (q);
+ p = floorl (q);
if (p == q)
return (one / fabsl (p - p));
long double halfp = p * 0.5L;
- if (halfp == __floorl (halfp))
+ if (halfp == floorl (halfp))
*signgamp = -1;
else
*signgamp = 1;
if (x < 13.5L)
{
p = 0;
- nx = __floorl (x + 0.5L);
+ nx = floorl (x + 0.5L);
nn = nx;
switch (nn)
{
yisint = 2; /* even integer y */
else if (iy >= 0x3ff00000) /* 1.0 */
{
- if (__floorl (y) == y)
+ if (floorl (y) == y)
{
z = 0.5 * y;
- if (__floorl (z) == z)
+ if (floorl (z) == z)
yisint = 2;
else
yisint = 1;
n = 0;
if (i > 0x3fe00000)
{ /* if |z| > 0.5, set n = [z+0.5] */
- n = __floorl (z + 0.5L);
+ n = floorl (z + 0.5L);
t = n;
p_h -= t;
}
{
/* Determine the half-integer region X lies in, handle exact
integers and determine the sign of the result. */
- int i = __floorl (-2 * x);
+ int i = floorl (-2 * x);
if ((i & 1) == 0 && i == -2 * x)
return 1.0L / 0.0L;
long double xn = ((i & 1) == 0 ? -i / 2 : (-i - 1) / 2);
approximations to an adjusted version of the gamma function. */
if (i < 2)
{
- int j = __floorl (-8 * x) - 16;
+ int j = floorl (-8 * x) - 16;
long double xm = (-33 - 2 * j) * 0.0625L;
long double x_adj = x - xm;
size_t deg = poly_deg[j];
/* Express x = ln 2 (k + remainder), remainder not exceeding 1/2. */
xx = C1 + C2; /* ln 2. */
- px = __floorl (0.5 + x / xx);
+ px = floorl (0.5 + x / xx);
k = px;
/* remainder times ln 2 */
x -= px * C1;
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
+#define NO_MATH_REDIRECT
#include <math.h>
#include <math_private.h>
#include <math_ldbl_opt.h>
else
{
/* The high part is a nonzero integer. */
- lo = xh > 0 ? __floor (xl) : __ceil (xl);
+ lo = xh > 0 ? floor (xl) : __ceil (xl);
xh = hi;
xl = lo;
ldbl_canonicalize_int (&xh, &xl);
* argument reduction, make sure inexact flag not raised if input
* is an integer
*/
- z = __floorl (y);
+ z = floorl (y);
if (z != y)
{ /* inexact anyway */
y *= 0.5;
- y = 2.0*(y - __floorl(y)); /* y = |x| mod 2.0 */
+ y = 2.0*(y - floorl(y)); /* y = |x| mod 2.0 */
n = (int) (y*4.0);
}
else
{
/* Determine the half-integer region X lies in, handle exact
integers and determine the sign of the result. */
- int i = __floorl (-2 * x);
+ int i = floorl (-2 * x);
if ((i & 1) == 0 && i == -2 * x)
return 1.0L / 0.0L;
long double xn = ((i & 1) == 0 ? -i / 2 : (-i - 1) / 2);
approximations to an adjusted version of the gamma function. */
if (i < 2)
{
- int j = __floorl (-8 * x) - 16;
+ int j = floorl (-8 * x) - 16;
long double xm = (-33 - 2 * j) * 0.0625L;
long double x_adj = x - xm;
size_t deg = poly_deg[j];
License along with the GNU C Library. If not, see
<http://www.gnu.org/licenses/>. */
+#define NO_MATH_REDIRECT
#include <math.h>
FLOAT
__z; })
# endif
-# ifndef __floor
-# define __floor(x) \
- ({ double __z; \
- __asm __volatile ( \
- " frim %0,%1\n" \
- : "=f" (__z) \
- : "f" (x)); \
- __z; })
-# endif
-# ifndef __floorf
-# define __floorf(x) \
- ({ float __z; \
- __asm __volatile ( \
- " frim %0,%1\n" \
- " frsp %0,%0\n" \
- : "=f" (__z) \
- : "f" (x)); \
- __z; })
-# endif
-
#endif /* defined _ARCH_PWR5X */
#endif /* _PPC_MATH_PRIVATE_H_ */
if (x >= 0.0)
{
- *iptr = __floor (x);
+ *iptr = floor (x);
return __copysign (x - *iptr, x);
}
else
if (x >= 0.0)
{
- *iptr = __floorf (x);
+ *iptr = floorf (x);
return __copysignf (x - *iptr, x);
}
else
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 <shlib-compat.h>
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 <shlib-compat.h>
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 <shlib-compat.h>
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 <shlib-compat.h>
License along with the GNU C Library. If not, see
<http://www.gnu.org/licenses/>. */
+#define NO_MATH_REDIRECT
#include <math.h>
#include <math_private.h>
#include <fenv_private.h>
License along with the GNU C Library. If not, see
<http://www.gnu.org/licenses/>. */
+#define NO_MATH_REDIRECT
#include <math.h>
#include <math_private.h>
#include <fenv_private.h>
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
+#define NO_MATH_REDIRECT
#include <sparc-ifunc.h>
#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 <sparc-ifunc.h>
#include <math.h>
#include <libm-alias-float.h>
# endif
return res;
}
-
-extern __always_inline double
-__floor (double d)
-{
- double res;
-# if defined __AVX__ || defined SSE2AVX
- asm ("vroundsd $1, %1, %0, %0" : "=x" (res) : "xm" (d));
-# else
- asm ("roundsd $1, %1, %0" : "=x" (res) : "xm" (d));
-# endif
- return res;
-}
-
-extern __always_inline float
-__floorf (float d)
-{
- float res;
-# if defined __AVX__ || defined SSE2AVX
- asm ("vroundss $1, %1, %0, %0" : "=x" (res) : "xm" (d));
-# else
- asm ("roundss $1, %1, %0" : "=x" (res) : "xm" (d));
-# endif
- return res;
-}
#endif /* __SSE4_1__ */
#endif /* X86_64_MATH_PRIVATE_H */
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
+#define NO_MATH_REDIRECT
#include <libm-alias-double.h>
#define floor __redirect_floor
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
+#define NO_MATH_REDIRECT
#include <libm-alias-float.h>
#define floorf __redirect_floorf
projects / thirdparty / glibc.git / commitdiff
