10 /* Now define the internal interfaces. */
13 # if IS_IN (libc) || IS_IN (libm)
14 hidden_proto (__finite)
15 hidden_proto (__isinf)
16 hidden_proto (__isnan)
17 hidden_proto (__finitef)
18 hidden_proto (__isinff)
19 hidden_proto (__isnanf)
21 # if !defined __NO_LONG_DOUBLE_MATH \
22 && __LONG_DOUBLE_USES_FLOAT128 == 0
23 hidden_proto (__finitel)
24 hidden_proto (__isinfl)
25 hidden_proto (__isnanl)
28 # if __HAVE_DISTINCT_FLOAT128
29 hidden_proto (__finitef128)
30 hidden_proto (__isinff128)
31 hidden_proto (__isnanf128)
32 hidden_proto (__signbitf128)
36 libm_hidden_proto (__fpclassify)
37 libm_hidden_proto (__fpclassifyf)
38 libm_hidden_proto (__issignaling)
39 libm_hidden_proto (__issignalingf)
40 libm_hidden_proto (__exp)
41 libm_hidden_proto (__expf)
42 libm_hidden_proto (__roundeven)
44 # if !defined __NO_LONG_DOUBLE_MATH \
45 && __LONG_DOUBLE_USES_FLOAT128 == 0
46 libm_hidden_proto (__fpclassifyl)
47 libm_hidden_proto (__issignalingl)
48 libm_hidden_proto (__expl)
49 libm_hidden_proto (__expm1l)
52 # if __HAVE_DISTINCT_FLOAT128
53 libm_hidden_proto (__fpclassifyf128)
54 libm_hidden_proto (__issignalingf128)
55 libm_hidden_proto (__expf128)
56 libm_hidden_proto (__expm1f128)
60 #include <nan-high-order-bit.h>
62 /* A union which permits us to convert between a float and a 32 bit
69 } ieee_float_shape_type;
71 /* Get a 32 bit int from a float. */
72 #ifndef GET_FLOAT_WORD
73 # define GET_FLOAT_WORD(i,d) \
75 ieee_float_shape_type gf_u; \
81 /* Set a float from a 32 bit int. */
82 #ifndef SET_FLOAT_WORD
83 # define SET_FLOAT_WORD(d,i) \
85 ieee_float_shape_type sf_u; \
92 __issignalingf (float x)
95 GET_FLOAT_WORD (xi, x);
96 #if HIGH_ORDER_BIT_IS_SET_FOR_SNAN
97 /* We only have to care about the high-order bit of x's significand, because
98 having it set (sNaN) already makes the significand different from that
99 used to designate infinity. */
100 return (xi & 0x7fc00000) == 0x7fc00000;
102 /* To keep the following comparison simple, toggle the quiet/signaling bit,
103 so that it is set for sNaNs. This is inverse to IEEE 754-2008 (as well as
104 common practice for IEEE 754-1985). */
106 /* We have to compare for greater (instead of greater or equal), because x's
107 significand being all-zero designates infinity not NaN. */
108 return (xi & 0x7fffffff) > 0x7fc00000;
112 # if __HAVE_DISTINCT_FLOAT128
114 /* __builtin_isinf_sign is broken in GCC < 7 for float128. */
115 # if ! __GNUC_PREREQ (7, 0)
116 # include <ieee754_float128.h>
118 __isinff128 (_Float128 x)
121 GET_FLOAT128_WORDS64 (hx, lx, x);
122 lx |= (hx & 0x7fffffffffffffffLL) ^ 0x7fff000000000000LL;
124 return ~(lx >> 63) & (hx >> 62);
128 extern inline _Float128
129 fabsf128 (_Float128 x)
131 return __builtin_fabsf128 (x);
135 # if !(defined __FINITE_MATH_ONLY__ && __FINITE_MATH_ONLY__ > 0)
136 # ifndef NO_MATH_REDIRECT
137 /* Declare some functions for use within GLIBC. Compilers typically
138 inline those functions as a single instruction. Use an asm to
139 avoid use of PLTs if it doesn't. */
140 # define MATH_REDIRECT(FUNC, PREFIX, ARGS) \
141 float (FUNC ## f) (ARGS (float)) asm (PREFIX #FUNC "f"); \
142 double (FUNC) (ARGS (double)) asm (PREFIX #FUNC ); \
143 MATH_REDIRECT_LDBL (FUNC, PREFIX, ARGS) \
144 MATH_REDIRECT_F128 (FUNC, PREFIX, ARGS)
145 # if defined __NO_LONG_DOUBLE_MATH \
146 || __LONG_DOUBLE_USES_FLOAT128 == 1
147 # define MATH_REDIRECT_LDBL(FUNC, PREFIX, ARGS)
149 # define MATH_REDIRECT_LDBL(FUNC, PREFIX, ARGS) \
150 long double (FUNC ## l) (ARGS (long double)) asm (PREFIX #FUNC "l");
152 # if __HAVE_DISTINCT_FLOAT128
153 # define MATH_REDIRECT_F128(FUNC, PREFIX, ARGS) \
154 _Float128 (FUNC ## f128) (ARGS (_Float128)) asm (PREFIX #FUNC "f128");
156 # define MATH_REDIRECT_F128(FUNC, PREFIX, ARGS)
158 # define MATH_REDIRECT_UNARY_ARGS(TYPE) TYPE
159 # define MATH_REDIRECT_BINARY_ARGS(TYPE) TYPE, TYPE
160 MATH_REDIRECT (sqrt, "__ieee754_", MATH_REDIRECT_UNARY_ARGS)
161 MATH_REDIRECT (ceil, "__", MATH_REDIRECT_UNARY_ARGS)
162 MATH_REDIRECT (floor, "__", MATH_REDIRECT_UNARY_ARGS)
163 MATH_REDIRECT (rint, "__", MATH_REDIRECT_UNARY_ARGS)
164 MATH_REDIRECT (trunc, "__", MATH_REDIRECT_UNARY_ARGS)
165 MATH_REDIRECT (round, "__", MATH_REDIRECT_UNARY_ARGS)
166 MATH_REDIRECT (copysign, "__", MATH_REDIRECT_BINARY_ARGS)