/* Inline math functions for i387 and SSE.
Copyright (C) 1995-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#ifndef _MATH_H
# error "Never use <bits/mathinline.h> directly; include <math.h> instead."
#endif
#ifndef __extern_always_inline
# define __MATH_INLINE __inline
#else
# define __MATH_INLINE __extern_always_inline
#endif
/* Disable x87 inlines when -fpmath=sse is passed and also when we're building
on x86_64. Older gcc (gcc-3.2 for example) does not define __SSE2_MATH__
for x86_64. */
#if !defined __SSE2_MATH__ && !defined __x86_64__
# if ((!defined __NO_MATH_INLINES || defined __LIBC_INTERNAL_MATH_INLINES) \
&& defined __OPTIMIZE__)
/* The inline functions do not set errno or raise necessarily the
correct exceptions. */
# undef math_errhandling
/* A macro to define float, double, and long double versions of various
math functions for the ix87 FPU. FUNC is the function name (which will
be suffixed with f and l for the float and long double version,
respectively). OP is the name of the FPU operation.
We define two sets of macros. The set with the additional NP
doesn't add a prototype declaration. */
# ifdef __USE_ISOC99
# define __inline_mathop(func, op) \
__inline_mathop_ (double, func, op) \
__inline_mathop_ (float, __CONCAT(func,f), op) \
__inline_mathop_ (long double, __CONCAT(func,l), op)
# define __inline_mathopNP(func, op) \
__inline_mathopNP_ (double, func, op) \
__inline_mathopNP_ (float, __CONCAT(func,f), op) \
__inline_mathopNP_ (long double, __CONCAT(func,l), op)
# else
# define __inline_mathop(func, op) \
__inline_mathop_ (double, func, op)
# define __inline_mathopNP(func, op) \
__inline_mathopNP_ (double, func, op)
# endif
# define __inline_mathop_(float_type, func, op) \
__inline_mathop_decl_ (float_type, func, op, "0" (__x))
# define __inline_mathopNP_(float_type, func, op) \
__inline_mathop_declNP_ (float_type, func, op, "0" (__x))
# ifdef __USE_ISOC99
# define __inline_mathop_decl(func, op, params...) \
__inline_mathop_decl_ (double, func, op, params) \
__inline_mathop_decl_ (float, __CONCAT(func,f), op, params) \
__inline_mathop_decl_ (long double, __CONCAT(func,l), op, params)
# define __inline_mathop_declNP(func, op, params...) \
__inline_mathop_declNP_ (double, func, op, params) \
__inline_mathop_declNP_ (float, __CONCAT(func,f), op, params) \
__inline_mathop_declNP_ (long double, __CONCAT(func,l), op, params)
# else
# define __inline_mathop_decl(func, op, params...) \
__inline_mathop_decl_ (double, func, op, params)
# define __inline_mathop_declNP(func, op, params...) \
__inline_mathop_declNP_ (double, func, op, params)
# endif
# define __inline_mathop_decl_(float_type, func, op, params...) \
__MATH_INLINE float_type func (float_type) __THROW; \
__inline_mathop_declNP_ (float_type, func, op, params)
# define __inline_mathop_declNP_(float_type, func, op, params...) \
__MATH_INLINE float_type __NTH (func (float_type __x)) \
{ \
register float_type __result; \
__asm __volatile__ (op : "=t" (__result) : params); \
return __result; \
}
# ifdef __USE_ISOC99
# define __inline_mathcode(func, arg, code) \
__inline_mathcode_ (double, func, arg, code) \
__inline_mathcode_ (float, __CONCAT(func,f), arg, code) \
__inline_mathcode_ (long double, __CONCAT(func,l), arg, code)
# define __inline_mathcodeNP(func, arg, code) \
__inline_mathcodeNP_ (double, func, arg, code) \
__inline_mathcodeNP_ (float, __CONCAT(func,f), arg, code) \
__inline_mathcodeNP_ (long double, __CONCAT(func,l), arg, code)
# define __inline_mathcode2(func, arg1, arg2, code) \
__inline_mathcode2_ (double, func, arg1, arg2, code) \
__inline_mathcode2_ (float, __CONCAT(func,f), arg1, arg2, code) \
__inline_mathcode2_ (long double, __CONCAT(func,l), arg1, arg2, code)
# define __inline_mathcodeNP2(func, arg1, arg2, code) \
__inline_mathcodeNP2_ (double, func, arg1, arg2, code) \
__inline_mathcodeNP2_ (float, __CONCAT(func,f), arg1, arg2, code) \
__inline_mathcodeNP2_ (long double, __CONCAT(func,l), arg1, arg2, code)
# define __inline_mathcode3(func, arg1, arg2, arg3, code) \
__inline_mathcode3_ (double, func, arg1, arg2, arg3, code) \
__inline_mathcode3_ (float, __CONCAT(func,f), arg1, arg2, arg3, code) \
__inline_mathcode3_ (long double, __CONCAT(func,l), arg1, arg2, arg3, code)
# define __inline_mathcodeNP3(func, arg1, arg2, arg3, code) \
__inline_mathcodeNP3_ (double, func, arg1, arg2, arg3, code) \
__inline_mathcodeNP3_ (float, __CONCAT(func,f), arg1, arg2, arg3, code) \
__inline_mathcodeNP3_ (long double, __CONCAT(func,l), arg1, arg2, arg3, code)
# else
# define __inline_mathcode(func, arg, code) \
__inline_mathcode_ (double, func, (arg), code)
# define __inline_mathcodeNP(func, arg, code) \
__inline_mathcodeNP_ (double, func, (arg), code)
# define __inline_mathcode2(func, arg1, arg2, code) \
__inline_mathcode2_ (double, func, arg1, arg2, code)
# define __inline_mathcodeNP2(func, arg1, arg2, code) \
__inline_mathcodeNP2_ (double, func, arg1, arg2, code)
# define __inline_mathcode3(func, arg1, arg2, arg3, code) \
__inline_mathcode3_ (double, func, arg1, arg2, arg3, code)
# define __inline_mathcodeNP3(func, arg1, arg2, arg3, code) \
__inline_mathcodeNP3_ (double, func, arg1, arg2, arg3, code)
# endif
# define __inline_mathcode_(float_type, func, arg, code) \
__MATH_INLINE float_type func (float_type) __THROW; \
__inline_mathcodeNP_(float_type, func, arg, code)
# define __inline_mathcodeNP_(float_type, func, arg, code) \
__MATH_INLINE float_type __NTH (func (float_type arg)) \
{ \
code; \
}
# define __inline_mathcode2_(float_type, func, arg1, arg2, code) \
__MATH_INLINE float_type func (float_type, float_type) __THROW; \
__inline_mathcodeNP2_ (float_type, func, arg1, arg2, code)
# define __inline_mathcodeNP2_(float_type, func, arg1, arg2, code) \
__MATH_INLINE float_type __NTH (func (float_type arg1, float_type arg2)) \
{ \
code; \
}
# define __inline_mathcode3_(float_type, func, arg1, arg2, arg3, code) \
__MATH_INLINE float_type func (float_type, float_type, float_type) __THROW; \
__inline_mathcodeNP3_(float_type, func, arg1, arg2, arg3, code)
# define __inline_mathcodeNP3_(float_type, func, arg1, arg2, arg3, code) \
__MATH_INLINE float_type __NTH (func (float_type arg1, float_type arg2, \
float_type arg3)) \
{ \
code; \
}
# endif
# if !defined __NO_MATH_INLINES && defined __OPTIMIZE__
/* Miscellaneous functions */
/* __FAST_MATH__ is defined by gcc -ffast-math. */
# ifdef __FAST_MATH__
/* Optimized inline implementation, sometimes with reduced precision
and/or argument range. */
# if __GNUC_PREREQ (3, 5)
# define __expm1_code \
register long double __temp; \
__temp = __builtin_expm1l (__x); \
return __temp ? __temp : __x
# else
# define __expm1_code \
register long double __value; \
register long double __exponent; \
register long double __temp; \
__asm __volatile__ \
("fldl2e # e^x - 1 = 2^(x * log2(e)) - 1\n\t" \
"fmul %%st(1) # x * log2(e)\n\t" \
"fst %%st(1)\n\t" \
"frndint # int(x * log2(e))\n\t" \
"fxch\n\t" \
"fsub %%st(1) # fract(x * log2(e))\n\t" \
"f2xm1 # 2^(fract(x * log2(e))) - 1\n\t" \
"fscale # 2^(x * log2(e)) - 2^(int(x * log2(e)))\n\t" \
: "=t" (__value), "=u" (__exponent) : "0" (__x)); \
__asm __volatile__ \
("fscale # 2^int(x * log2(e))\n\t" \
: "=t" (__temp) : "0" (1.0), "u" (__exponent)); \
__temp -= 1.0; \
__temp += __value; \
return __temp ? __temp : __x
# endif
__inline_mathcodeNP_ (long double, __expm1l, __x, __expm1_code)
# if __GNUC_PREREQ (3, 4)
__inline_mathcodeNP_ (long double, __expl, __x, return __builtin_expl (__x))
# else
# define __exp_code \
register long double __value; \
register long double __exponent; \
__asm __volatile__ \
("fldl2e # e^x = 2^(x * log2(e))\n\t" \
"fmul %%st(1) # x * log2(e)\n\t" \
"fst %%st(1)\n\t" \
"frndint # int(x * log2(e))\n\t" \
"fxch\n\t" \
"fsub %%st(1) # fract(x * log2(e))\n\t" \
"f2xm1 # 2^(fract(x * log2(e))) - 1\n\t" \
: "=t" (__value), "=u" (__exponent) : "0" (__x)); \
__value += 1.0; \
__asm __volatile__ \
("fscale" \
: "=t" (__value) : "0" (__value), "u" (__exponent)); \
return __value
__inline_mathcodeNP (exp, __x, __exp_code)
__inline_mathcodeNP_ (long double, __expl, __x, __exp_code)
# endif
# endif /* __FAST_MATH__ */
# ifdef __FAST_MATH__
# if !__GNUC_PREREQ (3,3)
__inline_mathopNP (sqrt, "fsqrt")
__inline_mathopNP_ (long double, __sqrtl, "fsqrt")
# define __libc_sqrtl(n) __sqrtl (n)
# else
# define __libc_sqrtl(n) __builtin_sqrtl (n)
# endif
# endif
# if __GNUC_PREREQ (2, 8)
__inline_mathcodeNP_ (double, fabs, __x, return __builtin_fabs (__x))
# ifdef __USE_ISOC99
__inline_mathcodeNP_ (float, fabsf, __x, return __builtin_fabsf (__x))
__inline_mathcodeNP_ (long double, fabsl, __x, return __builtin_fabsl (__x))
# endif
__inline_mathcodeNP_ (long double, __fabsl, __x, return __builtin_fabsl (__x))
# else
__inline_mathop (fabs, "fabs")
__inline_mathop_ (long double, __fabsl, "fabs")
# endif
__inline_mathcode_ (long double, __sgn1l, __x, \
__extension__ union { long double __xld; unsigned int __xi[3]; } __n = \
{ __xld: __x }; \
__n.__xi[2] = (__n.__xi[2] & 0x8000) | 0x3fff; \
__n.__xi[1] = 0x80000000; \
__n.__xi[0] = 0; \
return __n.__xld)
# ifdef __FAST_MATH__
/* The argument range of the inline version of sinhl is slightly reduced. */
__inline_mathcodeNP (sinh, __x, \
register long double __exm1 = __expm1l (__fabsl (__x)); \
return 0.5 * (__exm1 / (__exm1 + 1.0) + __exm1) * __sgn1l (__x))
__inline_mathcodeNP (cosh, __x, \
register long double __ex = __expl (__x); \
return 0.5 * (__ex + 1.0 / __ex))
__inline_mathcodeNP (tanh, __x, \
register long double __exm1 = __expm1l (-__fabsl (__x + __x)); \
return __exm1 / (__exm1 + 2.0) * __sgn1l (-__x))
# endif
/* Optimized versions for some non-standardized functions. */
# ifdef __USE_ISOC99
# ifdef __FAST_MATH__
__inline_mathcodeNP (expm1, __x, __expm1_code)
/* The argument range of the inline version of asinhl is slightly reduced. */
__inline_mathcodeNP (asinh, __x, \
register long double __y = __fabsl (__x); \
return (log1pl (__y * __y / (__libc_sqrtl (__y * __y + 1.0) + 1.0) + __y) \
* __sgn1l (__x)))
__inline_mathcodeNP (acosh, __x, \
return logl (__x + __libc_sqrtl (__x - 1.0) * __libc_sqrtl (__x + 1.0)))
__inline_mathcodeNP (atanh, __x, \
register long double __y = __fabsl (__x); \
return -0.5 * log1pl (-(__y + __y) / (1.0 + __y)) * __sgn1l (__x))
/* The argument range of the inline version of hypotl is slightly reduced. */
__inline_mathcodeNP2 (hypot, __x, __y,
return __libc_sqrtl (__x * __x + __y * __y))
# endif
# endif
/* Undefine some of the large macros which are not used anymore. */
# ifdef __FAST_MATH__
# undef __expm1_code
# undef __exp_code
# endif /* __FAST_MATH__ */
# endif /* __NO_MATH_INLINES */
/* This code is used internally in the GNU libc. */
# ifdef __LIBC_INTERNAL_MATH_INLINES
__inline_mathcode2_ (long double, __ieee754_atan2l, __y, __x,
register long double __value;
__asm __volatile__ ("fpatan\n\t"
: "=t" (__value)
: "0" (__x), "u" (__y) : "st(1)");
return __value;)
# endif
#endif /* !__SSE2_MATH__ && !__x86_64__ */