ab3b54def5368841f0519745e0cbdda29e94973e
[kopensolaris-gnu/glibc.git] / sysdeps / i386 / fpu / bits / mathinline.h
1 /* Inline math functions for i387.
2    Copyright (C) 1995,96,97,98,99,2000,2001,2003 Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4    Contributed by John C. Bowman <bowman@math.ualberta.ca>, 1995.
5
6    The GNU C Library is free software; you can redistribute it and/or
7    modify it under the terms of the GNU Lesser General Public
8    License as published by the Free Software Foundation; either
9    version 2.1 of the License, or (at your option) any later version.
10
11    The GNU C Library is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14    Lesser General Public License for more details.
15
16    You should have received a copy of the GNU Lesser General Public
17    License along with the GNU C Library; if not, write to the Free
18    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
19    02111-1307 USA.  */
20
21 #ifndef _MATH_H
22 # error "Never use <bits/mathinline.h> directly; include <math.h> instead."
23 #endif
24
25 #ifdef __cplusplus
26 # define __MATH_INLINE __inline
27 #else
28 # define __MATH_INLINE extern __inline
29 #endif
30
31
32 #if defined __USE_ISOC99 && defined __GNUC__ && __GNUC__ >= 2
33 # if __GNUC_PREREQ (2,97)
34 /* GCC 2.97 and up have builtins that actually can be used.  */
35 #  define isgreater(x, y) __builtin_isgreater (x, y)
36 #  define isgreaterequal(x, y) __builtin_isgreaterequal (x, y)
37 #  define isless(x, y) __builtin_isless (x, y)
38 #  define islessequal(x, y) __builtin_islessequal (x, y)
39 #  define islessgreater(x, y) __builtin_islessgreater (x, y)
40 #  define isunordered(x, y) __builtin_isunordered (x, y)
41 # else
42 /* ISO C99 defines some macros to perform unordered comparisons.  The
43    ix87 FPU supports this with special opcodes and we should use them.
44    These must not be inline functions since we have to be able to handle
45    all floating-point types.  */
46 #  ifdef __i686__
47 /* For the PentiumPro and more recent processors we can provide
48    better code.  */
49 #   define isgreater(x, y) \
50      ({ register char __result;                                               \
51         __asm__ ("fucomip %%st(1), %%st; seta %%al"                           \
52                  : "=a" (__result) : "u" (y), "t" (x) : "cc", "st");          \
53         __result; })
54 #   define isgreaterequal(x, y) \
55      ({ register char __result;                                               \
56         __asm__ ("fucomip %%st(1), %%st; setae %%al"                          \
57                  : "=a" (__result) : "u" (y), "t" (x) : "cc", "st");          \
58         __result; })
59
60 #   define isless(x, y) \
61      ({ register char __result;                                               \
62         __asm__ ("fucomip %%st(1), %%st; seta %%al"                           \
63                  : "=a" (__result) : "u" (x), "t" (y) : "cc", "st");          \
64         __result; })
65
66 #   define islessequal(x, y) \
67      ({ register char __result;                                               \
68         __asm__ ("fucomip %%st(1), %%st; setae %%al"                          \
69                  : "=a" (__result) : "u" (x), "t" (y) : "cc", "st");          \
70         __result; })
71
72 #   define islessgreater(x, y) \
73      ({ register char __result;                                               \
74         __asm__ ("fucomip %%st(1), %%st; setne %%al"                          \
75                  : "=a" (__result) : "u" (y), "t" (x) : "cc", "st");          \
76         __result; })
77
78 #   define isunordered(x, y) \
79      ({ register char __result;                                               \
80         __asm__ ("fucomip %%st(1), %%st; setp %%al"                           \
81                  : "=a" (__result) : "u" (y), "t" (x) : "cc", "st");          \
82         __result; })
83 #  else
84 /* This is the dumb, portable code for i386 and above.  */
85 #   define isgreater(x, y) \
86      ({ register char __result;                                               \
87         __asm__ ("fucompp; fnstsw; testb $0x45, %%ah; setz %%al"              \
88                  : "=a" (__result) : "u" (y), "t" (x) : "cc", "st", "st(1)"); \
89         __result; })
90
91 #   define isgreaterequal(x, y) \
92      ({ register char __result;                                               \
93         __asm__ ("fucompp; fnstsw; testb $0x05, %%ah; setz %%al"              \
94                  : "=a" (__result) : "u" (y), "t" (x) : "cc", "st", "st(1)"); \
95         __result; })
96
97 #   define isless(x, y) \
98      ({ register char __result;                                               \
99         __asm__ ("fucompp; fnstsw; testb $0x45, %%ah; setz %%al"              \
100                  : "=a" (__result) : "u" (x), "t" (y) : "cc", "st", "st(1)"); \
101         __result; })
102
103 #   define islessequal(x, y) \
104      ({ register char __result;                                               \
105         __asm__ ("fucompp; fnstsw; testb $0x05, %%ah; setz %%al"              \
106                  : "=a" (__result) : "u" (x), "t" (y) : "cc", "st", "st(1)"); \
107         __result; })
108
109 #   define islessgreater(x, y) \
110      ({ register char __result;                                               \
111         __asm__ ("fucompp; fnstsw; testb $0x44, %%ah; setz %%al"              \
112                  : "=a" (__result) : "u" (y), "t" (x) : "cc", "st", "st(1)"); \
113         __result; })
114
115 #   define isunordered(x, y) \
116      ({ register char __result;                                               \
117         __asm__ ("fucompp; fnstsw; sahf; setp %%al"                           \
118                  : "=a" (__result) : "u" (y), "t" (x) : "cc", "st", "st(1)"); \
119         __result; })
120 #  endif /* __i686__ */
121 # endif /* GCC 2.97 */
122
123 /* The gcc, version 2.7 or below, has problems with all this inlining
124    code.  So disable it for this version of the compiler.  */
125 # if __GNUC_PREREQ (2, 8)
126 /* Test for negative number.  Used in the signbit() macro.  */
127 __MATH_INLINE int
128 __signbitf (float __x) __THROW
129 {
130   __extension__ union { float __f; int __i; } __u = { __f: __x };
131   return __u.__i < 0;
132 }
133 __MATH_INLINE int
134 __signbit (double __x) __THROW
135 {
136   __extension__ union { double __d; int __i[2]; } __u = { __d: __x };
137   return __u.__i[1] < 0;
138 }
139 __MATH_INLINE int
140 __signbitl (long double __x) __THROW
141 {
142   __extension__ union { long double __l; int __i[3]; } __u = { __l: __x };
143   return (__u.__i[2] & 0x8000) != 0;
144 }
145 # endif
146 #endif
147
148
149 /* The gcc, version 2.7 or below, has problems with all this inlining
150    code.  So disable it for this version of the compiler.  */
151 #if __GNUC_PREREQ (2, 8)
152
153 #if ((!defined __NO_MATH_INLINES || defined __LIBC_INTERNAL_MATH_INLINES) \
154      && defined __OPTIMIZE__)
155
156 /* A macro to define float, double, and long double versions of various
157    math functions for the ix87 FPU.  FUNC is the function name (which will
158    be suffixed with f and l for the float and long double version,
159    respectively).  OP is the name of the FPU operation.
160    We define two sets of macros.  The set with the additional NP
161    doesn't add a prototype declaration.  */
162
163 #if defined __USE_MISC || defined __USE_ISOC99
164 # define __inline_mathop(func, op) \
165   __inline_mathop_ (double, func, op)                                         \
166   __inline_mathop_ (float, __CONCAT(func,f), op)                              \
167   __inline_mathop_ (long double, __CONCAT(func,l), op)
168 # define __inline_mathopNP(func, op) \
169   __inline_mathopNP_ (double, func, op)                                       \
170   __inline_mathopNP_ (float, __CONCAT(func,f), op)                            \
171   __inline_mathopNP_ (long double, __CONCAT(func,l), op)
172 #else
173 # define __inline_mathop(func, op) \
174   __inline_mathop_ (double, func, op)
175 # define __inline_mathopNP(func, op) \
176   __inline_mathopNP_ (double, func, op)
177 #endif
178
179 #define __inline_mathop_(float_type, func, op) \
180   __inline_mathop_decl_ (float_type, func, op, "0" (__x))
181 #define __inline_mathopNP_(float_type, func, op) \
182   __inline_mathop_declNP_ (float_type, func, op, "0" (__x))
183
184
185 #if defined __USE_MISC || defined __USE_ISOC99
186 # define __inline_mathop_decl(func, op, params...) \
187   __inline_mathop_decl_ (double, func, op, params)                            \
188   __inline_mathop_decl_ (float, __CONCAT(func,f), op, params)                 \
189   __inline_mathop_decl_ (long double, __CONCAT(func,l), op, params)
190 # define __inline_mathop_declNP(func, op, params...) \
191   __inline_mathop_declNP_ (double, func, op, params)                          \
192   __inline_mathop_declNP_ (float, __CONCAT(func,f), op, params)               \
193   __inline_mathop_declNP_ (long double, __CONCAT(func,l), op, params)
194 #else
195 # define __inline_mathop_decl(func, op, params...) \
196   __inline_mathop_decl_ (double, func, op, params)
197 # define __inline_mathop_declNP(func, op, params...) \
198   __inline_mathop_declNP_ (double, func, op, params)
199 #endif
200
201 #define __inline_mathop_decl_(float_type, func, op, params...) \
202   __MATH_INLINE float_type func (float_type) __THROW;                         \
203   __inline_mathop_declNP_ (float_type, func, op, params)
204
205 #define __inline_mathop_declNP_(float_type, func, op, params...) \
206   __MATH_INLINE float_type func (float_type __x) __THROW                      \
207   {                                                                           \
208     register float_type __result;                                             \
209     __asm __volatile__ (op : "=t" (__result) : params);                       \
210     return __result;                                                          \
211   }
212
213
214 #if defined __USE_MISC || defined __USE_ISOC99
215 # define __inline_mathcode(func, arg, code) \
216   __inline_mathcode_ (double, func, arg, code)                                \
217   __inline_mathcode_ (float, __CONCAT(func,f), arg, code)                     \
218   __inline_mathcode_ (long double, __CONCAT(func,l), arg, code)
219 # define __inline_mathcodeNP(func, arg, code) \
220   __inline_mathcodeNP_ (double, func, arg, code)                                      \
221   __inline_mathcodeNP_ (float, __CONCAT(func,f), arg, code)                   \
222   __inline_mathcodeNP_ (long double, __CONCAT(func,l), arg, code)
223 # define __inline_mathcode2(func, arg1, arg2, code) \
224   __inline_mathcode2_ (double, func, arg1, arg2, code)                        \
225   __inline_mathcode2_ (float, __CONCAT(func,f), arg1, arg2, code)             \
226   __inline_mathcode2_ (long double, __CONCAT(func,l), arg1, arg2, code)
227 # define __inline_mathcodeNP2(func, arg1, arg2, code) \
228   __inline_mathcodeNP2_ (double, func, arg1, arg2, code)                              \
229   __inline_mathcodeNP2_ (float, __CONCAT(func,f), arg1, arg2, code)           \
230   __inline_mathcodeNP2_ (long double, __CONCAT(func,l), arg1, arg2, code)
231 # define __inline_mathcode3(func, arg1, arg2, arg3, code) \
232   __inline_mathcode3_ (double, func, arg1, arg2, arg3, code)                  \
233   __inline_mathcode3_ (float, __CONCAT(func,f), arg1, arg2, arg3, code)       \
234   __inline_mathcode3_ (long double, __CONCAT(func,l), arg1, arg2, arg3, code)
235 # define __inline_mathcodeNP3(func, arg1, arg2, arg3, code) \
236   __inline_mathcodeNP3_ (double, func, arg1, arg2, arg3, code)                \
237   __inline_mathcodeNP3_ (float, __CONCAT(func,f), arg1, arg2, arg3, code)             \
238   __inline_mathcodeNP3_ (long double, __CONCAT(func,l), arg1, arg2, arg3, code)
239 #else
240 # define __inline_mathcode(func, arg, code) \
241   __inline_mathcode_ (double, func, (arg), code)
242 # define __inline_mathcodeNP(func, arg, code) \
243   __inline_mathcodeNP_ (double, func, (arg), code)
244 # define __inline_mathcode2(func, arg1, arg2, code) \
245   __inline_mathcode2_ (double, func, arg1, arg2, code)
246 # define __inline_mathcodeNP2(func, arg1, arg2, code) \
247   __inline_mathcodeNP2_ (double, func, arg1, arg2, code)
248 # define __inline_mathcode3(func, arg1, arg2, arg3, code) \
249   __inline_mathcode3_ (double, func, arg1, arg2, arg3, code)
250 # define __inline_mathcodeNP3(func, arg1, arg2, arg3, code) \
251   __inline_mathcodeNP3_ (double, func, arg1, arg2, arg3, code)
252 #endif
253
254 #define __inline_mathcode_(float_type, func, arg, code) \
255   __MATH_INLINE float_type func (float_type) __THROW;                         \
256   __inline_mathcodeNP_(float_type, func, arg, code)
257
258 #define __inline_mathcodeNP_(float_type, func, arg, code) \
259   __MATH_INLINE float_type func (float_type arg) __THROW                      \
260   {                                                                           \
261     code;                                                                     \
262   }
263
264
265 #define __inline_mathcode2_(float_type, func, arg1, arg2, code) \
266   __MATH_INLINE float_type func (float_type, float_type) __THROW;             \
267   __inline_mathcodeNP2_ (float_type, func, arg1, arg2, code)
268
269 #define __inline_mathcodeNP2_(float_type, func, arg1, arg2, code) \
270   __MATH_INLINE float_type func (float_type arg1, float_type arg2) __THROW    \
271   {                                                                           \
272     code;                                                                     \
273   }
274
275 #define __inline_mathcode3_(float_type, func, arg1, arg2, arg3, code) \
276   __MATH_INLINE float_type func (float_type, float_type, float_type) __THROW; \
277   __inline_mathcodeNP3_(float_type, func, arg1, arg2, arg3, code)
278
279 #define __inline_mathcodeNP3_(float_type, func, arg1, arg2, arg3, code) \
280   __MATH_INLINE float_type func (float_type arg1, float_type arg2,            \
281                                  float_type arg3) __THROW                     \
282   {                                                                           \
283     code;                                                                     \
284   }
285 #endif
286
287
288 #if !defined __NO_MATH_INLINES && defined __OPTIMIZE__
289 /* Miscellaneous functions */
290
291 __inline_mathcode (__sgn, __x, \
292   return __x == 0.0 ? 0.0 : (__x > 0.0 ? 1.0 : -1.0))
293
294 /* __FAST_MATH__ is defined by gcc -ffast-math.  */
295 #ifdef __FAST_MATH__
296 __inline_mathcode (__pow2, __x, \
297   register long double __value;                                               \
298   register long double __exponent;                                            \
299   __extension__ long long int __p = (long long int) __x;                      \
300   if (__x == (long double) __p)                                               \
301     {                                                                         \
302       __asm __volatile__                                                      \
303         ("fscale"                                                             \
304          : "=t" (__value) : "0" (1.0), "u" (__x));                            \
305       return __value;                                                         \
306     }                                                                         \
307   __asm __volatile__                                                          \
308     ("fld       %%st(0)\n\t"                                                  \
309      "frndint                   # int(x)\n\t"                                 \
310      "fxch\n\t"                                                               \
311      "fsub      %%st(1)         # fract(x)\n\t"                               \
312      "f2xm1                     # 2^(fract(x)) - 1\n\t"                       \
313      : "=t" (__value), "=u" (__exponent) : "0" (__x));                        \
314   __value += 1.0;                                                             \
315   __asm __volatile__                                                          \
316     ("fscale"                                                                 \
317      : "=t" (__value) : "0" (__value), "u" (__exponent));                     \
318   return __value)
319
320 # ifdef __USE_GNU
321 #  define __sincos_code \
322   register long double __cosr;                                                \
323   register long double __sinr;                                                \
324   __asm __volatile__                                                          \
325     ("fsincos\n\t"                                                            \
326      "fnstsw    %%ax\n\t"                                                     \
327      "testl     $0x400, %%eax\n\t"                                            \
328      "jz        1f\n\t"                                                       \
329      "fldpi\n\t"                                                              \
330      "fadd      %%st(0)\n\t"                                                  \
331      "fxch      %%st(1)\n\t"                                                  \
332      "2: fprem1\n\t"                                                          \
333      "fnstsw    %%ax\n\t"                                                     \
334      "testl     $0x400, %%eax\n\t"                                            \
335      "jnz       2b\n\t"                                                       \
336      "fstp      %%st(1)\n\t"                                                  \
337      "fsincos\n\t"                                                            \
338      "1:"                                                                     \
339      : "=t" (__cosr), "=u" (__sinr) : "0" (__x));                             \
340   *__sinx = __sinr;                                                           \
341   *__cosx = __cosr
342
343 __MATH_INLINE void
344 __sincos (double __x, double *__sinx, double *__cosx) __THROW
345 {
346   __sincos_code;
347 }
348
349 __MATH_INLINE void
350 __sincosf (float __x, float *__sinx, float *__cosx) __THROW
351 {
352   __sincos_code;
353 }
354
355 __MATH_INLINE void
356 __sincosl (long double __x, long double *__sinx, long double *__cosx) __THROW
357 {
358   __sincos_code;
359 }
360 # endif
361
362
363 /* Optimized inline implementation, sometimes with reduced precision
364    and/or argument range.  */
365
366 # define __expm1_code \
367   register long double __value;                                               \
368   register long double __exponent;                                            \
369   register long double __temp;                                                \
370   __asm __volatile__                                                          \
371     ("fldl2e                    # e^x - 1 = 2^(x * log2(e)) - 1\n\t"          \
372      "fmul      %%st(1)         # x * log2(e)\n\t"                            \
373      "fst       %%st(1)\n\t"                                                  \
374      "frndint                   # int(x * log2(e))\n\t"                       \
375      "fxch\n\t"                                                               \
376      "fsub      %%st(1)         # fract(x * log2(e))\n\t"                     \
377      "f2xm1                     # 2^(fract(x * log2(e))) - 1\n\t"             \
378      "fscale                    # 2^(x * log2(e)) - 2^(int(x * log2(e)))\n\t" \
379      : "=t" (__value), "=u" (__exponent) : "0" (__x));                        \
380   __asm __volatile__                                                          \
381     ("fscale                    # 2^int(x * log2(e))\n\t"                     \
382      : "=t" (__temp) : "0" (1.0), "u" (__exponent));                          \
383   __temp -= 1.0;                                                              \
384   __temp += __value;                                                          \
385   return __temp ? __temp : __x
386 __inline_mathcodeNP_ (long double, __expm1l, __x, __expm1_code)
387
388
389 # define __exp_code \
390   register long double __value;                                               \
391   register long double __exponent;                                            \
392   __asm __volatile__                                                          \
393     ("fldl2e                    # e^x = 2^(x * log2(e))\n\t"                  \
394      "fmul      %%st(1)         # x * log2(e)\n\t"                            \
395      "fst       %%st(1)\n\t"                                                  \
396      "frndint                   # int(x * log2(e))\n\t"                       \
397      "fxch\n\t"                                                               \
398      "fsub      %%st(1)         # fract(x * log2(e))\n\t"                     \
399      "f2xm1                     # 2^(fract(x * log2(e))) - 1\n\t"             \
400      : "=t" (__value), "=u" (__exponent) : "0" (__x));                        \
401   __value += 1.0;                                                             \
402   __asm __volatile__                                                          \
403     ("fscale"                                                                 \
404      : "=t" (__value) : "0" (__value), "u" (__exponent));                     \
405   return __value
406 __inline_mathcodeNP (exp, __x, __exp_code)
407 __inline_mathcodeNP_ (long double, __expl, __x, __exp_code)
408
409
410 __inline_mathcodeNP (tan, __x, \
411   register long double __value;                                               \
412   register long double __value2 __attribute__ ((__unused__));                 \
413   __asm __volatile__                                                          \
414     ("fptan"                                                                  \
415      : "=t" (__value2), "=u" (__value) : "0" (__x));                          \
416   return __value)
417 #endif /* __FAST_MATH__ */
418
419
420 #define __atan2_code \
421   register long double __value;                                               \
422   __asm __volatile__                                                          \
423     ("fpatan"                                                                 \
424      : "=t" (__value) : "0" (__x), "u" (__y) : "st(1)");                      \
425   return __value
426 __inline_mathcodeNP2 (atan2, __y, __x, __atan2_code)
427 __inline_mathcodeNP2_ (long double, __atan2l, __y, __x, __atan2_code)
428
429
430 __inline_mathcodeNP2 (fmod, __x, __y, \
431   register long double __value;                                               \
432   __asm __volatile__                                                          \
433     ("1:        fprem\n\t"                                                    \
434      "fnstsw    %%ax\n\t"                                                     \
435      "sahf\n\t"                                                               \
436      "jp        1b"                                                           \
437      : "=t" (__value) : "0" (__x), "u" (__y) : "ax", "cc");                   \
438   return __value)
439
440
441 #ifdef __FAST_MATH__
442 # if !__GNUC_PREREQ (3,3)
443 __inline_mathopNP (sqrt, "fsqrt")
444 __inline_mathopNP_ (long double, __sqrtl, "fsqrt")
445 #  define __libc_sqrtl(n) __sqrtl (n)
446 # else
447 #  define __libc_sqrtl(n) __builtin_sqrtl (n)
448 # endif
449 #endif
450
451 #if __GNUC_PREREQ (2, 8)
452 __inline_mathcodeNP_ (double, fabs, __x, return __builtin_fabs (__x))
453 __inline_mathcodeNP_ (float, fabsf, __x, return __builtin_fabsf (__x))
454 __inline_mathcodeNP_ (long double, fabsl, __x, return __builtin_fabsl (__x))
455 __inline_mathcodeNP_ (long double, __fabsl, __x, return __builtin_fabsl (__x))
456 #else
457 __inline_mathop (fabs, "fabs")
458 __inline_mathop_ (long double, __fabsl, "fabs")
459 #endif
460
461 #ifdef __FAST_MATH__
462 /* The argument range of this inline version is reduced.  */
463 __inline_mathopNP (sin, "fsin")
464 /* The argument range of this inline version is reduced.  */
465 __inline_mathopNP (cos, "fcos")
466
467 __inline_mathop_declNP (log, "fldln2; fxch; fyl2x", "0" (__x) : "st(1)")
468 __inline_mathop_declNP (log10, "fldlg2; fxch; fyl2x", "0" (__x) : "st(1)")
469
470 __inline_mathcodeNP (asin, __x, return __atan2l (__x, __libc_sqrtl (1.0 - __x * __x)))
471 __inline_mathcodeNP (acos, __x, return __atan2l (__libc_sqrtl (1.0 - __x * __x), __x))
472 #endif /* __FAST_MATH__ */
473
474 __inline_mathop_declNP (atan, "fld1; fpatan", "0" (__x) : "st(1)")
475
476 __inline_mathcode_ (long double, __sgn1l, __x, \
477   __extension__ union { long double __xld; unsigned int __xi[3]; } __n =      \
478     { __xld: __x };                                                           \
479   __n.__xi[2] = (__n.__xi[2] & 0x8000) | 0x3fff;                              \
480   __n.__xi[1] = 0x80000000;                                                   \
481   __n.__xi[0] = 0;                                                            \
482   return __n.__xld)
483
484
485 #ifdef __FAST_MATH__
486 /* The argument range of the inline version of sinhl is slightly reduced.  */
487 __inline_mathcodeNP (sinh, __x, \
488   register long double __exm1 = __expm1l (__fabsl (__x));                     \
489   return 0.5 * (__exm1 / (__exm1 + 1.0) + __exm1) * __sgn1l (__x))
490
491 __inline_mathcodeNP (cosh, __x, \
492   register long double __ex = __expl (__x);                                   \
493   return 0.5 * (__ex + 1.0 / __ex))
494
495 __inline_mathcodeNP (tanh, __x, \
496   register long double __exm1 = __expm1l (-__fabsl (__x + __x));              \
497   return __exm1 / (__exm1 + 2.0) * __sgn1l (-__x))
498 #endif
499
500 __inline_mathcodeNP (floor, __x, \
501   register long double __value;                                               \
502   __volatile unsigned short int __cw;                                         \
503   __volatile unsigned short int __cwtmp;                                      \
504   __asm __volatile ("fnstcw %0" : "=m" (__cw));                               \
505   __cwtmp = (__cw & 0xf3ff) | 0x0400; /* rounding down */                     \
506   __asm __volatile ("fldcw %0" : : "m" (__cwtmp));                            \
507   __asm __volatile ("frndint" : "=t" (__value) : "0" (__x));                  \
508   __asm __volatile ("fldcw %0" : : "m" (__cw));                               \
509   return __value)
510
511 __inline_mathcodeNP (ceil, __x, \
512   register long double __value;                                               \
513   __volatile unsigned short int __cw;                                         \
514   __volatile unsigned short int __cwtmp;                                      \
515   __asm __volatile ("fnstcw %0" : "=m" (__cw));                               \
516   __cwtmp = (__cw & 0xf3ff) | 0x0800; /* rounding up */                       \
517   __asm __volatile ("fldcw %0" : : "m" (__cwtmp));                            \
518   __asm __volatile ("frndint" : "=t" (__value) : "0" (__x));                  \
519   __asm __volatile ("fldcw %0" : : "m" (__cw));                               \
520   return __value)
521
522 #ifdef __FAST_MATH__
523 # define __ldexp_code \
524   register long double __value;                                               \
525   __asm __volatile__                                                          \
526     ("fscale"                                                                 \
527      : "=t" (__value) : "0" (__x), "u" ((long double) __y));                  \
528   return __value
529
530 __MATH_INLINE double
531 ldexp (double __x, int __y) __THROW
532 {
533   __ldexp_code;
534 }
535 #endif
536
537
538 /* Optimized versions for some non-standardized functions.  */
539 #if defined __USE_ISOC99 || defined __USE_MISC
540
541 # ifdef __FAST_MATH__
542 __inline_mathcodeNP (expm1, __x, __expm1_code)
543
544 /* We cannot rely on M_SQRT being defined.  So we do it for ourself
545    here.  */
546 #  define __M_SQRT2     1.41421356237309504880L /* sqrt(2) */
547
548 __inline_mathcodeNP (log1p, __x, \
549   register long double __value;                                               \
550   if (__fabsl (__x) >= 1.0 - 0.5 * __M_SQRT2)                                 \
551     __value = logl (1.0 + __x);                                               \
552   else                                                                        \
553     __asm __volatile__                                                        \
554       ("fldln2\n\t"                                                           \
555        "fxch\n\t"                                                             \
556        "fyl2xp1"                                                              \
557        : "=t" (__value) : "0" (__x) : "st(1)");                               \
558   return __value)
559
560
561 /* The argument range of the inline version of asinhl is slightly reduced.  */
562 __inline_mathcodeNP (asinh, __x, \
563   register long double  __y = __fabsl (__x);                                  \
564   return (log1pl (__y * __y / (__libc_sqrtl (__y * __y + 1.0) + 1.0) + __y)   \
565           * __sgn1l (__x)))
566
567 __inline_mathcodeNP (acosh, __x, \
568   return logl (__x + __libc_sqrtl (__x - 1.0) * __libc_sqrtl (__x + 1.0)))
569
570 __inline_mathcodeNP (atanh, __x, \
571   register long double __y = __fabsl (__x);                                   \
572   return -0.5 * log1pl (-(__y + __y) / (1.0 + __y)) * __sgn1l (__x))
573
574 /* The argument range of the inline version of hypotl is slightly reduced.  */
575 __inline_mathcodeNP2 (hypot, __x, __y,
576                       return __libc_sqrtl (__x * __x + __y * __y))
577
578 __inline_mathcodeNP(logb, __x, \
579   register long double __value;                                               \
580   register long double __junk;                                                \
581   __asm __volatile__                                                          \
582     ("fxtract\n\t"                                                            \
583      : "=t" (__junk), "=u" (__value) : "0" (__x));                            \
584   return __value)
585
586 # endif
587 #endif
588
589 #ifdef __USE_ISOC99
590 #ifdef __FAST_MATH__
591 __inline_mathop_declNP (log2, "fld1; fxch; fyl2x", "0" (__x) : "st(1)")
592
593 __MATH_INLINE float
594 ldexpf (float __x, int __y) __THROW
595 {
596   __ldexp_code;
597 }
598
599 __MATH_INLINE long double
600 ldexpl (long double __x, int __y) __THROW
601 {
602   __ldexp_code;
603 }
604
605 __inline_mathcodeNP3 (fma, __x, __y, __z, return (__x * __y) + __z)
606
607 __inline_mathopNP (rint, "frndint")
608 #endif /* __FAST_MATH__ */
609
610 #define __lrint_code \
611   long int __lrintres;                                                        \
612   __asm__ __volatile__                                                        \
613     ("fistpl %0"                                                              \
614      : "=m" (__lrintres) : "t" (__x) : "st");                                 \
615   return __lrintres
616 __MATH_INLINE long int
617 lrintf (float __x) __THROW
618 {
619   __lrint_code;
620 }
621 __MATH_INLINE long int
622 lrint (double __x) __THROW
623 {
624   __lrint_code;
625 }
626 __MATH_INLINE long int
627 lrintl (long double __x) __THROW
628 {
629   __lrint_code;
630 }
631 #undef __lrint_code
632
633 #define __llrint_code \
634   long long int __llrintres;                                                  \
635   __asm__ __volatile__                                                        \
636     ("fistpll %0"                                                             \
637      : "=m" (__llrintres) : "t" (__x) : "st");                                \
638   return __llrintres
639 __MATH_INLINE long long int
640 llrintf (float __x) __THROW
641 {
642   __llrint_code;
643 }
644 __MATH_INLINE long long int
645 llrint (double __x) __THROW
646 {
647   __llrint_code;
648 }
649 __MATH_INLINE long long int
650 llrintl (long double __x) __THROW
651 {
652   __llrint_code;
653 }
654 #undef __llrint_code
655
656 #endif
657
658
659 #ifdef __USE_MISC
660
661 __inline_mathcodeNP2 (drem, __x, __y, \
662   register double __value;                                                    \
663   register int __clobbered;                                                   \
664   __asm __volatile__                                                          \
665     ("1:        fprem1\n\t"                                                   \
666      "fstsw     %%ax\n\t"                                                     \
667      "sahf\n\t"                                                               \
668      "jp        1b"                                                           \
669      : "=t" (__value), "=&a" (__clobbered) : "0" (__x), "u" (__y) : "cc");    \
670   return __value)
671
672
673 /* This function is used in the `isfinite' macro.  */
674 __MATH_INLINE int
675 __finite (double __x) __THROW
676 {
677   return (__extension__
678           (((((union { double __d; int __i[2]; }) {__d: __x}).__i[1]
679              | 0x800fffffu) + 1) >> 31));
680 }
681
682 /* Miscellaneous functions */
683 #ifdef __FAST_MATH__
684 __inline_mathcode (__coshm1, __x, \
685   register long double __exm1 = __expm1l (__fabsl (__x));                     \
686   return 0.5 * (__exm1 / (__exm1 + 1.0)) * __exm1)
687
688 __inline_mathcode (__acosh1p, __x, \
689   return log1pl (__x + __libc_sqrtl (__x) * __libc_sqrtl (__x + 2.0)))
690
691 #endif /* __FAST_MATH__ */
692 #endif /* __USE_MISC  */
693
694 /* Undefine some of the large macros which are not used anymore.  */
695 #undef __atan2_code
696 #ifdef __FAST_MATH__
697 # undef __expm1_code
698 # undef __exp_code
699 # undef __sincos_code
700 #endif /* __FAST_MATH__ */
701
702 #endif /* __NO_MATH_INLINES  */
703
704
705 /* This code is used internally in the GNU libc.  */
706 #ifdef __LIBC_INTERNAL_MATH_INLINES
707 __inline_mathop (__ieee754_sqrt, "fsqrt")
708 __inline_mathcode2 (__ieee754_atan2, __y, __x,
709                     register long double __value;
710                     __asm __volatile__ ("fpatan\n\t"
711                                         : "=t" (__value)
712                                         : "0" (__x), "u" (__y) : "st(1)");
713                     return __value;)
714 #endif
715
716 #endif /* __GNUC__  */