Run libm tests separately for each function.

At present, libm tests for each function get built into a single
executable (for each floating point type, for each of normal / inline
/ finite-math-only functions, plus vector variants) and run together,
resulting in a single PASS or FAIL (for each of those nine variants
plus vector variants).  Building this executable involves reading
over 50 MB of libm-test-*.c sources.

This patch arranges for tests of each function to be run separately
from the makefiles instead.  There are 121 functions being tested for
each (type, variant pair) (actually 126, but run as 121 from the
Makefile because each of the pairs (exp10, pow10), (isfinite, finite),
(lgamma, gamma), (remainder, drem), (scalbn, ldexp), shares a table of
test results and so is run together), so 1089 separate tests run from
the Makefile, plus 48 vector tests on x86_64 (six functions for eight
vector variants).  Each test only involves a libm-test-<func>.c file
of no more than about 4 MB, rather than all such files taking about 50
MB.  With tests run separately, test summaries will indicate which
functions actually have problems (of course, those problems may just
be out-of-date libm-test-ulps files if the file hasn't been updated
for the architecture in question recently).

All the .c files for the 1089+48 tests are generated automatically
from the Makefiles.  Various checked-in boilerplate .c files are
removed as no longer needed.  CFLAGS definitions for the different
kinds of tests are generated using makefile iterators to apply
target-specific variable settings.  libm-have-vector-test.h is no
longer needed; the list of functions to test for each vector type is
now in the sysdeps Makefile.

This should reduce the amount of boilerplate needed for float128
testing support; test-float128.h will still be needed, but not various
.c files or Makefile CFLAGS definitions.  The logic for creating
dependencies on libm-test-support-*.o files should also render
<https://sourceware.org/ml/libc-alpha/2017-02/msg00279.html>
unnecessary.

Tested for x86_64 and x86.

	* math/Makefile (libm-tests-generated): Remove variable.
	(libm-tests-base-normal): New variable.
	(libm-tests-base-finite): Likewise.
	(libm-tests-base-inline): Likewise.
	(libm-tests-base): Likewise.
	(libm-tests-normal): Likewise.
	(libm-tests-finite): Likewise.
	(libm-tests-inline): Likewise.
	(libm-tests-vector): Likewise.
	(libm-tests): Define in terms of these new variables.
	(libm-tests-for-type): New variable.
	(libm-tests.o): Move definition.
	(tests): Move addition of $(libm-tests).
	(generated): Update for new and removed libm test files.
	($(objpfx)libm-test.c): Remove target.
	($(objpfx)libm-have-vector-test.h): Likewise.
	(CFLAGS-test-double-vlen2.c): Remove variable.
	(CFLAGS-test-double-vlen4.c): Likewise.
	(CFLAGS-test-double-vlen8.c): Likewise.
	(CFLAGS-test-float-vlen4.c): Likewise.
	(CFLAGS-test-float-vlen8.c): Likewise.
	(CFLAGS-test-float-vlen16.c): Likewise.
	(CFLAGS-test-float.c): Likewise.
	(CFLAGS-test-float-finite.c): Likewise.
	(CFLAGS-libm-test-support-float.c): Likewise.
	(CFLAGS-test-double.c): Likewise.
	(CFLAGS-test-double-finite.c): Likewise.
	(CFLAGS-libm-test-support-double.c): Likewise.
	(CFLAGS-test-ldouble.c): Likewise.
	(CFLAGS-test-ldouble-finite.c): Likewise.
	(CFLAGS-libm-test-support-ldouble.c): Likewise.
	(libm-test-inline-cflags): New variable.
	(CFLAGS-test-ifloat.c): Remove variable.
	(CFLAGS-test-idouble.c): Likewise.
	(CFLAGS-test-ildouble.c): Likewise.
	($(addprefix $(objpfx), $(libm-tests.o))): Move target and update
	dependencies.
	($(foreach t,$(libm-tests-normal),$(objpfx)$(t).c)): New rule.
	($(foreach t,$(libm-tests-finite),$(objpfx)$(t).c)): Likewise.
	($(foreach t,$(libm-tests-inline),$(objpfx)$(t).c)): Likewise.
	($(foreach t,$(libm-tests-vector),$(objpfx)$(t).c)): Likewise.
	($(foreach t,$(types),$(objpfx)libm-test-support-$(t).c)):
	Likewise.
	(dependencies on libm-test-support-*.o): Remove.
	($(foreach f,$(libm-test-funcs-all),$(objpfx)$(o)-$(f).o)): New
	rules using iterators.
	($(addprefix $(objpfx),$(call libm-tests-for-type,$(o)))):
	Likewise.
	($(objpfx)libm-test-support-$(o).o): Likewise.
	($(addprefix $(objpfx),$(filter-out $(tests-static)
	$(libm-vec-tests),$(tests)))): Filter out $(libm-tests-vector)
	instead.
	($(addprefix $(objpfx), $(libm-vec-tests))): Use iterator to
	define rule instead.
	* math/README.libm-test: Update.
	* math/libm-test-acos.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-acosh.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-asin.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-asinh.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-atan.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-atan2.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-atanh.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-cabs.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-cacos.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-cacosh.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-canonicalize.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-carg.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-casin.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-casinh.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-catan.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-catanh.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-cbrt.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-ccos.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-ccosh.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-ceil.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-cexp.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-cimag.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-clog.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-clog10.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-conj.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-copysign.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-cos.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-cosh.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-cpow.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-cproj.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-creal.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-csin.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-csinh.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-csqrt.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-ctan.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-ctanh.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-erf.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-erfc.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-exp.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-exp10.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-exp2.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-expm1.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-fabs.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-fdim.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-floor.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-fma.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-fmax.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-fmaxmag.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-fmin.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-fminmag.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-fmod.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-fpclassify.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-frexp.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-fromfp.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-fromfpx.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-getpayload.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-hypot.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-ilogb.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-iscanonical.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-iseqsig.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-isfinite.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-isgreater.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-isgreaterequal.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-isinf.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-isless.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-islessequal.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-islessgreater.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-isnan.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-isnormal.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-issignaling.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-issubnormal.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-isunordered.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-iszero.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-j0.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-j1.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-jn.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-lgamma.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-llogb.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-llrint.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-llround.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-log.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-log10.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-log1p.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-log2.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-logb.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-lrint.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-lround.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-modf.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-nearbyint.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-nextafter.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-nextdown.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-nexttoward.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-nextup.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-pow.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-remainder.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-remquo.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-rint.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-round.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-roundeven.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-scalb.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-scalbln.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-scalbn.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-setpayload.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-setpayloadsig.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-signbit.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-significand.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-sin.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-sincos.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-sinh.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-sqrt.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-tan.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-tanh.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-tgamma.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-totalorder.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-totalordermag.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-trunc.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-ufromfp.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-ufromfpx.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-y0.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-y1.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-yn.inc: Include libm-test-driver.c.
	(do_test): New function.
	* math/libm-test-driver.c: Do not include libm-have-vector-test.h.
	(HAVE_VECTOR): Remove macro.
	(START): Do not call HAVE_VECTOR.
	* math/test-double-vlen2.h (FUNC_TEST): Remove macro.
	* math/test-double-vlen4.h (FUNC_TEST): Remove macro.
	* math/test-double-vlen8.h (FUNC_TEST): Remove macro.
	* math/test-float-vlen16.h (FUNC_TEST): Remove macro.
	* math/test-float-vlen4.h (FUNC_TEST): Remove macro.
	* math/test-float-vlen8.h (FUNC_TEST): Remove macro.
	* math/test-math-vector.h (FUNC_TEST): New macro.
	(WRAPPER_DECL): Rename to WRAPPER_DECL_f.
	* sysdeps/x86_64/fpu/Makefile (double-vlen2-funcs): New variable.
	(double-vlen4-funcs): Likewise.
	(double-vlen4-avx2-funcs): Likewise.
	(double-vlen8-funcs): Likewise.
	(float-vlen4-funcs): Likewise.
	(float-vlen8-funcs): Likewise.
	(float-vlen8-avx2-funcs): Likewise.
	(float-vlen16-funcs): Likewise.
	(CFLAGS-test-double-vlen4-avx2.c): Remove variable.
	(CFLAGS-test-float-vlen8-avx2.c): Likewise.
	* sysdeps/x86_64/fpu/test-double-vlen4.h (TEST_VECTOR_cos): Remove
	macro.
	(TEST_VECTOR_sin): Likewise.
	(TEST_VECTOR_sincos): Likewise.
	(TEST_VECTOR_log): Likewise.
	(TEST_VECTOR_exp): Likewise.
	(TEST_VECTOR_pow): Likewise.
	* sysdeps/x86_64/fpu/test-double-vlen8.h (TEST_VECTOR_cos):
	Likewise.
	(TEST_VECTOR_sin): Likewise.
	(TEST_VECTOR_sincos): Likewise.
	(TEST_VECTOR_log): Likewise.
	(TEST_VECTOR_exp): Likewise.
	(TEST_VECTOR_pow): Likewise.
	* sysdeps/x86_64/fpu/test-float-vlen16.h (TEST_VECTOR_cosf):
	Likewise.
	(TEST_VECTOR_sinf): Likewise.
	(TEST_VECTOR_sincosf): Likewise.
	(TEST_VECTOR_logf): Likewise.
	(TEST_VECTOR_expf): Likewise.
	(TEST_VECTOR_powf): Likewise.
	* sysdeps/x86_64/fpu/test-float-vlen8.h (TEST_VECTOR_cosf):
	Likewise.
	(TEST_VECTOR_sinf): Likewise.
	(TEST_VECTOR_sincosf): Likewise.
	(TEST_VECTOR_logf): Likewise.
	(TEST_VECTOR_expf): Likewise.
	(TEST_VECTOR_powf): Likewise.
	* math/gen-libm-have-vector-test.sh: Remove file.
	* math/libm-test.inc: Likewise.
	* math/libm-test-support-double.c: Likewise.
	* math/libm-test-support-float.c: Likewise.
	* math/libm-test-support-ldouble.c: Likewise.
	* math/test-double-finite.c: Likewise.: Likewise.
	* math/test-double.c: Likewise.
	* math/test-float-finite.c: Likewise.
	* math/test-float.c: Likewise.
	* math/test-idouble.c: Likewise.
	* math/test-ifloat.c: Likewise.
	* math/test-ildouble.c: Likewise.
	* math/test-ldouble-finite.c: Likewise.
	* math/test-ldouble.c: Likewise.
	* sysdeps/x86_64/fpu/test-double-vlen2.c: Likewise.
	* sysdeps/x86_64/fpu/test-double-vlen2.h: Likewise.
	* sysdeps/x86_64/fpu/test-double-vlen4-avx2.c: Likewise.
	* sysdeps/x86_64/fpu/test-double-vlen4.c: Likewise.
	* sysdeps/x86_64/fpu/test-double-vlen8.c: Likewise.
	* sysdeps/x86_64/fpu/test-float-vlen16.c: Likewise.
	* sysdeps/x86_64/fpu/test-float-vlen4.c: Likewise.
	* sysdeps/x86_64/fpu/test-float-vlen4.h: Likewise.
	* sysdeps/x86_64/fpu/test-float-vlen8-avx2.c: Likewise.
	* sysdeps/x86_64/fpu/test-float-vlen8.c: Likewise.

161 files changed, 1512 insertions, 973 deletions

diff --git a/ChangeLog b/ChangeLog
index f1bf7ca6a4..da57aba27c 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,376 @@
+2017-02-24  Joseph Myers  <joseph@codesourcery.com>
+
+	* math/Makefile (libm-tests-generated): Remove variable.
+	(libm-tests-base-normal): New variable.
+	(libm-tests-base-finite): Likewise.
+	(libm-tests-base-inline): Likewise.
+	(libm-tests-base): Likewise.
+	(libm-tests-normal): Likewise.
+	(libm-tests-finite): Likewise.
+	(libm-tests-inline): Likewise.
+	(libm-tests-vector): Likewise.
+	(libm-tests): Define in terms of these new variables.
+	(libm-tests-for-type): New variable.
+	(libm-tests.o): Move definition.
+	(tests): Move addition of $(libm-tests).
+	(generated): Update for new and removed libm test files.
+	($(objpfx)libm-test.c): Remove target.
+	($(objpfx)libm-have-vector-test.h): Likewise.
+	(CFLAGS-test-double-vlen2.c): Remove variable.
+	(CFLAGS-test-double-vlen4.c): Likewise.
+	(CFLAGS-test-double-vlen8.c): Likewise.
+	(CFLAGS-test-float-vlen4.c): Likewise.
+	(CFLAGS-test-float-vlen8.c): Likewise.
+	(CFLAGS-test-float-vlen16.c): Likewise.
+	(CFLAGS-test-float.c): Likewise.
+	(CFLAGS-test-float-finite.c): Likewise.
+	(CFLAGS-libm-test-support-float.c): Likewise.
+	(CFLAGS-test-double.c): Likewise.
+	(CFLAGS-test-double-finite.c): Likewise.
+	(CFLAGS-libm-test-support-double.c): Likewise.
+	(CFLAGS-test-ldouble.c): Likewise.
+	(CFLAGS-test-ldouble-finite.c): Likewise.
+	(CFLAGS-libm-test-support-ldouble.c): Likewise.
+	(libm-test-inline-cflags): New variable.
+	(CFLAGS-test-ifloat.c): Remove variable.
+	(CFLAGS-test-idouble.c): Likewise.
+	(CFLAGS-test-ildouble.c): Likewise.
+	($(addprefix $(objpfx), $(libm-tests.o))): Move target and update
+	dependencies.
+	($(foreach t,$(libm-tests-normal),$(objpfx)$(t).c)): New rule.
+	($(foreach t,$(libm-tests-finite),$(objpfx)$(t).c)): Likewise.
+	($(foreach t,$(libm-tests-inline),$(objpfx)$(t).c)): Likewise.
+	($(foreach t,$(libm-tests-vector),$(objpfx)$(t).c)): Likewise.
+	($(foreach t,$(types),$(objpfx)libm-test-support-$(t).c)):
+	Likewise.
+	(dependencies on libm-test-support-*.o): Remove.
+	($(foreach f,$(libm-test-funcs-all),$(objpfx)$(o)-$(f).o)): New
+	rules using iterators.
+	($(addprefix $(objpfx),$(call libm-tests-for-type,$(o)))):
+	Likewise.
+	($(objpfx)libm-test-support-$(o).o): Likewise.
+	($(addprefix $(objpfx),$(filter-out $(tests-static)
+	$(libm-vec-tests),$(tests)))): Filter out $(libm-tests-vector)
+	instead.
+	($(addprefix $(objpfx), $(libm-vec-tests))): Use iterator to
+	define rule instead.
+	* math/README.libm-test: Update.
+	* math/libm-test-acos.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-acosh.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-asin.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-asinh.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-atan.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-atan2.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-atanh.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-cabs.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-cacos.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-cacosh.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-canonicalize.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-carg.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-casin.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-casinh.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-catan.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-catanh.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-cbrt.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-ccos.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-ccosh.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-ceil.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-cexp.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-cimag.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-clog.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-clog10.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-conj.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-copysign.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-cos.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-cosh.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-cpow.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-cproj.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-creal.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-csin.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-csinh.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-csqrt.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-ctan.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-ctanh.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-erf.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-erfc.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-exp.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-exp10.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-exp2.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-expm1.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-fabs.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-fdim.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-floor.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-fma.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-fmax.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-fmaxmag.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-fmin.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-fminmag.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-fmod.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-fpclassify.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-frexp.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-fromfp.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-fromfpx.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-getpayload.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-hypot.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-ilogb.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-iscanonical.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-iseqsig.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-isfinite.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-isgreater.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-isgreaterequal.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-isinf.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-isless.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-islessequal.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-islessgreater.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-isnan.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-isnormal.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-issignaling.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-issubnormal.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-isunordered.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-iszero.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-j0.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-j1.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-jn.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-lgamma.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-llogb.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-llrint.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-llround.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-log.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-log10.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-log1p.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-log2.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-logb.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-lrint.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-lround.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-modf.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-nearbyint.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-nextafter.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-nextdown.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-nexttoward.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-nextup.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-pow.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-remainder.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-remquo.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-rint.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-round.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-roundeven.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-scalb.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-scalbln.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-scalbn.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-setpayload.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-setpayloadsig.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-signbit.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-significand.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-sin.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-sincos.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-sinh.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-sqrt.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-tan.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-tanh.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-tgamma.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-totalorder.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-totalordermag.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-trunc.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-ufromfp.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-ufromfpx.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-y0.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-y1.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-yn.inc: Include libm-test-driver.c.
+	(do_test): New function.
+	* math/libm-test-driver.c: Do not include libm-have-vector-test.h.
+	(HAVE_VECTOR): Remove macro.
+	(START): Do not call HAVE_VECTOR.
+	* math/test-double-vlen2.h (FUNC_TEST): Remove macro.
+	* math/test-double-vlen4.h (FUNC_TEST): Remove macro.
+	* math/test-double-vlen8.h (FUNC_TEST): Remove macro.
+	* math/test-float-vlen16.h (FUNC_TEST): Remove macro.
+	* math/test-float-vlen4.h (FUNC_TEST): Remove macro.
+	* math/test-float-vlen8.h (FUNC_TEST): Remove macro.
+	* math/test-math-vector.h (FUNC_TEST): New macro.
+	(WRAPPER_DECL): Rename to WRAPPER_DECL_f.
+	* sysdeps/x86_64/fpu/Makefile (double-vlen2-funcs): New variable.
+	(double-vlen4-funcs): Likewise.
+	(double-vlen4-avx2-funcs): Likewise.
+	(double-vlen8-funcs): Likewise.
+	(float-vlen4-funcs): Likewise.
+	(float-vlen8-funcs): Likewise.
+	(float-vlen8-avx2-funcs): Likewise.
+	(float-vlen16-funcs): Likewise.
+	(CFLAGS-test-double-vlen4-avx2.c): Remove variable.
+	(CFLAGS-test-float-vlen8-avx2.c): Likewise.
+	* sysdeps/x86_64/fpu/test-double-vlen4.h (TEST_VECTOR_cos): Remove
+	macro.
+	(TEST_VECTOR_sin): Likewise.
+	(TEST_VECTOR_sincos): Likewise.
+	(TEST_VECTOR_log): Likewise.
+	(TEST_VECTOR_exp): Likewise.
+	(TEST_VECTOR_pow): Likewise.
+	* sysdeps/x86_64/fpu/test-double-vlen8.h (TEST_VECTOR_cos):
+	Likewise.
+	(TEST_VECTOR_sin): Likewise.
+	(TEST_VECTOR_sincos): Likewise.
+	(TEST_VECTOR_log): Likewise.
+	(TEST_VECTOR_exp): Likewise.
+	(TEST_VECTOR_pow): Likewise.
+	* sysdeps/x86_64/fpu/test-float-vlen16.h (TEST_VECTOR_cosf):
+	Likewise.
+	(TEST_VECTOR_sinf): Likewise.
+	(TEST_VECTOR_sincosf): Likewise.
+	(TEST_VECTOR_logf): Likewise.
+	(TEST_VECTOR_expf): Likewise.
+	(TEST_VECTOR_powf): Likewise.
+	* sysdeps/x86_64/fpu/test-float-vlen8.h (TEST_VECTOR_cosf):
+	Likewise.
+	(TEST_VECTOR_sinf): Likewise.
+	(TEST_VECTOR_sincosf): Likewise.
+	(TEST_VECTOR_logf): Likewise.
+	(TEST_VECTOR_expf): Likewise.
+	(TEST_VECTOR_powf): Likewise.
+	* math/gen-libm-have-vector-test.sh: Remove file.
+	* math/libm-test.inc: Likewise.
+	* math/libm-test-support-double.c: Likewise.
+	* math/libm-test-support-float.c: Likewise.
+	* math/libm-test-support-ldouble.c: Likewise.
+	* math/test-double-finite.c: Likewise.: Likewise.
+	* math/test-double.c: Likewise.
+	* math/test-float-finite.c: Likewise.
+	* math/test-float.c: Likewise.
+	* math/test-idouble.c: Likewise.
+	* math/test-ifloat.c: Likewise.
+	* math/test-ildouble.c: Likewise.
+	* math/test-ldouble-finite.c: Likewise.
+	* math/test-ldouble.c: Likewise.
+	* sysdeps/x86_64/fpu/test-double-vlen2.c: Likewise.
+	* sysdeps/x86_64/fpu/test-double-vlen2.h: Likewise.
+	* sysdeps/x86_64/fpu/test-double-vlen4-avx2.c: Likewise.
+	* sysdeps/x86_64/fpu/test-double-vlen4.c: Likewise.
+	* sysdeps/x86_64/fpu/test-double-vlen8.c: Likewise.
+	* sysdeps/x86_64/fpu/test-float-vlen16.c: Likewise.
+	* sysdeps/x86_64/fpu/test-float-vlen4.c: Likewise.
+	* sysdeps/x86_64/fpu/test-float-vlen4.h: Likewise.
+	* sysdeps/x86_64/fpu/test-float-vlen8-avx2.c: Likewise.
+	* sysdeps/x86_64/fpu/test-float-vlen8.c: Likewise.
+
 2017-02-23 Gabriel F. T. Gomes  <gftg@linux.vnet.ibm.com>
 	   Paul E. Murphy  <murphyp@linux.vnet.ibm.com>
 
diff --git a/math/Makefile b/math/Makefile
index 0cd3a4b4b9..29e7436162 100644
--- a/math/Makefile
+++ b/math/Makefile
@@ -196,13 +196,6 @@ endif
 
 ifneq (no,$(PERL))
 libm-vec-tests = $(addprefix test-,$(libmvec-tests))
-
-libm-tests = $(foreach t,$(types),test-$(t) test-$(t)-finite test-i$(t)) \
-	     $(libm-vec-tests)
-
-libm-tests.o = $(addsuffix .o,$(libm-tests))
-
-tests += $(libm-tests)
 libm-test-support = $(foreach t,$(types),libm-test-support-$(t))
 test-extras += $(libm-test-support)
 extra-test-objs += $(addsuffix .o, $(libm-test-support))
@@ -237,15 +230,42 @@ libm-test-funcs-noauto = canonicalize ceil cimag conj copysign cproj creal \
 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)
 libm-test-c-noauto = $(foreach f,$(libm-test-funcs-noauto),libm-test-$(f).c)
-libm-tests-generated = libm-test-ulps.h libm-have-vector-test.h libm-test.c \
-		       $(libm-test-c-auto) $(libm-test-c-noauto)
-generated += $(libm-tests-generated)
+generated += libm-test-ulps.h $(libm-test-c-auto) $(libm-test-c-noauto)
+
+libm-tests-base-normal = $(foreach t,$(types),test-$(t))
+libm-tests-base-finite = $(foreach t,$(types),test-$(t)-finite)
+libm-tests-base-inline = $(foreach t,$(types),test-i$(t))
+libm-tests-base = $(libm-tests-base-normal) $(libm-tests-base-finite) \
+		  $(libm-tests-base-inline) $(libm-vec-tests)
+libm-tests-normal = $(foreach t,$(libm-tests-base-normal),\
+				$(foreach f,$(libm-test-funcs-all),\
+					    $(t)-$(f)))
+libm-tests-finite = $(foreach t,$(libm-tests-base-finite),\
+				$(foreach f,$(libm-test-funcs-all),\
+					    $(t)-$(f)))
+libm-tests-inline = $(foreach t,$(libm-tests-base-inline),\
+				$(foreach f,$(libm-test-funcs-all),\
+					    $(t)-$(f)))
+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-vector)
+libm-tests-for-type = $(foreach f,$(libm-test-funcs-all),\
+				  test-$(1)-$(f) test-$(1)-finite-$(f) \
+				  test-i$(1)-$(f)) \
+		      $(filter test-$(1)-%,$(libm-tests-vector))
+
+libm-tests.o = $(addsuffix .o,$(libm-tests))
+
+tests += $(libm-tests)
+generated += $(addsuffix .c,$(libm-tests)) \
+	     $(foreach t,$(types),libm-test-support-$(t).c)
 
 libm-test-c-auto-obj = $(addprefix $(objpfx),$(libm-test-c-auto))
 libm-test-c-noauto-obj = $(addprefix $(objpfx),$(libm-test-c-noauto))
 
-$(objpfx)libm-test.c $(libm-test-c-noauto-obj): $(objpfx)libm-test%.c: \
-						libm-test%.inc gen-libm-test.pl
+$(libm-test-c-noauto-obj): $(objpfx)libm-test%.c: libm-test%.inc \
+						  gen-libm-test.pl
 	$(make-target-directory)
 	$(PERL) gen-libm-test.pl -c $< -a /dev/null -C $@
 
@@ -256,30 +276,18 @@ $(libm-test-c-auto-obj): $(objpfx)libm-test%.c: libm-test%.inc \
 	$(PERL) gen-libm-test.pl -c $< -a auto-libm-test-out$* -C $@
 
 libm-test-incs = $(foreach f,$(libm-test-funcs-all),libm-test-$(f).inc)
-
-$(objpfx)libm-have-vector-test.h: $(libm-test-incs) gen-libm-have-vector-test.sh
-	$(make-target-directory)
-	$(SHELL) gen-libm-have-vector-test.sh $(sort $(libm-test-incs)) > $@
 endif
 
 libm-test-fast-math-cflags = -fno-builtin -D__FAST_MATH__ -DTEST_FAST_MATH
 libm-test-vec-cflags = $(libm-test-fast-math-cflags) -fno-inline \
 		       -ffloat-store -D_OPENMP=201307 -Wno-unknown-pragmas
 
-CFLAGS-test-double-vlen2.c = $(libm-test-vec-cflags)
-
-CFLAGS-test-double-vlen4.c = $(libm-test-vec-cflags)
 CFLAGS-test-double-vlen4-wrappers.c = $(double-vlen4-arch-ext-cflags)
 
-CFLAGS-test-double-vlen8.c = $(libm-test-vec-cflags)
 CFLAGS-test-double-vlen8-wrappers.c = $(double-vlen8-arch-ext-cflags)
 
-CFLAGS-test-float-vlen4.c = $(libm-test-vec-cflags)
-
-CFLAGS-test-float-vlen8.c = $(libm-test-vec-cflags)
 CFLAGS-test-float-vlen8-wrappers.c = $(float-vlen8-arch-ext-cflags)
 
-CFLAGS-test-float-vlen16.c = $(libm-test-vec-cflags)
 CFLAGS-test-float-vlen16-wrappers.c = $(float-vlen16-arch-ext-cflags)
 
 # The no-inline tests use -fsignaling-nans, and thereby use the
@@ -292,15 +300,7 @@ libm-test-no-inline-cflags = -fno-inline -ffloat-store -fno-builtin \
 			     -fsignaling-nans
 libm-test-finite-cflags = $(libm-test-no-inline-cflags) \
 			  -U__FINITE_MATH_ONLY__ -D__FINITE_MATH_ONLY__=1
-CFLAGS-test-float.c = $(libm-test-no-inline-cflags)
-CFLAGS-test-float-finite.c = $(libm-test-finite-cflags)
-CFLAGS-libm-test-support-float.c = $(libm-test-no-inline-cflags)
-CFLAGS-test-double.c = $(libm-test-no-inline-cflags)
-CFLAGS-test-double-finite.c = $(libm-test-finite-cflags)
-CFLAGS-libm-test-support-double.c = $(libm-test-no-inline-cflags)
-CFLAGS-test-ldouble.c = $(libm-test-no-inline-cflags)
-CFLAGS-test-ldouble-finite.c = $(libm-test-finite-cflags)
-CFLAGS-libm-test-support-ldouble.c = $(libm-test-no-inline-cflags)
+libm-test-inline-cflags = $(libm-test-fast-math-cflags)
 CFLAGS-test-tgmath.c = -fno-builtin
 # The following testcase uses very long lines (>3 million), so it may take a
 # while to compile it. See: http://llvm.org/bugs/show_bug.cgi?id=14106 and
@@ -310,9 +310,6 @@ CFLAGS-test-tgmath-ret.c = -fno-builtin
 CFLAGS-test-powl.c = -fno-builtin
 
 CFLAGS-test-snan.c = -fsignaling-nans
-CFLAGS-test-ifloat.c = $(libm-test-fast-math-cflags)
-CFLAGS-test-idouble.c = $(libm-test-fast-math-cflags)
-CFLAGS-test-ildouble.c = $(libm-test-fast-math-cflags)
 
 CFLAGS-test-signgam-finite.c = -ffinite-math-only
 CFLAGS-test-signgam-finite-c99.c = -ffinite-math-only -std=c99
@@ -375,20 +372,111 @@ $(foreach t, $(call type-foreach, $(gen-all-calls)), \
 
 ifneq (no,$(PERL))
 # This must come after the inclusion of sysdeps Makefiles via Rules.
-$(addprefix $(objpfx), $(libm-tests.o)): $(addprefix $(objpfx),\
-						     $(libm-tests-generated))
 
-$(addprefix $(objpfx),\
-	    $(filter test-float% test-ifloat%,\
-		     $(libm-tests))): $(objpfx)libm-test-support-float.o
+$(foreach t,$(libm-tests-normal),$(objpfx)$(t).c): $(objpfx)test-%.c:
+	type_func=$*; \
+	type=$${type_func%%-*}; \
+	func=$${type_func#*-}; \
+	( \
+	  echo "#include <test-$$type.h>"; \
+	  echo "#include <test-math-no-finite.h>"; \
+	  echo "#include <test-math-no-inline.h>"; \
+	  echo "#include <test-math-errno.h>"; \
+	  echo "#include <test-math-scalar.h>"; \
+	  echo "#include <libm-test-$$func.c>"; \
+	) > $@
+
+$(foreach t,$(libm-tests-finite),$(objpfx)$(t).c): $(objpfx)test-%.c:
+	type_func=$*; \
+	type=$${type_func%%-*}; \
+	func=$${type_func#*-finite-}; \
+	( \
+	  echo "#include <test-$$type.h>"; \
+	  echo "#include <test-math-finite.h>"; \
+	  echo "#include <test-math-no-inline.h>"; \
+	  echo "#include <test-math-scalar.h>"; \
+	  echo "#include <libm-test-$$func.c>"; \
+	) > $@
+
+$(foreach t,$(libm-tests-inline),$(objpfx)$(t).c): $(objpfx)test-i%.c:
+	type_func=$*; \
+	type=$${type_func%%-*}; \
+	func=$${type_func#*-}; \
+	( \
+	  echo "#include <test-$$type.h>"; \
+	  echo "#include <test-math-inline.h>"; \
+	  echo "#include <test-math-scalar.h>"; \
+	  echo "#include <libm-test-$$func.c>"; \
+	) > $@
+
+$(foreach t,$(libm-tests-vector),$(objpfx)$(t).c): $(objpfx)test-%.c:
+	type_func=$*; \
+	type=$${type_func%-*}; \
+	func=$${type_func##*-}; \
+	func_args=$$(grep ALL_RM_TEST libm-test-$$func.inc \
+		     | sed 's/.*RUN_TEST_LOOP_//;s/_.*//'); \
+	( \
+	  echo "#include <test-$$type.h>"; \
+	  echo "WRAPPER_DECL_$$func_args (WRAPPER_NAME (FUNC ($$func)))"; \
+	  echo "#include <libm-test-$$func.c>"; \
+	) > $@
+
+$(foreach t,$(types),\
+	    $(objpfx)libm-test-support-$(t).c): $(objpfx)libm-test-support-%.c:
+	( \
+	  echo "#include <test-$*.h>"; \
+	  echo "#include <libm-test-support.c>"; \
+	) > $@
+
+$(addprefix $(objpfx), $(libm-tests.o)): $(objpfx)libm-test-ulps.h
 
-$(addprefix $(objpfx),\
-	    $(filter test-double% test-idouble%,\
-		     $(libm-tests))): $(objpfx)libm-test-support-double.o
+define o-iterator-doit
+$(foreach f,$(libm-test-funcs-all),\
+	    $(objpfx)$(o)-$(f).o): $(objpfx)$(o)%.o: $(objpfx)libm-test%.c
+endef
+object-suffixes-left := $(libm-tests-base)
+include $(o-iterator)
+
+define o-iterator-doit
+$(foreach f,$(libm-test-funcs-all),\
+	    $(objpfx)$(o)-$(f).o): CFLAGS += $(libm-test-no-inline-cflags)
+endef
+object-suffixes-left := $(libm-tests-base-normal)
+include $(o-iterator)
 
+define o-iterator-doit
+$(foreach f,$(libm-test-funcs-all),\
+	    $(objpfx)$(o)-$(f).o): CFLAGS += $(libm-test-finite-cflags)
+endef
+object-suffixes-left := $(libm-tests-base-finite)
+include $(o-iterator)
+
+define o-iterator-doit
+$(foreach f,$(libm-test-funcs-all),\
+	    $(objpfx)$(o)-$(f).o): CFLAGS += $(libm-test-inline-cflags)
+endef
+object-suffixes-left := $(libm-tests-base-inline)
+include $(o-iterator)
+
+define o-iterator-doit
+$(foreach f,$($(o)-funcs),\
+	    $(objpfx)test-$(o)-$(f).o): CFLAGS += $(libm-test-vec-cflags)
+endef
+object-suffixes-left := $(libmvec-tests)
+include $(o-iterator)
+
+define o-iterator-doit
 $(addprefix $(objpfx),\
-	    $(filter test-ldouble% test-ildouble%,\
-		     $(libm-tests))): $(objpfx)libm-test-support-ldouble.o
+	    $(call libm-tests-for-type,$(o))): $(objpfx)libm-test-support-$(o).o
+endef
+object-suffixes-left := $(types)
+include $(o-iterator)
+
+define o-iterator-doit
+$(objpfx)libm-test-support-$(o).o: CFLAGS += $(libm-test-no-inline-cflags)
+endef
+object-suffixes-left := $(types)
+include $(o-iterator)
 
 # Run the math programs to automatically generate ULPs files.
 .PHONY: regen-ulps
@@ -465,10 +553,16 @@ $(objpfx)libieee.a: $(objpfx)ieee-math.o
 	$(LN_S) $(<F) $(@F)
 
 $(addprefix $(objpfx),\
-	    $(filter-out $(tests-static) $(libm-vec-tests),$(tests))): $(libm)
+	    $(filter-out $(tests-static) $(libm-tests-vector),\
+			 $(tests))): $(libm)
 $(addprefix $(objpfx),$(tests-static)): $(objpfx)libm.a
-$(addprefix $(objpfx), $(libm-vec-tests)): $(objpfx)%: $(objpfx)%-wrappers.o \
-						       $(libm) $(libmvec)
+define o-iterator-doit
+$(foreach f,$($(o)-funcs),\
+	    $(objpfx)test-$(o)-$(f)): $(objpfx)test-$(o)-wrappers.o \
+				      $(libm) $(libmvec)
+endef
+object-suffixes-left := $(libmvec-tests)
+include $(o-iterator)
 
 gmp-objs = $(patsubst %,$(common-objpfx)stdlib/%.o,\
 		      add_n sub_n cmp addmul_1 mul_1 mul_n divmod_1 \
diff --git a/math/README.libm-test b/math/README.libm-test
index 442a47aff2..0271f83f3b 100644
--- a/math/README.libm-test
+++ b/math/README.libm-test
@@ -33,17 +33,18 @@ processing are "libm-test-<func>.c" and a file "libm-test-ulps.h" with
 platform specific deltas by which the actual math function results may
 deviate from the expected results and still be considered correct.
 
-The test drivers "test-double.c", "test-float.c", and "test-ldouble.c"
-test the normal double, float and long double implementation of libm.
-The test drivers with an 'i' in their name ("test-idouble.c",
-"test-ifloat.c", and "test-ildoubl.c") test the corresponding inline
-functions (where available - otherwise they also test the real
-functions in libm).  Each driver selects the desired real floating
-type to exercise the math functions to test with (float, double, or
-long double) by defining a small set of macros just before including
-the generic "libm-test.c" file.  Each driver also either defines or
-undefines the __NO_MATH_INLINES macro just before including
-"libm-test.c" to select either the real or inline functions,
+The test drivers "test-double-<func>.c", "test-float-<func>.c", and
+"test-ldouble-<func>.c", generated by the Makefile, test the normal
+double, float and long double implementation of libm.  The test
+drivers with an 'i' in their name ("test-idouble-<func>.c",
+"test-ifloat-<func>.c", and "test-ildoubl-<func>.c") test the
+corresponding inline functions (where available - otherwise they also
+test the real functions in libm).  Each driver selects the desired
+real floating type to exercise the math functions to test with (float,
+double, or long double) by defining a small set of macros just before
+including the generic "libm-test.c" file.  Each driver also either
+defines or undefines the __NO_MATH_INLINES macro just before including
+"libm-test-<func>.c" to select either the real or inline functions,
 respectively.  Each driver is compiled into a single executable test
 program with the corresponding name.
 
diff --git a/math/gen-libm-have-vector-test.sh b/math/gen-libm-have-vector-test.sh
deleted file mode 100644
index 7d9d6d7b02..0000000000
--- a/math/gen-libm-have-vector-test.sh
+++ /dev/null
@@ -1,52 +0,0 @@
-#!/bin/sh
-# Copyright (C) 2014-2017 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/>.
-
-# Generate series of definitions used for vector math functions tests.
-# TEST_VECTOR_* and WRAPPER_NAME are defined in vector math functions tests.
-# *_VEC_SUFF is used in individual tests, as result of FUNC_TEST unfolding
-# to avoid warnings / errors about undeclared functions.
-print_defs()
-{
-  echo "#if defined TEST_VECTOR_$1 && TEST_VECTOR_$1"
-  echo "# define HAVE_VECTOR_$1 1"
-  echo "# define ${1}_VEC_SUFF WRAPPER_NAME ($1)"
-  echo "WRAPPER_DECL$2 (WRAPPER_NAME ($1))"
-  echo "#else"
-  echo "# define HAVE_VECTOR_$1 0"
-  echo "# define ${1}_VEC_SUFF $1"
-  echo "#endif"
-  echo
-}
-
-for func in $(cat $@ | grep ALL_RM_TEST | grep -v define | grep -v RUN_TEST_LOOP_ff_f | grep -v RUN_TEST_LOOP_fFF_11 | sed -r "s/.*\(//; s/,.*//" ); do
-  print_defs ${func}
-  print_defs ${func}f
-  print_defs ${func}l
-done
-
-for func in $(cat $@ | grep ALL_RM_TEST | grep RUN_TEST_LOOP_ff_f | sed -r "s/.*\(//; s/,.*//" ); do
-  print_defs ${func} "_ff"
-  print_defs ${func}f "_ff"
-  print_defs ${func}l "_ff"
-done
-
-for func in $(cat $@ | grep ALL_RM_TEST | grep RUN_TEST_LOOP_fFF_11 | sed -r "s/.*\(//; s/,.*//" ); do
-  print_defs ${func} "_fFF"
-  print_defs ${func}f "_fFF"
-  print_defs ${func}l "_fFF"
-done
diff --git a/math/libm-test-acos.inc b/math/libm-test-acos.inc
index c98da4f222..d795793a15 100644
--- a/math/libm-test-acos.inc
+++ b/math/libm-test-acos.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data acos_test_data[] =
   {
     TEST_f_f (acos, plus_infty, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM),
@@ -40,6 +42,12 @@ acos_test (void)
   ALL_RM_TEST (acos, 0, acos_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  acos_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-acosh.inc b/math/libm-test-acosh.inc
index 470fa29cd1..816a1cd371 100644
--- a/math/libm-test-acosh.inc
+++ b/math/libm-test-acosh.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data acosh_test_data[] =
   {
     TEST_f_f (acosh, plus_infty, plus_infty, ERRNO_UNCHANGED),
@@ -45,6 +47,12 @@ acosh_test (void)
   ALL_RM_TEST (acosh, 0, acosh_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  acosh_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-asin.inc b/math/libm-test-asin.inc
index 6d3ed8ec9e..9b6d229df1 100644
--- a/math/libm-test-asin.inc
+++ b/math/libm-test-asin.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data asin_test_data[] =
   {
     TEST_f_f (asin, plus_infty, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM),
@@ -40,6 +42,12 @@ asin_test (void)
   ALL_RM_TEST (asin, 0, asin_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  asin_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-asinh.inc b/math/libm-test-asinh.inc
index af8392afad..f218e032c3 100644
--- a/math/libm-test-asinh.inc
+++ b/math/libm-test-asinh.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data asinh_test_data[] =
   {
     TEST_f_f (asinh, plus_infty, plus_infty, ERRNO_UNCHANGED|NO_TEST_INLINE),
@@ -33,6 +35,12 @@ asinh_test (void)
   ALL_RM_TEST (asinh, 0, asinh_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  asinh_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-atan.inc b/math/libm-test-atan.inc
index 365ca87bf1..ed96133616 100644
--- a/math/libm-test-atan.inc
+++ b/math/libm-test-atan.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data atan_test_data[] =
   {
     TEST_f_f (atan, plus_infty, lit_pi_2_d, ERRNO_UNCHANGED),
@@ -34,6 +36,12 @@ atan_test (void)
   ALL_RM_TEST (atan, 0, atan_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  atan_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-atan2.inc b/math/libm-test-atan2.inc
index 9caedf7bea..e9001133f1 100644
--- a/math/libm-test-atan2.inc
+++ b/math/libm-test-atan2.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_ff_f_data atan2_test_data[] =
   {
     /* atan2 (y,inf) == +0 for finite y > 0 or +0.  */
@@ -196,6 +198,12 @@ atan2_test (void)
   ALL_RM_TEST (atan2, 0, atan2_test_data, RUN_TEST_LOOP_ff_f, END);
 }
 
+static void
+do_test (void)
+{
+  atan2_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-atanh.inc b/math/libm-test-atanh.inc
index 97990b3507..a57aebbca7 100644
--- a/math/libm-test-atanh.inc
+++ b/math/libm-test-atanh.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data atanh_test_data[] =
   {
     TEST_f_f (atanh, 1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE),
@@ -42,6 +44,12 @@ atanh_test (void)
   ALL_RM_TEST (atanh, 0, atanh_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  atanh_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-cabs.inc b/math/libm-test-cabs.inc
index 36d609ad9a..d9a66fa631 100644
--- a/math/libm-test-cabs.inc
+++ b/math/libm-test-cabs.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_c_f_data cabs_test_data[] =
   {
     /* cabs (x + iy) is specified as hypot (x,y) */
@@ -39,6 +41,12 @@ cabs_test (void)
   ALL_RM_TEST (cabs, 0, cabs_test_data, RUN_TEST_LOOP_c_f, END);
 }
 
+static void
+do_test (void)
+{
+  cabs_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-cacos.inc b/math/libm-test-cacos.inc
index 492f8f1fe0..f4cd32f993 100644
--- a/math/libm-test-cacos.inc
+++ b/math/libm-test-cacos.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_c_c_data cacos_test_data[] =
   {
     TEST_c_c (cacos, minus_infty, plus_infty, lit_pi_3_m_4_d, minus_infty),
@@ -67,6 +69,12 @@ cacos_test (void)
   ALL_RM_TEST (cacos, 0, cacos_test_data, RUN_TEST_LOOP_c_c, END_COMPLEX);
 }
 
+static void
+do_test (void)
+{
+  cacos_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-cacosh.inc b/math/libm-test-cacosh.inc
index 4a16d10077..518cb29aa6 100644
--- a/math/libm-test-cacosh.inc
+++ b/math/libm-test-cacosh.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_c_c_data cacosh_test_data[] =
   {
     TEST_c_c (cacosh, minus_infty, plus_infty, plus_infty, lit_pi_3_m_4_d),
@@ -67,6 +69,12 @@ cacosh_test (void)
   ALL_RM_TEST (cacosh, 0, cacosh_test_data, RUN_TEST_LOOP_c_c, END_COMPLEX);
 }
 
+static void
+do_test (void)
+{
+  cacosh_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-canonicalize.inc b/math/libm-test-canonicalize.inc
index 93a0a9bb6b..e0ba3eceaa 100644
--- a/math/libm-test-canonicalize.inc
+++ b/math/libm-test-canonicalize.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_Ff_b1_data canonicalize_test_data[] =
   {
     TEST_Ffp_b1 (canonicalize, plus_infty, 0, plus_infty, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -80,6 +82,12 @@ canonicalize_test (void)
   ALL_RM_TEST (canonicalize, 1, canonicalize_test_data, RUN_TEST_LOOP_Ffp_b1, END, x);
 }
 
+static void
+do_test (void)
+{
+  canonicalize_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-carg.inc b/math/libm-test-carg.inc
index e92d4fbcce..e03389310f 100644
--- a/math/libm-test-carg.inc
+++ b/math/libm-test-carg.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_c_f_data carg_test_data[] =
   {
     /* carg (x + iy) is specified as atan2 (y, x) */
@@ -57,6 +59,12 @@ carg_test (void)
   ALL_RM_TEST (carg, 0, carg_test_data, RUN_TEST_LOOP_c_f, END);
 }
 
+static void
+do_test (void)
+{
+  carg_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-casin.inc b/math/libm-test-casin.inc
index 9e3918631c..d78077590f 100644
--- a/math/libm-test-casin.inc
+++ b/math/libm-test-casin.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_c_c_data casin_test_data[] =
   {
     TEST_c_c (casin, plus_infty, plus_infty, lit_pi_4_d, plus_infty),
@@ -68,6 +70,12 @@ casin_test (void)
   ALL_RM_TEST (casin, 0, casin_test_data, RUN_TEST_LOOP_c_c, END_COMPLEX);
 }
 
+static void
+do_test (void)
+{
+  casin_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-casinh.inc b/math/libm-test-casinh.inc
index 476207443d..5298c812b8 100644
--- a/math/libm-test-casinh.inc
+++ b/math/libm-test-casinh.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_c_c_data casinh_test_data[] =
   {
     TEST_c_c (casinh, plus_infty, plus_infty, plus_infty, lit_pi_4_d),
@@ -68,6 +70,12 @@ casinh_test (void)
   ALL_RM_TEST (casinh, 0, casinh_test_data, RUN_TEST_LOOP_c_c, END_COMPLEX);
 }
 
+static void
+do_test (void)
+{
+  casinh_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-catan.inc b/math/libm-test-catan.inc
index 1d8cf180db..ee9662924f 100644
--- a/math/libm-test-catan.inc
+++ b/math/libm-test-catan.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_c_c_data catan_test_data[] =
   {
     TEST_c_c (catan, plus_zero, 1.0L, plus_zero, plus_infty, DIVIDE_BY_ZERO_EXCEPTION),
@@ -77,6 +79,12 @@ catan_test (void)
   ALL_RM_TEST (catan, 0, catan_test_data, RUN_TEST_LOOP_c_c, END_COMPLEX);
 }
 
+static void
+do_test (void)
+{
+  catan_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-catanh.inc b/math/libm-test-catanh.inc
index 321a0bd200..6ec6fbad64 100644
--- a/math/libm-test-catanh.inc
+++ b/math/libm-test-catanh.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_c_c_data catanh_test_data[] =
   {
     TEST_c_c (catanh, 1.0L, plus_zero, plus_infty, plus_zero, DIVIDE_BY_ZERO_EXCEPTION),
@@ -76,6 +78,12 @@ catanh_test (void)
   ALL_RM_TEST (catanh, 0, catanh_test_data, RUN_TEST_LOOP_c_c, END_COMPLEX);
 }
 
+static void
+do_test (void)
+{
+  catanh_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-cbrt.inc b/math/libm-test-cbrt.inc
index 11a8a3bae7..769f52e89f 100644
--- a/math/libm-test-cbrt.inc
+++ b/math/libm-test-cbrt.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data cbrt_test_data[] =
   {
     TEST_f_f (cbrt, plus_infty, plus_infty, ERRNO_UNCHANGED),
@@ -34,6 +36,12 @@ cbrt_test (void)
   ALL_RM_TEST (cbrt, 0, cbrt_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  cbrt_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-ccos.inc b/math/libm-test-ccos.inc
index 3180b55c66..2497af1d49 100644
--- a/math/libm-test-ccos.inc
+++ b/math/libm-test-ccos.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_c_c_data ccos_test_data[] =
   {
     TEST_c_c (ccos, plus_infty, 0.0, qnan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN),
@@ -72,6 +74,12 @@ ccos_test (void)
   ALL_RM_TEST (ccos, 0, ccos_test_data, RUN_TEST_LOOP_c_c, END_COMPLEX);
 }
 
+static void
+do_test (void)
+{
+  ccos_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-ccosh.inc b/math/libm-test-ccosh.inc
index ac4c103e67..7c22c9e38f 100644
--- a/math/libm-test-ccosh.inc
+++ b/math/libm-test-ccosh.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_c_c_data ccosh_test_data[] =
   {
     TEST_c_c (ccosh, 0.0, plus_infty, qnan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN),
@@ -72,6 +74,12 @@ ccosh_test (void)
   ALL_RM_TEST (ccosh, 0, ccosh_test_data, RUN_TEST_LOOP_c_c, END_COMPLEX);
 }
 
+static void
+do_test (void)
+{
+  ccosh_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-ceil.inc b/math/libm-test-ceil.inc
index c173b7e36e..d6356a574b 100644
--- a/math/libm-test-ceil.inc
+++ b/math/libm-test-ceil.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data ceil_test_data[] =
   {
     TEST_f_f (ceil, 0.0, 0.0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -162,6 +164,12 @@ ceil_test (void)
   ALL_RM_TEST (ceil, 1, ceil_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  ceil_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-cexp.inc b/math/libm-test-cexp.inc
index 355748c50c..f4bd962c5d 100644
--- a/math/libm-test-cexp.inc
+++ b/math/libm-test-cexp.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_c_c_data cexp_test_data[] =
   {
     TEST_c_c (cexp, plus_infty, plus_zero, plus_infty, 0.0),
@@ -69,6 +71,12 @@ cexp_test (void)
   ALL_RM_TEST (cexp, 0, cexp_test_data, RUN_TEST_LOOP_c_c, END_COMPLEX);
 }
 
+static void
+do_test (void)
+{
+  cexp_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-cimag.inc b/math/libm-test-cimag.inc
index a711f4cf53..569d20c5df 100644
--- a/math/libm-test-cimag.inc
+++ b/math/libm-test-cimag.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_c_f_data cimag_test_data[] =
   {
     TEST_c_f (cimag, 1.0, 0.0, 0.0, NO_INEXACT_EXCEPTION),
@@ -37,6 +39,12 @@ cimag_test (void)
   ALL_RM_TEST (cimag, 1, cimag_test_data, RUN_TEST_LOOP_c_f, END);
 }
 
+static void
+do_test (void)
+{
+  cimag_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-clog.inc b/math/libm-test-clog.inc
index 261aaad6ba..6a97d5a31d 100644
--- a/math/libm-test-clog.inc
+++ b/math/libm-test-clog.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_c_c_data clog_test_data[] =
   {
     TEST_c_c (clog, minus_zero, 0, minus_infty, lit_pi, DIVIDE_BY_ZERO_EXCEPTION),
@@ -76,6 +78,12 @@ clog_test (void)
   ALL_RM_TEST (clog, 0, clog_test_data, RUN_TEST_LOOP_c_c, END_COMPLEX);
 }
 
+static void
+do_test (void)
+{
+  clog_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-clog10.inc b/math/libm-test-clog10.inc
index 0c92a79b96..b330d74d53 100644
--- a/math/libm-test-clog10.inc
+++ b/math/libm-test-clog10.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_c_c_data clog10_test_data[] =
   {
     TEST_c_c (clog10, minus_zero, 0, minus_infty, lit_pi_ln10_d, DIVIDE_BY_ZERO_EXCEPTION),
@@ -75,6 +77,12 @@ clog10_test (void)
   ALL_RM_TEST (clog10, 0, clog10_test_data, RUN_TEST_LOOP_c_c, END_COMPLEX);
 }
 
+static void
+do_test (void)
+{
+  clog10_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-conj.inc b/math/libm-test-conj.inc
index cfa0a53810..e5b2529b88 100644
--- a/math/libm-test-conj.inc
+++ b/math/libm-test-conj.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_c_c_data conj_test_data[] =
   {
     TEST_c_c (conj, 0.0, 0.0, 0.0, minus_zero, NO_INEXACT_EXCEPTION),
@@ -36,6 +38,12 @@ conj_test (void)
   ALL_RM_TEST (conj, 1, conj_test_data, RUN_TEST_LOOP_c_c, END_COMPLEX);
 }
 
+static void
+do_test (void)
+{
+  conj_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-copysign.inc b/math/libm-test-copysign.inc
index e717160673..635cb02f66 100644
--- a/math/libm-test-copysign.inc
+++ b/math/libm-test-copysign.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_ff_f_data copysign_test_data[] =
   {
     TEST_ff_f (copysign, 0, 0, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -105,6 +107,12 @@ copysign_test (void)
   ALL_RM_TEST (copysign, 1, copysign_test_data, RUN_TEST_LOOP_ff_f, END);
 }
 
+static void
+do_test (void)
+{
+  copysign_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-cos.inc b/math/libm-test-cos.inc
index 1ca5b41454..246b37154e 100644
--- a/math/libm-test-cos.inc
+++ b/math/libm-test-cos.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data cos_test_data[] =
   {
     TEST_f_f (cos, plus_infty, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM),
@@ -34,6 +36,12 @@ cos_test (void)
   ALL_RM_TEST (cos, 0, cos_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  cos_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-cosh.inc b/math/libm-test-cosh.inc
index a6456440d5..a0b88b0884 100644
--- a/math/libm-test-cosh.inc
+++ b/math/libm-test-cosh.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data cosh_test_data[] =
   {
     TEST_f_f (cosh, plus_infty, plus_infty, ERRNO_UNCHANGED|NO_TEST_INLINE),
@@ -34,6 +36,12 @@ cosh_test (void)
   ALL_RM_TEST (cosh, 0, cosh_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  cosh_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-cpow.inc b/math/libm-test-cpow.inc
index 2f4cda209c..ffd112844e 100644
--- a/math/libm-test-cpow.inc
+++ b/math/libm-test-cpow.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_cc_c_data cpow_test_data[] =
   {
     TEST_cc_c (cpow, qnan_value, qnan_value, qnan_value, qnan_value, qnan_value, qnan_value),
@@ -29,6 +31,12 @@ cpow_test (void)
   ALL_RM_TEST (cpow, 0, cpow_test_data, RUN_TEST_LOOP_cc_c, END_COMPLEX);
 }
 
+static void
+do_test (void)
+{
+  cpow_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-cproj.inc b/math/libm-test-cproj.inc
index 2daa6ab59f..441d58ba7f 100644
--- a/math/libm-test-cproj.inc
+++ b/math/libm-test-cproj.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_c_c_data cproj_test_data[] =
   {
     TEST_c_c (cproj, 0.0, 0.0, 0.0, 0.0, NO_INEXACT_EXCEPTION),
@@ -80,6 +82,12 @@ cproj_test (void)
   ALL_RM_TEST (cproj, 1, cproj_test_data, RUN_TEST_LOOP_c_c, END_COMPLEX);
 }
 
+static void
+do_test (void)
+{
+  cproj_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-creal.inc b/math/libm-test-creal.inc
index 20ea43c914..aaa1412ac6 100644
--- a/math/libm-test-creal.inc
+++ b/math/libm-test-creal.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_c_f_data creal_test_data[] =
   {
     TEST_c_f (creal, 0.0, 1.0, 0.0, NO_INEXACT_EXCEPTION),
@@ -37,6 +39,12 @@ creal_test (void)
   ALL_RM_TEST (creal, 1, creal_test_data, RUN_TEST_LOOP_c_f, END);
 }
 
+static void
+do_test (void)
+{
+  creal_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-csin.inc b/math/libm-test-csin.inc
index f42828c874..03214ad512 100644
--- a/math/libm-test-csin.inc
+++ b/math/libm-test-csin.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_c_c_data csin_test_data[] =
   {
     TEST_c_c (csin, 0.0, plus_infty, 0.0, plus_infty),
@@ -72,6 +74,12 @@ csin_test (void)
   ALL_RM_TEST (csin, 0, csin_test_data, RUN_TEST_LOOP_c_c, END_COMPLEX);
 }
 
+static void
+do_test (void)
+{
+  csin_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-csinh.inc b/math/libm-test-csinh.inc
index 06877c8468..41b9092bb1 100644
--- a/math/libm-test-csinh.inc
+++ b/math/libm-test-csinh.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_c_c_data csinh_test_data[] =
   {
     TEST_c_c (csinh, 0.0, plus_infty, 0.0, qnan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN),
@@ -72,6 +74,12 @@ csinh_test (void)
   ALL_RM_TEST (csinh, 0, csinh_test_data, RUN_TEST_LOOP_c_c, END_COMPLEX);
 }
 
+static void
+do_test (void)
+{
+  csinh_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-csqrt.inc b/math/libm-test-csqrt.inc
index 6ff26faa9b..43918fe146 100644
--- a/math/libm-test-csqrt.inc
+++ b/math/libm-test-csqrt.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_c_c_data csqrt_test_data[] =
   {
     TEST_c_c (csqrt, minus_infty, 0, 0.0, plus_infty),
@@ -66,6 +68,12 @@ csqrt_test (void)
   ALL_RM_TEST (csqrt, 0, csqrt_test_data, RUN_TEST_LOOP_c_c, END_COMPLEX);
 }
 
+static void
+do_test (void)
+{
+  csqrt_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-ctan.inc b/math/libm-test-ctan.inc
index a5689400f3..e485828b8c 100644
--- a/math/libm-test-ctan.inc
+++ b/math/libm-test-ctan.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_c_c_data ctan_test_data[] =
   {
     TEST_c_c (ctan, 0, plus_infty, 0.0, 1.0),
@@ -126,6 +128,12 @@ ctan_test (void)
   ALL_RM_TEST (ctan, 0, ctan_test_data, RUN_TEST_LOOP_c_c, END_COMPLEX);
 }
 
+static void
+do_test (void)
+{
+  ctan_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-ctanh.inc b/math/libm-test-ctanh.inc
index 48002ebde6..6ddeb0d361 100644
--- a/math/libm-test-ctanh.inc
+++ b/math/libm-test-ctanh.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_c_c_data ctanh_test_data[] =
   {
     TEST_c_c (ctanh, plus_infty, 0, 1.0, 0.0),
@@ -125,6 +127,12 @@ ctanh_test (void)
   ALL_RM_TEST (ctanh, 0, ctanh_test_data, RUN_TEST_LOOP_c_c, END_COMPLEX);
 }
 
+static void
+do_test (void)
+{
+  ctanh_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-driver.c b/math/libm-test-driver.c
index d24c5aadaf..161419837d 100644
--- a/math/libm-test-driver.c
+++ b/math/libm-test-driver.c
@@ -952,15 +952,9 @@ struct test_Ff_b1_data
 #define STR_CONCAT(a, b, c) __STRING (a##b##c)
 #define STR_CON3(a, b, c) STR_CONCAT (a, b, c)
 
-/* This generated header defines series of macros started with HAVE_VECTOR_. */
-#include "libm-have-vector-test.h"
-
-#define HAVE_VECTOR(func) __CONCAT (HAVE_VECTOR_, func)
-
 /* Start and end the tests for a given function.  */
 #define START(FUN, SUFF, EXACT)					\
   CHECK_ARCH_EXT;						\
-  if (TEST_MATHVEC && !HAVE_VECTOR (FUNC (FUN))) return;	\
   const char *this_func = STR_CON3 (FUN, SUFF, VEC_SUFF);	\
   init_max_error (this_func, EXACT)
 #define END					\
diff --git a/math/libm-test-erf.inc b/math/libm-test-erf.inc
index 20a389ec5a..bcc96e5e6c 100644
--- a/math/libm-test-erf.inc
+++ b/math/libm-test-erf.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data erf_test_data[] =
   {
     TEST_f_f (erf, plus_infty, 1, ERRNO_UNCHANGED),
@@ -34,6 +36,12 @@ erf_test (void)
   ALL_RM_TEST (erf, 0, erf_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  erf_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-erfc.inc b/math/libm-test-erfc.inc
index ed6190e05d..7018eb34d7 100644
--- a/math/libm-test-erfc.inc
+++ b/math/libm-test-erfc.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data erfc_test_data[] =
   {
     TEST_f_f (erfc, plus_infty, 0.0, ERRNO_UNCHANGED),
@@ -32,6 +34,12 @@ erfc_test (void)
   ALL_RM_TEST (erfc, 0, erfc_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  erfc_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-exp.inc b/math/libm-test-exp.inc
index a5ed2e2fd3..323a82c360 100644
--- a/math/libm-test-exp.inc
+++ b/math/libm-test-exp.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data exp_test_data[] =
   {
     TEST_f_f (exp, plus_infty, plus_infty, ERRNO_UNCHANGED|NO_TEST_INLINE),
@@ -34,6 +36,12 @@ exp_test (void)
   ALL_RM_TEST (exp, 0, exp_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  exp_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-exp10.inc b/math/libm-test-exp10.inc
index 6be936bc2e..92c81adb7a 100644
--- a/math/libm-test-exp10.inc
+++ b/math/libm-test-exp10.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data exp10_test_data[] =
   {
     TEST_f_f (exp10, plus_infty, plus_infty, ERRNO_UNCHANGED),
@@ -41,6 +43,13 @@ pow10_test (void)
   ALL_RM_TEST (pow10, 0, exp10_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  exp10_test ();
+  pow10_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-exp2.inc b/math/libm-test-exp2.inc
index 0c0e4dadbc..3c2561aa7f 100644
--- a/math/libm-test-exp2.inc
+++ b/math/libm-test-exp2.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data exp2_test_data[] =
   {
     TEST_f_f (exp2, plus_infty, plus_infty, ERRNO_UNCHANGED),
@@ -34,6 +36,12 @@ exp2_test (void)
   ALL_RM_TEST (exp2, 0, exp2_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  exp2_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-expm1.inc b/math/libm-test-expm1.inc
index c01abf8774..c18c596933 100644
--- a/math/libm-test-expm1.inc
+++ b/math/libm-test-expm1.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data expm1_test_data[] =
   {
     TEST_f_f (expm1, plus_infty, plus_infty, ERRNO_UNCHANGED|NO_TEST_INLINE),
@@ -34,6 +36,12 @@ expm1_test (void)
   ALL_RM_TEST (expm1, 0, expm1_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  expm1_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-fabs.inc b/math/libm-test-fabs.inc
index 1b0dc54f36..392cb68542 100644
--- a/math/libm-test-fabs.inc
+++ b/math/libm-test-fabs.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data fabs_test_data[] =
   {
     TEST_f_f (fabs, 0, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -44,6 +46,12 @@ fabs_test (void)
   ALL_RM_TEST (fabs, 1, fabs_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  fabs_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-fdim.inc b/math/libm-test-fdim.inc
index 28aa6adfe4..73713a6c20 100644
--- a/math/libm-test-fdim.inc
+++ b/math/libm-test-fdim.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_ff_f_data fdim_test_data[] =
   {
     TEST_ff_f (fdim, 0, 0, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -114,6 +116,12 @@ fdim_test (void)
   ALL_RM_TEST (fdim, 1, fdim_test_data, RUN_TEST_LOOP_ff_f, END);
 }
 
+static void
+do_test (void)
+{
+  fdim_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-floor.inc b/math/libm-test-floor.inc
index a0abcb2bb3..cceeed90bb 100644
--- a/math/libm-test-floor.inc
+++ b/math/libm-test-floor.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data floor_test_data[] =
   {
     TEST_f_f (floor, 0.0, 0.0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -159,6 +161,12 @@ floor_test (void)
   ALL_RM_TEST (floor, 1, floor_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  floor_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-fma.inc b/math/libm-test-fma.inc
index 6da8daddf6..77641773a3 100644
--- a/math/libm-test-fma.inc
+++ b/math/libm-test-fma.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_fff_f_data fma_test_data[] =
   {
     TEST_fff_f (fma, qnan_value, 2.0, 3.0, qnan_value, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -120,6 +122,12 @@ fma_test (void)
   ALL_RM_TEST (fma, 1, fma_test_data, RUN_TEST_LOOP_fff_f, END);
 }
 
+static void
+do_test (void)
+{
+  fma_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-fmax.inc b/math/libm-test-fmax.inc
index 950a2cbb0c..682a1b8918 100644
--- a/math/libm-test-fmax.inc
+++ b/math/libm-test-fmax.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_ff_f_data fmax_test_data[] =
   {
     TEST_ff_f (fmax, 0, 0, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -115,6 +117,12 @@ fmax_test (void)
   ALL_RM_TEST (fmax, 1, fmax_test_data, RUN_TEST_LOOP_ff_f, END);
 }
 
+static void
+do_test (void)
+{
+  fmax_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-fmaxmag.inc b/math/libm-test-fmaxmag.inc
index 0253f27d1a..94ef268d3c 100644
--- a/math/libm-test-fmaxmag.inc
+++ b/math/libm-test-fmaxmag.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_ff_f_data fmaxmag_test_data[] =
   {
     TEST_ff_f (fmaxmag, 0, 0, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -129,6 +131,12 @@ fmaxmag_test (void)
   ALL_RM_TEST (fmaxmag, 1, fmaxmag_test_data, RUN_TEST_LOOP_ff_f, END);
 }
 
+static void
+do_test (void)
+{
+  fmaxmag_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-fmin.inc b/math/libm-test-fmin.inc
index 024ca909d1..0d2217df27 100644
--- a/math/libm-test-fmin.inc
+++ b/math/libm-test-fmin.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_ff_f_data fmin_test_data[] =
   {
     TEST_ff_f (fmin, 0, 0, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -114,6 +116,12 @@ fmin_test (void)
   ALL_RM_TEST (fmin, 1, fmin_test_data, RUN_TEST_LOOP_ff_f, END);
 }
 
+static void
+do_test (void)
+{
+  fmin_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-fminmag.inc b/math/libm-test-fminmag.inc
index 1ce5ac8c1b..267153b709 100644
--- a/math/libm-test-fminmag.inc
+++ b/math/libm-test-fminmag.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_ff_f_data fminmag_test_data[] =
   {
     TEST_ff_f (fminmag, 0, 0, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -128,6 +130,12 @@ fminmag_test (void)
   ALL_RM_TEST (fminmag, 1, fminmag_test_data, RUN_TEST_LOOP_ff_f, END);
 }
 
+static void
+do_test (void)
+{
+  fminmag_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-fmod.inc b/math/libm-test-fmod.inc
index e536af7218..c8acc14a42 100644
--- a/math/libm-test-fmod.inc
+++ b/math/libm-test-fmod.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_ff_f_data fmod_test_data[] =
   {
     /* fmod (+0, y) == +0 for y != 0.  */
@@ -262,6 +264,12 @@ fmod_test (void)
   ALL_RM_TEST (fmod, 1, fmod_test_data, RUN_TEST_LOOP_ff_f, END);
 }
 
+static void
+do_test (void)
+{
+  fmod_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-fpclassify.inc b/math/libm-test-fpclassify.inc
index dd2eec2a64..a85f52c8e4 100644
--- a/math/libm-test-fpclassify.inc
+++ b/math/libm-test-fpclassify.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_i_data fpclassify_test_data[] =
   {
     TEST_f_i (fpclassify, qnan_value, FP_NAN, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -41,6 +43,12 @@ fpclassify_test (void)
   ALL_RM_TEST (fpclassify, 1, fpclassify_test_data, RUN_TEST_LOOP_f_i_tg, END);
 }
 
+static void
+do_test (void)
+{
+  fpclassify_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-frexp.inc b/math/libm-test-frexp.inc
index bfc80df87c..b6f7d7160e 100644
--- a/math/libm-test-frexp.inc
+++ b/math/libm-test-frexp.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f1_data frexp_test_data[] =
   {
     TEST_fI_f1 (frexp, plus_infty, plus_infty, IGNORE, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -81,6 +83,12 @@ frexp_test (void)
   ALL_RM_TEST (frexp, 1, frexp_test_data, RUN_TEST_LOOP_fI_f1, END, x);
 }
 
+static void
+do_test (void)
+{
+  frexp_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-fromfp.inc b/math/libm-test-fromfp.inc
index fb31e85e5a..f2d520574e 100644
--- a/math/libm-test-fromfp.inc
+++ b/math/libm-test-fromfp.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_fiu_M_data fromfp_test_data[] =
   {
     /* Infinity, NaN and values that are definitely out of range
@@ -11931,6 +11933,12 @@ fromfp_test (void)
   ALL_RM_TEST (fromfp, 1, fromfp_test_data, RUN_TEST_LOOP_fiu_M, END);
 }
 
+static void
+do_test (void)
+{
+  fromfp_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-fromfpx.inc b/math/libm-test-fromfpx.inc
index b8a466ccc6..34e0af33ec 100644
--- a/math/libm-test-fromfpx.inc
+++ b/math/libm-test-fromfpx.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_fiu_M_data fromfpx_test_data[] =
   {
     /* Infinity, NaN and values that are definitely out of range
@@ -11931,6 +11933,12 @@ fromfpx_test (void)
   ALL_RM_TEST (fromfpx, 1, fromfpx_test_data, RUN_TEST_LOOP_fiu_M, END);
 }
 
+static void
+do_test (void)
+{
+  fromfpx_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-getpayload.inc b/math/libm-test-getpayload.inc
index 335a11e3e8..def4d8bd23 100644
--- a/math/libm-test-getpayload.inc
+++ b/math/libm-test-getpayload.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data getpayload_test_data[] =
   {
     TEST_fp_f (getpayload, plus_infty, IGNORE, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -74,6 +76,12 @@ getpayload_test (void)
   ALL_RM_TEST (getpayload, 1, getpayload_test_data, RUN_TEST_LOOP_fp_f, END);
 }
 
+static void
+do_test (void)
+{
+  getpayload_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-hypot.inc b/math/libm-test-hypot.inc
index f440e27ecb..7d679828cd 100644
--- a/math/libm-test-hypot.inc
+++ b/math/libm-test-hypot.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_ff_f_data hypot_test_data[] =
   {
     TEST_ff_f (hypot, plus_infty, 1, plus_infty, ERRNO_UNCHANGED),
@@ -171,6 +173,12 @@ hypot_test (void)
   ALL_RM_TEST (hypot, 0, hypot_test_data, RUN_TEST_LOOP_ff_f, END);
 }
 
+static void
+do_test (void)
+{
+  hypot_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-ilogb.inc b/math/libm-test-ilogb.inc
index 957e5c1561..7c94d62291 100644
--- a/math/libm-test-ilogb.inc
+++ b/math/libm-test-ilogb.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_i_data ilogb_test_data[] =
   {
     TEST_f_i (ilogb, 1, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -57,6 +59,12 @@ ilogb_test (void)
   ALL_RM_TEST (ilogb, 1, ilogb_test_data, RUN_TEST_LOOP_f_i, END);
 }
 
+static void
+do_test (void)
+{
+  ilogb_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-iscanonical.inc b/math/libm-test-iscanonical.inc
index c940027ac8..3d4c850ab8 100644
--- a/math/libm-test-iscanonical.inc
+++ b/math/libm-test-iscanonical.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_i_data iscanonical_test_data[] =
   {
     TEST_f_b (iscanonical, 0, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -41,6 +43,12 @@ iscanonical_test (void)
   ALL_RM_TEST (iscanonical, 1, iscanonical_test_data, RUN_TEST_LOOP_f_b_tg, END);
 }
 
+static void
+do_test (void)
+{
+  iscanonical_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-iseqsig.inc b/math/libm-test-iseqsig.inc
index aa1dcabfaa..d021fc88a7 100644
--- a/math/libm-test-iseqsig.inc
+++ b/math/libm-test-iseqsig.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_ff_i_data iseqsig_test_data[] =
   {
     TEST_ff_i (iseqsig, minus_zero, minus_zero, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -75,6 +77,12 @@ iseqsig_test (void)
   ALL_RM_TEST (iseqsig, 1, iseqsig_test_data, RUN_TEST_LOOP_ff_i_tg, END);
 }
 
+static void
+do_test (void)
+{
+  iseqsig_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-isfinite.inc b/math/libm-test-isfinite.inc
index 593822c2e5..48d4c2e15b 100644
--- a/math/libm-test-isfinite.inc
+++ b/math/libm-test-isfinite.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_i_data isfinite_test_data[] =
   {
     TEST_f_b (isfinite, 0, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -48,6 +50,13 @@ finite_test (void)
   ALL_RM_TEST (finite, 1, isfinite_test_data, RUN_TEST_LOOP_f_b, END);
 }
 
+static void
+do_test (void)
+{
+  isfinite_test ();
+  finite_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-isgreater.inc b/math/libm-test-isgreater.inc
index ba2ee90b07..468523aa18 100644
--- a/math/libm-test-isgreater.inc
+++ b/math/libm-test-isgreater.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_ff_i_data isgreater_test_data[] =
   {
     TEST_ff_i (isgreater, minus_zero, minus_zero, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -75,6 +77,12 @@ isgreater_test (void)
   ALL_RM_TEST (isgreater, 1, isgreater_test_data, RUN_TEST_LOOP_ff_i_tg, END);
 }
 
+static void
+do_test (void)
+{
+  isgreater_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-isgreaterequal.inc b/math/libm-test-isgreaterequal.inc
index 7f37fa8842..51e564ecf6 100644
--- a/math/libm-test-isgreaterequal.inc
+++ b/math/libm-test-isgreaterequal.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_ff_i_data isgreaterequal_test_data[] =
   {
     TEST_ff_i (isgreaterequal, minus_zero, minus_zero, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -75,6 +77,12 @@ isgreaterequal_test (void)
   ALL_RM_TEST (isgreaterequal, 1, isgreaterequal_test_data, RUN_TEST_LOOP_ff_i_tg, END);
 }
 
+static void
+do_test (void)
+{
+  isgreaterequal_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-isinf.inc b/math/libm-test-isinf.inc
index 08d9b4b375..cc6355414b 100644
--- a/math/libm-test-isinf.inc
+++ b/math/libm-test-isinf.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_i_data isinf_test_data[] =
   {
     TEST_f_b (isinf, 0, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -41,6 +43,12 @@ isinf_test (void)
   ALL_RM_TEST (isinf, 1, isinf_test_data, RUN_TEST_LOOP_f_b_tg, END);
 }
 
+static void
+do_test (void)
+{
+  isinf_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-isless.inc b/math/libm-test-isless.inc
index f93bb667a3..402dd978a3 100644
--- a/math/libm-test-isless.inc
+++ b/math/libm-test-isless.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_ff_i_data isless_test_data[] =
   {
     TEST_ff_i (isless, minus_zero, minus_zero, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -75,6 +77,12 @@ isless_test (void)
   ALL_RM_TEST (isless, 1, isless_test_data, RUN_TEST_LOOP_ff_i_tg, END);
 }
 
+static void
+do_test (void)
+{
+  isless_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-islessequal.inc b/math/libm-test-islessequal.inc
index 93e4252001..e71ec28178 100644
--- a/math/libm-test-islessequal.inc
+++ b/math/libm-test-islessequal.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_ff_i_data islessequal_test_data[] =
   {
     TEST_ff_i (islessequal, minus_zero, minus_zero, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -75,6 +77,12 @@ islessequal_test (void)
   ALL_RM_TEST (islessequal, 1, islessequal_test_data, RUN_TEST_LOOP_ff_i_tg, END);
 }
 
+static void
+do_test (void)
+{
+  islessequal_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-islessgreater.inc b/math/libm-test-islessgreater.inc
index baa8b7afa5..b17bd07803 100644
--- a/math/libm-test-islessgreater.inc
+++ b/math/libm-test-islessgreater.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_ff_i_data islessgreater_test_data[] =
   {
     TEST_ff_i (islessgreater, minus_zero, minus_zero, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -75,6 +77,12 @@ islessgreater_test (void)
   ALL_RM_TEST (islessgreater, 1, islessgreater_test_data, RUN_TEST_LOOP_ff_i_tg, END);
 }
 
+static void
+do_test (void)
+{
+  islessgreater_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-isnan.inc b/math/libm-test-isnan.inc
index ec8f45bf97..d125ec4627 100644
--- a/math/libm-test-isnan.inc
+++ b/math/libm-test-isnan.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_i_data isnan_test_data[] =
   {
     TEST_f_b (isnan, 0, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -41,6 +43,12 @@ isnan_test (void)
   ALL_RM_TEST (isnan, 1, isnan_test_data, RUN_TEST_LOOP_f_b_tg, END);
 }
 
+static void
+do_test (void)
+{
+  isnan_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-isnormal.inc b/math/libm-test-isnormal.inc
index e5b3881ec0..9f16e9b443 100644
--- a/math/libm-test-isnormal.inc
+++ b/math/libm-test-isnormal.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_i_data isnormal_test_data[] =
   {
     TEST_f_b (isnormal, 0, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -41,6 +43,12 @@ isnormal_test (void)
   ALL_RM_TEST (isnormal, 1, isnormal_test_data, RUN_TEST_LOOP_f_b_tg, END);
 }
 
+static void
+do_test (void)
+{
+  isnormal_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-issignaling.inc b/math/libm-test-issignaling.inc
index 3f0b7c1e86..e3df38b912 100644
--- a/math/libm-test-issignaling.inc
+++ b/math/libm-test-issignaling.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_i_data issignaling_test_data[] =
   {
     TEST_f_b (issignaling, 0, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -43,6 +45,12 @@ issignaling_test (void)
   ALL_RM_TEST (issignaling, 1, issignaling_test_data, RUN_TEST_LOOP_f_b_tg, END);
 }
 
+static void
+do_test (void)
+{
+  issignaling_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-issubnormal.inc b/math/libm-test-issubnormal.inc
index 94de45a8b0..930dd5c66d 100644
--- a/math/libm-test-issubnormal.inc
+++ b/math/libm-test-issubnormal.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_i_data issubnormal_test_data[] =
   {
     TEST_f_b (issubnormal, 0, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -41,6 +43,12 @@ issubnormal_test (void)
   ALL_RM_TEST (issubnormal, 1, issubnormal_test_data, RUN_TEST_LOOP_f_b_tg, END);
 }
 
+static void
+do_test (void)
+{
+  issubnormal_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-isunordered.inc b/math/libm-test-isunordered.inc
index 8a3ca076e1..9c2bb247b3 100644
--- a/math/libm-test-isunordered.inc
+++ b/math/libm-test-isunordered.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_ff_i_data isunordered_test_data[] =
   {
     TEST_ff_i (isunordered, minus_zero, minus_zero, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -75,6 +77,12 @@ isunordered_test (void)
   ALL_RM_TEST (isunordered, 1, isunordered_test_data, RUN_TEST_LOOP_ff_i_tg, END);
 }
 
+static void
+do_test (void)
+{
+  isunordered_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-iszero.inc b/math/libm-test-iszero.inc
index 8694296a3e..0519c090fc 100644
--- a/math/libm-test-iszero.inc
+++ b/math/libm-test-iszero.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_i_data iszero_test_data[] =
   {
     TEST_f_b (iszero, 0, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -41,6 +43,12 @@ iszero_test (void)
   ALL_RM_TEST (iszero, 1, iszero_test_data, RUN_TEST_LOOP_f_b_tg, END);
 }
 
+static void
+do_test (void)
+{
+  iszero_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-j0.inc b/math/libm-test-j0.inc
index 5628d7c34b..2fa8c8ee48 100644
--- a/math/libm-test-j0.inc
+++ b/math/libm-test-j0.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data j0_test_data[] =
   {
     /* j0 is the Bessel function of the first kind of order 0 */
@@ -35,6 +37,12 @@ j0_test (void)
   ALL_RM_TEST (j0, 0, j0_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  j0_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-j1.inc b/math/libm-test-j1.inc
index a9ab7b2978..44b831480c 100644
--- a/math/libm-test-j1.inc
+++ b/math/libm-test-j1.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data j1_test_data[] =
   {
     /* j1 is the Bessel function of the first kind of order 1 */
@@ -35,6 +37,12 @@ j1_test (void)
   ALL_RM_TEST (j1, 0, j1_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  j1_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-jn.inc b/math/libm-test-jn.inc
index 7bb6d75832..2bc72d1711 100644
--- a/math/libm-test-jn.inc
+++ b/math/libm-test-jn.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_if_f_data jn_test_data[] =
   {
     /* jn is the Bessel function of the first kind of order n.  */
@@ -60,6 +62,12 @@ jn_test (void)
   ALL_RM_TEST (jn, 0, jn_test_data, RUN_TEST_LOOP_if_f, END);
 }
 
+static void
+do_test (void)
+{
+  jn_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-lgamma.inc b/math/libm-test-lgamma.inc
index 1bca7f1a3b..9799aa9aaf 100644
--- a/math/libm-test-lgamma.inc
+++ b/math/libm-test-lgamma.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f1_data lgamma_test_data[] =
   {
     TEST_f_f1 (lgamma, plus_infty, plus_infty, 1, ERRNO_UNCHANGED),
@@ -47,6 +49,13 @@ gamma_test (void)
   ALL_RM_TEST (gamma, 0, lgamma_test_data, RUN_TEST_LOOP_f_f1, END, signgam);
 }
 
+static void
+do_test (void)
+{
+  lgamma_test ();
+  gamma_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-llogb.inc b/math/libm-test-llogb.inc
index 08b07919d2..66c5d00b1a 100644
--- a/math/libm-test-llogb.inc
+++ b/math/libm-test-llogb.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_l_data llogb_test_data[] =
   {
     TEST_f_l (llogb, 1, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -57,6 +59,12 @@ llogb_test (void)
   ALL_RM_TEST (llogb, 1, llogb_test_data, RUN_TEST_LOOP_f_l, END);
 }
 
+static void
+do_test (void)
+{
+  llogb_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-llrint.inc b/math/libm-test-llrint.inc
index 053424bbce..20a64d63a3 100644
--- a/math/libm-test-llrint.inc
+++ b/math/libm-test-llrint.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_L_data llrint_test_data[] =
   {
     /* Bug 6798: errno setting may be missing.  */
@@ -250,6 +252,12 @@ llrint_test (void)
   ALL_RM_TEST (llrint, 1, llrint_test_data, RUN_TEST_LOOP_f_L, END);
 }
 
+static void
+do_test (void)
+{
+  llrint_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-llround.inc b/math/libm-test-llround.inc
index 72ef87b883..9f430d7cf0 100644
--- a/math/libm-test-llround.inc
+++ b/math/libm-test-llround.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_L_data llround_test_data[] =
   {
     /* Bug 6797: errno setting may be missing.  */
@@ -285,6 +287,12 @@ llround_test (void)
   ALL_RM_TEST (llround, 1, llround_test_data, RUN_TEST_LOOP_f_L, END);
 }
 
+static void
+do_test (void)
+{
+  llround_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-log.inc b/math/libm-test-log.inc
index 57c2942062..d53eb7fe07 100644
--- a/math/libm-test-log.inc
+++ b/math/libm-test-log.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data log_test_data[] =
   {
     TEST_f_f (log, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE),
@@ -41,6 +43,12 @@ log_test (void)
   ALL_RM_TEST (log, 0, log_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  log_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-log10.inc b/math/libm-test-log10.inc
index 4543898655..0c31b190e3 100644
--- a/math/libm-test-log10.inc
+++ b/math/libm-test-log10.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data log10_test_data[] =
   {
     TEST_f_f (log10, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE),
@@ -43,6 +45,12 @@ log10_test (void)
   ALL_RM_TEST (log10, 0, log10_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  log10_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-log1p.inc b/math/libm-test-log1p.inc
index 3df681eeec..5dd223fb6d 100644
--- a/math/libm-test-log1p.inc
+++ b/math/libm-test-log1p.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data log1p_test_data[] =
   {
     TEST_f_f (log1p, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE),
@@ -38,6 +40,12 @@ log1p_test (void)
   ALL_RM_TEST (log1p, 0, log1p_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  log1p_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-log2.inc b/math/libm-test-log2.inc
index c232c36415..adae1f129b 100644
--- a/math/libm-test-log2.inc
+++ b/math/libm-test-log2.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data log2_test_data[] =
   {
     TEST_f_f (log2, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE),
@@ -42,6 +44,12 @@ log2_test (void)
   ALL_RM_TEST (log2, 0, log2_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  log2_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-logb.inc b/math/libm-test-logb.inc
index 2fe87c3ca8..38bb00fdf6 100644
--- a/math/libm-test-logb.inc
+++ b/math/libm-test-logb.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data logb_test_data[] =
   {
     TEST_f_f (logb, plus_infty, plus_infty, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -70,6 +72,12 @@ logb_test (void)
   ALL_RM_TEST (logb, 1, logb_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  logb_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-lrint.inc b/math/libm-test-lrint.inc
index eb2d6700ed..42ce6b08b1 100644
--- a/math/libm-test-lrint.inc
+++ b/math/libm-test-lrint.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_l_data lrint_test_data[] =
   {
     /* Bug 6798: errno setting may be missing.  */
@@ -345,6 +347,12 @@ lrint_test (void)
   ALL_RM_TEST (lrint, 1, lrint_test_data, RUN_TEST_LOOP_f_l, END);
 }
 
+static void
+do_test (void)
+{
+  lrint_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-lround.inc b/math/libm-test-lround.inc
index cadc36925b..57fc6fa451 100644
--- a/math/libm-test-lround.inc
+++ b/math/libm-test-lround.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_l_data lround_test_data[] =
   {
     /* Bug 6797: errno setting may be missing.  */
@@ -356,6 +358,12 @@ lround_test (void)
   ALL_RM_TEST (lround, 1, lround_test_data, RUN_TEST_LOOP_f_l, END);
 }
 
+static void
+do_test (void)
+{
+  lround_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-modf.inc b/math/libm-test-modf.inc
index e268ba67d0..fa951174ed 100644
--- a/math/libm-test-modf.inc
+++ b/math/libm-test-modf.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_fF_f1_data modf_test_data[] =
   {
     TEST_fF_f1 (modf, plus_infty, 0, plus_infty, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -50,6 +52,12 @@ modf_test (void)
   ALL_RM_TEST (modf, 1, modf_test_data, RUN_TEST_LOOP_fF_f1, END, x);
 }
 
+static void
+do_test (void)
+{
+  modf_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-nearbyint.inc b/math/libm-test-nearbyint.inc
index c5c404f3ca..9e67ea0eb3 100644
--- a/math/libm-test-nearbyint.inc
+++ b/math/libm-test-nearbyint.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data nearbyint_test_data[] =
   {
     TEST_f_f (nearbyint, qnan_value, qnan_value, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -169,6 +171,12 @@ nearbyint_test (void)
   ALL_RM_TEST (nearbyint, 1, nearbyint_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  nearbyint_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-nextafter.inc b/math/libm-test-nextafter.inc
index fdc4e6a5a6..3497554116 100644
--- a/math/libm-test-nextafter.inc
+++ b/math/libm-test-nextafter.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_ff_f_data nextafter_test_data[] =
   {
     TEST_ff_f (nextafter, 0, 0, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -129,6 +131,12 @@ nextafter_test (void)
   ALL_RM_TEST (nextafter, 1, nextafter_test_data, RUN_TEST_LOOP_ff_f, END);
 }
 
+static void
+do_test (void)
+{
+  nextafter_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-nextdown.inc b/math/libm-test-nextdown.inc
index 4d4c6244a1..06d23c2ed8 100644
--- a/math/libm-test-nextdown.inc
+++ b/math/libm-test-nextdown.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data nextdown_test_data[] =
   {
     TEST_f_f (nextdown, minus_zero, -min_subnorm_value, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -69,6 +71,12 @@ nextdown_test (void)
    argument to TEST_ indicates the literal should not be post-processed by
    gen-libm-test.pl.  */
 
+static void
+do_test (void)
+{
+  nextdown_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-nexttoward.inc b/math/libm-test-nexttoward.inc
index a83e3e24a3..f05cf5fe4b 100644
--- a/math/libm-test-nexttoward.inc
+++ b/math/libm-test-nexttoward.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_fj_f_data nexttoward_test_data[] =
   {
     TEST_fj_f (nexttoward, 0, 0, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -154,6 +156,12 @@ nexttoward_test (void)
   ALL_RM_TEST (nexttoward, 1, nexttoward_test_data, RUN_TEST_LOOP_fj_f, END);
 }
 
+static void
+do_test (void)
+{
+  nexttoward_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-nextup.inc b/math/libm-test-nextup.inc
index 15c1f456d7..8e2130c327 100644
--- a/math/libm-test-nextup.inc
+++ b/math/libm-test-nextup.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data nextup_test_data[] =
   {
     TEST_f_f (nextup, minus_zero, min_subnorm_value, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -64,6 +66,12 @@ nextup_test (void)
   ALL_RM_TEST (nextup, 1, nextup_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  nextup_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-pow.inc b/math/libm-test-pow.inc
index b78a16a117..b308109bb2 100644
--- a/math/libm-test-pow.inc
+++ b/math/libm-test-pow.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_ff_f_data pow_test_data[] =
   {
     TEST_ff_f (pow, qnan_value, 0, 1, ERRNO_UNCHANGED|NO_TEST_MATHVEC),
@@ -369,6 +371,12 @@ pow_test (void)
   ALL_RM_TEST (pow, 0, pow_test_data, RUN_TEST_LOOP_ff_f, END);
 }
 
+static void
+do_test (void)
+{
+  pow_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-remainder.inc b/math/libm-test-remainder.inc
index 828e94e5e7..ddeba66dab 100644
--- a/math/libm-test-remainder.inc
+++ b/math/libm-test-remainder.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_ff_f_data remainder_test_data[] =
   {
     TEST_ff_f (remainder, 1, 0, qnan_value, NO_INEXACT_EXCEPTION|INVALID_EXCEPTION|ERRNO_EDOM),
@@ -186,6 +188,13 @@ drem_test (void)
   ALL_RM_TEST (drem, 1, remainder_test_data, RUN_TEST_LOOP_ff_f, END);
 }
 
+static void
+do_test (void)
+{
+  remainder_test ();
+  drem_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-remquo.inc b/math/libm-test-remquo.inc
index c01c7470ee..c3292cc35c 100644
--- a/math/libm-test-remquo.inc
+++ b/math/libm-test-remquo.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_ffI_f1_data remquo_test_data[] =
   {
     /* Bug 6802: errno setting may be missing.  */
@@ -177,6 +179,12 @@ remquo_test (void)
   ALL_RM_TEST (remquo, 1, remquo_test_data, RUN_TEST_LOOP_ffI_f1_mod8, END, x);
 }
 
+static void
+do_test (void)
+{
+  remquo_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-rint.inc b/math/libm-test-rint.inc
index b2eeb28421..56f8bde6bb 100644
--- a/math/libm-test-rint.inc
+++ b/math/libm-test-rint.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data rint_test_data[] =
   {
     TEST_f_f (rint, qnan_value, qnan_value, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -169,6 +171,12 @@ rint_test (void)
   ALL_RM_TEST (rint, 1, rint_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  rint_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-round.inc b/math/libm-test-round.inc
index 3949db40f4..5ae154c2ad 100644
--- a/math/libm-test-round.inc
+++ b/math/libm-test-round.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data round_test_data[] =
   {
     TEST_f_f (round, 0, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -183,6 +185,12 @@ round_test (void)
   ALL_RM_TEST (round, 1, round_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  round_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-roundeven.inc b/math/libm-test-roundeven.inc
index 5dc10ed4a7..4e53214f7f 100644
--- a/math/libm-test-roundeven.inc
+++ b/math/libm-test-roundeven.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data roundeven_test_data[] =
   {
     TEST_f_f (roundeven, plus_zero, plus_zero, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -618,6 +620,12 @@ roundeven_test (void)
   ALL_RM_TEST (roundeven, 1, roundeven_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  roundeven_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-scalb.inc b/math/libm-test-scalb.inc
index 483c8dc7e5..228a93d349 100644
--- a/math/libm-test-scalb.inc
+++ b/math/libm-test-scalb.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_ff_f_data scalb_test_data[] =
   {
     /* Results in this case are unspecified by POSIX, so, for an
@@ -150,6 +152,12 @@ scalb_test (void)
   ALL_RM_TEST (scalb, 1, scalb_test_data, RUN_TEST_LOOP_ff_f, END);
 }
 
+static void
+do_test (void)
+{
+  scalb_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-scalbln.inc b/math/libm-test-scalbln.inc
index 1db2071fe3..3611d635f2 100644
--- a/math/libm-test-scalbln.inc
+++ b/math/libm-test-scalbln.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_fl_f_data scalbln_test_data[] =
   {
     TEST_fl_f (scalbln, 0, 0, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -138,6 +140,12 @@ scalbln_test (void)
   ALL_RM_TEST (scalbln, 1, scalbln_test_data, RUN_TEST_LOOP_fl_f, END);
 }
 
+static void
+do_test (void)
+{
+  scalbln_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-scalbn.inc b/math/libm-test-scalbn.inc
index f20295d7d1..b696b57ff2 100644
--- a/math/libm-test-scalbn.inc
+++ b/math/libm-test-scalbn.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_fi_f_data scalbn_test_data[] =
   {
     TEST_fi_f (scalbn, 0, 0, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -99,6 +101,13 @@ ldexp_test (void)
   ALL_RM_TEST (ldexp, 1, scalbn_test_data, RUN_TEST_LOOP_fi_f, END);
 }
 
+static void
+do_test (void)
+{
+  scalbn_test ();
+  ldexp_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-setpayload.inc b/math/libm-test-setpayload.inc
index 24d543cccf..c5ae6fdb1b 100644
--- a/math/libm-test-setpayload.inc
+++ b/math/libm-test-setpayload.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_Ff_b1_data setpayload_test_data[] =
   {
 #if HIGH_ORDER_BIT_IS_SET_FOR_SNAN
@@ -97,6 +99,12 @@ setpayload_test (void)
   ALL_RM_TEST (setpayload, 1, setpayload_test_data, RUN_TEST_LOOP_Ff_b1, END, x);
 }
 
+static void
+do_test (void)
+{
+  setpayload_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-setpayloadsig.inc b/math/libm-test-setpayloadsig.inc
index 682b825888..5f38f5da15 100644
--- a/math/libm-test-setpayloadsig.inc
+++ b/math/libm-test-setpayloadsig.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_Ff_b1_data setpayloadsig_test_data[] =
   {
 #if HIGH_ORDER_BIT_IS_SET_FOR_SNAN
@@ -97,6 +99,12 @@ setpayloadsig_test (void)
   ALL_RM_TEST (setpayloadsig, 1, setpayloadsig_test_data, RUN_TEST_LOOP_Ff_b1, END, x);
 }
 
+static void
+do_test (void)
+{
+  setpayloadsig_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-signbit.inc b/math/libm-test-signbit.inc
index 3400352aec..f590a84106 100644
--- a/math/libm-test-signbit.inc
+++ b/math/libm-test-signbit.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_i_data signbit_test_data[] =
   {
     TEST_f_b (signbit, 0, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -45,6 +47,12 @@ signbit_test (void)
   ALL_RM_TEST (signbit, 1, signbit_test_data, RUN_TEST_LOOP_f_b_tg, END);
 }
 
+static void
+do_test (void)
+{
+  signbit_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-significand.inc b/math/libm-test-significand.inc
index 6edde8333b..372c076fae 100644
--- a/math/libm-test-significand.inc
+++ b/math/libm-test-significand.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data significand_test_data[] =
   {
     /* significand returns the mantissa of the exponential
@@ -51,6 +53,12 @@ significand_test (void)
   ALL_RM_TEST (significand, 1, significand_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  significand_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-sin.inc b/math/libm-test-sin.inc
index 8723783928..eb3cf40de5 100644
--- a/math/libm-test-sin.inc
+++ b/math/libm-test-sin.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data sin_test_data[] =
   {
     TEST_f_f (sin, plus_infty, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM),
@@ -34,6 +36,12 @@ sin_test (void)
   ALL_RM_TEST (sin, 0, sin_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  sin_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-sincos.inc b/math/libm-test-sincos.inc
index fb57984956..2652582308 100644
--- a/math/libm-test-sincos.inc
+++ b/math/libm-test-sincos.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_fFF_11_data sincos_test_data[] =
   {
     TEST_fFF_11 (sincos, plus_infty, qnan_value, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM),
@@ -36,6 +38,12 @@ sincos_test (void)
   ALL_RM_TEST (sincos, 0, sincos_test_data, RUN_TEST_LOOP_fFF_11, END, sin_res, cos_res);
 }
 
+static void
+do_test (void)
+{
+  sincos_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-sinh.inc b/math/libm-test-sinh.inc
index 8675fcef74..1380470fb4 100644
--- a/math/libm-test-sinh.inc
+++ b/math/libm-test-sinh.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data sinh_test_data[] =
   {
     TEST_f_f (sinh, plus_infty, plus_infty, ERRNO_UNCHANGED|NO_TEST_INLINE),
@@ -34,6 +36,12 @@ sinh_test (void)
   ALL_RM_TEST (sinh, 0, sinh_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  sinh_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-sqrt.inc b/math/libm-test-sqrt.inc
index e72222e2c8..c5d2a31d7c 100644
--- a/math/libm-test-sqrt.inc
+++ b/math/libm-test-sqrt.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data sqrt_test_data[] =
   {
     TEST_f_f (sqrt, qnan_value, qnan_value, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -41,6 +43,12 @@ sqrt_test (void)
   ALL_RM_TEST (sqrt, 1, sqrt_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  sqrt_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-support-double.c b/math/libm-test-support-double.c
deleted file mode 100644
index c90925a26d..0000000000
--- a/math/libm-test-support-double.c
+++ /dev/null
@@ -1,20 +0,0 @@
-/* Support code for testing libm functions (double).
-   Copyright (C) 2017 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 "test-double.h"
-#include "libm-test-support.c"
diff --git a/math/libm-test-support-float.c b/math/libm-test-support-float.c
deleted file mode 100644
index 842d933370..0000000000
--- a/math/libm-test-support-float.c
+++ /dev/null
@@ -1,20 +0,0 @@
-/* Support code for testing libm functions (float).
-   Copyright (C) 2017 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 "test-float.h"
-#include "libm-test-support.c"
diff --git a/math/libm-test-support-ldouble.c b/math/libm-test-support-ldouble.c
deleted file mode 100644
index f1eb9c8e65..0000000000
--- a/math/libm-test-support-ldouble.c
+++ /dev/null
@@ -1,20 +0,0 @@
-/* Support code for testing libm functions (long double).
-   Copyright (C) 2017 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 "test-ldouble.h"
-#include "libm-test-support.c"
diff --git a/math/libm-test-tan.inc b/math/libm-test-tan.inc
index 33f64ce010..35681e0fda 100644
--- a/math/libm-test-tan.inc
+++ b/math/libm-test-tan.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data tan_test_data[] =
   {
     TEST_f_f (tan, plus_infty, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM),
@@ -34,6 +36,12 @@ tan_test (void)
   ALL_RM_TEST (tan, 0, tan_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  tan_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-tanh.inc b/math/libm-test-tanh.inc
index 1ce26a7e3e..f9db69ee06 100644
--- a/math/libm-test-tanh.inc
+++ b/math/libm-test-tanh.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data tanh_test_data[] =
   {
     TEST_f_f (tanh, plus_infty, 1, ERRNO_UNCHANGED|NO_TEST_INLINE),
@@ -34,6 +36,12 @@ tanh_test (void)
   ALL_RM_TEST (tanh, 0, tanh_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  tanh_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-tgamma.inc b/math/libm-test-tgamma.inc
index 3c428fc5ca..4e7debfbd7 100644
--- a/math/libm-test-tgamma.inc
+++ b/math/libm-test-tgamma.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data tgamma_test_data[] =
   {
     TEST_f_f (tgamma, plus_infty, plus_infty, ERRNO_UNCHANGED),
@@ -39,6 +41,12 @@ tgamma_test (void)
   ALL_RM_TEST (tgamma, 0, tgamma_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  tgamma_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-totalorder.inc b/math/libm-test-totalorder.inc
index 3c068da09a..d92e2aa6fd 100644
--- a/math/libm-test-totalorder.inc
+++ b/math/libm-test-totalorder.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_ff_i_data totalorder_test_data[] =
   {
     TEST_ff_b (totalorder, minus_zero, minus_zero, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -263,6 +265,12 @@ totalorder_test (void)
   ALL_RM_TEST (totalorder, 1, totalorder_test_data, RUN_TEST_LOOP_ff_b, END);
 }
 
+static void
+do_test (void)
+{
+  totalorder_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-totalordermag.inc b/math/libm-test-totalordermag.inc
index 480b4eb2f4..2ebf1d0c50 100644
--- a/math/libm-test-totalordermag.inc
+++ b/math/libm-test-totalordermag.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_ff_i_data totalordermag_test_data[] =
   {
     TEST_ff_b (totalordermag, minus_zero, minus_zero, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -263,6 +265,12 @@ totalordermag_test (void)
   ALL_RM_TEST (totalordermag, 1, totalordermag_test_data, RUN_TEST_LOOP_ff_b, END);
 }
 
+static void
+do_test (void)
+{
+  totalordermag_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-trunc.inc b/math/libm-test-trunc.inc
index 97da772e09..88c9128bdb 100644
--- a/math/libm-test-trunc.inc
+++ b/math/libm-test-trunc.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data trunc_test_data[] =
   {
     TEST_f_f (trunc, plus_infty, plus_infty, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@@ -179,6 +181,12 @@ trunc_test (void)
   ALL_RM_TEST (trunc, 1, trunc_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  trunc_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-ufromfp.inc b/math/libm-test-ufromfp.inc
index 9bedde5dd1..42e6a03f5c 100644
--- a/math/libm-test-ufromfp.inc
+++ b/math/libm-test-ufromfp.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_fiu_U_data ufromfp_test_data[] =
   {
     /* Infinity, NaN and values that are definitely out of range
@@ -6830,6 +6832,12 @@ ufromfp_test (void)
   ALL_RM_TEST (ufromfp, 1, ufromfp_test_data, RUN_TEST_LOOP_fiu_U, END);
 }
 
+static void
+do_test (void)
+{
+  ufromfp_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-ufromfpx.inc b/math/libm-test-ufromfpx.inc
index 532df78ea1..667ca53892 100644
--- a/math/libm-test-ufromfpx.inc
+++ b/math/libm-test-ufromfpx.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_fiu_U_data ufromfpx_test_data[] =
   {
     /* Infinity, NaN and values that are definitely out of range
@@ -6830,6 +6832,12 @@ ufromfpx_test (void)
   ALL_RM_TEST (ufromfpx, 1, ufromfpx_test_data, RUN_TEST_LOOP_fiu_U, END);
 }
 
+static void
+do_test (void)
+{
+  ufromfpx_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-y0.inc b/math/libm-test-y0.inc
index 812d0b203c..4ad2cd7807 100644
--- a/math/libm-test-y0.inc
+++ b/math/libm-test-y0.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data y0_test_data[] =
   {
     /* y0 is the Bessel function of the second kind of order 0 */
@@ -41,6 +43,12 @@ y0_test (void)
   ALL_RM_TEST (y0, 0, y0_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  y0_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-y1.inc b/math/libm-test-y1.inc
index b9c0f57e31..ccb0d1a17b 100644
--- a/math/libm-test-y1.inc
+++ b/math/libm-test-y1.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_f_f_data y1_test_data[] =
   {
     /* y1 is the Bessel function of the second kind of order 1 */
@@ -41,6 +43,12 @@ y1_test (void)
   ALL_RM_TEST (y1, 0, y1_test_data, RUN_TEST_LOOP_f_f, END);
 }
 
+static void
+do_test (void)
+{
+  y1_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test-yn.inc b/math/libm-test-yn.inc
index 7e17d59475..dec0b2fe3f 100644
--- a/math/libm-test-yn.inc
+++ b/math/libm-test-yn.inc
@@ -16,6 +16,8 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include "libm-test-driver.c"
+
 static const struct test_if_f_data yn_test_data[] =
   {
     /* yn is the Bessel function of the second kind of order n */
@@ -119,6 +121,12 @@ yn_test (void)
   ALL_RM_TEST (yn, 0, yn_test_data, RUN_TEST_LOOP_if_f, END);
 }
 
+static void
+do_test (void)
+{
+  yn_test ();
+}
+
 /*
  * Local Variables:
  * mode:c
diff --git a/math/libm-test.inc b/math/libm-test.inc
deleted file mode 100644
index ee5c0fe5a2..0000000000
--- a/math/libm-test.inc
+++ /dev/null
@@ -1,319 +0,0 @@
-/* Copyright (C) 1997-2017 Free Software Foundation, Inc.
-   This file is part of the GNU C Library.
-   Contributed by Andreas Jaeger <aj@suse.de>, 1997.
-
-   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/>.  */
-
-/* The bulk of the implementation, other than the tests of individual
-   functions, is in a separate file.  */
-#include "libm-test-driver.c"
-
-/****************************************************************************
-  Tests for single functions of libm.
-  Please keep them alphabetically sorted!
-****************************************************************************/
-
-#include "libm-test-acos.c"
-#include "libm-test-acosh.c"
-#include "libm-test-asin.c"
-#include "libm-test-asinh.c"
-#include "libm-test-atan.c"
-#include "libm-test-atan2.c"
-#include "libm-test-atanh.c"
-#include "libm-test-cabs.c"
-#include "libm-test-cacos.c"
-#include "libm-test-cacosh.c"
-#include "libm-test-canonicalize.c"
-#include "libm-test-carg.c"
-#include "libm-test-casin.c"
-#include "libm-test-casinh.c"
-#include "libm-test-catan.c"
-#include "libm-test-catanh.c"
-#include "libm-test-cbrt.c"
-#include "libm-test-ccos.c"
-#include "libm-test-ccosh.c"
-#include "libm-test-ceil.c"
-#include "libm-test-cexp.c"
-#include "libm-test-cimag.c"
-#include "libm-test-clog.c"
-#include "libm-test-clog10.c"
-#include "libm-test-conj.c"
-#include "libm-test-copysign.c"
-#include "libm-test-cos.c"
-#include "libm-test-cosh.c"
-#include "libm-test-cpow.c"
-#include "libm-test-cproj.c"
-#include "libm-test-creal.c"
-#include "libm-test-csin.c"
-#include "libm-test-csinh.c"
-#include "libm-test-csqrt.c"
-#include "libm-test-ctan.c"
-#include "libm-test-ctanh.c"
-#include "libm-test-erf.c"
-#include "libm-test-erfc.c"
-#include "libm-test-exp.c"
-#include "libm-test-exp10.c"
-#include "libm-test-exp2.c"
-#include "libm-test-expm1.c"
-#include "libm-test-fabs.c"
-#include "libm-test-fdim.c"
-#include "libm-test-floor.c"
-#include "libm-test-fma.c"
-#include "libm-test-fmax.c"
-#include "libm-test-fmaxmag.c"
-#include "libm-test-fmin.c"
-#include "libm-test-fminmag.c"
-#include "libm-test-fmod.c"
-#include "libm-test-fpclassify.c"
-#include "libm-test-frexp.c"
-#include "libm-test-fromfp.c"
-#include "libm-test-fromfpx.c"
-#include "libm-test-getpayload.c"
-#include "libm-test-hypot.c"
-#include "libm-test-ilogb.c"
-#include "libm-test-iscanonical.c"
-#include "libm-test-iseqsig.c"
-#include "libm-test-isfinite.c"
-#include "libm-test-isgreater.c"
-#include "libm-test-isgreaterequal.c"
-#include "libm-test-isinf.c"
-#include "libm-test-isless.c"
-#include "libm-test-islessequal.c"
-#include "libm-test-islessgreater.c"
-#include "libm-test-isnan.c"
-#include "libm-test-isnormal.c"
-#include "libm-test-issignaling.c"
-#include "libm-test-issubnormal.c"
-#include "libm-test-isunordered.c"
-#include "libm-test-iszero.c"
-#include "libm-test-j0.c"
-#include "libm-test-j1.c"
-#include "libm-test-jn.c"
-#include "libm-test-lgamma.c"
-#include "libm-test-llogb.c"
-#include "libm-test-llrint.c"
-#include "libm-test-llround.c"
-#include "libm-test-log.c"
-#include "libm-test-log10.c"
-#include "libm-test-log1p.c"
-#include "libm-test-log2.c"
-#include "libm-test-logb.c"
-#include "libm-test-lrint.c"
-#include "libm-test-lround.c"
-#include "libm-test-modf.c"
-#include "libm-test-nearbyint.c"
-#include "libm-test-nextafter.c"
-#include "libm-test-nextdown.c"
-#include "libm-test-nexttoward.c"
-#include "libm-test-nextup.c"
-#include "libm-test-pow.c"
-#include "libm-test-remainder.c"
-#include "libm-test-remquo.c"
-#include "libm-test-rint.c"
-#include "libm-test-round.c"
-#include "libm-test-roundeven.c"
-#include "libm-test-scalb.c"
-#include "libm-test-scalbln.c"
-#include "libm-test-scalbn.c"
-#include "libm-test-setpayload.c"
-#include "libm-test-setpayloadsig.c"
-#include "libm-test-signbit.c"
-#include "libm-test-significand.c"
-#include "libm-test-sin.c"
-#include "libm-test-sincos.c"
-#include "libm-test-sinh.c"
-#include "libm-test-sqrt.c"
-#include "libm-test-tan.c"
-#include "libm-test-tanh.c"
-#include "libm-test-tgamma.c"
-#include "libm-test-totalorder.c"
-#include "libm-test-totalordermag.c"
-#include "libm-test-trunc.c"
-#include "libm-test-ufromfp.c"
-#include "libm-test-ufromfpx.c"
-#include "libm-test-y0.c"
-#include "libm-test-y1.c"
-#include "libm-test-yn.c"
-
-static void
-do_test (void)
-{
-  /* Keep the tests a wee bit ordered (according to ISO C99).  */
-  /* Classification macros:  */
-  finite_test ();
-  fpclassify_test ();
-  iscanonical_test ();
-  isfinite_test ();
-  isinf_test ();
-  isnan_test ();
-  isnormal_test ();
-  issignaling_test ();
-  issubnormal_test ();
-  iszero_test ();
-  signbit_test ();
-
-  /* Trigonometric functions:  */
-  acos_test ();
-  asin_test ();
-  atan_test ();
-  atan2_test ();
-  cos_test ();
-  sin_test ();
-  sincos_test ();
-  tan_test ();
-
-  /* Hyperbolic functions:  */
-  acosh_test ();
-  asinh_test ();
-  atanh_test ();
-  cosh_test ();
-  sinh_test ();
-  tanh_test ();
-
-  /* Exponential and logarithmic functions:  */
-  exp_test ();
-  exp10_test ();
-  exp2_test ();
-  expm1_test ();
-  frexp_test ();
-  ldexp_test ();
-  log_test ();
-  log10_test ();
-  log1p_test ();
-  log2_test ();
-  logb_test ();
-  modf_test ();
-  pow10_test ();
-  ilogb_test ();
-  llogb_test ();
-  scalb_test ();
-  scalbn_test ();
-  scalbln_test ();
-  significand_test ();
-
-  /* Power and absolute value functions:  */
-  cbrt_test ();
-  fabs_test ();
-  hypot_test ();
-  pow_test ();
-  sqrt_test ();
-
-  /* Error and gamma functions:  */
-  erf_test ();
-  erfc_test ();
-  gamma_test ();
-  lgamma_test ();
-  tgamma_test ();
-
-  /* Nearest integer functions:  */
-  ceil_test ();
-  floor_test ();
-  nearbyint_test ();
-  rint_test ();
-  lrint_test ();
-  llrint_test ();
-  round_test ();
-  roundeven_test ();
-  lround_test ();
-  llround_test ();
-  trunc_test ();
-  fromfp_test ();
-  fromfpx_test ();
-  ufromfp_test ();
-  ufromfpx_test ();
-
-  /* Remainder functions:  */
-  drem_test ();
-  fmod_test ();
-  remainder_test ();
-  remquo_test ();
-
-  /* Manipulation functions:  */
-  copysign_test ();
-  nextup_test();
-  nextdown_test();
-  nextafter_test ();
-  nexttoward_test ();
-
-  /* maximum, minimum and positive difference functions */
-  fdim_test ();
-  fmax_test ();
-  fmaxmag_test ();
-  fmin_test ();
-  fminmag_test ();
-
-  /* Multiply and add:  */
-  fma_test ();
-
-  /* Comparison macros:  */
-  iseqsig_test ();
-  isgreater_test ();
-  isgreaterequal_test ();
-  isless_test ();
-  islessequal_test ();
-  islessgreater_test ();
-  isunordered_test ();
-
-  /* Total order functions:  */
-  totalorder_test ();
-  totalordermag_test ();
-
-  /* Canonicalize functions:  */
-  canonicalize_test ();
-
-  /* NaN functions:  */
-  getpayload_test ();
-  setpayload_test ();
-  setpayloadsig_test ();
-
-  /* Complex functions:  */
-  cabs_test ();
-  cacos_test ();
-  cacosh_test ();
-  carg_test ();
-  casin_test ();
-  casinh_test ();
-  catan_test ();
-  catanh_test ();
-  ccos_test ();
-  ccosh_test ();
-  cexp_test ();
-  cimag_test ();
-  clog10_test ();
-  clog_test ();
-  conj_test ();
-  cpow_test ();
-  cproj_test ();
-  creal_test ();
-  csin_test ();
-  csinh_test ();
-  csqrt_test ();
-  ctan_test ();
-  ctanh_test ();
-
-  /* Bessel functions:  */
-  j0_test ();
-  j1_test ();
-  jn_test ();
-  y0_test ();
-  y1_test ();
-  yn_test ();
-}
-
-/*
- * Local Variables:
- * mode:c
- * End:
- */
diff --git a/math/test-double-finite.c b/math/test-double-finite.c
deleted file mode 100644
index c181925ffb..0000000000
--- a/math/test-double-finite.c
+++ /dev/null
@@ -1,23 +0,0 @@
-/* Copyright (C) 1997-2017 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 "test-double.h"
-#include "test-math-finite.h"
-#include "test-math-no-inline.h"
-#include "test-math-scalar.h"
-
-#include "libm-test.c"
diff --git a/math/test-double-vlen2.h b/math/test-double-vlen2.h
index 06571cf65c..39c2e4dfb9 100644
--- a/math/test-double-vlen2.h
+++ b/math/test-double-vlen2.h
@@ -24,5 +24,3 @@
 
 #define VEC_SUFF _vlen2
 #define VEC_LEN 2
-
-#define FUNC_TEST(function) function ## _VEC_SUFF
diff --git a/math/test-double-vlen4.h b/math/test-double-vlen4.h
index 47254703b6..37b67bc56c 100644
--- a/math/test-double-vlen4.h
+++ b/math/test-double-vlen4.h
@@ -24,5 +24,3 @@
 
 #define VEC_SUFF _vlen4
 #define VEC_LEN 4
-
-#define FUNC_TEST(function) function ## _VEC_SUFF
diff --git a/math/test-double-vlen8.h b/math/test-double-vlen8.h
index a1254ae396..0dce3e28aa 100644
--- a/math/test-double-vlen8.h
+++ b/math/test-double-vlen8.h
@@ -24,5 +24,3 @@
 
 #define VEC_SUFF _vlen8
 #define VEC_LEN 8
-
-#define FUNC_TEST(function) function ## _VEC_SUFF
diff --git a/math/test-double.c b/math/test-double.c
deleted file mode 100644
index 3672370bcb..0000000000
--- a/math/test-double.c
+++ /dev/null
@@ -1,25 +0,0 @@
-/* Copyright (C) 1997-2017 Free Software Foundation, Inc.
-   This file is part of the GNU C Library.
-   Contributed by Andreas Jaeger <aj@suse.de>, 1997.
-
-   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 "test-double.h"
-#include "test-math-no-finite.h"
-#include "test-math-no-inline.h"
-#include "test-math-errno.h"
-#include "test-math-scalar.h"
-
-#include "libm-test.c"
diff --git a/math/test-float-finite.c b/math/test-float-finite.c
deleted file mode 100644
index 09ea1e948b..0000000000
--- a/math/test-float-finite.c
+++ /dev/null
@@ -1,23 +0,0 @@
-/* Copyright (C) 1997-2017 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 "test-float.h"
-#include "test-math-finite.h"
-#include "test-math-no-inline.h"
-#include "test-math-scalar.h"
-
-#include "libm-test.c"
diff --git a/math/test-float-vlen16.h b/math/test-float-vlen16.h
index b6d209e61c..829ceabf66 100644
--- a/math/test-float-vlen16.h
+++ b/math/test-float-vlen16.h
@@ -24,5 +24,3 @@
 
 #define VEC_SUFF _vlen16
 #define VEC_LEN 16
-
-#define FUNC_TEST(function) function ## f ## _VEC_SUFF
diff --git a/math/test-float-vlen4.h b/math/test-float-vlen4.h
index 4bac669d21..acde7775ea 100644
--- a/math/test-float-vlen4.h
+++ b/math/test-float-vlen4.h
@@ -24,5 +24,3 @@
 
 #define VEC_SUFF _vlen4
 #define VEC_LEN 4
-
-#define FUNC_TEST(function) function ## f ## _VEC_SUFF
diff --git a/math/test-float-vlen8.h b/math/test-float-vlen8.h
index e72257ceee..a09bd9fecd 100644
--- a/math/test-float-vlen8.h
+++ b/math/test-float-vlen8.h
@@ -24,5 +24,3 @@
 
 #define VEC_SUFF _vlen8
 #define VEC_LEN 8
-
-#define FUNC_TEST(function) function ## f ## _VEC_SUFF
diff --git a/math/test-float.c b/math/test-float.c
deleted file mode 100644
index 25ba35a9d1..0000000000
--- a/math/test-float.c
+++ /dev/null
@@ -1,25 +0,0 @@
-/* Copyright (C) 1997-2017 Free Software Foundation, Inc.
-   This file is part of the GNU C Library.
-   Contributed by Andreas Jaeger <aj@suse.de>, 1997.
-
-   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 "test-float.h"
-#include "test-math-no-finite.h"
-#include "test-math-no-inline.h"
-#include "test-math-errno.h"
-#include "test-math-scalar.h"
-
-#include "libm-test.c"
diff --git a/math/test-idouble.c b/math/test-idouble.c
deleted file mode 100644
index 944d981cc2..0000000000
--- a/math/test-idouble.c
+++ /dev/null
@@ -1,23 +0,0 @@
-/* Copyright (C) 1997-2017 Free Software Foundation, Inc.
-   This file is part of the GNU C Library.
-   Contributed by Andreas Jaeger <aj@suse.de>, 1997.
-
-   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 "test-double.h"
-#include "test-math-inline.h"
-#include "test-math-scalar.h"
-
-#include "libm-test.c"
diff --git a/math/test-ifloat.c b/math/test-ifloat.c
deleted file mode 100644
index 20c028e1a3..0000000000
--- a/math/test-ifloat.c
+++ /dev/null
@@ -1,23 +0,0 @@
-/* Copyright (C) 1997-2017 Free Software Foundation, Inc.
-   This file is part of the GNU C Library.
-   Contributed by Andreas Jaeger <aj@suse.de>, 1997.
-
-   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 "test-float.h"
-#include "test-math-inline.h"
-#include "test-math-scalar.h"
-
-#include "libm-test.c"
diff --git a/math/test-ildouble.c b/math/test-ildouble.c
deleted file mode 100644
index ddba3e4722..0000000000
--- a/math/test-ildouble.c
+++ /dev/null
@@ -1,23 +0,0 @@
-/* Copyright (C) 1997-2017 Free Software Foundation, Inc.
-   This file is part of the GNU C Library.
-   Contributed by Andreas Jaeger <aj@suse.de>, 1997.
-
-   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 "test-ldouble.h"
-#include "test-math-inline.h"
-#include "test-math-scalar.h"
-
-#include "libm-test.c"
diff --git a/math/test-ldouble-finite.c b/math/test-ldouble-finite.c
deleted file mode 100644
index 47cac2c71e..0000000000
--- a/math/test-ldouble-finite.c
+++ /dev/null
@@ -1,23 +0,0 @@
-/* Copyright (C) 1997-2017 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 "test-ldouble.h"
-#include "test-math-finite.h"
-#include "test-math-no-inline.h"
-#include "test-math-scalar.h"
-
-#include "libm-test.c"
diff --git a/math/test-ldouble.c b/math/test-ldouble.c
deleted file mode 100644
index 209a81683f..0000000000
--- a/math/test-ldouble.c
+++ /dev/null
@@ -1,25 +0,0 @@
-/* Copyright (C) 1997-2017 Free Software Foundation, Inc.
-   This file is part of the GNU C Library.
-   Contributed by Andreas Jaeger <aj@suse.de>, 1997.
-
-   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 "test-ldouble.h"
-#include "test-math-no-finite.h"
-#include "test-math-no-inline.h"
-#include "test-math-errno.h"
-#include "test-math-scalar.h"
-
-#include "libm-test.c"
diff --git a/math/test-math-vector.h b/math/test-math-vector.h
index 8a9ae9caa1..424fef6c60 100644
--- a/math/test-math-vector.h
+++ b/math/test-math-vector.h
@@ -25,6 +25,7 @@
 #define CONCAT(a, b) CNCT (a, b)
 
 #define WRAPPER_NAME(function) CONCAT (function, VEC_SUFF)
+#define FUNC_TEST(function) WRAPPER_NAME (FUNC (function))
 
 /* This macro is used in VECTOR_WRAPPER macros for vector tests.  */
 #define TEST_VEC_LOOP(vec, len) 				\
@@ -51,7 +52,7 @@
     }								\
   while (0)
 
-#define WRAPPER_DECL(function) extern FLOAT function (FLOAT);
+#define WRAPPER_DECL_f(function) extern FLOAT function (FLOAT);
 #define WRAPPER_DECL_ff(function) extern FLOAT function (FLOAT, FLOAT);
 #define WRAPPER_DECL_fFF(function) extern void function (FLOAT, FLOAT *, FLOAT *);
 
diff --git a/sysdeps/x86_64/fpu/Makefile b/sysdeps/x86_64/fpu/Makefile
index fad605a841..36f090b826 100644
--- a/sysdeps/x86_64/fpu/Makefile
+++ b/sysdeps/x86_64/fpu/Makefile
@@ -178,6 +178,15 @@ $(objpfx)test-float-libmvec-sincosf-avx512: \
   $(objpfx)test-float-libmvec-sincosf-avx512-main.o $(libmvec)
 endif
 
+double-vlen2-funcs = cos exp log pow sin sincos
+double-vlen4-funcs = cos exp log pow sin sincos
+double-vlen4-avx2-funcs = cos exp log pow sin sincos
+double-vlen8-funcs = cos exp log pow sin sincos
+float-vlen4-funcs = cos exp log pow sin sincos
+float-vlen8-funcs = cos exp log pow sin sincos
+float-vlen8-avx2-funcs = cos exp log pow sin sincos
+float-vlen16-funcs = cos exp log pow sin sincos
+
 double-vlen4-arch-ext-cflags = -mavx
 double-vlen4-arch-ext2-cflags = -mavx2
 double-vlen8-arch-ext-cflags = -mavx512f
@@ -199,10 +208,8 @@ CFLAGS-test-float-libmvec-alias-avx-mod.c = $(double-vlen4-arch-ext-cflags) $(li
 CFLAGS-test-float-libmvec-alias-avx2-mod.c = $(double-vlen4-arch-ext2-cflags) $(libmvec-alias-cflags) -DREQUIRE_AVX2
 CFLAGS-test-float-libmvec-alias-avx512-mod.c = $(double-vlen8-arch-ext-cflags) $(libmvec-alias-cflags) -DREQUIRE_AVX512F
 
-CFLAGS-test-double-vlen4-avx2.c = $(libm-test-vec-cflags)
 CFLAGS-test-double-vlen4-avx2-wrappers.c = $(double-vlen4-arch-ext2-cflags)
 
-CFLAGS-test-float-vlen8-avx2.c = $(libm-test-vec-cflags)
 CFLAGS-test-float-vlen8-avx2-wrappers.c = $(float-vlen8-arch-ext2-cflags)
 
 CFLAGS-test-double-libmvec-sincos-main.c = $(libmvec-sincos-cflags)
diff --git a/sysdeps/x86_64/fpu/test-double-vlen2.c b/sysdeps/x86_64/fpu/test-double-vlen2.c
deleted file mode 100644
index b706f2aa9f..0000000000
--- a/sysdeps/x86_64/fpu/test-double-vlen2.c
+++ /dev/null
@@ -1,21 +0,0 @@
-/* Tests for SSE ISA versions of vector math functions.
-   Copyright (C) 2014-2017 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 <test-double-vlen2.h>
-
-#include "libm-test.c"
diff --git a/sysdeps/x86_64/fpu/test-double-vlen2.h b/sysdeps/x86_64/fpu/test-double-vlen2.h
deleted file mode 100644
index 3e3ef8ebf4..0000000000
--- a/sysdeps/x86_64/fpu/test-double-vlen2.h
+++ /dev/null
@@ -1,26 +0,0 @@
-/* Tests for SSE ISA versions of vector math functions.
-   Copyright (C) 2014-2017 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_next <test-double-vlen2.h>
-
-#define TEST_VECTOR_cos 1
-#define TEST_VECTOR_sin 1
-#define TEST_VECTOR_sincos 1
-#define TEST_VECTOR_log 1
-#define TEST_VECTOR_exp 1
-#define TEST_VECTOR_pow 1
diff --git a/sysdeps/x86_64/fpu/test-double-vlen4-avx2.c b/sysdeps/x86_64/fpu/test-double-vlen4-avx2.c
deleted file mode 100644
index ccf2d15ffa..0000000000
--- a/sysdeps/x86_64/fpu/test-double-vlen4-avx2.c
+++ /dev/null
@@ -1,21 +0,0 @@
-/* Tests for AVX2 ISA versions of vector math functions.
-   Copyright (C) 2014-2017 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 <test-double-vlen4-avx2.h>
-
-#include "libm-test.c"
diff --git a/sysdeps/x86_64/fpu/test-double-vlen4.c b/sysdeps/x86_64/fpu/test-double-vlen4.c
deleted file mode 100644
index f039207d1f..0000000000
--- a/sysdeps/x86_64/fpu/test-double-vlen4.c
+++ /dev/null
@@ -1,21 +0,0 @@
-/* Tests for AVX ISA versions of vector math functions.
-   Copyright (C) 2014-2017 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 <test-double-vlen4.h>
-
-#include "libm-test.c"
diff --git a/sysdeps/x86_64/fpu/test-double-vlen4.h b/sysdeps/x86_64/fpu/test-double-vlen4.h
index 396b7714c9..1698e621d6 100644
--- a/sysdeps/x86_64/fpu/test-double-vlen4.h
+++ b/sysdeps/x86_64/fpu/test-double-vlen4.h
@@ -18,11 +18,4 @@
 
 #include_next <test-double-vlen4.h>
 
-#define TEST_VECTOR_cos 1
-#define TEST_VECTOR_sin 1
-#define TEST_VECTOR_sincos 1
-#define TEST_VECTOR_log 1
-#define TEST_VECTOR_exp 1
-#define TEST_VECTOR_pow 1
-
 #define REQUIRE_AVX
diff --git a/sysdeps/x86_64/fpu/test-double-vlen8.c b/sysdeps/x86_64/fpu/test-double-vlen8.c
deleted file mode 100644
index 04db81ac41..0000000000
--- a/sysdeps/x86_64/fpu/test-double-vlen8.c
+++ /dev/null
@@ -1,21 +0,0 @@
-/* Tests for AVX-512 versions of vector math functions.
-   Copyright (C) 2014-2017 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 <test-double-vlen8.h>
-
-#include "libm-test.c"
diff --git a/sysdeps/x86_64/fpu/test-double-vlen8.h b/sysdeps/x86_64/fpu/test-double-vlen8.h
index 38097740fa..5802abc121 100644
--- a/sysdeps/x86_64/fpu/test-double-vlen8.h
+++ b/sysdeps/x86_64/fpu/test-double-vlen8.h
@@ -18,11 +18,4 @@
 
 #include_next <test-double-vlen8.h>
 
-#define TEST_VECTOR_cos 1
-#define TEST_VECTOR_sin 1
-#define TEST_VECTOR_sincos 1
-#define TEST_VECTOR_log 1
-#define TEST_VECTOR_exp 1
-#define TEST_VECTOR_pow 1
-
 #define REQUIRE_AVX512F
diff --git a/sysdeps/x86_64/fpu/test-float-vlen16.c b/sysdeps/x86_64/fpu/test-float-vlen16.c
deleted file mode 100644
index 13a31d076d..0000000000
--- a/sysdeps/x86_64/fpu/test-float-vlen16.c
+++ /dev/null
@@ -1,21 +0,0 @@
-/* Tests for AVX-512 ISA versions of vector math functions.
-   Copyright (C) 2014-2017 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 <test-float-vlen16.h>
-
-#include "libm-test.c"
diff --git a/sysdeps/x86_64/fpu/test-float-vlen16.h b/sysdeps/x86_64/fpu/test-float-vlen16.h
index 0f1658f5ca..b2bfbf5371 100644
--- a/sysdeps/x86_64/fpu/test-float-vlen16.h
+++ b/sysdeps/x86_64/fpu/test-float-vlen16.h
@@ -18,11 +18,4 @@
 
 #include_next <test-float-vlen16.h>
 
-#define TEST_VECTOR_cosf 1
-#define TEST_VECTOR_sinf 1
-#define TEST_VECTOR_sincosf 1
-#define TEST_VECTOR_logf 1
-#define TEST_VECTOR_expf 1
-#define TEST_VECTOR_powf 1
-
 #define REQUIRE_AVX512F
diff --git a/sysdeps/x86_64/fpu/test-float-vlen4.c b/sysdeps/x86_64/fpu/test-float-vlen4.c
deleted file mode 100644
index 78bc99c127..0000000000
--- a/sysdeps/x86_64/fpu/test-float-vlen4.c
+++ /dev/null
@@ -1,21 +0,0 @@
-/* Tests for SSE ISA versions of vector math functions.
-   Copyright (C) 2014-2017 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 <test-float-vlen4.h>
-
-#include "libm-test.c"
diff --git a/sysdeps/x86_64/fpu/test-float-vlen4.h b/sysdeps/x86_64/fpu/test-float-vlen4.h
deleted file mode 100644
index 0831a21908..0000000000
--- a/sysdeps/x86_64/fpu/test-float-vlen4.h
+++ /dev/null
@@ -1,26 +0,0 @@
-/* Tests for SSE ISA versions of vector math functions.
-   Copyright (C) 2014-2017 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_next <test-float-vlen4.h>
-
-#define TEST_VECTOR_cosf 1
-#define TEST_VECTOR_sinf 1
-#define TEST_VECTOR_sincosf 1
-#define TEST_VECTOR_logf 1
-#define TEST_VECTOR_expf 1
-#define TEST_VECTOR_powf 1
diff --git a/sysdeps/x86_64/fpu/test-float-vlen8-avx2.c b/sysdeps/x86_64/fpu/test-float-vlen8-avx2.c
deleted file mode 100644
index bb1f70ee32..0000000000
--- a/sysdeps/x86_64/fpu/test-float-vlen8-avx2.c
+++ /dev/null
@@ -1,21 +0,0 @@
-/* Tests for AVX2 ISA versions of vector math functions.
-   Copyright (C) 2014-2017 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 <test-float-vlen8-avx2.h>
-
-#include "libm-test.c"
diff --git a/sysdeps/x86_64/fpu/test-float-vlen8.c b/sysdeps/x86_64/fpu/test-float-vlen8.c
deleted file mode 100644
index fb50fd7a75..0000000000
--- a/sysdeps/x86_64/fpu/test-float-vlen8.c
+++ /dev/null
@@ -1,21 +0,0 @@
-/* Tests for AVX ISA versions of vector math functions.
-   Copyright (C) 2014-2017 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 <test-float-vlen8.h>
-
-#include "libm-test.c"
diff --git a/sysdeps/x86_64/fpu/test-float-vlen8.h b/sysdeps/x86_64/fpu/test-float-vlen8.h
index a6bfebf0d8..23ef71c6c5 100644
--- a/sysdeps/x86_64/fpu/test-float-vlen8.h
+++ b/sysdeps/x86_64/fpu/test-float-vlen8.h
@@ -18,11 +18,4 @@
 
 #include_next <test-float-vlen8.h>
 
-#define TEST_VECTOR_cosf 1
-#define TEST_VECTOR_sinf 1
-#define TEST_VECTOR_sincosf 1
-#define TEST_VECTOR_logf 1
-#define TEST_VECTOR_expf 1
-#define TEST_VECTOR_powf 1
-
 #define REQUIRE_AVX