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.

2 files changed, 32 insertions, 295 deletions

diff --git a/sysdeps/x86/fpu/bits/mathinline.h b/sysdeps/x86/fpu/bits/mathinline.h
deleted file mode 100644
index 95ab9f5b82..0000000000
--- a/sysdeps/x86/fpu/bits/mathinline.h
+++ /dev/null
@@ -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__ */
diff --git a/sysdeps/x86/fpu/math_private.h b/sysdeps/x86/fpu/math_private.h
new file mode 100644
index 0000000000..dba29d6428
--- /dev/null
+++ b/sysdeps/x86/fpu/math_private.h
@@ -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