Run libm long double tests for long double = double.

All interfaces in the glibc API ought to be covered by the testsuite,
even where they alias other interfaces.  This patch arranges for libm
tests to be run for long double when it aliases double; previously
those tests were run only for the floating-point types with distinct
formats.  The long double tests are made to use the double ulps values
in this case, as having a separate duplicate set of ulps for them
seems unnecessary; to accommodate that, the test-<type>.h headers now
specify the macro indexing into the ulps array explicitly instead of
having it computed from PREFIX.

Nothing special is done about vector function tests.  None are
supported for any long double = double platforms, and supporting
vector functions for a type alias such as _Float32 would not simply
fall out of adding the scalar aliases for that type - it would require
vector function wrappers like those for *_finite (or, better, a new
GCC feature to allow specifying the asm name for vector functions
independently of that for scalar ones, as previously discussed), so it
seems reasonable to require the sysdeps makefile setting of
libmvec-tests to be updated if any such tests are to be run for type
aliases.

Tested for x86_64 and arm.

	* math/Makefile (test-types-basic): New variable.
	(test-types): Likewise.
	(libm-test-support): Use $(test-types) instead of $(types).
	(libm-tests-base-normal): Likewise.
	(libm-tests-base-finite): Likewise.
	(libm-tests-base-inline): Likewise.
	(generated): Likewise.
	($(objpfx)libm-test-support-$(t).c): Likewise.
	(libm-tests-for-type iterator): Likewise.
	(libm-test-support iterator): Likewise.
	* math/libm-test-support.c (ulp_i_idx): Use ULP_I_IDX.
	(ulp_idx): Use ULP_IDX.
	* math/test-ldouble.h: Include <float.h>.
	(TYPE_STR): Define conditional on [LDBL_MANT_DIG == DBL_MANT_DIG].
	(ULP_IDX): New macro.
	(ULP_I_IDX): Likewise.
	* math/test-double.h (ULP_IDX): Likewise.
	(ULP_I_IDX): Likewise.
	* math/test-float.h (ULP_IDX): Likewise.
	(ULP_I_IDX): Likewise.
	* math/test-float128.h (ULP_IDX): Likewise.
	(ULP_I_IDX): Likewise.

diff --git a/ChangeLog b/ChangeLog
index 3a1dba949894ad19e79735a83bdaa2145a748dc1..e8f8382a5c1da74e1fe4c9d1de858f7e8c45c90e 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,28 @@
+2017-10-11  Joseph Myers  <joseph@codesourcery.com>
+
+       * math/Makefile (test-types-basic): New variable.
+       (test-types): Likewise.
+       (libm-test-support): Use $(test-types) instead of $(types).
+       (libm-tests-base-normal): Likewise.
+       (libm-tests-base-finite): Likewise.
+       (libm-tests-base-inline): Likewise.
+       (generated): Likewise.
+       ($(objpfx)libm-test-support-$(t).c): Likewise.
+       (libm-tests-for-type iterator): Likewise.
+       (libm-test-support iterator): Likewise.
+       * math/libm-test-support.c (ulp_i_idx): Use ULP_I_IDX.
+       (ulp_idx): Use ULP_IDX.
+       * math/test-ldouble.h: Include <float.h>.
+       (TYPE_STR): Define conditional on [LDBL_MANT_DIG == DBL_MANT_DIG].
+       (ULP_IDX): New macro.
+       (ULP_I_IDX): Likewise.
+       * math/test-double.h (ULP_IDX): Likewise.
+       (ULP_I_IDX): Likewise.
+       * math/test-float.h (ULP_IDX): Likewise.
+       (ULP_I_IDX): Likewise.
+       * math/test-float128.h (ULP_IDX): Likewise.
+       (ULP_I_IDX): Likewise.
+
 2017-10-11  Adhemerval Zanella  <adhemerval.zanella@linaro.org>
 
        * sysdeps/unix/sysv/linux/aarch64/sysdep-cancel.h: Remove file.

diff --git a/math/Makefile b/math/Makefile
index d4f9e6b6e90b2e204dddbbff4f3d38ac471d81f7..4014471f74d525c695bc700e9b95164ef57dba92 100644 (file)
--- a/math/Makefile
+++ b/math/Makefile
@@ -102,6 +102,10 @@ libm-compat-calls =                                                        \
 # after the Rules makefile has been parsed.
 types-basic = $(type-ldouble-$(long-double-fcts)) double float
 
+# Like types, but includes types whose functions alias those for
+# another type.
+test-types-basic = ldouble double float
+
 # long double support
 type-ldouble-suffix := l
 type-ldouble-routines := t_sincosl k_sincosl s_iscanonicall
@@ -123,6 +127,7 @@ type-float128-suffix := f128
 type-float128-routines := t_sincosf128 k_sincosf128
 type-float128-yes := float128
 types = $(types-basic) $(type-float128-$(float128-fcts))
+test-types = $(test-types-basic) $(type-float128-$(float128-fcts))
 
 # For each of the basic types (float, double, long double), replace the
 # occurrences of 'F' in arg 1 with the appropriate suffix for the type.
@@ -214,7 +219,7 @@ endif
 
 ifneq (no,$(PERL))
 libm-vec-tests = $(addprefix test-,$(libmvec-tests))
-libm-test-support = $(foreach t,$(types),libm-test-support-$(t))
+libm-test-support = $(foreach t,$(test-types),libm-test-support-$(t))
 test-extras += $(libm-test-support)
 extra-test-objs += $(addsuffix .o, $(libm-test-support))
 libm-vec-test-wrappers = $(addsuffix -wrappers, $(libm-vec-tests))
@@ -250,9 +255,9 @@ 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)
 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-normal = $(foreach t,$(test-types),test-$(t))
+libm-tests-base-finite = $(foreach t,$(test-types),test-$(t)-finite)
+libm-tests-base-inline = $(foreach t,$(test-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),\
@@ -277,7 +282,7 @@ libm-tests.o = $(addsuffix .o,$(libm-tests))
 
 tests += $(libm-tests)
 generated += $(addsuffix .c,$(libm-tests)) \
-            $(foreach t,$(types),libm-test-support-$(t).c)
+            $(foreach t,$(test-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))
@@ -448,7 +453,7 @@ $(foreach t,$(libm-tests-vector),$(objpfx)$(t).c): $(objpfx)test-%.c:
          echo "#include <libm-test-$$func.c>"; \
        ) > $@
 
-$(foreach t,$(types),\
+$(foreach t,$(test-types),\
            $(objpfx)libm-test-support-$(t).c): $(objpfx)libm-test-support-%.c:
        ( \
          echo "#include <test-$*.h>"; \
@@ -496,13 +501,13 @@ define o-iterator-doit
 $(addprefix $(objpfx),\
            $(call libm-tests-for-type,$(o))): $(objpfx)libm-test-support-$(o).o
 endef
-object-suffixes-left := $(types)
+object-suffixes-left := $(test-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)
+object-suffixes-left := $(test-types)
 include $(o-iterator)
 
 # Run the math programs to automatically generate ULPs files.

diff --git a/math/libm-test-support.c b/math/libm-test-support.c
index 9ce3eb1c04512f888c2544c37622a999724274bc..ede0d161a268c4c3bc2556764f93822a8e7f1ac9 100644 (file)
--- a/math/libm-test-support.c
+++ b/math/libm-test-support.c
@@ -45,6 +45,9 @@
 
    TYPE_STR: The name of the type as used in ulps files, as a string.
 
+   ULP_IDX, ULP_I_IDX: The array indexes for ulps values for this
+   function.
+
    LIT: Append the correct suffix to a literal.
 
    LITM: Append the correct suffix to an M_* macro name.
@@ -191,8 +194,8 @@ compare_ulp_data (const void *key, const void *ulp)
   return strcmp (keystr, ulpdat->name);
 }
 
-static const int ulp_i_idx = __CONCATX (ULP_I_, PREFIX);
-static const int ulp_idx = __CONCATX (ULP_, PREFIX);
+static const int ulp_i_idx = ULP_I_IDX;
+static const int ulp_idx = ULP_IDX;
 
 /* Return the ulps for NAME in array DATA with NMEMB elements, or 0 if
    no ulps listed.  */

diff --git a/math/test-double.h b/math/test-double.h
index 3c562e27f57a2715302f161ccd43efc0478ad63c..08138c4478ab85db6b32090f33496a6d1765aac3 100644 (file)
--- a/math/test-double.h
+++ b/math/test-double.h
@@ -23,6 +23,8 @@
 #define PREFIX DBL
 #define LIT(x) (x)
 #define TYPE_STR "double"
+#define ULP_IDX ULP_DBL
+#define ULP_I_IDX ULP_I_DBL
 #define LITM(x) x
 #define FTOSTR strfromd
 #define snan_value_MACRO SNAN

diff --git a/math/test-float.h b/math/test-float.h
index 97e98c768a1e39bafd8b10a433db9f57553a1932..7382d37639c6308ee19a5d2c576770f29da87b6e 100644 (file)
--- a/math/test-float.h
+++ b/math/test-float.h
@@ -22,6 +22,8 @@
 #define BUILD_COMPLEX(real, imag) (CMPLXF ((real), (imag)))
 #define PREFIX FLT
 #define TYPE_STR "float"
+#define ULP_IDX ULP_FLT
+#define ULP_I_IDX ULP_I_FLT
 #define LIT(x) (x ## f)
 /* Use the double variants of macro constants.  */
 #define LITM(x) x

diff --git a/math/test-float128.h b/math/test-float128.h
index 17c5928bf6cc9181f890257e85b8f5e2776f40b5..3132766aa4619d23bf3594804f36758d5ebf2d27 100644 (file)
--- a/math/test-float128.h
+++ b/math/test-float128.h
@@ -29,6 +29,8 @@
 #define BUILD_COMPLEX(real, imag) (CMPLXF128 ((real), (imag)))
 #define PREFIX FLT128
 #define TYPE_STR "float128"
+#define ULP_IDX ULP_FLT128
+#define ULP_I_IDX ULP_I_FLT128
 #define LIT(x) __f128 (x)
 #define LITM(x) x ## f128
 #define FTOSTR strfromf128

diff --git a/math/test-ldouble.h b/math/test-ldouble.h
index 89d4940117088afc93337516a8555c2ede2752f5..90a293386c532883e37f58196965a5b1916d082a 100644 (file)
--- a/math/test-ldouble.h
+++ b/math/test-ldouble.h
@@ -16,12 +16,22 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include <float.h>
+
 #define FUNC(function) function##l
 #define FLOAT long double
 #define CFLOAT __complex__ long double
 #define BUILD_COMPLEX(real, imag) (CMPLXL ((real), (imag)))
 #define PREFIX LDBL
-#define TYPE_STR "ldouble"
+#if LDBL_MANT_DIG == DBL_MANT_DIG
+# define TYPE_STR "double"
+# define ULP_IDX ULP_DBL
+# define ULP_I_IDX ULP_I_DBL
+#else
+# define TYPE_STR "ldouble"
+# define ULP_IDX ULP_LDBL
+# define ULP_I_IDX ULP_I_LDBL
+#endif
 #define LIT(x) (x ## L)
 #define LITM(x) x ## l
 #define FTOSTR strfroml