[v3,2/2] x86 long double: Add tests for pseudo normal numbers

  Add some tests for fpclassify, isnan, isinf and issignaling.

Co-authored-by: Adhemerval Zanella <adhemerval.zanella@linaro.org>
---
 math/libm-test-driver.c        | 38 ++++++++++++++++++++++++++++++++++
 math/libm-test-fpclassify.inc  | 14 +++++++++++++
 math/libm-test-isinf.inc       | 14 +++++++++++++
 math/libm-test-isnan.inc       | 14 +++++++++++++
 math/libm-test-issignaling.inc | 14 +++++++++++++
 5 files changed, 94 insertions(+)
  

On 23/12/2020 23:45, Siddhesh Poyarekar wrote:
> Add some tests for fpclassify, isnan, isinf and issignaling.
> 
> Co-authored-by: Adhemerval Zanella <adhemerval.zanella@linaro.org>

LGTM, thanks.

> ---
>  math/libm-test-driver.c        | 38 ++++++++++++++++++++++++++++++++++
>  math/libm-test-fpclassify.inc  | 14 +++++++++++++
>  math/libm-test-isinf.inc       | 14 +++++++++++++
>  math/libm-test-isnan.inc       | 14 +++++++++++++
>  math/libm-test-issignaling.inc | 14 +++++++++++++
>  5 files changed, 94 insertions(+)
> 
> diff --git a/math/libm-test-driver.c b/math/libm-test-driver.c
> index 11b541b2e7..7f1af071da 100644
> --- a/math/libm-test-driver.c
> +++ b/math/libm-test-driver.c
> @@ -19,6 +19,7 @@
>  #include "libm-test-support.h"
>  
>  #include <math-tests-arch.h>
> +#include <nan-pseudo-number.h>
>  
>  /* Flags set by the including file.  */
>  const int flag_test_errno = TEST_ERRNO;
> @@ -122,6 +123,16 @@ const char qtype_str[] = TYPE_STR;
>  /* For nexttoward tests.  */
>  #define snan_value_ld	__builtin_nansl ("")
>  
> +/* For pseudo-normal number tests.  */
> +#if HANDLE_PSEUDO_NUMBERS
> +# include <math_ldbl.h>
> +#define pseudo_inf { .parts = { 0x00000000, 0x00000000, 0x7fff }}
> +#define pseudo_zero { .parts = { 0x00000000, 0x00000000, 0x0100 }}
> +#define pseudo_qnan { .parts = { 0x00000001, 0x00000000, 0x7fff }}
> +#define pseudo_snan { .parts = { 0x00000001, 0x40000000, 0x7fff }}
> +#define pseudo_unnormal { .parts = { 0x00000001, 0x40000000, 0x0100 }}
> +#endif
> +
>  /* Structures for each kind of test.  */
>  /* Used for both RUN_TEST_LOOP_f_f and RUN_TEST_LOOP_fp_f.  */
>  struct test_f_f_data
> @@ -316,6 +327,19 @@ struct test_f_i_data
>      int exceptions;
>    } rd, rn, rz, ru;
>  };
> +/* Used for RUN_TEST_LOOP_f_i_tg_u and RUN_TEST_LOOP_f_b_tg_u.  */
> +#if HANDLE_PSEUDO_NUMBERS
> +struct test_f_i_data_u
> +{
> +  const char *arg_str;
> +  ieee_long_double_shape_type arg;
> +  struct
> +  {
> +    int expected;
> +    int exceptions;
> +  } rd, rn, rz, ru;
> +};
> +#endif
>  /* Used for RUN_TEST_LOOP_ff_b, RUN_TEST_LOOP_fpfp_b and
>     RUN_TEST_LOOP_ff_i_tg.  */
>  struct test_ff_i_data
> @@ -832,6 +856,20 @@ struct test_Ff_b1_data
>  		       (ARRAY)[i].RM_##ROUNDING_MODE.expected,		\
>  		       (ARRAY)[i].RM_##ROUNDING_MODE.exceptions);	\
>    ROUND_RESTORE_ ## ROUNDING_MODE
> +#define RUN_TEST_LOOP_f_b_tg_u(FUNC_NAME, ARRAY, ROUNDING_MODE)		\
> +  IF_ROUND_INIT_ ## ROUNDING_MODE					\
> +  for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++)	\
> +  RUN_TEST_f_b_tg ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg.value,	\
> +		   (ARRAY)[i].RM_##ROUNDING_MODE.expected,		\
> +		   (ARRAY)[i].RM_##ROUNDING_MODE.exceptions);		\
> +  ROUND_RESTORE_ ## ROUNDING_MODE
> +#define RUN_TEST_LOOP_f_i_tg_u(FUNC_NAME, ARRAY, ROUNDING_MODE)		\
> +  IF_ROUND_INIT_ ## ROUNDING_MODE					\
> +  for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++)	\
> +  RUN_TEST_f_i_tg ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg.value,	\
> +		   (ARRAY)[i].RM_##ROUNDING_MODE.expected,		\
> +		   (ARRAY)[i].RM_##ROUNDING_MODE.exceptions);		\
> +  ROUND_RESTORE_ ## ROUNDING_MODE
>  #define RUN_TEST_ff_b(ARG_STR, FUNC_NAME, ARG1, ARG2, EXPECTED,		\
>  		      EXCEPTIONS)					\
>    do									\
> diff --git a/math/libm-test-fpclassify.inc b/math/libm-test-fpclassify.inc
> index 96b557ecb4..480ccfe9cb 100644
> --- a/math/libm-test-fpclassify.inc
> +++ b/math/libm-test-fpclassify.inc
> @@ -37,10 +37,24 @@ static const struct test_f_i_data fpclassify_test_data[] =
>      TEST_f_i (fpclassify, -min_subnorm_value, FP_SUBNORMAL, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
>    };
>  
> +#if HANDLE_PSEUDO_NUMBERS
> +static const struct test_f_i_data_u fpclassify_test_data_u[] =
> +  {
> +    TEST_f_i (fpclassify, pseudo_zero, FP_NAN, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
> +    TEST_f_i (fpclassify, pseudo_inf, FP_NAN, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
> +    TEST_f_i (fpclassify, pseudo_qnan, FP_NAN, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
> +    TEST_f_i (fpclassify, pseudo_snan, FP_NAN, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
> +    TEST_f_i (fpclassify, pseudo_unnormal, FP_NAN, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
> +  };
> +#endif
> +
>  static void
>  fpclassify_test (void)
>  {
>    ALL_RM_TEST (fpclassify, 1, fpclassify_test_data, RUN_TEST_LOOP_f_i_tg, END);
> +#if HANDLE_PSEUDO_NUMBERS
> +  ALL_RM_TEST (fpclassify, 1, fpclassify_test_data_u, RUN_TEST_LOOP_f_i_tg_u, END);
> +#endif
>  }
>  
>  static void
> diff --git a/math/libm-test-isinf.inc b/math/libm-test-isinf.inc
> index 6ecbf7ba6e..44cebd2198 100644
> --- a/math/libm-test-isinf.inc
> +++ b/math/libm-test-isinf.inc
> @@ -37,10 +37,24 @@ static const struct test_f_i_data isinf_test_data[] =
>      TEST_f_b (isinf, -snan_value, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
>    };
>  
> +#if HANDLE_PSEUDO_NUMBERS
> +static const struct test_f_i_data_u isinf_test_data_u[] =
> +  {
> +    TEST_f_b (isinf, pseudo_zero, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
> +    TEST_f_b (isinf, pseudo_inf, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
> +    TEST_f_b (isinf, pseudo_qnan, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
> +    TEST_f_b (isinf, pseudo_snan, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
> +    TEST_f_b (isinf, pseudo_unnormal, 0, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
> +  };
> +#endif
> +
>  static void
>  isinf_test (void)
>  {
>    ALL_RM_TEST (isinf, 1, isinf_test_data, RUN_TEST_LOOP_f_b_tg, END);
> +#if HANDLE_PSEUDO_NUMBERS
> +  ALL_RM_TEST (isinf, 1, isinf_test_data_u, RUN_TEST_LOOP_f_b_tg_u, END);
> +#endif
>  }
>  
>  static void
> diff --git a/math/libm-test-isnan.inc b/math/libm-test-isnan.inc
> index e6e2bb6a47..d8545c4dc5 100644
> --- a/math/libm-test-isnan.inc
> +++ b/math/libm-test-isnan.inc
> @@ -37,10 +37,24 @@ static const struct test_f_i_data isnan_test_data[] =
>      TEST_f_b (isnan, -snan_value, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
>    };
>  
> +#if HANDLE_PSEUDO_NUMBERS
> +static const struct test_f_i_data_u isnan_test_data_u[] =
> +  {
> +    TEST_f_b (isnan, pseudo_zero, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
> +    TEST_f_b (isnan, pseudo_inf, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
> +    TEST_f_b (isnan, pseudo_qnan, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
> +    TEST_f_b (isnan, pseudo_snan, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
> +    TEST_f_b (isnan, pseudo_unnormal, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
> +  };
> +#endif
> +
>  static void
>  isnan_test (void)
>  {
>    ALL_RM_TEST (isnan, 1, isnan_test_data, RUN_TEST_LOOP_f_b_tg, END);
> +#if HANDLE_PSEUDO_NUMBERS
> +  ALL_RM_TEST (isnan, 1, isnan_test_data_u, RUN_TEST_LOOP_f_b_tg_u, END);
> +#endif
>  }
>  
>  static void
> diff --git a/math/libm-test-issignaling.inc b/math/libm-test-issignaling.inc
> index a2bdcef265..80060dcb75 100644
> --- a/math/libm-test-issignaling.inc
> +++ b/math/libm-test-issignaling.inc
> @@ -39,10 +39,24 @@ static const struct test_f_i_data issignaling_test_data[] =
>      TEST_f_b (issignaling, -snan_value_MACRO, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
>    };
>  
> +#if HANDLE_PSEUDO_NUMBERS
> +static const struct test_f_i_data_u issignaling_test_data_u[] =
> +  {
> +    TEST_f_b (issignaling, pseudo_zero, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
> +    TEST_f_b (issignaling, pseudo_inf, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
> +    TEST_f_b (issignaling, pseudo_qnan, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
> +    TEST_f_b (issignaling, pseudo_snan, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
> +    TEST_f_b (issignaling, pseudo_unnormal, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
> +  };
> +#endif
> +
>  static void
>  issignaling_test (void)
>  {
>    ALL_RM_TEST (issignaling, 1, issignaling_test_data, RUN_TEST_LOOP_f_b_tg, END);
> +#if HANDLE_PSEUDO_NUMBERS
> +  ALL_RM_TEST (issignaling, 1, issignaling_test_data_u, RUN_TEST_LOOP_f_b_tg_u, END);
> +#endif
>  }
>  
>  static void
>
  

On Thu, 24 Dec 2020, Siddhesh Poyarekar via Libc-alpha wrote:

> Add some tests for fpclassify, isnan, isinf and issignaling.

This looks like these tests get duplicated for every floating-point type 
for which they are run.  They should only be run for long double and 
_Float64x; when the libm tests are run for other floating-point types 
(choices of FLOAT), these new tests should be compiled out.

Note that "f" in the test macro names means FLOAT, but these tests seem 
always to test long double, indpendent of the choice of FLOAT, not FLOAT.  
(The second argument of nexttoward is the only case where it's *correct* 
for a math/ test to use long double independent of FLOAT.)

Properly testing _Float64x (i.e. with that as the argument type to the 
macro, not long double, when FLOAT is _Float64x) may need further changes; 
either not using the math_ldbl.h unions but a local union with FLOAT, or 
casting the argument to type FLOAT.

> +/* For pseudo-normal number tests.  */
> +#if HANDLE_PSEUDO_NUMBERS
> +# include <math_ldbl.h>
> +#define pseudo_inf { .parts = { 0x00000000, 0x00000000, 0x7fff }}
> +#define pseudo_zero { .parts = { 0x00000000, 0x00000000, 0x0100 }}
> +#define pseudo_qnan { .parts = { 0x00000001, 0x00000000, 0x7fff }}
> +#define pseudo_snan { .parts = { 0x00000001, 0x40000000, 0x7fff }}
> +#define pseudo_unnormal { .parts = { 0x00000001, 0x40000000, 0x0100 }}

I think the right condition here (and everywhere in this patch) is 
TEST_COND_intel96: a condition on the format for which the tests are being 
run rather than on how glibc is built.  The tests are both specific to 
rules for that format about which encodings are valid (the high bit of the 
significand is unspecified for NaNs and infinities for m68k), and, in the 
form in which they're written here, also specific to little-endian, since 
you're relying on the ordering of initializer elements rather than using 
designated initializers, so wouldn't work on m68k for that reason as well.

If you need to avoid these tests for ia64 because of different rules on 
such encodings for ia64, some other condition might then be used *inside* 
a TEST_COND_intel96 condition.