Run libm tests separately for each function.

author Joseph Myers <joseph@codesourcery.com>

Fri, 24 Feb 2017 00:51:45 +0000 (00:51 +0000)

committer Joseph Myers <joseph@codesourcery.com>

Fri, 24 Feb 2017 00:52:49 +0000 (00:52 +0000)
author Joseph Myers <joseph@codesourcery.com>
Fri, 24 Feb 2017 00:51:45 +0000 (00:51 +0000)
committer Joseph Myers <joseph@codesourcery.com>
Fri, 24 Feb 2017 00:52:49 +0000 (00:52 +0000)
diff --git a/ChangeLog b/ChangeLog

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

index 0cd3a4b4b93f11efcbae9516b16d772c77ffa2d0..29e7436162639a15ff8f0171b614e7b998bf0b0d 100644 (file)
--- a/math/Makefile
+++ b/math/Makefile
@@ -196,13 +196,6 @@ endif
  
  ifneq (no,$(PERL))
  libm-vec-tests = $(addprefix test-,$(libmvec-tests))
-
-libm-tests = $(foreach t,$(types),test-$(t) test-$(t)-finite test-i$(t)) \
-            $(libm-vec-tests)
-
-libm-tests.o = $(addsuffix .o,$(libm-tests))
-
-tests += $(libm-tests)
  libm-test-support = $(foreach t,$(types),libm-test-support-$(t))
  test-extras += $(libm-test-support)
  extra-test-objs += $(addsuffix .o, $(libm-test-support))
@@ -237,15 +230,42 @@ libm-test-funcs-noauto = canonicalize ceil cimag conj copysign cproj creal \
  libm-test-funcs-all = $(libm-test-funcs-auto) $(libm-test-funcs-noauto)
  libm-test-c-auto = $(foreach f,$(libm-test-funcs-auto),libm-test-$(f).c)
  libm-test-c-noauto = $(foreach f,$(libm-test-funcs-noauto),libm-test-$(f).c)
-libm-tests-generated = libm-test-ulps.h libm-have-vector-test.h libm-test.c \
-                      $(libm-test-c-auto) $(libm-test-c-noauto)
-generated += $(libm-tests-generated)
+generated += libm-test-ulps.h $(libm-test-c-auto) $(libm-test-c-noauto)
+
+libm-tests-base-normal = $(foreach t,$(types),test-$(t))
+libm-tests-base-finite = $(foreach t,$(types),test-$(t)-finite)
+libm-tests-base-inline = $(foreach t,$(types),test-i$(t))
+libm-tests-base = $(libm-tests-base-normal) $(libm-tests-base-finite) \
+                 $(libm-tests-base-inline) $(libm-vec-tests)
+libm-tests-normal = $(foreach t,$(libm-tests-base-normal),\
+                               $(foreach f,$(libm-test-funcs-all),\
+                                           $(t)-$(f)))
+libm-tests-finite = $(foreach t,$(libm-tests-base-finite),\
+                               $(foreach f,$(libm-test-funcs-all),\
+                                           $(t)-$(f)))
+libm-tests-inline = $(foreach t,$(libm-tests-base-inline),\
+                               $(foreach f,$(libm-test-funcs-all),\
+                                           $(t)-$(f)))
+libm-tests-vector = $(foreach t,$(libmvec-tests),\
+                               $(foreach f,$($(t)-funcs),test-$(t)-$(f)))
+libm-tests = $(libm-tests-normal) $(libm-tests-finite) $(libm-tests-inline) \
+            $(libm-tests-vector)
+libm-tests-for-type = $(foreach f,$(libm-test-funcs-all),\
+                                 test-$(1)-$(f) test-$(1)-finite-$(f) \
+                                 test-i$(1)-$(f)) \
+                     $(filter test-$(1)-%,$(libm-tests-vector))
+
+libm-tests.o = $(addsuffix .o,$(libm-tests))
+
+tests += $(libm-tests)
+generated += $(addsuffix .c,$(libm-tests)) \
+            $(foreach t,$(types),libm-test-support-$(t).c)
  
  libm-test-c-auto-obj = $(addprefix $(objpfx),$(libm-test-c-auto))
  libm-test-c-noauto-obj = $(addprefix $(objpfx),$(libm-test-c-noauto))
  
-$(objpfx)libm-test.c $(libm-test-c-noauto-obj): $(objpfx)libm-test%.c: \
-                                               libm-test%.inc gen-libm-test.pl
+$(libm-test-c-noauto-obj): $(objpfx)libm-test%.c: libm-test%.inc \
+                                                 gen-libm-test.pl
         $(make-target-directory)
         $(PERL) gen-libm-test.pl -c $< -a /dev/null -C $@
  
@@ -256,30 +276,18 @@ $(libm-test-c-auto-obj): $(objpfx)libm-test%.c: libm-test%.inc \
         $(PERL) gen-libm-test.pl -c $< -a auto-libm-test-out$* -C $@
  
  libm-test-incs = $(foreach f,$(libm-test-funcs-all),libm-test-$(f).inc)
-
-$(objpfx)libm-have-vector-test.h: $(libm-test-incs) gen-libm-have-vector-test.sh
-       $(make-target-directory)
-       $(SHELL) gen-libm-have-vector-test.sh $(sort $(libm-test-incs)) > $@
  endif
  
  libm-test-fast-math-cflags = -fno-builtin -D__FAST_MATH__ -DTEST_FAST_MATH
  libm-test-vec-cflags = $(libm-test-fast-math-cflags) -fno-inline \
                        -ffloat-store -D_OPENMP=201307 -Wno-unknown-pragmas
  
-CFLAGS-test-double-vlen2.c = $(libm-test-vec-cflags)
-
-CFLAGS-test-double-vlen4.c = $(libm-test-vec-cflags)
  CFLAGS-test-double-vlen4-wrappers.c = $(double-vlen4-arch-ext-cflags)
  
-CFLAGS-test-double-vlen8.c = $(libm-test-vec-cflags)
  CFLAGS-test-double-vlen8-wrappers.c = $(double-vlen8-arch-ext-cflags)
  
-CFLAGS-test-float-vlen4.c = $(libm-test-vec-cflags)
-
-CFLAGS-test-float-vlen8.c = $(libm-test-vec-cflags)
  CFLAGS-test-float-vlen8-wrappers.c = $(float-vlen8-arch-ext-cflags)
  
-CFLAGS-test-float-vlen16.c = $(libm-test-vec-cflags)
  CFLAGS-test-float-vlen16-wrappers.c = $(float-vlen16-arch-ext-cflags)
  
  # The no-inline tests use -fsignaling-nans, and thereby use the
@@ -292,15 +300,7 @@ libm-test-no-inline-cflags = -fno-inline -ffloat-store -fno-builtin \
                              -fsignaling-nans
  libm-test-finite-cflags = $(libm-test-no-inline-cflags) \
                           -U__FINITE_MATH_ONLY__ -D__FINITE_MATH_ONLY__=1
-CFLAGS-test-float.c = $(libm-test-no-inline-cflags)
-CFLAGS-test-float-finite.c = $(libm-test-finite-cflags)
-CFLAGS-libm-test-support-float.c = $(libm-test-no-inline-cflags)
-CFLAGS-test-double.c = $(libm-test-no-inline-cflags)
-CFLAGS-test-double-finite.c = $(libm-test-finite-cflags)
-CFLAGS-libm-test-support-double.c = $(libm-test-no-inline-cflags)
-CFLAGS-test-ldouble.c = $(libm-test-no-inline-cflags)
-CFLAGS-test-ldouble-finite.c = $(libm-test-finite-cflags)
-CFLAGS-libm-test-support-ldouble.c = $(libm-test-no-inline-cflags)
+libm-test-inline-cflags = $(libm-test-fast-math-cflags)
  CFLAGS-test-tgmath.c = -fno-builtin
  # The following testcase uses very long lines (>3 million), so it may take a
  # while to compile it. See: http://llvm.org/bugs/show_bug.cgi?id=14106 and
@@ -310,9 +310,6 @@ CFLAGS-test-tgmath-ret.c = -fno-builtin
  CFLAGS-test-powl.c = -fno-builtin
  
  CFLAGS-test-snan.c = -fsignaling-nans
-CFLAGS-test-ifloat.c = $(libm-test-fast-math-cflags)
-CFLAGS-test-idouble.c = $(libm-test-fast-math-cflags)
-CFLAGS-test-ildouble.c = $(libm-test-fast-math-cflags)
  
  CFLAGS-test-signgam-finite.c = -ffinite-math-only
  CFLAGS-test-signgam-finite-c99.c = -ffinite-math-only -std=c99
@@ -375,20 +372,111 @@ $(foreach t, $(call type-foreach, $(gen-all-calls)), \
  
  ifneq (no,$(PERL))
  # This must come after the inclusion of sysdeps Makefiles via Rules.
-$(addprefix $(objpfx), $(libm-tests.o)): $(addprefix $(objpfx),\
-                                                    $(libm-tests-generated))
  
-$(addprefix $(objpfx),\
-           $(filter test-float% test-ifloat%,\
-                    $(libm-tests))): $(objpfx)libm-test-support-float.o
+$(foreach t,$(libm-tests-normal),$(objpfx)$(t).c): $(objpfx)test-%.c:
+       type_func=$*; \
+       type=$${type_func%%-*}; \
+       func=$${type_func#*-}; \
+       ( \
+         echo "#include <test-$$type.h>"; \
+         echo "#include <test-math-no-finite.h>"; \
+         echo "#include <test-math-no-inline.h>"; \
+         echo "#include <test-math-errno.h>"; \
+         echo "#include <test-math-scalar.h>"; \
+         echo "#include <libm-test-$$func.c>"; \
+       ) > $@
+
+$(foreach t,$(libm-tests-finite),$(objpfx)$(t).c): $(objpfx)test-%.c:
+       type_func=$*; \
+       type=$${type_func%%-*}; \
+       func=$${type_func#*-finite-}; \
+       ( \
+         echo "#include <test-$$type.h>"; \
+         echo "#include <test-math-finite.h>"; \
+         echo "#include <test-math-no-inline.h>"; \
+         echo "#include <test-math-scalar.h>"; \
+         echo "#include <libm-test-$$func.c>"; \
+       ) > $@
+
+$(foreach t,$(libm-tests-inline),$(objpfx)$(t).c): $(objpfx)test-i%.c:
+       type_func=$*; \
+       type=$${type_func%%-*}; \
+       func=$${type_func#*-}; \
+       ( \
+         echo "#include <test-$$type.h>"; \
+         echo "#include <test-math-inline.h>"; \
+         echo "#include <test-math-scalar.h>"; \
+         echo "#include <libm-test-$$func.c>"; \
+       ) > $@
+
+$(foreach t,$(libm-tests-vector),$(objpfx)$(t).c): $(objpfx)test-%.c:
+       type_func=$*; \
+       type=$${type_func%-*}; \
+       func=$${type_func##*-}; \
+       func_args=$$(grep ALL_RM_TEST libm-test-$$func.inc \
+                    | sed 's/.*RUN_TEST_LOOP_//;s/_.*//'); \
+       ( \
+         echo "#include <test-$$type.h>"; \
+         echo "WRAPPER_DECL_$$func_args (WRAPPER_NAME (FUNC ($$func)))"; \
+         echo "#include <libm-test-$$func.c>"; \
+       ) > $@
+
+$(foreach t,$(types),\
+           $(objpfx)libm-test-support-$(t).c): $(objpfx)libm-test-support-%.c:
+       ( \
+         echo "#include <test-$*.h>"; \
+         echo "#include <libm-test-support.c>"; \
+       ) > $@
+
+$(addprefix $(objpfx), $(libm-tests.o)): $(objpfx)libm-test-ulps.h
  
-$(addprefix $(objpfx),\
-           $(filter test-double% test-idouble%,\
-                    $(libm-tests))): $(objpfx)libm-test-support-double.o
+define o-iterator-doit
+$(foreach f,$(libm-test-funcs-all),\
+           $(objpfx)$(o)-$(f).o): $(objpfx)$(o)%.o: $(objpfx)libm-test%.c
+endef
+object-suffixes-left := $(libm-tests-base)
+include $(o-iterator)
+
+define o-iterator-doit
+$(foreach f,$(libm-test-funcs-all),\
+           $(objpfx)$(o)-$(f).o): CFLAGS += $(libm-test-no-inline-cflags)
+endef
+object-suffixes-left := $(libm-tests-base-normal)
+include $(o-iterator)
  
+define o-iterator-doit
+$(foreach f,$(libm-test-funcs-all),\
+           $(objpfx)$(o)-$(f).o): CFLAGS += $(libm-test-finite-cflags)
+endef
+object-suffixes-left := $(libm-tests-base-finite)
+include $(o-iterator)
+
+define o-iterator-doit
+$(foreach f,$(libm-test-funcs-all),\
+           $(objpfx)$(o)-$(f).o): CFLAGS += $(libm-test-inline-cflags)
+endef
+object-suffixes-left := $(libm-tests-base-inline)
+include $(o-iterator)
+
+define o-iterator-doit
+$(foreach f,$($(o)-funcs),\
+           $(objpfx)test-$(o)-$(f).o): CFLAGS += $(libm-test-vec-cflags)
+endef
+object-suffixes-left := $(libmvec-tests)
+include $(o-iterator)
+
+define o-iterator-doit
  $(addprefix $(objpfx),\
-           $(filter test-ldouble% test-ildouble%,\
-                    $(libm-tests))): $(objpfx)libm-test-support-ldouble.o
+           $(call libm-tests-for-type,$(o))): $(objpfx)libm-test-support-$(o).o
+endef
+object-suffixes-left := $(types)
+include $(o-iterator)
+
+define o-iterator-doit
+$(objpfx)libm-test-support-$(o).o: CFLAGS += $(libm-test-no-inline-cflags)
+endef
+object-suffixes-left := $(types)
+include $(o-iterator)
  
  # Run the math programs to automatically generate ULPs files.
  .PHONY: regen-ulps
@@ -465,10 +553,16 @@ $(objpfx)libieee.a: $(objpfx)ieee-math.o
         $(LN_S) $(<F) $(@F)
  
  $(addprefix $(objpfx),\
-           $(filter-out $(tests-static) $(libm-vec-tests),$(tests))): $(libm)
+           $(filter-out $(tests-static) $(libm-tests-vector),\
+                        $(tests))): $(libm)
  $(addprefix $(objpfx),$(tests-static)): $(objpfx)libm.a
-$(addprefix $(objpfx), $(libm-vec-tests)): $(objpfx)%: $(objpfx)%-wrappers.o \
-                                                      $(libm) $(libmvec)
+define o-iterator-doit
+$(foreach f,$($(o)-funcs),\
+           $(objpfx)test-$(o)-$(f)): $(objpfx)test-$(o)-wrappers.o \
+                                     $(libm) $(libmvec)
+endef
+object-suffixes-left := $(libmvec-tests)
+include $(o-iterator)
  
  gmp-objs = $(patsubst %,$(common-objpfx)stdlib/%.o,\
                       add_n sub_n cmp addmul_1 mul_1 mul_n divmod_1 \
diff --git a/math/README.libm-test b/math/README.libm-test

index 442a47aff2879c667c18c86c0a58b2703e179d3d..0271f83f3b744c04d9329b1d44c456e4a3d5e371 100644 (file)
--- 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 (file)

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 c98da4f2221c74888ed787122e56a8f1e15cfbd1..d795793a15f35c013573f4170c6d042d6cf33310 100644 (file)
--- 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 470fa29cd1ff4bcf1d264b7b443d9c6fdffd4afd..816a1cd371e474cfea15b92761086f5fb4f8786e 100644 (file)
--- 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 6d3ed8ec9e18ed641a3408f1021e043ee42d41f8..9b6d229df15208308348ae88ab74a86943b7cb9a 100644 (file)
--- 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 af8392afad93b373ffe374056e80ff887748f14b..f218e032c303ae9ea406e3f95f90d1ba1a3049e2 100644 (file)
--- 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 365ca87bf1b712cea2b8181de8035b21027c98eb..ed96133616b8c3882f45a6cce4eec63b45e4a388 100644 (file)
--- 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 9caedf7bea3563a02836f44d86e81870fd6cdb22..e9001133f1d08fd1350140edf7d65b15a2c2c331 100644 (file)
--- 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 97990b350703506c9fd2a2202807e5a9699d1f41..a57aebbca75468349366668dd7c8d847f6b2e5ed 100644 (file)
--- 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 36d609ad9a5bf3a94d1844d1d9d9155f4a38e461..d9a66fa63101901bff378b001f95b40441e156a0 100644 (file)
--- 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 492f8f1fe02f172749aa86b59e24fcf77e165f5c..f4cd32f99391401f1e1bae6befe90f0b44b6517b 100644 (file)
--- a/math/libm-test-cacos.inc
+++ b/math/libm-test-cacos.inc
@@ -16,6 +16,8 @@
     License along with the GNU C Library; if not, see
     <http://www.gnu.org/licenses/>.  */
  
+#include "libm-test-driver.c"
+
  static const struct test_c_c_data cacos_test_data[] =
    {
      TEST_c_c (cacos, minus_infty, plus_infty, lit_pi_3_m_4_d, minus_infty),
@@ -67,6 +69,12 @@ cacos_test (void)
    ALL_RM_TEST (cacos, 0, cacos_test_data, RUN_TEST_LOOP_c_c, END_COMPLEX);
  }
  
+static void
+do_test (void)
+{
+  cacos_test ();
+}
+
  /*
   * Local Variables:
   * mode:c
diff --git a/math/libm-test-cacosh.inc b/math/libm-test-cacosh.inc

index 4a16d10077428e0fa492b404af697d06cba7ff71..518cb29aa655486ee767c9b3e1a3b67654b5149b 100644 (file)
--- a/math/libm-test-cacosh.inc
+++ b/math/libm-test-cacosh.inc
@@ -16,6 +16,8 @@
     License along with the GNU C Library; if not, see
     <http://www.gnu.org/licenses/>.  */
  
+#include "libm-test-driver.c"
+
  static const struct test_c_c_data cacosh_test_data[] =
    {
      TEST_c_c (cacosh, minus_infty, plus_infty, plus_infty, lit_pi_3_m_4_d),
@@ -67,6 +69,12 @@ cacosh_test (void)
    ALL_RM_TEST (cacosh, 0, cacosh_test_data, RUN_TEST_LOOP_c_c, END_COMPLEX);
  }
  
+static void
+do_test (void)
+{
+  cacosh_test ();
+}
+
  /*
   * Local Variables:
   * mode:c
diff --git a/math/libm-test-canonicalize.inc b/math/libm-test-canonicalize.inc

index 93a0a9bb6bc38591d24cd3d22007614b0abf1cd6..e0ba3eceaacfc35461bf7e307822a6129e0a717a 100644 (file)
--- 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 e92d4fbcceb5a0a5b7524ed0e65ed9c001e45a75..e03389310ff7239ede793a7d21c1ac3f2b1b2d7f 100644 (file)
--- 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 9e3918631c9933301a487f31425dfa3715a3ca4a..d78077590f26f34bc65f65377704c0b5ba834f57 100644 (file)
--- a/math/libm-test-casin.inc
+++ b/math/libm-test-casin.inc
@@ -16,6 +16,8 @@
     License along with the GNU C Library; if not, see
     <http://www.gnu.org/licenses/>.  */
  
+#include "libm-test-driver.c"
+
  static const struct test_c_c_data casin_test_data[] =
    {
      TEST_c_c (casin, plus_infty, plus_infty, lit_pi_4_d, plus_infty),
@@ -68,6 +70,12 @@ casin_test (void)
    ALL_RM_TEST (casin, 0, casin_test_data, RUN_TEST_LOOP_c_c, END_COMPLEX);
  }
  
+static void
+do_test (void)
+{
+  casin_test ();
+}
+
  /*
   * Local Variables:
   * mode:c
diff --git a/math/libm-test-casinh.inc b/math/libm-test-casinh.inc

index 476207443db75db356e69822001fc001e986ac28..5298c812b848cb440fa2d44ba9ae8718953ce20a 100644 (file)
--- a/math/libm-test-casinh.inc
+++ b/math/libm-test-casinh.inc
@@ -16,6 +16,8 @@
     License along with the GNU C Library; if not, see
     <http://www.gnu.org/licenses/>.  */
  
+#include "libm-test-driver.c"
+
  static const struct test_c_c_data casinh_test_data[] =
    {
      TEST_c_c (casinh, plus_infty, plus_infty, plus_infty, lit_pi_4_d),
@@ -68,6 +70,12 @@ casinh_test (void)
    ALL_RM_TEST (casinh, 0, casinh_test_data, RUN_TEST_LOOP_c_c, END_COMPLEX);
  }
  
+static void
+do_test (void)
+{
+  casinh_test ();
+}
+
  /*
   * Local Variables:
   * mode:c
diff --git a/math/libm-test-catan.inc b/math/libm-test-catan.inc

index 1d8cf180db223cfc5d10fae7ef7b3f22e5133416..ee9662924f8810216423363bc3238fb17604a6bc 100644 (file)
--- a/math/libm-test-catan.inc
+++ b/math/libm-test-catan.inc
@@ -16,6 +16,8 @@
     License along with the GNU C Library; if not, see
     <http://www.gnu.org/licenses/>.  */
  
+#include "libm-test-driver.c"
+
  static const struct test_c_c_data catan_test_data[] =
    {
      TEST_c_c (catan, plus_zero, 1.0L, plus_zero, plus_infty, DIVIDE_BY_ZERO_EXCEPTION),
@@ -77,6 +79,12 @@ catan_test (void)
    ALL_RM_TEST (catan, 0, catan_test_data, RUN_TEST_LOOP_c_c, END_COMPLEX);
  }
  
+static void
+do_test (void)
+{
+  catan_test ();
+}
+
  /*
   * Local Variables:
   * mode:c
diff --git a/math/libm-test-catanh.inc b/math/libm-test-catanh.inc

index 321a0bd200e2a931d6a28b64d555b8ebeef64194..6ec6fbad64c7ae825607482203150fe134e26fab 100644 (file)
--- a/math/libm-test-catanh.inc
+++ b/math/libm-test-catanh.inc
@@ -16,6 +16,8 @@
     License along with the GNU C Library; if not, see
     <http://www.gnu.org/licenses/>.  */
  
+#include "libm-test-driver.c"
+
  static const struct test_c_c_data catanh_test_data[] =
    {
      TEST_c_c (catanh, 1.0L, plus_zero, plus_infty, plus_zero, DIVIDE_BY_ZERO_EXCEPTION),
@@ -76,6 +78,12 @@ catanh_test (void)
    ALL_RM_TEST (catanh, 0, catanh_test_data, RUN_TEST_LOOP_c_c, END_COMPLEX);
  }
  
+static void
+do_test (void)
+{
+  catanh_test ();
+}
+
  /*
   * Local Variables:
   * mode:c
diff --git a/math/libm-test-cbrt.inc b/math/libm-test-cbrt.inc

index 11a8a3bae722e9632af614186553eb90541b9e32..769f52e89fdca1cfa5ca8dfaca800df158b33435 100644 (file)
--- 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 3180b55c66605855cd78094dc2461dd4586b920a..2497af1d49f43c7c8216752859e6bb120124cdaa 100644 (file)
--- 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 ac4c103e671831384ae11d1c84064676afc796a1..7c22c9e38f1c992ea2122fff9aaa5665107af38a 100644 (file)
--- 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 c173b7e36e314c8b9da0293d1a73574e40b9d23e..d6356a574ba685ef11143edd7f14ac81cbfa3fc6 100644 (file)
--- 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 355748c50cfce6b9a7dd81b2e7c18351b9246e7f..f4bd962c5d892c78c3aa0b42908efb5cf08d17e0 100644 (file)
--- 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 a711f4cf537ec96bb5a42dbf9a2895bf0d918912..569d20c5df0ea5f27c5212b284e1ee9205175da8 100644 (file)
--- 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 261aaad6bad8a0e52e0a4d5ccec3ead470d2ef73..6a97d5a31d95d4bb85ec256f71a2580508ff9a3c 100644 (file)
--- 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 0c92a79b96a90c200a9a13795c8cdc20eebcbab5..b330d74d53bf9022a807b3839d4c4b36f0cefb3a 100644 (file)
--- 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 cfa0a53810d8ba1a9bf2f3d09e054d91db30a40b..e5b2529b88e62a09ba4ad292a066188001e7075c 100644 (file)
--- 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 e717160673bb153847ae10a77739b901c7f8f616..635cb02f66999bad2e6b472a3843d318b105f5d9 100644 (file)
--- 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 1ca5b41454958b548d008a6510ad4fe1a06d1bff..246b37154e11714e616683352e739129aca1b9ea 100644 (file)
--- 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 a6456440d58d6b0776b0152cbd33df5d7c8731ab..a0b88b0884d9246946613cf39ff6e362f82b44ad 100644 (file)
--- 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 2f4cda209c393131108257b22cb18ae937432e6c..ffd112844e0a6ea1e239f0f6da74a0cf4a806172 100644 (file)
--- 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 2daa6ab59f5168f0ac17263b1831727ef6018e2d..441d58ba7f47ba931bfc68bbf437de1daa78ef60 100644 (file)
--- 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 20ea43c914637c57921d1ba0d84a393030884d39..aaa1412ac65a072e867f55cb893d354b0ad0bc3b 100644 (file)
--- 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 f42828c87495417db8bb3b5b092879a703b3ff11..03214ad512ae1a894107d3ed359181e2e1d2c462 100644 (file)
--- 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 06877c846889a3ba34ad241127e1bf74f321d42e..41b9092bb16571055dcc70e2c02db3fc9b2ce4b4 100644 (file)
--- 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 6ff26faa9bd6c9af6cfbcbe71beb100789cba36d..43918fe1461d65d68fc3c6ba34f1e1b05966c280 100644 (file)
--- 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 a5689400f3059ee90ff995cf2f1512bf1ea08061..e485828b8c3265d4bcb24479e86b5eda03a20ef6 100644 (file)
--- 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 48002ebde68442296164898effd6815cbd67a1ca..6ddeb0d3612902ac07f7bbed4a0c8048bc21459a 100644 (file)
--- 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 d24c5aadaf0a5aa719ca8f5f56d1cef132538399..161419837dbbe9cf6b35e9ab2e0483e83a96e674 100644 (file)
--- 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 20a389ec5a8b83b14dc2d2e8655500398a430729..bcc96e5e6c22347a7617f863b30fba3949960f51 100644 (file)
--- 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 ed6190e05de7f930cfac26907344c2e1cb6bef45..7018eb34d7a0741781c5ad941114df3f17687c19 100644 (file)
--- 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 a5ed2e2fd378bee0a0fc42fbc643f13aa7048f0a..323a82c360c44cf65e11bdb6d2834bde76eb39e9 100644 (file)
--- 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 6be936bc2efae081bc66ce88c1d172e30357e4d4..92c81adb7aec88710264889e8084c7bb24be7d86 100644 (file)
--- 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 0c0e4dadbc98ab619f0a2cc790b200acdf4dfce7..3c2561aa7f0c0f508bb3556a879ed6249e94c904 100644 (file)
--- 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 c01abf8774947b6da045bc223d4b10e21b0cb9c2..c18c596933ef02dd23e5d133c73035c99c029a98 100644 (file)
--- 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 1b0dc54f369085a9f072544664acda1d7c027ebc..392cb68542018c8f2dfadce963d85b3d7e43a74d 100644 (file)
--- 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 28aa6adfe49bb6924ae646dee7d5b0ce9d20756c..73713a6c2000153a87b3f98a4561396f8bbd8663 100644 (file)
--- 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 a0abcb2bb3b66efefd2d12cbf1f27ad2322a50b2..cceeed90bb49811c396f216d6bdc507a7e2c20a8 100644 (file)
--- 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 6da8daddf63c0f57578c46d4fcba02863b6c5179..77641773a34b5ba2d1e4701c66d05edb95c3ea27 100644 (file)
--- 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 950a2cbb0c715ac446095eddc79fc094e4722362..682a1b891809e3a6d6880a8c8b71ef7be080b6cd 100644 (file)
--- 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 0253f27d1ad68a07b3f70867ba71e018ac402b9c..94ef268d3c0034207c528d5145d2fb45fe36b80b 100644 (file)
--- 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 024ca909d155c9214ec3f72ca90808ca06b7329a..0d2217df277aed6321558c42116fdb8e678e98dc 100644 (file)
--- 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 1ce5ac8c1b7e6f1b0ed95066c798ce0c9b95ab26..267153b709e371e053ece9cf226234d9abcf6a49 100644 (file)
--- 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 e536af7218faf19f086e96c076a457ba7915b666..c8acc14a4272da0b8042d3257eb945f465bc20d4 100644 (file)
--- 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 dd2eec2a6449662ba422d87d646c4f90f5ebdfa9..a85f52c8e42ee494e479fa80b48e2698b4aa700e 100644 (file)
--- 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 bfc80df87c4f6880fd105deccbeee3c277fe5007..b6f7d7160ed9d926fb9c5bb5be7ed6c41b369be0 100644 (file)
--- 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 fb31e85e5a10213db1b4a9f85fac9010dcfd3176..f2d520574e038a406dd0bf1ac5fe75ffad574fd7 100644 (file)
--- 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 b8a466ccc65243823283a7878a5ac32ff8134415..34e0af33ec1eec482a218cf2ad85ca4c7a6b3aa5 100644 (file)
--- 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 335a11e3e8194394d08e0487492efb0842252112..def4d8bd23bee484184b15317f04178e62c2082e 100644 (file)
--- 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 f440e27ecb22c1563b780737d404cd376f49430c..7d679828cd7f1422b623f85eeb2d5d3e66b1167a 100644 (file)
--- 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 957e5c156133ff68a8c1222c365cf0c62937b4a6..7c94d622911088d85e44466d366e5d5fde9ae858 100644 (file)
--- 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 c940027ac803d472d87187a79214beba94ac7ecf..3d4c850ab807a3747cfd39d9a0425dcd24f27223 100644 (file)
--- 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 aa1dcabfaa31491e2c6864191e9a2ad7018f702b..d021fc88a7e65b2f9e6110497c6d698f5e3f1cc8 100644 (file)
--- 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 593822c2e5d4aecfa75fc4158d85e9e0f5daadfc..48d4c2e15b50bf4c4aee450337e483de545517d3 100644 (file)
--- 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 ba2ee90b075c4c886adf2cfe40fcb897859edba7..468523aa18ab07d73ee2b43a40d16599948477a4 100644 (file)
--- 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 7f37fa8842cc55880e52a9eddfecadbd8818d589..51e564ecf6a39bea3631704172e88a7a37cfe6c7 100644 (file)
--- 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 08d9b4b375d422478f01f66cf4e3c475b839ac57..cc6355414b7c75f38fe2e5b4e1c82d64426c9240 100644 (file)
--- 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 f93bb667a38634071c91b756df9398a3c3be04e6..402dd978a363283e1bf6ef7ac005b06ac3d03077 100644 (file)
--- 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 93e425200189d7a63d9be1167df1dc6e99e1cb1e..e71ec2817800e321da4cc3106ffbde5c88b1739c 100644 (file)
--- 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 baa8b7afa5dbc064560e042b945bf10fe1735d38..b17bd078031064ec3acacf6b692f7b397e27051a 100644 (file)
--- 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 ec8f45bf97073662c196bb08a82ef6731320db6d..d125ec462757b8294cc81a554bc04351683e8ad7 100644 (file)
--- 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 e5b3881ec00fcd830cbc52b3a7a916936a4cfd23..9f16e9b443fdb5e5755de6ed9cec0fcd56ac2d92 100644 (file)
--- 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 3f0b7c1e86d7865a57d6bcc4dc9f1acc1ed7f1bb..e3df38b91295a46a88a3481f80ce1b9c94b6c9a0 100644 (file)
--- 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 94de45a8b0d3163202eafd8160519c0cb6a6c526..930dd5c66dadcf80603e059b88c753a1ead8dbe8 100644 (file)
--- 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 8a3ca076e1e766f1729454f648ed565a5299946f..9c2bb247b3f4ccd4f0a18b16b9f967e58753784e 100644 (file)
--- 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 8694296a3e64c0d6b448822e7f2e89de60fae4da..0519c090fc234c789a1bc9f076559a4569807b37 100644 (file)
--- 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 5628d7c34b059091ab64ce67fdeeda918a79685f..2fa8c8ee482c84f530af2ef6b087a9bdc50b9e54 100644 (file)
--- 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 a9ab7b297864a8def5d3517e4ad5cc6d47f94edd..44b831480c4efed0e925a0cd7abe1e893fe4f716 100644 (file)
--- 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 7bb6d758326a181e4252387cc54b551b6ea78524..2bc72d1711134821711dbff36fdec3ffab298bc4 100644 (file)
--- 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 1bca7f1a3be175b273ba753c4d7ed4ff18788ef5..9799aa9aaffd9086f952698e30d22635c9fae03f 100644 (file)
--- 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 08b07919d258db2a43d36955369e659c7d93578d..66c5d00b1aee1b791d470027e18c70d51b07dc32 100644 (file)
--- 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 053424bbce0a88afcba05c98a4f29fe5f04f61dc..20a64d63a35eaf25363ef4bf1dd9b3104acd1edf 100644 (file)
--- 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 72ef87b88337573c586378584f682ebac63a7c03..9f430d7cf08a479c1ad0f1968146ff26bb10328e 100644 (file)
--- 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 57c2942062ddb2601ee971a23c07230528f225c9..d53eb7fe079e248fb0866b375295e3ceb56c8ae4 100644 (file)
--- 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 4543898655b8ebc6d2e164dc87f138c2884b226d..0c31b190e3a16122863846b71e5c8bdc2b70bf27 100644 (file)
--- 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 3df681eeecae239095ccc54e34b858e85cc8a477..5dd223fb6d50bf06329841872261364d42c5e9ef 100644 (file)
--- 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 c232c364156f804a309c74395a95da72481c37dd..adae1f129be07e725e327c7e58935c40c733bbfa 100644 (file)
--- 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 2fe87c3ca8c2f57f69560237d4451a0c8da0d39b..38bb00fdf6b19a7f647ded72016f2105b2eae334 100644 (file)
--- 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 eb2d6700ed086148c8a1dd146e728288e76177d1..42ce6b08b180c92b9b85c5e204c4bbf0b6a2f8f3 100644 (file)
--- 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 cadc36925b20efa75953d71f4800b773d8f628a0..57fc6fa451f4294a6bbd94fa15ef49ec78334ab7 100644 (file)
--- 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 e268ba67d0994822ec35d798762bede1d0132a38..fa951174ed33463ac86edc1e621de71c6327de69 100644 (file)
--- 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 c5c404f3ca21be5c112953421f080c4992b6884b..9e67ea0eb32eabba7dbed8458e31c5c67f53e774 100644 (file)
--- 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 fdc4e6a5a6739100516769fc877259898b11951d..3497554116c09779489ee3f722d2049269adc05a 100644 (file)
--- 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 4d4c6244a1c00947866519b1edcbed7de1a13198..06d23c2ed8c1bd94f6eaca51d0b94c5c6727c2aa 100644 (file)
--- 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 a83e3e24a3f3fbd9d78582cfe93b37f671052672..f05cf5fe4bf49ce5eb468430d40d36dcb8f9dafe 100644 (file)
--- 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 15c1f456d71f24d3a1ad48427a8b6b8c520e5187..8e2130c3276f4ed7e3d2c0f15416df09c3c71fb4 100644 (file)
--- 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 b78a16a117e036301c4e593b645e68c0a861e635..b308109bb2578acd088c5521b4dad9b4f7548878 100644 (file)
--- 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 828e94e5e7902d0c9c4d0294f3da7f44f712b7cc..ddeba66dabfb99ef68deb9d1b64533937a7010a8 100644 (file)
--- 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 c01c7470ee645bb70abea9e65be0bfe4defa156d..c3292cc35c680f0c7a82806c7ff8a28105cdaf96 100644 (file)
--- 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 b2eeb28421dfd6a2e3342a7b2cae79de6229501d..56f8bde6bbe5d4e26eb0683274d18bed943eeec7 100644 (file)
--- 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 3949db40f477032e0e9caa872ac23a05d4c13664..5ae154c2ade17e023d1e25aec94c6ab3857fff83 100644 (file)
--- 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 5dc10ed4a7c16517c97daf690bd9b0e101ac689c..4e53214f7fb321ce25af1763e94f582032cec13b 100644 (file)
--- 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 483c8dc7e5154d285729f47dc92dfe694b07e12a..228a93d349279833be7180ab25d55c11663aebd2 100644 (file)
--- 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 1db2071fe32bcafe336c01c740b64a7208049fd8..3611d635f2ae80d91bd45d8fd10fd137ad75a493 100644 (file)
--- 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 f20295d7d14f941e78a008262a3bc80d0183ff28..b696b57ff2c0c5c9df48604a89701688b8deeb74 100644 (file)
--- 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 24d543cccf58dd52ec0a021557cf6004553411d8..c5ae6fdb1bb7d78e049b2838b9214a0fc26f7772 100644 (file)
--- 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 682b825888823cd1dd6f552ceac9b0730a316b58..5f38f5da15f3ea0c2097f5994323801dbc50a4bc 100644 (file)
--- 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 3400352aecdc2beb2f671f681eb9d44b169ed6fc..f590a84106f6a954b26eb3479be68379c6843daf 100644 (file)
--- 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 6edde8333b665ca28e3502d2a136b8cb5d84c8a4..372c076fae2ebe17056b637a1edbf955bc2a6db8 100644 (file)
--- 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 87237839286d34dd0694c3fb1ce86ae4681dbef5..eb3cf40de58559df2a95f0ba91e0a2e35c1819ef 100644 (file)
--- 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 fb57984956b468eec3e2f0c0222e133c12bf99db..2652582308335220665c4469967b1df62b29f8e4 100644 (file)
--- 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 8675fcef74e7d8b6e8c6c1f655b5b03778fb1acd..1380470fb4fd6bfd107eb6d3ce21e0551f2af3ac 100644 (file)
--- 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 e72222e2c88d824deb02ab6de6a4fc155cc63755..c5d2a31d7c93f00520a9e0545a4ea4aafa2b980c 100644 (file)
--- 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 (file)

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 (file)

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 (file)

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 33f64ce010d9640cf8af717705856c6e116ddb2c..35681e0fda951efbc7b52e9987a82641292cc1c1 100644 (file)
--- 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 1ce26a7e3e095714a0334ed358fab01cc20b0957..f9db69ee06830a337339872386f768ce7fb56b23 100644 (file)
--- 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 3c428fc5ca294aa57ccea51de59a056b82db2390..4e7debfbd71ec369401b67a0948484ad0ca5461d 100644 (file)
--- 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 3c068da09a2ccf09b90d609edf6aef2c376d869f..d92e2aa6fdc4e659b25a418c0bf333d3506dd220 100644 (file)
--- 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 480b4eb2f4aed8d0c950a09634ada24ce42f2b59..2ebf1d0c50597cd3c14aeeff1515cded804aaa5d 100644 (file)
--- 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 97da772e09ed58684a2de2c4ed564a1ed789fd23..88c9128bdb762a13218f29b1b8af4ace989f9a70 100644 (file)
--- 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 9bedde5dd1d8195ddf4854d7018151d2701addf2..42e6a03f5c84cc515052269fa5353dad8fc2316a 100644 (file)
--- 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 532df78ea1b1e853b295a04cc1e731e03d832ed6..667ca538923cfb5440c126ee6cf69e10af03241a 100644 (file)
--- 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 812d0b203cb56f020267afe1998d1c202155c28b..4ad2cd7807829ea5a83d18c59371705003fe70df 100644 (file)
--- 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 b9c0f57e31966504009fd840ed6b6e8f93e12185..ccb0d1a17b795ee74941e2a878bc743ea69a80a5 100644 (file)
--- 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 7e17d5947579f63ca2cf952e87344cc459e7488c..dec0b2fe3ffa4a8c4534cadaea82f573d111e357 100644 (file)
--- 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 (file)

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 (file)

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 06571cf65c98d42096d344633d6774628efea95c..39c2e4dfb95162ac17cb74058eb0153b52dfd8e0 100644 (file)
--- 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 47254703b689e3cb1f843294b03622ab84350ea4..37b67bc56c628a45322b19415ab308bd950ec8c8 100644 (file)
--- 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 a1254ae396125a666671b11de78c17ef3974e676..0dce3e28aafcb9e65e3e39c062cb722df835a63f 100644 (file)
--- 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 (file)

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 (file)

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 b6d209e61c1dd67f343c2359886ace1795d53616..829ceabf664443f986c47353fa20861913eb657e 100644 (file)
--- 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 4bac669d214864b52d91e80e006f7f940bec3840..acde7775eac741c22a317fe9cf46d97f8705f3e9 100644 (file)
--- 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 e72257ceee37a3cc62b47fbc89935b75dd791715..a09bd9fecd7aa6f8ef2db6506aca0a06820dc8c4 100644 (file)
--- 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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 8a9ae9caa1bcb131d7ccd83079eef23f2a654d52..424fef6c60a8f3f5031d2a1d603f24ac68497d41 100644 (file)
--- 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 fad605a841ee1ca21a5891bc9e78db9e63f86104..36f090b826a4f5452b7de86f84bad09742776e0e 100644 (file)
--- 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 (file)

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 (file)

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 (file)

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 (file)

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 396b7714c98257ceb5652aca37f7c96ed034f2ca..1698e621d6001caeea68e600031573bd63baae82 100644 (file)
--- 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 (file)

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 38097740fa52202bbb6fed7e1bd7dfe35baf8549..5802abc121df3d0bbc3c199cae8f07a2e7f80f1b 100644 (file)
--- 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 (file)

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 0f1658f5ca626f27eaf31729b62fcd8bfef42c3d..b2bfbf53711ac4a5a507d18fec79808864c5ae7b 100644 (file)
--- 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 (file)

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 (file)

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 (file)

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 (file)

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 a6bfebf0d88cc10b8f0b668e6d7b2e7bba6778fb..23ef71c6c5dc348f59be7d4301e700279fc364f5 100644 (file)
--- 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
author	Joseph Myers <joseph@codesourcery.com>
	Fri, 24 Feb 2017 00:51:45 +0000 (00:51 +0000)
committer	Joseph Myers <joseph@codesourcery.com>
	Fri, 24 Feb 2017 00:52:49 +0000 (00:52 +0000)
ChangeLog		patch \| blob \| blame \| history
math/Makefile		patch \| blob \| blame \| history
math/README.libm-test		patch \| blob \| blame \| history
math/gen-libm-have-vector-test.sh	[deleted file]	patch \| blob \| blame \| history
math/libm-test-acos.inc		patch \| blob \| blame \| history
math/libm-test-acosh.inc		patch \| blob \| blame \| history
math/libm-test-asin.inc		patch \| blob \| blame \| history
math/libm-test-asinh.inc		patch \| blob \| blame \| history
math/libm-test-atan.inc		patch \| blob \| blame \| history
math/libm-test-atan2.inc		patch \| blob \| blame \| history
math/libm-test-atanh.inc		patch \| blob \| blame \| history
math/libm-test-cabs.inc		patch \| blob \| blame \| history
math/libm-test-cacos.inc		patch \| blob \| blame \| history
math/libm-test-cacosh.inc		patch \| blob \| blame \| history
math/libm-test-canonicalize.inc		patch \| blob \| blame \| history
math/libm-test-carg.inc		patch \| blob \| blame \| history
math/libm-test-casin.inc		patch \| blob \| blame \| history
math/libm-test-casinh.inc		patch \| blob \| blame \| history
math/libm-test-catan.inc		patch \| blob \| blame \| history
math/libm-test-catanh.inc		patch \| blob \| blame \| history
math/libm-test-cbrt.inc		patch \| blob \| blame \| history
math/libm-test-ccos.inc		patch \| blob \| blame \| history
math/libm-test-ccosh.inc		patch \| blob \| blame \| history
math/libm-test-ceil.inc		patch \| blob \| blame \| history
math/libm-test-cexp.inc		patch \| blob \| blame \| history
math/libm-test-cimag.inc		patch \| blob \| blame \| history
math/libm-test-clog.inc		patch \| blob \| blame \| history
math/libm-test-clog10.inc		patch \| blob \| blame \| history
math/libm-test-conj.inc		patch \| blob \| blame \| history
math/libm-test-copysign.inc		patch \| blob \| blame \| history
math/libm-test-cos.inc		patch \| blob \| blame \| history
math/libm-test-cosh.inc		patch \| blob \| blame \| history
math/libm-test-cpow.inc		patch \| blob \| blame \| history
math/libm-test-cproj.inc		patch \| blob \| blame \| history
math/libm-test-creal.inc		patch \| blob \| blame \| history
math/libm-test-csin.inc		patch \| blob \| blame \| history
math/libm-test-csinh.inc		patch \| blob \| blame \| history
math/libm-test-csqrt.inc		patch \| blob \| blame \| history
math/libm-test-ctan.inc		patch \| blob \| blame \| history
math/libm-test-ctanh.inc		patch \| blob \| blame \| history
math/libm-test-driver.c		patch \| blob \| blame \| history
math/libm-test-erf.inc		patch \| blob \| blame \| history
math/libm-test-erfc.inc		patch \| blob \| blame \| history
math/libm-test-exp.inc		patch \| blob \| blame \| history
math/libm-test-exp10.inc		patch \| blob \| blame \| history
math/libm-test-exp2.inc		patch \| blob \| blame \| history
math/libm-test-expm1.inc		patch \| blob \| blame \| history
math/libm-test-fabs.inc		patch \| blob \| blame \| history
math/libm-test-fdim.inc		patch \| blob \| blame \| history
math/libm-test-floor.inc		patch \| blob \| blame \| history
math/libm-test-fma.inc		patch \| blob \| blame \| history
math/libm-test-fmax.inc		patch \| blob \| blame \| history
math/libm-test-fmaxmag.inc		patch \| blob \| blame \| history
math/libm-test-fmin.inc		patch \| blob \| blame \| history
math/libm-test-fminmag.inc		patch \| blob \| blame \| history
math/libm-test-fmod.inc		patch \| blob \| blame \| history
math/libm-test-fpclassify.inc		patch \| blob \| blame \| history
math/libm-test-frexp.inc		patch \| blob \| blame \| history
math/libm-test-fromfp.inc		patch \| blob \| blame \| history
math/libm-test-fromfpx.inc		patch \| blob \| blame \| history
math/libm-test-getpayload.inc		patch \| blob \| blame \| history
math/libm-test-hypot.inc		patch \| blob \| blame \| history
math/libm-test-ilogb.inc		patch \| blob \| blame \| history
math/libm-test-iscanonical.inc		patch \| blob \| blame \| history
math/libm-test-iseqsig.inc		patch \| blob \| blame \| history
math/libm-test-isfinite.inc		patch \| blob \| blame \| history
math/libm-test-isgreater.inc		patch \| blob \| blame \| history
math/libm-test-isgreaterequal.inc		patch \| blob \| blame \| history
math/libm-test-isinf.inc		patch \| blob \| blame \| history
math/libm-test-isless.inc		patch \| blob \| blame \| history
math/libm-test-islessequal.inc		patch \| blob \| blame \| history
math/libm-test-islessgreater.inc		patch \| blob \| blame \| history
math/libm-test-isnan.inc		patch \| blob \| blame \| history
math/libm-test-isnormal.inc		patch \| blob \| blame \| history
math/libm-test-issignaling.inc		patch \| blob \| blame \| history
math/libm-test-issubnormal.inc		patch \| blob \| blame \| history
math/libm-test-isunordered.inc		patch \| blob \| blame \| history
math/libm-test-iszero.inc		patch \| blob \| blame \| history
math/libm-test-j0.inc		patch \| blob \| blame \| history
math/libm-test-j1.inc		patch \| blob \| blame \| history
math/libm-test-jn.inc		patch \| blob \| blame \| history
math/libm-test-lgamma.inc		patch \| blob \| blame \| history
math/libm-test-llogb.inc		patch \| blob \| blame \| history
math/libm-test-llrint.inc		patch \| blob \| blame \| history
math/libm-test-llround.inc		patch \| blob \| blame \| history
math/libm-test-log.inc		patch \| blob \| blame \| history
math/libm-test-log10.inc		patch \| blob \| blame \| history
math/libm-test-log1p.inc		patch \| blob \| blame \| history
math/libm-test-log2.inc		patch \| blob \| blame \| history
math/libm-test-logb.inc		patch \| blob \| blame \| history
math/libm-test-lrint.inc		patch \| blob \| blame \| history
math/libm-test-lround.inc		patch \| blob \| blame \| history
math/libm-test-modf.inc		patch \| blob \| blame \| history
math/libm-test-nearbyint.inc		patch \| blob \| blame \| history
math/libm-test-nextafter.inc		patch \| blob \| blame \| history
math/libm-test-nextdown.inc		patch \| blob \| blame \| history
math/libm-test-nexttoward.inc		patch \| blob \| blame \| history
math/libm-test-nextup.inc		patch \| blob \| blame \| history
math/libm-test-pow.inc		patch \| blob \| blame \| history
math/libm-test-remainder.inc		patch \| blob \| blame \| history
math/libm-test-remquo.inc		patch \| blob \| blame \| history
math/libm-test-rint.inc		patch \| blob \| blame \| history
math/libm-test-round.inc		patch \| blob \| blame \| history
math/libm-test-roundeven.inc		patch \| blob \| blame \| history
math/libm-test-scalb.inc		patch \| blob \| blame \| history
math/libm-test-scalbln.inc		patch \| blob \| blame \| history
math/libm-test-scalbn.inc		patch \| blob \| blame \| history
math/libm-test-setpayload.inc		patch \| blob \| blame \| history
math/libm-test-setpayloadsig.inc		patch \| blob \| blame \| history
math/libm-test-signbit.inc		patch \| blob \| blame \| history
math/libm-test-significand.inc		patch \| blob \| blame \| history
math/libm-test-sin.inc		patch \| blob \| blame \| history
math/libm-test-sincos.inc		patch \| blob \| blame \| history
math/libm-test-sinh.inc		patch \| blob \| blame \| history
math/libm-test-sqrt.inc		patch \| blob \| blame \| history
math/libm-test-support-double.c	[deleted file]	patch \| blob \| blame \| history
math/libm-test-support-float.c	[deleted file]	patch \| blob \| blame \| history
math/libm-test-support-ldouble.c	[deleted file]	patch \| blob \| blame \| history
math/libm-test-tan.inc		patch \| blob \| blame \| history
math/libm-test-tanh.inc		patch \| blob \| blame \| history
math/libm-test-tgamma.inc		patch \| blob \| blame \| history
math/libm-test-totalorder.inc		patch \| blob \| blame \| history
math/libm-test-totalordermag.inc		patch \| blob \| blame \| history
math/libm-test-trunc.inc		patch \| blob \| blame \| history
math/libm-test-ufromfp.inc		patch \| blob \| blame \| history
math/libm-test-ufromfpx.inc		patch \| blob \| blame \| history
math/libm-test-y0.inc		patch \| blob \| blame \| history
math/libm-test-y1.inc		patch \| blob \| blame \| history
math/libm-test-yn.inc		patch \| blob \| blame \| history
math/libm-test.inc	[deleted file]	patch \| blob \| blame \| history
math/test-double-finite.c	[deleted file]	patch \| blob \| blame \| history
math/test-double-vlen2.h		patch \| blob \| blame \| history
math/test-double-vlen4.h		patch \| blob \| blame \| history
math/test-double-vlen8.h		patch \| blob \| blame \| history
math/test-double.c	[deleted file]	patch \| blob \| blame \| history
math/test-float-finite.c	[deleted file]	patch \| blob \| blame \| history
math/test-float-vlen16.h		patch \| blob \| blame \| history
math/test-float-vlen4.h		patch \| blob \| blame \| history
math/test-float-vlen8.h		patch \| blob \| blame \| history
math/test-float.c	[deleted file]	patch \| blob \| blame \| history
math/test-idouble.c	[deleted file]	patch \| blob \| blame \| history
math/test-ifloat.c	[deleted file]	patch \| blob \| blame \| history
math/test-ildouble.c	[deleted file]	patch \| blob \| blame \| history
math/test-ldouble-finite.c	[deleted file]	patch \| blob \| blame \| history
math/test-ldouble.c	[deleted file]	patch \| blob \| blame \| history
math/test-math-vector.h		patch \| blob \| blame \| history
sysdeps/x86_64/fpu/Makefile		patch \| blob \| blame \| history
sysdeps/x86_64/fpu/test-double-vlen2.c	[deleted file]	patch \| blob \| blame \| history
sysdeps/x86_64/fpu/test-double-vlen2.h	[deleted file]	patch \| blob \| blame \| history
sysdeps/x86_64/fpu/test-double-vlen4-avx2.c	[deleted file]	patch \| blob \| blame \| history
sysdeps/x86_64/fpu/test-double-vlen4.c	[deleted file]	patch \| blob \| blame \| history
sysdeps/x86_64/fpu/test-double-vlen4.h		patch \| blob \| blame \| history
sysdeps/x86_64/fpu/test-double-vlen8.c	[deleted file]	patch \| blob \| blame \| history
sysdeps/x86_64/fpu/test-double-vlen8.h		patch \| blob \| blame \| history
sysdeps/x86_64/fpu/test-float-vlen16.c	[deleted file]	patch \| blob \| blame \| history
sysdeps/x86_64/fpu/test-float-vlen16.h		patch \| blob \| blame \| history
sysdeps/x86_64/fpu/test-float-vlen4.c	[deleted file]	patch \| blob \| blame \| history
sysdeps/x86_64/fpu/test-float-vlen4.h	[deleted file]	patch \| blob \| blame \| history
sysdeps/x86_64/fpu/test-float-vlen8-avx2.c	[deleted file]	patch \| blob \| blame \| history
sysdeps/x86_64/fpu/test-float-vlen8.c	[deleted file]	patch \| blob \| blame \| history
sysdeps/x86_64/fpu/test-float-vlen8.h		patch \| blob \| blame \| history