Make totalorder and totalordermag functions take pointer arguments.

The resolution of C floating-point Clarification Request 25
<http://www.open-std.org/jtc1/sc22/wg14/www/docs/n2397.htm#dr_25> is
that the totalorder and totalordermag functions should take pointer
arguments, and this has been adopted in C2X (with const added; note
that the integration of this change into C2X is present in the C
standard git repository but postdates the most recent public PDF
draft).

This patch updates glibc accordingly.  As a defect resolution, the API
is changed unconditionally rather than supporting any sort of TS
18661-1 mode for compilation with the old version of the API.  There
are compat symbols for existing binaries that pass floating-point
arguments directly.  As a consequence of changing to pointer
arguments, there are no longer type-generic macros in tgmath.h for
these functions.

Because of the fairly complicated logic for creating libm function
aliases and determining the set of aliases to create in a given glibc
configuration, rather than duplicating all that in individual source
files to create the versioned and compat symbols, the source files for
the various versions of totalorder functions are set up to redefine
weak_alias before using libm_alias_* macros to create the symbols
required.  In turn, this requires creating a separate alias for each
symbol version pointing to the same implementation (see binutils bug
<https://sourceware.org/bugzilla/show_bug.cgi?id=23840>), which is
done automatically using __COUNTER__.  (As I noted in
<https://sourceware.org/ml/libc-alpha/2018-10/msg00631.html>, it might
well make sense for glibc's symbol versioning macros to do that alias
creation with __COUNTER__ themselves, which would somewhat simplify
the logic in the totalorder source files.)

It is of course desirable to test the compat symbols.  I did this with
the generic libm-test machinery, but didn't wish to duplicate the
actual tables of test inputs and outputs, and thought it risky to
attempt to have a single object file refer to both default and compat
versions of the same function in order to test them together.  Thus, I
created libm-test-compat_totalorder.inc and
libm-test-compat_totalordermag.inc which include the generated .c
files (with the processed version of those tables of inputs) from the
non-compat tests, and added appropriate dependencies.  I think this
provides sufficient test coverage for the compat symbols without also
needing to make the special ldbl-96 and ldbl-128ibm tests (of
peculiarities relating to the representations of those formats that
can't be covered in the generic tests) run for the compat symbols.

Tests of compat symbols need to be internal tests, meaning _ISOMAC is
not defined.  Making some libm-test tests into internal tests showed
up two other issues.  GCC diagnoses duplicate macro definitions of
__STDC_* macros, including __STDC_WANT_IEC_60559_TYPES_EXT__; I added
an appropriate conditional and filed
<https://gcc.gnu.org/bugzilla/show_bug.cgi?id=91451> for this issue.
On ia64, include/setjmp.h ends up getting included indirectly from
libm-symbols.h, resulting in conflicting definitions of the STR macro
(also defined in libm-test-driver.c); I renamed the macros in
include/setjmp.h.  (It's arguable that we should have common internal
headers used everywhere for stringizing and concatenation macros.)

Tested for x86_64 and x86, and with build-many-glibcs.py.

	* math/bits/mathcalls.h
	[__GLIBC_USE (IEC_60559_BFP_EXT) || __MATH_DECLARING_FLOATN]
	(totalorder): Take pointer arguments.
	[__GLIBC_USE (IEC_60559_BFP_EXT) || __MATH_DECLARING_FLOATN]
	(totalordermag): Likewise.
	* manual/arith.texi (totalorder): Likewise.
	(totalorderf): Likewise.
	(totalorderl): Likewise.
	(totalorderfN): Likewise.
	(totalorderfNx): Likewise.
	(totalordermag): Likewise.
	(totalordermagf): Likewise.
	(totalordermagl): Likewise.
	(totalordermagfN): Likewise.
	(totalordermagfNx): Likewise.
	* math/tgmath.h (__TGMATH_BINARY_REAL_RET_ONLY): Remove macro.
	[__GLIBC_USE (IEC_60559_BFP_EXT)] (totalorder): Likewise.
	[__GLIBC_USE (IEC_60559_BFP_EXT)] (totalordermag): Likewise.
	* math/Versions (GLIBC_2.31): Add totalorder, totalorderf,
	totalorderl, totalordermag, totalordermagf, totalordermagl,
	totalorderf32, totalorderf64, totalorderf32x, totalordermagf32,
	totalordermagf64, totalordermagf32x, totalorderf64x,
	totalordermagf64x, totalorderf128 and totalordermagf128.
	* math/Makefile (libm-test-funcs-noauto): Add compat_totalorder
	and compat_totalordermag.
	(libm-test-funcs-compat): New variable.
	(libm-tests-compat): Likewise.
	(tests): Do not include compat tests.
	(tests-internal): Add compat tests.
	($(foreach t,$(libm-tests-base),
	$(objpfx)$(t)-compat_totalorder.o)): Depend
	on $(objpfx)libm-test-totalorder.c.
	($(foreach t,$(libm-tests-base),
	$(objpfx)$(t)-compat_totalordermag.o): Depend on
	$(objpfx)libm-test-totalordermag.c.
	(tgmath3-macros): Remove totalorder and totalordermag.
	* math/libm-test-compat_totalorder.inc: New file.
	* math/libm-test-compat_totalordermag.inc: Likewise.
	* math/libm-test-driver.c (struct test_ff_i_data): Update comment.
	(RUN_TEST_fpfp_b): New macro.
	(RUN_TEST_LOOP_fpfp_b): Likewise.
	* math/libm-test-totalorder.inc (totalorder_test_data): Use
	TEST_fpfp_b.
	(totalorder_test): Condition on [!COMPAT_TEST].
	(do_test): Likewise.
	* math/libm-test-totalordermag.inc (totalordermag_test_data): Use
	TEST_fpfp_b.
	(totalordermag_test): Condition on [!COMPAT_TEST].
	(do_test): Likewise.
	* math/gen-tgmath-tests.py (Tests.add_all_tests): Remove
	totalorder and totalordermag.
	* math/test-tgmath.c (NCALLS): Change to 132.
	(F(compile_test)): Do not call totalorder or totalordermag.
	(F(totalorder)): Remove.
	(F(totalordermag)): Likewise.
	* include/float.h (__STDC_WANT_IEC_60559_TYPES_EXT__): Do not
	define if [__STDC_WANT_IEC_60559_TYPES_EXT__].
	* include/setjmp.h [!_ISOMAC] (STR_HELPER): Rename to
	SJSTR_HELPER.
	[!_ISOMAC] (STR): Rename to SJSTR.  Update call to STR_HELPER.
	[!_ISOMAC] (TEST_SIZE): Update call to STR.
	[!_ISOMAC] (TEST_ALIGN): Likewise.
	[!_ISOMAC] (TEST_OFFSET): Likewise.
	* sysdeps/ieee754/dbl-64/s_totalorder.c: Include <shlib-compat.h>
	and <first-versions.h>.
	(__totalorder): Take pointer arguments.  Add symbol versions and
	compat symbols.
	* sysdeps/ieee754/dbl-64/s_totalordermag.c: Include
	<shlib-compat.h> and <first-versions.h>.
	(__totalordermag): Take pointer arguments.  Add symbol versions
	and compat symbols.
	* sysdeps/ieee754/dbl-64/wordsize-64/s_totalorder.c: Include
	<shlib-compat.h> and <first-versions.h>.
	(__totalorder): Take pointer arguments.  Add symbol versions and
	compat symbols.
	* sysdeps/ieee754/dbl-64/wordsize-64/s_totalordermag.c: Include
	<shlib-compat.h> and <first-versions.h>.
	(__totalordermag): Take pointer arguments.  Add symbol versions
	and compat symbols.
	* sysdeps/ieee754/float128/float128_private.h
	(__totalorder_compatl): New macro.
	(__totalordermag_compatl): Likewise.
	* sysdeps/ieee754/flt-32/s_totalorderf.c: Include <shlib-compat.h>
	and <first-versions.h>.
	(__totalorderf): Take pointer arguments.  Add symbol versions and
	compat symbols.
	* sysdeps/ieee754/flt-32/s_totalordermagf.c: Include
	<shlib-compat.h> and <first-versions.h>.
	(__totalordermagf): Take pointer arguments.  Add symbol versions
	and compat symbols.
	* sysdeps/ieee754/ldbl-128/s_totalorderl.c: Include
	<shlib-compat.h> and <first-versions.h>.
	(__totalorderl): Take pointer arguments.  Add symbol versions and
	compat symbols.
	* sysdeps/ieee754/ldbl-128/s_totalordermagl.c: Include
	<shlib-compat.h> and <first-versions.h>.
	(__totalordermagl): Take pointer arguments.  Add symbol versions
	and compat symbols.
	* sysdeps/ieee754/ldbl-128ibm/s_totalorderl.c: Include
	<shlib-compat.h>.
	(__totalorderl): Take pointer arguments.  Add symbol versions and
	compat symbols.
	* sysdeps/ieee754/ldbl-128ibm/s_totalordermagl.c: Include
	<shlib-compat.h>.
	(__totalordermagl): Take pointer arguments.  Add symbol versions
	and compat symbols.
	* sysdeps/ieee754/ldbl-96/s_totalorderl.c: Include
	<shlib-compat.h> and <first-versions.h>.
	(__totalorderl): Take pointer arguments.  Add symbol versions and
	compat symbols.
	* sysdeps/ieee754/ldbl-96/s_totalordermagl.c: Include
	<shlib-compat.h> and <first-versions.h>.
	(__totalordermagl): Take pointer arguments.  Add symbol versions
	and compat symbols.
	* sysdeps/ieee754/ldbl-opt/nldbl-totalorder.c (totalorderl): Take
	pointer arguments.
	* sysdeps/ieee754/ldbl-opt/nldbl-totalordermag.c (totalordermagl):
	Likewise.
	* sysdeps/ieee754/ldbl-128ibm/test-totalorderl-ldbl-128ibm.c
	(do_test): Update calls to totalorderl and totalordermagl.
	* sysdeps/ieee754/ldbl-96/test-totalorderl-ldbl-96.c (do_test):
	Update calls to totalorderl and totalordermagl.
	* sysdeps/mach/hurd/i386/libm.abilist: Update.
	* sysdeps/unix/sysv/linux/aarch64/libm.abilist: Likewise.
	* sysdeps/unix/sysv/linux/alpha/libm.abilist: Likewise.
	* sysdeps/unix/sysv/linux/arm/libm.abilist: Likewise.
	* sysdeps/unix/sysv/linux/csky/libm.abilist: Likewise.
	* sysdeps/unix/sysv/linux/hppa/libm.abilist: Likewise.
	* sysdeps/unix/sysv/linux/i386/libm.abilist: Likewise.
	* sysdeps/unix/sysv/linux/ia64/libm.abilist: Likewise.
	* sysdeps/unix/sysv/linux/m68k/coldfire/libm.abilist: Likewise.
	* sysdeps/unix/sysv/linux/m68k/m680x0/libm.abilist: Likewise.
	* sysdeps/unix/sysv/linux/microblaze/libm.abilist: Likewise.
	* sysdeps/unix/sysv/linux/mips/mips32/libm.abilist: Likewise.
	* sysdeps/unix/sysv/linux/mips/mips64/libm.abilist: Likewise.
	* sysdeps/unix/sysv/linux/nios2/libm.abilist: Likewise.
	* sysdeps/unix/sysv/linux/powerpc/powerpc32/fpu/libm.abilist:
	Likewise.
	* sysdeps/unix/sysv/linux/powerpc/powerpc32/nofpu/libm.abilist:
	Likewise.
	* sysdeps/unix/sysv/linux/powerpc/powerpc64/be/libm.abilist:
	Likewise.
	* sysdeps/unix/sysv/linux/powerpc/powerpc64/le/libm.abilist:
	Likewise.
	* sysdeps/unix/sysv/linux/riscv/rv64/libm.abilist: Likewise.
	* sysdeps/unix/sysv/linux/s390/s390-32/libm.abilist: Likewise.
	* sysdeps/unix/sysv/linux/s390/s390-64/libm.abilist: Likewise.
	* sysdeps/unix/sysv/linux/sh/libm.abilist: Likewise.
	* sysdeps/unix/sysv/linux/sparc/sparc32/libm.abilist: Likewise.
	* sysdeps/unix/sysv/linux/sparc/sparc64/libm.abilist: Likewise.
	* sysdeps/unix/sysv/linux/x86_64/64/libm.abilist: Likewise.
	* sysdeps/unix/sysv/linux/x86_64/x32/libm.abilist: Likewise.

11 files changed, 624 insertions, 506 deletions

diff --git a/math/Makefile b/math/Makefile
index cb4eaec6a9..15c864c98b 100644
--- a/math/Makefile
+++ b/math/Makefile
@@ -287,7 +287,8 @@ libm-test-funcs-noauto = canonicalize ceil cimag conj copysign cproj creal \
 			 nextup remainder remquo rint round roundeven scalb \
 			 scalbln scalbn setpayload setpayloadsig signbit \
 			 significand totalorder totalordermag trunc ufromfp \
-			 ufromfpx
+			 ufromfpx compat_totalorder compat_totalordermag
+libm-test-funcs-compat = compat_totalorder compat_totalordermag
 libm-test-funcs-narrow = add div mul sub
 libm-test-funcs-all = $(libm-test-funcs-auto) $(libm-test-funcs-noauto)
 libm-test-c-auto = $(foreach f,$(libm-test-funcs-auto),libm-test-$(f).c)
@@ -319,6 +320,11 @@ libm-tests-vector = $(foreach t,$(libmvec-tests),\
 				$(foreach f,$($(t)-funcs),test-$(t)-$(f)))
 libm-tests = $(libm-tests-normal) $(libm-tests-finite) $(libm-tests-inline) \
 	     $(libm-tests-narrow) $(libm-tests-vector)
+libm-tests-compat = $(foreach t,$(libm-tests-base-normal) \
+				$(libm-tests-base-finite) \
+				$(libm-tests-base-inline),\
+				$(foreach f,$(libm-test-funcs-compat),\
+					    $(t)-$(f)))
 libm-tests-for-type = $(foreach f,$(libm-test-funcs-all),\
 				  test-$(1)-$(f) test-$(1)-finite-$(f) \
 				  test-i$(1)-$(f)) \
@@ -327,7 +333,8 @@ libm-tests-for-type = $(foreach f,$(libm-test-funcs-all),\
 
 libm-tests.o = $(addsuffix .o,$(libm-tests))
 
-tests += $(libm-tests)
+tests += $(filter-out $(libm-tests-compat),$(libm-tests))
+tests-internal += $(libm-tests-compat)
 generated += $(addsuffix .c,$(libm-tests)) \
 	     $(foreach t,$(test-types),libm-test-support-$(t).c)
 
@@ -352,6 +359,15 @@ $(libm-test-c-narrow-obj): $(objpfx)libm-test%.c: libm-test%.inc \
 	$(make-target-directory)
 	$(PYTHON) gen-libm-test.py -c $< -a auto-libm-test-out$* -C $@
 
+# Tests for totalorder compat symbols reuse the table of tests as
+# processed by gen-libm-test.py, so add dependencies on the generated
+# .c files.
+$(foreach t,$(libm-tests-base),\
+	    $(objpfx)$(t)-compat_totalorder.o): $(objpfx)libm-test-totalorder.c
+
+$(foreach t,$(libm-tests-base),\
+	    $(objpfx)$(t)-compat_totalordermag.o): $(objpfx)libm-test-totalordermag.c
+
 tgmath3-macros = atan2 cbrt ceil copysign erf erfc exp2 expm1 fdim floor \
 		 fma fmax fmin fmod frexp hypot ilogb ldexp lgamma llrint \
 		 llround log10 log1p log2 logb lrint lround nearbyint \
@@ -359,8 +375,7 @@ tgmath3-macros = atan2 cbrt ceil copysign erf erfc exp2 expm1 fdim floor \
 		 scalbln tgamma trunc acos asin atan acosh asinh atanh cos \
 		 sin tan cosh sinh tanh exp log pow sqrt fabs carg cimag conj \
 		 cproj creal roundeven nextup nextdown fminmag fmaxmag llogb \
-		 fromfp fromfpx ufromfp ufromfpx totalorder totalordermag \
-		 scalb
+		 fromfp fromfpx ufromfp ufromfpx scalb
 tgmath3-macro-tests = $(addprefix test-tgmath3-,$(tgmath3-macros))
 tests += $(tgmath3-macro-tests)
 generated += $(addsuffix .c,$(tgmath3-macro-tests))
diff --git a/math/Versions b/math/Versions
index f1ab297577..d892c5f911 100644
--- a/math/Versions
+++ b/math/Versions
@@ -579,4 +579,15 @@ libm {
     # No SVID compatible error handling.
     exp; exp2; log; log2; pow;
   }
+  GLIBC_2.31 {
+    # totalorder changed to take pointer arguments.
+    totalorder; totalorderf; totalorderl;
+    totalordermag; totalordermagf; totalordermagl;
+    totalorderf32; totalorderf64; totalorderf32x;
+    totalordermagf32; totalordermagf64; totalordermagf32x;
+    totalorderf64x;
+    totalordermagf64x;
+    totalorderf128;
+    totalordermagf128;
+  }
 }
diff --git a/math/bits/mathcalls.h b/math/bits/mathcalls.h
index 47808a2915..66832c7827 100644
--- a/math/bits/mathcalls.h
+++ b/math/bits/mathcalls.h
@@ -373,11 +373,12 @@ __MATHDECL_1 (int, canonicalize,, (_Mdouble_ *__cx, const _Mdouble_ *__x));
 
 #if __GLIBC_USE (IEC_60559_BFP_EXT) || __MATH_DECLARING_FLOATN
 /* Total order operation.  */
-__MATHDECL_1 (int, totalorder,, (_Mdouble_ __x, _Mdouble_ __y))
+__MATHDECL_1 (int, totalorder,, (const _Mdouble_ *__x, const _Mdouble_ *__y))
      __attribute__ ((__const__));
 
 /* Total order operation on absolute values.  */
-__MATHDECL_1 (int, totalordermag,, (_Mdouble_ __x, _Mdouble_ __y))
+__MATHDECL_1 (int, totalordermag,, (const _Mdouble_ *__x,
+				    const _Mdouble_ *__y))
      __attribute__ ((__const__));
 
 /* Get NaN payload.  */
diff --git a/math/gen-tgmath-tests.py b/math/gen-tgmath-tests.py
index 724a437b69..2a7d94e737 100755
--- a/math/gen-tgmath-tests.py
+++ b/math/gen-tgmath-tests.py
@@ -575,8 +575,6 @@ class Tests(object):
         self.add_tests('fromfpx', 'intmax_t', ['r', 'int', 'unsigned int'])
         self.add_tests('ufromfp', 'uintmax_t', ['r', 'int', 'unsigned int'])
         self.add_tests('ufromfpx', 'uintmax_t', ['r', 'int', 'unsigned int'])
-        self.add_tests('totalorder', 'int', ['r', 'r'])
-        self.add_tests('totalordermag', 'int', ['r', 'r'])
         # The functions that round their result to a narrower type,
         # and the associated type-generic macros, are not yet
         # supported by this script or by glibc.
diff --git a/math/libm-test-compat_totalorder.inc b/math/libm-test-compat_totalorder.inc
new file mode 100644
index 0000000000..7ad87342fd
--- /dev/null
+++ b/math/libm-test-compat_totalorder.inc
@@ -0,0 +1,56 @@
+/* Test totalorder compat symbol.
+   Copyright (C) 2019 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/>.  */
+
+#include <shlib-compat.h>
+#include <first-versions.h>
+#define COMPAT_TEST
+#include "libm-test-totalorder.c"
+
+#define CONCATX(x, y) x ## y
+#define CONCAT(x, y) CONCATX (x, y)
+#define COMPAT_VER CONCAT (FIRST_VERSION_libm_, FUNC_TEST (totalorder))
+
+#if TEST_COMPAT (libm, COMPAT_VER, GLIBC_2_31)
+
+int FUNC_TEST (compat_totalorder) (FLOAT, FLOAT);
+compat_symbol_reference (libm,
+			 FUNC_TEST (compat_totalorder),
+			 FUNC_TEST (totalorder),
+			 COMPAT_VER);
+
+static void
+compat_totalorder_test (void)
+{
+  ALL_RM_TEST (compat_totalorder, 1, totalorder_test_data, RUN_TEST_LOOP_ff_b, END);
+}
+
+#endif
+
+static void
+do_test (void)
+{
+#if TEST_COMPAT (libm, GLIBC_2_25, GLIBC_2_31)
+  compat_totalorder_test ();
+#endif
+}
+
+/*
+ * Local Variables:
+ * mode:c
+ * End:
+ */
diff --git a/math/libm-test-compat_totalordermag.inc b/math/libm-test-compat_totalordermag.inc
new file mode 100644
index 0000000000..1f82946fbf
--- /dev/null
+++ b/math/libm-test-compat_totalordermag.inc
@@ -0,0 +1,56 @@
+/* Test totalordermag compat symbol.
+   Copyright (C) 2019 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/>.  */
+
+#include <shlib-compat.h>
+#include <first-versions.h>
+#define COMPAT_TEST
+#include "libm-test-totalordermag.c"
+
+#define CONCATX(x, y) x ## y
+#define CONCAT(x, y) CONCATX (x, y)
+#define COMPAT_VER CONCAT (FIRST_VERSION_libm_, FUNC_TEST (totalordermag))
+
+#if TEST_COMPAT (libm, COMPAT_VER, GLIBC_2_31)
+
+int FUNC_TEST (compat_totalordermag) (FLOAT, FLOAT);
+compat_symbol_reference (libm,
+			 FUNC_TEST (compat_totalordermag),
+			 FUNC_TEST (totalordermag),
+			 COMPAT_VER);
+
+static void
+compat_totalordermag_test (void)
+{
+  ALL_RM_TEST (compat_totalordermag, 1, totalordermag_test_data, RUN_TEST_LOOP_ff_b, END);
+}
+
+#endif
+
+static void
+do_test (void)
+{
+#if TEST_COMPAT (libm, GLIBC_2_25, GLIBC_2_31)
+  compat_totalordermag_test ();
+#endif
+}
+
+/*
+ * Local Variables:
+ * mode:c
+ * End:
+ */
diff --git a/math/libm-test-driver.c b/math/libm-test-driver.c
index 4640f30d64..d9b9b383ad 100644
--- a/math/libm-test-driver.c
+++ b/math/libm-test-driver.c
@@ -326,7 +326,8 @@ struct test_f_i_data
     int exceptions;
   } rd, rn, rz, ru;
 };
-/* Used for both RUN_TEST_LOOP_ff_b and RUN_TEST_LOOP_ff_i_tg.  */
+/* Used for RUN_TEST_LOOP_ff_b, RUN_TEST_LOOP_fpfp_b and
+   RUN_TEST_LOOP_ff_i_tg.  */
 struct test_ff_i_data
 {
   const char *arg_str;
@@ -860,6 +861,26 @@ struct test_Ff_b1_data
 		     (ARRAY)[i].RM_##ROUNDING_MODE.expected,		\
 		     (ARRAY)[i].RM_##ROUNDING_MODE.exceptions);		\
   ROUND_RESTORE_ ## ROUNDING_MODE
+#define RUN_TEST_fpfp_b(ARG_STR, FUNC_NAME, ARG1, ARG2, EXPECTED,	\
+			EXCEPTIONS)					\
+  do									\
+    if (enable_test (EXCEPTIONS))					\
+      {									\
+	COMMON_TEST_SETUP (ARG_STR);					\
+	check_bool (test_name,						\
+		    FUNC_TEST (FUNC_NAME) (&(ARG1), &(ARG2)),		\
+		    EXPECTED, EXCEPTIONS);				\
+	COMMON_TEST_CLEANUP;						\
+      }									\
+  while (0)
+#define RUN_TEST_LOOP_fpfp_b(FUNC_NAME, ARRAY, ROUNDING_MODE)		\
+  IF_ROUND_INIT_ ## ROUNDING_MODE					\
+    for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++)	\
+      RUN_TEST_fpfp_b ((ARRAY)[i].arg_str, FUNC_NAME,			\
+		       (ARRAY)[i].arg1, (ARRAY)[i].arg2,		\
+		       (ARRAY)[i].RM_##ROUNDING_MODE.expected,		\
+		       (ARRAY)[i].RM_##ROUNDING_MODE.exceptions);	\
+  ROUND_RESTORE_ ## ROUNDING_MODE
 #define RUN_TEST_ff_i_tg(ARG_STR, FUNC_NAME, ARG1, ARG2, EXPECTED,	\
 			 EXCEPTIONS)					\
   do									\
diff --git a/math/libm-test-totalorder.inc b/math/libm-test-totalorder.inc
index dc6106e2a4..9f3216b485 100644
--- a/math/libm-test-totalorder.inc
+++ b/math/libm-test-totalorder.inc
@@ -20,249 +20,250 @@
 
 static const struct test_ff_i_data totalorder_test_data[] =
   {
-    TEST_ff_b (totalorder, minus_zero, minus_zero, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, minus_zero, plus_zero, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, minus_zero, 1, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, minus_zero, minus_infty, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, minus_zero, plus_infty, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, minus_zero, qnan_value, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, minus_zero, -qnan_value, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, minus_zero, snan_value, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, minus_zero, -snan_value, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, plus_zero, minus_zero, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, plus_zero, plus_zero, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, plus_zero, 1, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, plus_zero, minus_infty, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, plus_zero, plus_infty, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, plus_zero, qnan_value, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, plus_zero, -qnan_value, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, plus_zero, snan_value, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, plus_zero, -snan_value, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, 1, minus_zero, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, 1, plus_zero, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, 1, 1, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, 1, minus_infty, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, 1, plus_infty, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, 1, qnan_value, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, 1, -qnan_value, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, 1, snan_value, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, 1, -snan_value, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, minus_infty, minus_zero, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, minus_infty, plus_zero, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, minus_infty, 1, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, minus_infty, minus_infty, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, minus_infty, plus_infty, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, minus_infty, qnan_value, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, minus_infty, -qnan_value, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, minus_infty, snan_value, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, minus_infty, -snan_value, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, plus_infty, minus_zero, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, plus_infty, plus_zero, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, plus_infty, 1, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, plus_infty, minus_infty, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, plus_infty, plus_infty, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, plus_infty, qnan_value, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, plus_infty, -qnan_value, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, plus_infty, snan_value, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, plus_infty, -snan_value, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, qnan_value, minus_zero, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, -qnan_value, minus_zero, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, qnan_value, plus_zero, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, -qnan_value, plus_zero, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
-    TEST_ff_b (totalorder, qnan_value, 1, 0, NO_INEXACT_EXCEPTION|ERRN