Move math_opt_barrier, math_force_eval to separate math-barriers.h [committed]

Message ID alpine.DEB.2.20.1805091946420.21191@digraph.polyomino.org.uk
State New
Headers show
Series
  • Move math_opt_barrier, math_force_eval to separate math-barriers.h [committed]
Related show

Commit Message

Joseph Myers May 9, 2018, 7:47 p.m.
This patch continues cleaning up math_private.h by moving the
math_opt_barrier and math_force_eval macros to a separate header
math-barriers.h.

At present, those macros are inside a "#ifndef math_opt_barrier" in
math_private.h to allow architectures to override them and then use
#include_next to include the generic math_private.h.  With the move to
a separate math-barriers.h header, no such #ifndef or #include_next is
needed; architectures just have their own alternative version of
math-barriers.h when providing their own optimized versions that avoid
going through memory unnecessarily.  The generic math-barriers.h has a
comment added to document these two macros.

In this patch, math_private.h is made to #include <math-barriers.h>,
so files using these macros do not need updating yet.  That is because
of uses of math_force_eval in math_check_force_underflow and
math_check_force_underflow_nonneg, which are still defined in
math_private.h.  Once those are moved out to a separate header, that
separate header can be made to include <math-barriers.h>, as can the
other files directly using these barrier macros, and then the include
of <math-barriers.h> from math_private.h can be removed.

Tested for x86_64 and x86.  Also tested with build-many-glibcs.py that
installed stripped shared libraries are unchanged by this patch.  
Committed.

2018-05-09  Joseph Myers  <joseph@codesourcery.com>

	* sysdeps/generic/math-barriers.h: New file.
	* sysdeps/generic/math_private.h [!math_opt_barrier]
	(math_opt_barrier): Move to math-barriers.h.
	[!math_opt_barrier] (math_force_eval): Likewise.
	* sysdeps/aarch64/fpu/math-barriers.h: New file.
	* sysdeps/aarch64/fpu/math_private.h (math_opt_barrier): Move to
	math-barriers.h.
	(math_force_eval): Likewise.
	* sysdeps/alpha/fpu/math-barriers.h: New file.
	* sysdeps/alpha/fpu/math_private.h (math_opt_barrier): Move to
	math-barriers.h.
	(math_force_eval): Likewise.
	* sysdeps/x86/fpu/math-barriers.h: New file.
	* sysdeps/i386/fpu/fenv_private.h (math_opt_barrier): Move to
	math-barriers.h.
	(math_force_eval): Likewise.
	* sysdeps/m68k/m680x0/fpu/math_private.h: Move to....
	* sysdeps/m68k/m680x0/fpu/math-barriers.h: ... here.  Adjust
	multiple-include guard for rename.
	* sysdeps/powerpc/fpu/math-barriers.h: New file.
	* sysdeps/powerpc/fpu/math_private.h (math_opt_barrier): Move to
	math-barriers.h.
	(math_force_eval): Likewise.

Patch

diff --git a/sysdeps/aarch64/fpu/math-barriers.h b/sysdeps/aarch64/fpu/math-barriers.h
new file mode 100644
index 0000000..7db937b
--- /dev/null
+++ b/sysdeps/aarch64/fpu/math-barriers.h
@@ -0,0 +1,27 @@ 
+/* Control when floating-point expressions are evaluated.  AArch64 version.
+   Copyright (C) 2014-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 AARCH64_MATH_BARRIERS_H
+#define AARCH64_MATH_BARRIERS_H 1
+
+#define math_opt_barrier(x)					\
+  ({ __typeof (x) __x = (x); __asm ("" : "+w" (__x)); __x; })
+#define math_force_eval(x)						\
+  ({ __typeof (x) __x = (x); __asm __volatile__ ("" : : "w" (__x)); })
+
+#endif
diff --git a/sysdeps/aarch64/fpu/math_private.h b/sysdeps/aarch64/fpu/math_private.h
index d9c2d71..fcd02c0 100644
--- a/sysdeps/aarch64/fpu/math_private.h
+++ b/sysdeps/aarch64/fpu/math_private.h
@@ -22,11 +22,6 @@ 
 #include <fenv.h>
 #include <fpu_control.h>
 
-#define math_opt_barrier(x) \
-({ __typeof (x) __x = (x); __asm ("" : "+w" (__x)); __x; })
-#define math_force_eval(x) \
-({ __typeof (x) __x = (x); __asm __volatile__ ("" : : "w" (__x)); })
-
 static __always_inline void
 libc_feholdexcept_aarch64 (fenv_t *envp)
 {
diff --git a/sysdeps/alpha/fpu/math-barriers.h b/sysdeps/alpha/fpu/math-barriers.h
new file mode 100644
index 0000000..27a64d7
--- /dev/null
+++ b/sysdeps/alpha/fpu/math-barriers.h
@@ -0,0 +1,28 @@ 
+/* Control when floating-point expressions are evaluated.  Alpha version.
+   Copyright (C) 2014-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 ALPHA_MATH_BARRIERS_H
+#define ALPHA_MATH_BARRIERS_H 1
+
+/* Generic code forces values to memory; we don't need to do that.  */
+#define math_opt_barrier(x) \
+  ({ __typeof (x) __x = (x); __asm ("" : "+frm" (__x)); __x; })
+#define math_force_eval(x) \
+  ({ __typeof (x) __x = (x); __asm __volatile__ ("" : : "frm" (__x)); })
+
+#endif
diff --git a/sysdeps/alpha/fpu/math_private.h b/sysdeps/alpha/fpu/math_private.h
index 95dc32c..c71447a 100644
--- a/sysdeps/alpha/fpu/math_private.h
+++ b/sysdeps/alpha/fpu/math_private.h
@@ -13,12 +13,6 @@ 
 # define __isnanf __isnanf
 #endif
 
-/* Generic code forces values to memory; we don't need to do that.  */
-#define math_opt_barrier(x) \
-  ({ __typeof (x) __x = (x); __asm ("" : "+frm" (__x)); __x; })
-#define math_force_eval(x) \
-  ({ __typeof (x) __x = (x); __asm __volatile__ ("" : : "frm" (__x)); })
-
 #include_next <math_private.h>
 
 #endif /* ALPHA_MATH_PRIVATE_H */
diff --git a/sysdeps/generic/math-barriers.h b/sysdeps/generic/math-barriers.h
new file mode 100644
index 0000000..4251731
--- /dev/null
+++ b/sysdeps/generic/math-barriers.h
@@ -0,0 +1,37 @@ 
+/* Control when floating-point expressions are evaluated.  Generic version.
+   Copyright (C) 2007-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_BARRIERS_H
+#define _MATH_BARRIERS_H	1
+
+/* math_opt_barrier evaluates and returns its floating-point argument
+   and ensures that the evaluation of any expression using the result
+   of math_opt_barrier is not moved before the call.  math_force_eval
+   ensures that its floating-point argument is evaluated for its side
+   effects even if its value is apparently unused, and that the
+   evaluation of its argument is not moved after the call.  Both these
+   macros are used to ensure the correct ordering of floating-point
+   expression evaluations with respect to accesses to the
+   floating-point environment.  */
+
+#define math_opt_barrier(x)					\
+  ({ __typeof (x) __x = (x); __asm ("" : "+m" (__x)); __x; })
+#define math_force_eval(x)						\
+  ({ __typeof (x) __x = (x); __asm __volatile__ ("" : : "m" (__x)); })
+
+#endif /* math-barriers.h */
diff --git a/sysdeps/generic/math_private.h b/sysdeps/generic/math_private.h
index 703f506..f6faf71 100644
--- a/sysdeps/generic/math_private.h
+++ b/sysdeps/generic/math_private.h
@@ -263,12 +263,7 @@  extern double __mpsin (double __x, double __dx, bool __range_reduce);
 extern double __mpcos (double __x, double __dx, bool __range_reduce);
 extern void __docos (double __x, double __dx, double __v[]);
 
-#ifndef math_opt_barrier
-# define math_opt_barrier(x) \
-({ __typeof (x) __x = (x); __asm ("" : "+m" (__x)); __x; })
-# define math_force_eval(x) \
-({ __typeof (x) __x = (x); __asm __volatile__ ("" : : "m" (__x)); })
-#endif
+#include <math-barriers.h>
 
 #define fabs_tg(x) __MATH_TG ((x), (__typeof (x)) __builtin_fabs, (x))
 
diff --git a/sysdeps/i386/fpu/fenv_private.h b/sysdeps/i386/fpu/fenv_private.h
index 357613a..59e83d8 100644
--- a/sysdeps/i386/fpu/fenv_private.h
+++ b/sysdeps/i386/fpu/fenv_private.h
@@ -5,45 +5,6 @@ 
 #include <fenv.h>
 #include <fpu_control.h>
 
-#ifdef __SSE2_MATH__
-# define math_opt_barrier(x)						\
-  ({ __typeof(x) __x;							\
-     if (sizeof (x) <= sizeof (double)					\
-	|| __builtin_types_compatible_p (__typeof (x), _Float128))	\
-       __asm ("" : "=x" (__x) : "0" (x));				\
-     else								\
-       __asm ("" : "=t" (__x) : "0" (x));				\
-     __x; })
-# define math_force_eval(x)						\
-  do {									\
-    if (sizeof (x) <= sizeof (double)					\
-	|| __builtin_types_compatible_p (__typeof (x), _Float128))	\
-      __asm __volatile ("" : : "x" (x));				\
-    else								\
-      __asm __volatile ("" : : "f" (x));				\
-  } while (0)
-#else
-# define math_opt_barrier(x)						\
-  ({ __typeof (x) __x;							\
-     if (__builtin_types_compatible_p (__typeof (x), _Float128))	\
-       {								\
-	 __x = (x);							\
-	 __asm ("" : "+m" (__x));					\
-       }								\
-     else								\
-       __asm ("" : "=t" (__x) : "0" (x));				\
-     __x; })
-# define math_force_eval(x)						\
-  do {									\
-    __typeof (x) __x = (x);						\
-    if (sizeof (x) <= sizeof (double)					\
-	|| __builtin_types_compatible_p (__typeof (x), _Float128))	\
-      __asm __volatile ("" : : "m" (__x));				\
-    else								\
-      __asm __volatile ("" : : "f" (__x));				\
-  } while (0)
-#endif
-
 /* This file is used by both the 32- and 64-bit ports.  The 64-bit port
    has a field in the fenv_t for the mxcsr; the 32-bit port does not.
    Instead, we (ab)use the only 32-bit field extant in the struct.  */
diff --git a/sysdeps/m68k/m680x0/fpu/math-barriers.h b/sysdeps/m68k/m680x0/fpu/math-barriers.h
new file mode 100644
index 0000000..b1b78d5
--- /dev/null
+++ b/sysdeps/m68k/m680x0/fpu/math-barriers.h
@@ -0,0 +1,37 @@ 
+/* Control when floating-point expressions are evaluated.  M68k version.
+   Copyright (C) 2011-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 M68K_MATH_BARRIERS_H
+#define M68K_MATH_BARRIERS_H 1
+
+#define math_opt_barrier(x) \
+({ __typeof (x) __x;					\
+   __asm ("" : "=f" (__x) : "0" (x));			\
+   __x; })
+#define math_force_eval(x) \
+do							\
+  {							\
+    __typeof (x) __x = (x);				\
+    if (sizeof (x) <= sizeof (double))			\
+      __asm __volatile ("" : : "m" (__x));		\
+    else						\
+      __asm __volatile ("" : : "f" (__x));		\
+  }							\
+while (0)
+
+#endif
diff --git a/sysdeps/m68k/m680x0/fpu/math_private.h b/sysdeps/m68k/m680x0/fpu/math_private.h
deleted file mode 100644
index 2b79095..0000000
--- a/sysdeps/m68k/m680x0/fpu/math_private.h
+++ /dev/null
@@ -1,20 +0,0 @@ 
-#ifndef M68K_MATH_PRIVATE_H
-#define M68K_MATH_PRIVATE_H 1
-
-#define math_opt_barrier(x) \
-({ __typeof (x) __x;					\
-   __asm ("" : "=f" (__x) : "0" (x));			\
-   __x; })
-#define math_force_eval(x) \
-do							\
-  {							\
-    __typeof (x) __x = (x);				\
-    if (sizeof (x) <= sizeof (double))			\
-      __asm __volatile ("" : : "m" (__x));		\
-    else						\
-      __asm __volatile ("" : : "f" (__x));		\
-  }							\
-while (0)
-
-#include_next <math_private.h>
-#endif
diff --git a/sysdeps/powerpc/fpu/math-barriers.h b/sysdeps/powerpc/fpu/math-barriers.h
new file mode 100644
index 0000000..6da2102
--- /dev/null
+++ b/sysdeps/powerpc/fpu/math-barriers.h
@@ -0,0 +1,28 @@ 
+/* Control when floating-point expressions are evaluated.  PowerPC version.
+   Copyright (C) 2017-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 POWERPC_MATH_BARRIERS_H
+#define POWERPC_MATH_BARRIERS_H 1
+
+/* Avoid putting floating point values in memory.  */
+# define math_opt_barrier(x)					\
+  ({ __typeof (x) __x = (x); __asm ("" : "+dwa" (__x)); __x; })
+# define math_force_eval(x)						\
+  ({ __typeof (x) __x = (x); __asm __volatile__ ("" : : "dwa" (__x)); })
+
+#endif
diff --git a/sysdeps/powerpc/fpu/math_private.h b/sysdeps/powerpc/fpu/math_private.h
index b9fc721..e642d6c 100644
--- a/sysdeps/powerpc/fpu/math_private.h
+++ b/sysdeps/powerpc/fpu/math_private.h
@@ -24,12 +24,6 @@ 
 #include <dl-procinfo.h>
 #include <fenv_private.h>
 
-/* Avoid putting floating point values in memory.  */
-# define math_opt_barrier(x)					\
-  ({ __typeof (x) __x = (x); __asm ("" : "+dwa" (__x)); __x; })
-# define math_force_eval(x)						\
-  ({ __typeof (x) __x = (x); __asm __volatile__ ("" : : "dwa" (__x)); })
-
 #include_next <math_private.h>
 
 #if defined _ARCH_PWR9 && __HAVE_DISTINCT_FLOAT128
diff --git a/sysdeps/x86/fpu/math-barriers.h b/sysdeps/x86/fpu/math-barriers.h
new file mode 100644
index 0000000..1e1fabd
--- /dev/null
+++ b/sysdeps/x86/fpu/math-barriers.h
@@ -0,0 +1,61 @@ 
+/* Control when floating-point expressions are evaluated.  x86 version.
+   Copyright (C) 2007-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_BARRIERS_H
+#define X86_MATH_BARRIERS_H 1
+
+#ifdef __SSE2_MATH__
+# define math_opt_barrier(x)						\
+  ({ __typeof(x) __x;							\
+     if (sizeof (x) <= sizeof (double)					\
+	|| __builtin_types_compatible_p (__typeof (x), _Float128))	\
+       __asm ("" : "=x" (__x) : "0" (x));				\
+     else								\
+       __asm ("" : "=t" (__x) : "0" (x));				\
+     __x; })
+# define math_force_eval(x)						\
+  do {									\
+    if (sizeof (x) <= sizeof (double)					\
+	|| __builtin_types_compatible_p (__typeof (x), _Float128))	\
+      __asm __volatile ("" : : "x" (x));				\
+    else								\
+      __asm __volatile ("" : : "f" (x));				\
+  } while (0)
+#else
+# define math_opt_barrier(x)						\
+  ({ __typeof (x) __x;							\
+     if (__builtin_types_compatible_p (__typeof (x), _Float128))	\
+       {								\
+	 __x = (x);							\
+	 __asm ("" : "+m" (__x));					\
+       }								\
+     else								\
+       __asm ("" : "=t" (__x) : "0" (x));				\
+     __x; })
+# define math_force_eval(x)						\
+  do {									\
+    __typeof (x) __x = (x);						\
+    if (sizeof (x) <= sizeof (double)					\
+	|| __builtin_types_compatible_p (__typeof (x), _Float128))	\
+      __asm __volatile ("" : : "m" (__x));				\
+    else								\
+      __asm __volatile ("" : : "f" (__x));				\
+  } while (0)
+#endif
+
+#endif