Re: [PATCH] rs6000: Update the vsx-vector-6.* tests.

["Kewen.Lin" <linkw@linux.ibm.com>]

Hi Carl,

on 2023/5/31 04:46, Carl Love wrote:
> GCC maintainers:
> 
> The following patch takes the tests in vsx-vector-6-p7.h,  vsx-vector-
> 6-p8.h, vsx-vector-6-p9.h and reorganizes them into a series of smaller
> test files by functionality rather than processor version.
> 
> The patch has been tested on Power 10 with no regressions.
> 
> Please let me know if this patch is acceptable for mainline.  Thanks.
> 
>                        Carl
> 
> ------------------------------------------
> rs6000: Update the vsx-vector-6.* tests.
> 
> The vsx-vector-6.h file is included into the processor specific test files
> vsx-vector-6.p7.c, vsx-vector-6.p8.c, and vsx-vector-6.p9.c.  The .h file
> contains a large number of vsx vector builtin tests.  The processor
> specific files contain the number of instructions that the tests are
> expected to generate for that processor.  The tests are compile only.
> 
> The tests are broken up into a seriers of files for related tests.  The
> new tests are runnable tests to verify the builtin argument types and the

But the newly added test cases are all with "dg-do compile", it doesn't
match what you said here.

> functional correctness of each test rather then verifying the type and
> number of instructions generated.

It's good to have more coverage with runnable case, but we miss some test
coverages on the expected insn counts which cases p{7,8,9}.c can provide
originally.  Unless we can ensure it's already tested somewhere else (do
we? it wasn't stated in this patch), I think we still need those checks.

> 
> gcc/testsuite/
> 	* gcc.target/powerpc/vsx-vector-6-1op.c: New test file.
> 	* gcc.target/powerpc/vsx-vector-6-2lop.c: New test file.
> 	* gcc.target/powerpc/vsx-vector-6-2op.c: New test file.
> 	* gcc.target/powerpc/vsx-vector-6-3op.c: New test file.
> 	* gcc.target/powerpc/vsx-vector-6-cmp-all.c: New test file.
> 	* gcc.target/powerpc/vsx-vector-6-cmp.c: New test file.
> 	* gcc.target/powerpc/vsx-vector-6.h: Remove test file.
> 	* gcc.target/powerpc/vsx-vector-6-p7.h: Remove test file.
> 	* gcc.target/powerpc/vsx-vector-6-p8.h: Remove test file.
> 	* gcc.target/powerpc/vsx-vector-6-p9.h: Remove test file.
> ---
>  .../powerpc/vsx-vector-6-func-1op.c           | 319 +++++++++++++
>  .../powerpc/vsx-vector-6-func-2lop.c          | 305 +++++++++++++
>  .../powerpc/vsx-vector-6-func-2op.c           | 278 ++++++++++++
>  .../powerpc/vsx-vector-6-func-3op.c           | 229 ++++++++++
>  .../powerpc/vsx-vector-6-func-cmp-all.c       | 429 ++++++++++++++++++
>  .../powerpc/vsx-vector-6-func-cmp.c           | 237 ++++++++++
>  .../gcc.target/powerpc/vsx-vector-6.h         | 154 -------
>  .../gcc.target/powerpc/vsx-vector-6.p7.c      |  43 --
>  .../gcc.target/powerpc/vsx-vector-6.p8.c      |  43 --
>  .../gcc.target/powerpc/vsx-vector-6.p9.c      |  42 --
>  10 files changed, 1797 insertions(+), 282 deletions(-)
>  create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-1op.c
>  create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-2lop.c
>  create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-2op.c
>  create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-3op.c
>  create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-cmp-all.c
>  create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-cmp.c
>  delete mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-vector-6.h
>  delete mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-vector-6.p7.c
>  delete mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-vector-6.p8.c
>  delete mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-vector-6.p9.c
> 
> diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-1op.c b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-1op.c
> new file mode 100644
> index 00000000000..90a360ea158
> --- /dev/null
> +++ b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-1op.c
> @@ -0,0 +1,319 @@
> +/* { dg-do compile { target lp64 } } */
> +/* { dg-skip-if "" { powerpc*-*-darwin* } } */
> +/* { dg-options "-O2 -mdejagnu-cpu=power7" } */
> +
> +/* Functional test of the one operand vector builtins.  */
> +
> +#include <altivec.h>
> +#include <stdio.h>
> +#include <stdlib.h>
> +
> +#define DEBUG 0
> +
> +void abort (void);
> +
> +int
> +main () {
> +  int i;
> +  vector float f_src = { 125.44, 23.04, -338.56, 17.64};
> +  vector float f_result;
> +  vector float f_abs_expected = { 125.44, 23.04, 338.56, 17.64};
> +  vector float f_ceil_expected = { 126.0, 24.0, -338, 18.0};
> +  vector float f_floor_expected = { 125.0, 23.0, -339, 17.0};
> +  vector float f_nearbyint_expected = { 125.0, 23.0, -339, 18.0};
> +  vector float f_rint_expected = { 125.0, 23.0, -339, 18.0};
> +  vector float f_sqrt_expected = { 11.2, 4.8, 18.4, 4.2};
> +  vector float f_trunc_expected = { 125.0, 23.0, -338, 17};
> +
> +  vector double d_src = { 125.44, -338.56};
> +  vector double d_result;
> +  vector double d_abs_expected = { 125.44, 338.56};
> +  vector double d_ceil_expected = { 126.0, -338.0};
> +  vector double d_floor_expected = { 125.0, -339.0};
> +  vector double d_nearbyint_expected = { 125.0, -339.0};
> +  vector double d_rint_expected = { 125.0, -339.0};
> +  vector double d_sqrt_expected = { 11.2, 18.4};
> +  vector double d_trunc_expected = { 125.0, -338.0};
> +
> +  /* Abs, float */
> +  f_result = vec_abs (f_src);
> +
> +  if ((f_result[0] != f_abs_expected[0])
> +      || (f_result[1] != f_abs_expected[1])
> +      || (f_result[2] != f_abs_expected[2])
> +      || (f_result[3] != f_abs_expected[3]))
> +#if DEBUG
> +    {
> +      printf("ERROR: vec_abs (float) expected value does not match\n");
> +      printf("   expected[0] = %f; result[0] = %f\n",
> +	     f_abs_expected[0], f_result[0]);
> +      printf("   expected[1] = %f; result[1] = %f\n",
> +	     f_abs_expected[1], f_result[1]);
> +      printf("   expected[2] = %f; result[2] = %f\n",
> +	     f_abs_expected[2], f_result[2]);
> +      printf("   expected[3] = %f; result[3] = %f\n",
> +	     f_abs_expected[3], f_result[3]);
> +    }
> +#else
> +  abort();
> +#endif
> +
> +  /* Ceiling, float */
> +  f_result = vec_ceil (f_src);
> +
> +  if ((f_result[0] != f_ceil_expected[0])
> +      || (f_result[1] != f_ceil_expected[1])
> +      || (f_result[2] != f_ceil_expected[2])
> +      || (f_result[3] != f_ceil_expected[3]))
> +#if DEBUG
> +    {
> +      printf("ERROR: vec_ceil (float) expected value does not match\n");
> +      printf("   expected[0] = %f; result[0] = %f\n",
> +	     f_ceil_expected[0], f_result[0]);
> +      printf("   expected[1] = %f; result[1] = %f\n",
> +	     f_ceil_expected[1], f_result[1]);
> +      printf("   expected[2] = %f; result[2] = %f\n",
> +	     f_ceil_expected[2], f_result[2]);
> +      printf("   expected[3] = %f; result[3] = %f\n",
> +	     f_ceil_expected[3], f_result[3]);
> +    }
> +#else
> +  abort();
> +#endif

It looks that you can use some macro for different floating point functions
and its check and dumping here, since the basic skeleton are sharable, some
thing like:

#define FLOAT_CHECK(NAME)                                                      \
  f_result = vec_##NAME(f_src);                                                \
                                                                               \
  if ((f_result[0] != f_##NAME##_expected[0]) ||                               \
      (f_result[1] != f_##NAME##_expected[1]) ||                               \
      (f_result[2] != f_##NAME##_expected[2]) ||                               \
      (f_result[3] != f_##NAME##_expected[3])) {                               \
    if (DEBUG) {                                                               \
      printf("ERROR: vec_%s (float) expected value does not match\n", #NAME); \
      printf("   expected[0] = %f; result[0] = %f\n", f_##NAME##_expected[0],  \
             f_result[0]);                                                     \
      printf("   expected[1] = %f; result[1] = %f\n", f_##NAME##_expected[1],  \
             f_result[1]);                                                     \
      printf("   expected[2] = %f; result[2] = %f\n", f_##NAME##_expected[2],  \
             f_result[2]);                                                     \
      printf("   expected[3] = %f; result[3] = %f\n", f_##NAME##_expected[3],  \
             f_result[3]);                                                     \
    } else                                                                     \
      abort();                                                                 \
  }

...
FLOAT_CHECK(ceil)
FLOAT_CHECK(nearbyint)
...

I hope it can help to make it brief and avoid some copy & paste typos.
But since you already expanded them, it's fine to me if you wanted to keep
the expanded ones.  :)

> +
> +  /* Floor, float */
> +  f_result = vec_floor (f_src);
> +
> +  if ((f_result[0] != f_floor_expected[0])
> +      || (f_result[1] != f_floor_expected[1])
> +      || (f_result[2] != f_floor_expected[2])
> +      || (f_result[3] != f_floor_expected[3]))
> +#if DEBUG
> +    {
> +      printf("ERROR: vec_floor (float) expected value does not match\n");
> +      printf("   expected[0] = %f; result[0] = %f\n",
> +	     f_floor_expected[0], f_result[0]);
> +      printf("   expected[1] = %f; result[1] = %f\n",
> +	     f_floor_expected[1], f_result[1]);
> +      printf("   expected[2] = %f; result[2] = %f\n",
> +	     f_floor_expected[2], f_result[2]);
> +      printf("   expected[3] = %f; result[3] = %f\n",
> +	     f_floor_expected[3], f_result[3]);
> +    }
> +#else
> +  abort();
> +#endif
> +
> +  /* Nearby int, float */
> +  f_result = vec_nearbyint (f_src);
> +
> +  if ((f_result[0] != f_nearbyint_expected[0])
> +      || (f_result[1] != f_nearbyint_expected[1])
> +      || (f_result[2] != f_nearbyint_expected[2])
> +      || (f_result[3] != f_nearbyint_expected[3]))
> +#if DEBUG
> +    {
> +      printf("ERROR: vec_nearby (float) expected value does not match\n");
> +      printf("   expected[0] = %f; result[0] = %f\n",
> +	     f_nearbyint_expected[0], f_result[0]);
> +      printf("   expected[1] = %f; result[1] = %f\n",
> +	     f_nearbyint_expected[1], f_result[1]);
> +      printf("   expected[2] = %f; result[2] = %f\n",
> +	     f_nearbyint_expected[2], f_result[2]);
> +      printf("   expected[3] = %f; result[3] = %f\n",
> +	     f_nearbyint_expected[3], f_result[3]);
> +    }
> +#else
> +  abort();
> +#endif
> +
> +  /* Round, float */
> +  f_result = vec_rint (f_src);
> +
> +  if ((f_result[0] != f_rint_expected[0])
> +      || (f_result[1] != f_rint_expected[1])
> +      || (f_result[2] != f_rint_expected[2])
> +      || (f_result[3] != f_rint_expected[3]))
> +#if DEBUG
> +    {
> +      printf("ERROR: vec_rint (float) expected value does not match\n");
> +      printf("   expected[0] = %f; result[0] = %f\n",
> +	     f_rint_expected[0], f_result[0]);
> +      printf("   expected[1] = %f; result[1] = %f\n",
> +	     f_rint_expected[1], f_result[1]);
> +      printf("   expected[2] = %f; result[2] = %f\n",
> +	     f_rint_expected[2], f_result[2]);
> +      printf("   expected[3] = %f; result[3] = %f\n",
> +	     f_rint_expected[3], f_result[3]);
> +    }
> +#else
> +  abort();
> +#endif
> +
> +    /* Square, float */
> +  f_result = vec_sqrt (vec_abs(f_src));
> +
> +  if ((f_result[0] != f_sqrt_expected[0])
> +      || (f_result[1] != f_sqrt_expected[1])
> +      || (f_result[2] != f_sqrt_expected[2])
> +      || (f_result[3] != f_sqrt_expected[3]))
> +#if DEBUG
> +    {
> +      printf("ERROR: vec_sqrt (float) expected value does not match\n");
> +      printf("   expected[0] = %f; result[0] = %f\n",
> +	     f_sqrt_expected[0], f_result[0]);
> +      printf("   expected[1] = %f; result[1] = %f\n",
> +	     f_sqrt_expected[1], f_result[1]);
> +      printf("   expected[2] = %f; result[2] = %f\n",
> +	     f_sqrt_expected[2], f_result[2]);
> +      printf("   expected[3] = %f; result[3] = %f\n",
> +	     f_sqrt_expected[3], f_result[3]);
> +    }
> +#else
> +  abort();
> +#endif
> +
> +    /* Truncate, float */
> +  f_result = vec_trunc (f_src);
> +
> +  if ((f_result[0] != f_trunc_expected[0])
> +      || (f_result[1] != f_trunc_expected[1])
> +      || (f_result[2] != f_trunc_expected[2])
> +      || (f_result[3] != f_trunc_expected[3]))
> +#if DEBUG
> +    {
> +      printf("ERROR: vec_trunc (float) expected value does not match\n");
> +      printf("   expected[0] = %f; result[0] = %f\n",
> +	     f_trunc_expected[0], f_result[0]);
> +      printf("   expected[1] = %f; result[1] = %f\n",
> +	     f_trunc_expected[1], f_result[1]);
> +      printf("   expected[2] = %f; result[2] = %f\n",
> +	     f_trunc_expected[2], f_result[2]);
> +      printf("   expected[3] = %f; result[3] = %f\n",
> +	     f_trunc_expected[3], f_result[3]);
> +    }
> +#else
> +  abort();
> +#endif
> +
> 

snip ...

> +
> +  /* Vector select */
> +  d_result = vec_sel (d_src_a, d_src_b, ull_src_c);
> +
> +  if ((d_result[0] != d_selectu_expected[0])
> +      || (d_result[1] != d_selectu_expected[1]))
> +#if DEBUG
> +    {
> +      printf("ERROR: vec_msub (double, unsigned) expected value does not match\n");

Copy & paste typo.

> +      printf("   expected[0] = %f; result[0] = %f\n",
> +	     d_selectu_expected[0], d_result[0]);
> +      printf("   expected[1] = %f; result[1] = %f\n",
> +	     d_selectu_expected[1], d_result[1]);
> +    }
> +#else
> +  abort();
> +#endif
> +
> +  d_result = vec_sel (d_src_a, d_src_b, bll_src_c);
> +
> +  if ((d_result[0] != d_selectb_expected[0])
> +      || (d_result[1] != d_selectb_expected[1]))
> +#if DEBUG
> +    {
> +      printf("ERROR: vec_msub (double, bool) expected value does not match\n");

Ditto

> +      printf("   expected[0] = %f; result[0] = %f\n",
> +	     d_selectb_expected[0], d_result[0]);
> +      printf("   expected[1] = %f; result[1] = %f\n",
> +	     d_selectb_expected[1], d_result[1]);
> +    }
> +#else
> +  abort();
> +#endif
> +
> +  /* Vector permute */
> +  d_result = vec_perm (d_src_a, d_src_b, uc_src_c);
> +
> +  if ((d_result[0] != d_perm_expected[0])
> +      || (d_result[1] != d_perm_expected[1]))
> +#if DEBUG
> +    {
> +      printf("ERROR: vec_perf (unsigned char) expected value does not match\n");

perf -> perm

> +      printf("   expected[0] = %f; result[0] = %f\n",
> +	     d_perm_expected[0], d_result[0]);
> +      printf("   expected[1] = %f; result[1] = %f\n",
> +	     d_perm_expected[1], d_result[1]);
> +    }
> +#else
> +  abort();
> +#endif
> +
> +  return 0;
> +}
> diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-cmp-all.c b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-cmp-all.c
> new file mode 100644
> index 00000000000..4558918058e
> --- /dev/null
> +++ b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-cmp-all.c
> @@ -0,0 +1,429 @@
> +/* { dg-do compile { target lp64 } } */
> +/* { dg-skip-if "" { powerpc*-*-darwin* } } */
> +/* { dg-options "-O2 -mdejagnu-cpu=power7" } */
> +
> +/* Functional test of the vector compare all builtins.  */
> +
> +#include <altivec.h>
> +#include <stdio.h>
> +#include <stdlib.h>
> +#include <stdbool.h>
> +
> +#define DEBUG 0
> +
> +void abort (void);
> +
> +int
> +main () {
> +  int i;
> +  vector float f_src_a = {126.0, 23.0, -338.0, 17.0};
> +  vector float f_src_b = {2.00, 23.0, 1.0, 4.0};
> +  bool f_result;
> +  bool f_all_eq_expected = 0;
> +  bool f_all_gt_expected = 0;
> +  bool f_all_ge_expected = 0;
> +  bool f_all_lt_expected = 0;
> +  bool f_all_le_expected = 0;
> +  bool f_all_nan_expected = 0;
> +  bool f_all_numeric_expected = 1;
> +  bool f_any_eq_expected = 1;
> +  bool f_any_gt_expected = 1;
> +  bool f_any_ge_expected = 1;
> +  bool f_any_lt_expected = 1;
> +  bool f_any_le_expected = 1;
> +  bool f_any_nan_expected = 0;
> +  bool f_any_numeric_expected = 1;
> +
> +  vector double d_src_a = { 125.44, -338.56};
> +  vector double d_src_b = d_src_a;
> +  bool d_result;
> +  bool d_all_eq_expected = 1;
> +  bool d_all_gt_expected = 0;
> +  bool d_all_ge_expected = 1;
> +  bool d_all_lt_expected = 0;
> +  bool d_all_le_expected = 1;
> +  bool d_all_nan_expected = 0;
> +  bool d_all_numeric_expected = 1;
> +  bool d_any_eq_expected = 1;
> +  bool d_any_gt_expected = 0;
> +  bool d_any_ge_expected = 1;
> +  bool d_any_lt_expected = 0;
> +  bool d_any_le_expected = 1;
> +  bool d_any_nan_expected = 0;
> +  bool d_any_numeric_expected = 1;
> +
> +  /* Compare all equal, float */
> +  f_result = vec_all_eq (f_src_a, f_src_b);
> +
> +  if (f_result != f_all_eq_expected)
> +#if DEBUG
> +    {
> +      printf("ERROR: vec_all_eq (float) expected value does not match\n");
> +      printf("   expected = %d; result = %d\n",
> +	     f_all_eq_expected, f_result);
> +    }
> +#else
> +  abort();
> +#endif
> +
> +  /* Compare all greater than, float */
> +  f_result = vec_all_gt (f_src_a, f_src_b);
> +
> +  if (f_result != f_all_gt_expected)
> +#if DEBUG
> +    {
> +      printf("ERROR: vec_all_gt (float) expected value does not match\n");
> +      printf("   expected = %d; result = %d\n",
> +	     f_all_gt_expected, f_result);
> +    }
> +#else
> +  abort();
> +#endif
> +
> +  /* Compare all greater than or equal, float */
> +  f_result = vec_all_ge (f_src_a, f_src_b);
> +
> +  if (f_result != f_all_ge_expected)
> +#if DEBUG
> +    {
> +      printf("ERROR: vec_all_ge(float) expected value does not match\n");

inconsistent style (missing one space after vec_all_ge).

> +      printf("   expected] = %d; result = %d\n", f_all_ge_expected, f_result);
> +    }
> +#else
> +  abort();
> +#endif
> +
> +  /* Compare all less than, float */
> +  f_result = vec_all_lt (f_src_a, f_src_b);
> +
> +  if (f_result != f_all_lt_expected)
> +#if DEBUG
> +    {
> +      printf("ERROR: vec_all_lt (float) expected value does not match\n");
> +      printf("   expected = %d; result = %d\n", f_all_lt_expected, f_result);
> +    }
> +#else
> +  abort();
> +#endif
> +
> +  /* Compare all less than or equal, float */
> +  f_result = vec_all_le (f_src_a, f_src_b);
> +
> +  if (f_result != f_all_le_expected)
> +#if DEBUG
> +    {
> +      printf("ERROR: vec_all_le (float) expected value does not match\n");
> +      printf("   expected = %d; result = %d\n", f_all_le_expected, f_result);
> +    }
> +#else
> +  abort();
> +#endif
> +
> +  /* All NaN, float */
> +  f_result = vec_all_nan (f_src_a);
> +
> +  if (f_result != f_all_nan_expected)
> +#if DEBUG
> +    {
> +      printf("ERROR: vec_all_le (float) expected value does not match\n");

copy & paste typo.

> +      printf("   expected = %d; result = %d\n", f_all_nan_expected, f_result);
> +    }
> +#else
> +  abort();
> +#endif
> +
> +  /* All numeric, float */
> +  f_result = vec_all_numeric (f_src_a);
> +
> +  if (f_result != f_all_numeric_expected)
> +#if DEBUG
> +    {
> +      printf("ERROR: vec_all_numeric (float) expected value does not match\n");
> +      printf("   expected = %d; result = %d\n", f_all_numeric_expected,
> +	     f_result);
> +    }
> +#else
> +  abort();
> +#endif
> +
> +
> +  /* Compare any equal, float */
> +  f_result = vec_any_eq (f_src_a, f_src_b);
> +
> +  if (f_result != f_any_eq_expected)
> +#if DEBUG
> +    {
> +      printf("ERROR: vec_any_eq (float) expected value does not match\n");
> +      printf("   expected = %d; result = %d\n",
> +	     f_any_eq_expected, f_result);
> +    }
> +#else
> +  abort();
> +#endif
> +
> +  /* Compare any greater than, float */
> +  f_result = vec_any_gt (f_src_a, f_src_b);
> +
> +  if (f_result != f_any_gt_expected)
> +#if DEBUG
> +    {
> +      printf("ERROR: vec_any_gt (float) expected value does not match\n");
> +      printf("   expected = %d; result = %d\n",
> +	     f_any_gt_expected, f_result);
> +    }
> +#else
> +  abort();
> +#endif
> +
> +  /* Compare any greater than or equal, float */
> +  f_result = vec_any_ge (f_src_a, f_src_b);
> +
> +  if (f_result != f_any_ge_expected)
> +#if DEBUG
> +    {
> +      printf("ERROR: vec_any_ge(float) expected value does not match\n");

missing one space.

> +      printf("   expected] = %d; result = %d\n", f_any_ge_expected, f_result);
> +    }
> +#else
> +  abort();
> +#endif
> +
> +  /* Compare any less than, float */
> +  f_result = vec_any_lt (f_src_a, f_src_b);
> +
> +  if (f_result != f_any_lt_expected)
> +#if DEBUG
> +    {
> +      printf("ERROR: vec_any_lt (float) expected value does not match\n");
> +      printf("   expected = %d; result = %d\n", f_any_lt_expected, f_result);
> +    }
> +#else
> +  abort();
> +#endif
> +
> +  /* Compare any less than or equal, float */
> +  f_result = vec_any_le (f_src_a, f_src_b);
> +
> +  if (f_result != f_any_le_expected)
> +#if DEBUG
> +    {
> +      printf("ERROR: vec_any_le (float) expected value does not match\n");
> +      printf("   expected = %d; result = %d\n", f_any_le_expected, f_result);
> +    }
> +#else
> +  abort();
> +#endif
> +
> +  /* Any NaN, float */
> +  f_result = vec_any_nan (f_src_a);
> +
> +  if (f_result != f_any_nan_expected)
> +#if DEBUG
> +    {
> +      printf("ERROR: vec_any_le (float) expected value does not match\n");

typo, s/vec_any_le/vec_any_nan/

BR,
Kewen