Remove x86 mathinline.h.
After previous cleanups, the only code in the x86 bits/mathinline.h that is relevant with current compilers is the inline of __ieee754_atan2l that is conditional on __LIBC_INTERNAL_MATH_INLINES (i.e. for when libm itself is being built). This inline is something that does belong in glibc not GCC, since __ieee754_atan2l is a purely internal function name. This patch moves that inline to a new sysdeps/x86/fpu/math_private.h, removing the bits/mathinline.h header. Note that previously the inline was only for non-SSE 32-bit x86. That condition does not make sense, however, for a long double function; if it's not inlined, exactly the same x87 instruction will end up getting used by the out-of-line function, for both 32-bit and 64-bit. So that condition is not retained in the new version. Tested for x86_64 and x86. As expected, installed stripped shared libraries are unchanged for 32-bit x86, but installed stripped libm.so is changed for x86_64 because calls to __ieee754_atan2l start being inlined where previously they were out of line calls. (The same change to start inlining the function would presumably also apply for 32-bit built with -mfpmath=sse, but that's not a configuration I've tested.) * sysdeps/x86/fpu/math_private.h: New file. * sysdeps/x86/fpu/bits/mathinline.h: Remove.
This commit is contained in:
Joseph Myers
parent
515f463f52
commit
da75c1b180
|
|
@ -1,5 +1,8 @@
|
|||
2018-12-19 Joseph Myers <joseph@codesourcery.com>
|
||||
|
||||
* sysdeps/x86/fpu/math_private.h: New file.
|
||||
* sysdeps/x86/fpu/bits/mathinline.h: Remove.
|
||||
|
||||
* sysdeps/x86/fpu/bits/mathinline.h (sinh): Remove inline
|
||||
definition.
|
||||
(cosh): Likewise.
|
||||
|
|
|
|||
|
|
@ -1,295 +0,0 @@
|
|||
/* 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)
|
||||
|
||||
|
||||
/* Optimized versions for some non-standardized functions. */
|
||||
# ifdef __USE_ISOC99
|
||||
|
||||
# ifdef __FAST_MATH__
|
||||
__inline_mathcodeNP (expm1, __x, __expm1_code)
|
||||
|
||||
# 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__ */
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
/* Private inline math functions for x86.
|
||||
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 X86_MATH_PRIVATE_H
|
||||
#define X86_MATH_PRIVATE_H 1
|
||||
|
||||
#include_next <math_private.h>
|
||||
|
||||
__extern_always_inline long double
|
||||
__NTH (__ieee754_atan2l (long double y, long double x))
|
||||
{
|
||||
long double ret;
|
||||
__asm__ __volatile__ ("fpatan" : "=t" (ret) : "0" (x), "u" (y) : "st(1)");
|
||||
return ret;
|
||||
}
|
||||
|
||||
#endif
|
||||
Loading…
Reference in New Issue