Run libm long double tests for long double = double [committed]

diff --git a/math/Makefile b/math/Makefile
index d4f9e6b..4014471 100644
--- 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 9ce3eb1..ede0d16 100644
--- 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 3c562e2..08138c4 100644
--- 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 97e98c7..7382d37 100644
--- 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 17c5928..3132766 100644
--- 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 89d4940..90a2933 100644
--- 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