diff mbox

RFC: Run libm tests separately for each function

Message ID alpine.DEB.2.20.1702162305250.14439@digraph.polyomino.org.uk
State New
Headers show

Commit Message

Joseph Myers Feb. 16, 2017, 11:08 p.m. UTC
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
about 40 MB of libm-test-*.c sources, which would grow to maybe 70 or
80 MB when the complex inverse trig and hyperbolic functions move to
the auto-libm-test-* mechanism (that move is practical now that tests
for all functions don't need regenerating for any change to
auto-libm-test-in but you can instead regenerate each
auto-libm-test-out-* file independently; auto-libm-test-out-casin and
auto-libm-test-out-casinh take about 38 minutes each to generate on my
system after such a move, auto-libm-test-out-cacos and
auto-libm-test-out-cacosh take about 80 minutes each).

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 40
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 remove 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.

Any comments?  Especially regarding the use of iterators; there is
existing precedent (in elf/Makefile) for using o-iterator.mk as a
generic iterator with object-suffixes-left set to something other than
a list of object suffixes, but maybe there should be a differently
named iterator for such generic uses?

2017-02-16  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.

Comments

Florian Weimer Feb. 17, 2017, 7:46 a.m. UTC | #1
* Joseph Myers:

> Any comments?  Especially regarding the use of iterators; there is
> existing precedent (in elf/Makefile) for using o-iterator.mk as a
> generic iterator with object-suffixes-left set to something other than
> a list of object suffixes, but maybe there should be a differently
> named iterator for such generic uses?

Does this patch depend on another change?  I get a build failure on
x86-64:

In file included from ../sysdeps/x86_64/fpu/test-double-libmvec-alias-mod.c:25:0,
                 from ../sysdeps/x86_64/fpu/test-double-libmvec-alias-avx512-mod.c:1:
../sysdeps/x86_64/fpu/test-libmvec-alias-mod.c: In function ‘init_arg’:
../sysdeps/x86_64/fpu/test-libmvec-alias-mod.c:33:3: error: implicit declaration of function ‘GLRO’ [-Werror=implicit-function-declaration]
   CHECK_ARCH_EXT;
   ^

My immediate concern is that o-iterator.mk appears to have quadratic
behavior in the number of elements.  I'd like to run some build-time
benchmarks to ensure that this has no excessive build-time impact.
Sam Ravnborg Feb. 17, 2017, 9:16 a.m. UTC | #2
Hi Joseph.

(I have no knowledge on glibc build stuff, so be warned).

> This patch arranges for tests of each function to be run separately
...
Previously you wrote that things took 30 minutes / 80 minutes.
But the resulting build-time / run-time after this patch is applied
is not included. So the effect is not known.
It would be good to know the benefit (and eventual build time cost).

> 
> diff --git a/math/Makefile b/math/Makefile
> index 2735212..fabd0e9 100644
> --- a/math/Makefile
> +++ b/math/Makefile
> @@ -192,13 +192,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)


> @@ -232,15 +225,42 @@ libm-test-funcs-noauto = cacos cacosh canonicalize casin casinh catan catanh \
>  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))

"-i$(t))" looks like a typing error in vi - (I know this was the original syntax).
So when this is anyway changed a consistent naming style could be introduced.
Something like:
+libm-tests-base-inline = $(foreach t,$(types),test-$(t)-inline)


> +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))

> @@ -370,20 +367,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#*-}; \

For people that do not speak bash fluently it would be nice with a few comments here.
As inline code often grows larger over time it can be simpler to move it all to a shell
script and then handling comments and dealing with escapes are much simpler.

"%%" will delete the longest match from the back.
"#" will delete the shortest match from the front.
I wonder if you wanted to use the longest match in both cases.

> +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",
If the naming is changed to $(...)-inline this comments needs to be adjusted.

	Sam
Joseph Myers Feb. 17, 2017, 1:32 p.m. UTC | #3
On Fri, 17 Feb 2017, Florian Weimer wrote:

> * Joseph Myers:
> 
> > Any comments?  Especially regarding the use of iterators; there is
> > existing precedent (in elf/Makefile) for using o-iterator.mk as a
> > generic iterator with object-suffixes-left set to something other than
> > a list of object suffixes, but maybe there should be a differently
> > named iterator for such generic uses?
> 
> Does this patch depend on another change?  I get a build failure on
> x86-64:
> 
> In file included from ../sysdeps/x86_64/fpu/test-double-libmvec-alias-mod.c:25:0,
>                  from ../sysdeps/x86_64/fpu/test-double-libmvec-alias-avx512-mod.c:1:
> ../sysdeps/x86_64/fpu/test-libmvec-alias-mod.c: In function ‘init_arg’:
> ../sysdeps/x86_64/fpu/test-libmvec-alias-mod.c:33:3: error: implicit declaration of function ‘GLRO’ [-Werror=implicit-function-declaration]
>    CHECK_ARCH_EXT;
>    ^

That's not one of the tests affected by my patch.  I see that with current 
unmodified sources and suspect Zack's header changes.

> My immediate concern is that o-iterator.mk appears to have quadratic
> behavior in the number of elements.  I'd like to run some build-time
> benchmarks to ensure that this has no excessive build-time impact.

Note that o-iterator.mk is used with object-suffixes-left containing at 
most 17 elements (libm-tests-base, on x86_64; would be 20 elements with 
float128 support added on x86_64), not with it containing anything 
involving the 121 functions under test.

I'd expect this patch to improve test time for sufficiently high 
parallelism, where the move from 17 separately built large tests to 1137 
smaller tests (on x86_64) allows more parallelism that outweighs the 
overheads of running more tests separately from the makefile.  And of 
course if you compare with 2.25, that had serialization for the run of 
gen-libm-test.pl (which happened unnecessarily as part of the build rather 
than only when testing because of the before-compile setting).
Joseph Myers Feb. 17, 2017, 1:41 p.m. UTC | #4
On Fri, 17 Feb 2017, Sam Ravnborg wrote:

> Hi Joseph.
> 
> (I have no knowledge on glibc build stuff, so be warned).
> 
> > This patch arranges for tests of each function to be run separately
> ...
> Previously you wrote that things took 30 minutes / 80 minutes.

That's for regenerating auto-libm-test-out-{casin,casinh,cacos,cacosh}.  
Those are (will be) checked-in files and the time to regenerate them is 
only relevant to developers adding or modifying tests of those four 
<complex.h> functions (or modifying gen-auto-libm-tests in a way that 
requires all auto-libm-test-out-* to be regenerated), not to people 
building or testing glibc.

> > +libm-tests-base-inline = $(foreach t,$(types),test-i$(t))
> 
> "-i$(t))" looks like a typing error in vi - (I know this was the 
> original syntax). So when this is anyway changed a consistent naming 
> style could be introduced.

I don't think mixing such a change in this large patch is appropriate 
(indeed, I already split some changes into 17 separate preliminary commits 
to get to this patch that didn't seem conveniently splittable further).  
Such a change in naming convention would more naturally be done separately 
(and probably combined with changing the convention used within 
libm-test-ulps files as well).

> > +	type=$${type_func%%-*}; \
> > +	func=$${type_func#*-}; \
> 
> For people that do not speak bash fluently it would be nice with a few comments here.
> As inline code often grows larger over time it can be simpler to move it all to a shell
> script and then handling comments and dealing with escapes are much simpler.
> 
> "%%" will delete the longest match from the back.
> "#" will delete the shortest match from the front.
> I wonder if you wanted to use the longest match in both cases.

No.  If matching something of the form foo-bar, shortest match in one 
place goes together with longest match in the other place to ensure proper 
results if foo or bar contains a hyphen.  (In this case they can't contain 
a hyphen, but I think using shortest at one end and longest at the other 
is the appropriate idiom unless you can't get the right semantics that 
way.)
Florian Weimer Feb. 17, 2017, 4:26 p.m. UTC | #5
* Joseph Myers:

> On Fri, 17 Feb 2017, Florian Weimer wrote:
>
>> * Joseph Myers:
>> 
>> > Any comments?  Especially regarding the use of iterators; there is
>> > existing precedent (in elf/Makefile) for using o-iterator.mk as a
>> > generic iterator with object-suffixes-left set to something other than
>> > a list of object suffixes, but maybe there should be a differently
>> > named iterator for such generic uses?
>> 
>> Does this patch depend on another change?  I get a build failure on
>> x86-64:
>> 
>> In file included from ../sysdeps/x86_64/fpu/test-double-libmvec-alias-mod.c:25:0,
>>                  from ../sysdeps/x86_64/fpu/test-double-libmvec-alias-avx512-mod.c:1:
>> ../sysdeps/x86_64/fpu/test-libmvec-alias-mod.c: In function ‘init_arg’:
>> ../sysdeps/x86_64/fpu/test-libmvec-alias-mod.c:33:3: error: implicit declaration of function ‘GLRO’ [-Werror=implicit-function-declaration]
>>    CHECK_ARCH_EXT;
>>    ^
>
> That's not one of the tests affected by my patch.  I see that with current 
> unmodified sources and suspect Zack's header changes.

Right, it's the change to sysdeps/x86_64/fpu/math-tests-arch.h in:

commit ceaa98897cb717685bb3b51a81d733b64340bb19
Author: Zack Weinberg <zackw@panix.com>
Date:   Thu Feb 16 17:31:42 2017 -0500

    Add missing header files throughout the testsuite.

I'm not simply reverting this for now because I don't know the exact
direction Zack wants to move in, but we'll probably have to do this
soon in case a real fix doesn't appear.

>> My immediate concern is that o-iterator.mk appears to have quadratic
>> behavior in the number of elements.  I'd like to run some build-time
>> benchmarks to ensure that this has no excessive build-time impact.
>
> Note that o-iterator.mk is used with object-suffixes-left containing at 
> most 17 elements (libm-tests-base, on x86_64; would be 20 elements with 
> float128 support added on x86_64), not with it containing anything 
> involving the 121 functions under test.

Ah, this certainly explains why make performance isn't abysmal with
this change.
Zack Weinberg Feb. 17, 2017, 4:32 p.m. UTC | #6
On Fri, Feb 17, 2017 at 11:26 AM, Florian Weimer <fw@deneb.enyo.de> wrote:
>>
>> That's not one of the tests affected by my patch.  I see that with current
>> unmodified sources and suspect Zack's header changes.
>
> Right, it's the change to sysdeps/x86_64/fpu/math-tests-arch.h in:
>
> commit ceaa98897cb717685bb3b51a81d733b64340bb19
> Author: Zack Weinberg <zackw@panix.com>
> Date:   Thu Feb 16 17:31:42 2017 -0500
>
>     Add missing header files throughout the testsuite.
>
> I'm not simply reverting this for now because I don't know the exact
> direction Zack wants to move in, but we'll probably have to do this
> soon in case a real fix doesn't appear.

Please go ahead and back out the changes to
sysdeps/x86_64/fpu/math-tests-arch.h and
sysdeps/x86_64/multiarch/test-multiarch.h.  Those two changes seemed
like they would be safe by themselves, although they're only
_necessary_ in the context of my larger patchset, but I guess not.

zw
Joseph Myers Feb. 17, 2017, 6:57 p.m. UTC | #7
On Fri, 17 Feb 2017, Joseph Myers wrote:

> I'd expect this patch to improve test time for sufficiently high 
> parallelism, where the move from 17 separately built large tests to 1137 
> smaller tests (on x86_64) allows more parallelism that outweighs the 
> overheads of running more tests separately from the makefile.  And of 
> course if you compare with 2.25, that had serialization for the run of 
> gen-libm-test.pl (which happened unnecessarily as part of the build rather 
> than only when testing because of the before-compile setting).

A single -j12 run before and after the patch (based on current mainline, 
so with my move of more functions to auto-libm-test-*) gives timings 
before

real    0m27.193s
user    4m27.496s
sys     0m7.988s

and after

real    0m33.617s
user    5m11.500s
sys     0m22.392s

which I consider acceptable (and as noted I'd expect test time to improve 
for sufficiently high parallelism on systems with enough CPU cores where 
the previous 17 compilations of 50 MB of code had a serializing effect).
Joseph Myers Feb. 22, 2017, 4:39 p.m. UTC | #8
Any more comments before I commit this patch?
Joseph Myers Feb. 24, 2017, 12:53 a.m. UTC | #9
Now committed.
Florian Weimer Feb. 26, 2017, 7:56 a.m. UTC | #10
* Joseph Myers:

> On Fri, 17 Feb 2017, Joseph Myers wrote:
>
>> I'd expect this patch to improve test time for sufficiently high 
>> parallelism, where the move from 17 separately built large tests to 1137 
>> smaller tests (on x86_64) allows more parallelism that outweighs the 
>> overheads of running more tests separately from the makefile.  And of 
>> course if you compare with 2.25, that had serialization for the run of 
>> gen-libm-test.pl (which happened unnecessarily as part of the build rather 
>> than only when testing because of the before-compile setting).
>
> A single -j12 run before and after the patch (based on current mainline, 
> so with my move of more functions to auto-libm-test-*) gives timings 
> before
>
> real    0m27.193s
> user    4m27.496s
> sys     0m7.988s
>
> and after
>
> real    0m33.617s
> user    5m11.500s
> sys     0m22.392s
>
> which I consider acceptable (and as noted I'd expect test time to improve 
> for sufficiently high parallelism on systems with enough CPU cores where 
> the previous 17 compilations of 50 MB of code had a serializing effect).

Agreed, these numbers look reasonable.
diff mbox

Patch

diff --git a/math/Makefile b/math/Makefile
index 2735212..fabd0e9 100644
--- a/math/Makefile
+++ b/math/Makefile
@@ -192,13 +192,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))
@@ -232,15 +225,42 @@  libm-test-funcs-noauto = cacos cacosh canonicalize casin casinh catan catanh \
 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 $@
 
@@ -251,30 +271,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
@@ -287,15 +295,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
@@ -305,9 +305,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
@@ -370,20 +367,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
@@ -460,10 +548,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 442a47a..0271f83 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 7d9d6d7..0000000
--- 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 c98da4f..d795793 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 470fa29..816a1cd 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 6d3ed8e..9b6d229 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 af8392a..f218e03 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 365ca87..ed96133 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 9caedf7..e900113 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 97990b3..a57aebb 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 36d609a..d9a66fa 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 2a4e2f9..33f62eb 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, 0, 0, lit_pi_2_d, minus_zero),
@@ -704,6 +706,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 21e65b1..b6c1527 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, 0, 0, 0.0, lit_pi_2_d),
@@ -698,6 +700,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 93a0a9b..e0ba3ec 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 e92d4fb..e033893 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 a74c6ec..23a7362 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, 0, 0, 0.0, 0.0),
@@ -705,6 +707,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 ffe36ad..b8cdbcb 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, 0, 0, 0.0, 0.0),
@@ -705,6 +707,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 687c730..ead73ab 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, 0, 0, 0, 0),
@@ -522,6 +524,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 6848e60..4d04b0a 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, 0, 0, 0.0, 0.0),
@@ -521,6 +523,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 11a8a3b..769f52e 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 3180b55..2497af1 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 ac4c103..7c22c9e 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 c173b7e..d6356a5 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 355748c..f4bd962 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 a711f4c..569d20c 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 261aaad..6a97d5a 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 0c92a79..b330d74 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 cfa0a53..e5b2529 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 e717160..635cb02 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 1ca5b41..246b371 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 a645644..a0b88b0 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 2f4cda2..ffd1128 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 2daa6ab..441d58b 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 20ea43c..aaa1412 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 f42828c..03214ad 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 06877c8..41b9092 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 6ff26fa..43918fe 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 a568940..e485828 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 48002ebd..6ddeb0d 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 d24c5aa..1614198 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 20a389e..bcc96e5 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 ed6190e..7018eb3 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 a5ed2e2..323a82c 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 6be936b..92c81ad 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 0c0e4da..3c2561a 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 c01abf8..c18c596 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 1b0dc54..392cb68 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 28aa6ad..73713a6 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 a0abcb2..cceeed9 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 6da8dad..7764177 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 950a2cb..682a1b8 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 0253f27..94ef268 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 024ca90..0d2217d 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 1ce5ac8..267153b 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 e536af7..c8acc14 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 dd2eec2..a85f52c 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 bfc80df..b6f7d71 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 fb31e85..f2d5205 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 b8a466c..34e0af3 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 335a11e..def4d8b 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 f440e27..7d67982 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 957e5c1..7c94d62 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 c940027..3d4c850 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 aa1dcab..d021fc8 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 593822c..48d4c2e 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 ba2ee90..468523a 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 7f37fa8..51e564e 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 08d9b4b..cc63554 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 f93bb66..402dd97 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 93e4252..e71ec28 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 baa8b7a..b17bd07 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 ec8f45b..d125ec4 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 e5b3881..9f16e9b 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 3f0b7c1..e3df38b 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 94de45a..930dd5c 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 8a3ca07..9c2bb24 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 8694296..0519c09 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 5628d7c..2fa8c8e 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 a9ab7b2..44b8314 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 7bb6d75..2bc72d1 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 1bca7f1..9799aa9 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 08b0791..66c5d00 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 053424b..20a64d6 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 72ef87b..9f430d7 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 57c2942..d53eb7f 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 4543898..0c31b19 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 3df681e..5dd223f 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 c232c36..adae1f1 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 2fe87c3..38bb00f 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 eb2d670..42ce6b0 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 cadc369..57fc6fa 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 e268ba6..fa95117 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 c5c404f..9e67ea0 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 fdc4e6a..3497554 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 4d4c624..06d23c2 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 a83e3e2..f05cf5f 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 15c1f45..8e2130c 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 b78a16a..b308109 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 828e94e..ddeba66 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 c01c747..c3292cc 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 b2eeb28..56f8bde 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 3949db4..5ae154c 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 5dc10ed..4e53214 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 483c8dc..228a93d 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 1db2071..3611d63 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 f20295d..b696b57 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 24d543c..c5ae6fd 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 682b825..5f38f5d 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 3400352..f590a84 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 6edde83..372c076 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 8723783..eb3cf40 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 fb57984..2652582 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 8675fce..1380470 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 e72222e..c5d2a31 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 c90925a..0000000
--- 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 842d933..0000000
--- 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 f1eb9c8..0000000
--- 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 33f64ce..35681e0 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 1ce26a7..f9db69e 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 3c428fc..4e7debf 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 3c068da..d92e2aa 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 480b4eb..2ebf1d0 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 97da772..88c9128 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 9bedde5..42e6a03 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 532df78..667ca53 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 812d0b2..4ad2cd7 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 b9c0f57..ccb0d1a 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 7e17d59..dec0b2f 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 ee5c0fe..0000000
--- 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 c181925..0000000
--- 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 06571cf..39c2e4d 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 4725470..37b67bc 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 a1254ae..0dce3e2 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 3672370..0000000
--- 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 09ea1e9..0000000
--- 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 b6d209e..829ceab 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 4bac669..acde777 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 e72257c..a09bd9f 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 25ba35a..0000000
--- 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 944d981..0000000
--- 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 20c028e..0000000
--- 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 ddba3e4..0000000
--- 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 47cac2c..0000000
--- 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 209a816..0000000
--- 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 8a9ae9c..424fef6 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 fad605a..36f090b 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 b706f2a..0000000
--- 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 3e3ef8e..0000000
--- 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 ccf2d15..0000000
--- 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 f039207..0000000
--- 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 396b771..1698e62 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 04db81a..0000000
--- 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 3809774..5802abc 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 13a31d0..0000000
--- 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 0f1658f..b2bfbf5 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 78bc99c..0000000
--- 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 0831a21..0000000
--- 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 bb1f70e..0000000
--- 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 fb50fd7..0000000
--- 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 a6bfebf..23ef71c 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