[ver,3] rs6000: Update the vsx-vector-6.* tests.

  GCC maintainers:

Ver 3.  Added __attribute__ ((noipa)) to the test files.  Changed some
of the scan-assembler-times checks to cover multiple similar
instructions.  Change the function check macro to a macro to generate a
function to do the test and check the results.  Retested on the various
processor types and BE/LE versions.

Ver 2.  Switched to using code macros to generate the call to the
builtin and test the results.  Added in instruction counts for the key
instruction for the builtin.  Moved the tests into an additional
function call to ensure the compile doesn't replace the builtin call
code with the statically computed results.  The compiler was doing this
for a few of the simpler tests.  

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.

Tested the patch on Power 8 LE/BE, Power 9 LE/BE and Power 10 LE with
no regresions.

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
functional correctness of each test rather then verifying the type and
number of instructions generated.

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           | 141 ++++++++++
 .../powerpc/vsx-vector-6-func-2lop.c          | 217 +++++++++++++++
 .../powerpc/vsx-vector-6-func-2op.c           | 133 +++++++++
 .../powerpc/vsx-vector-6-func-3op.c           | 257 ++++++++++++++++++
 .../powerpc/vsx-vector-6-func-cmp-all.c       | 211 ++++++++++++++
 .../powerpc/vsx-vector-6-func-cmp.c           | 121 +++++++++
 .../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, 1080 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
  

Hi Carl,

on 2023/6/30 05:36, Carl Love wrote:
> GCC maintainers:
> 
> Ver 3.  Added __attribute__ ((noipa)) to the test files.  Changed some
> of the scan-assembler-times checks to cover multiple similar
> instructions.  Change the function check macro to a macro to generate a
> function to do the test and check the results.  Retested on the various
> processor types and BE/LE versions.
> 
> Ver 2.  Switched to using code macros to generate the call to the
> builtin and test the results.  Added in instruction counts for the key
> instruction for the builtin.  Moved the tests into an additional
> function call to ensure the compile doesn't replace the builtin call
> code with the statically computed results.  The compiler was doing this
> for a few of the simpler tests.  
> 
> 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.
> 
> Tested the patch on Power 8 LE/BE, Power 9 LE/BE and Power 10 LE with
> no regresions.
> 
> 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

s/seriers/series/

> new tests are runnable tests to verify the builtin argument types and the
> functional correctness of each test rather then verifying the type and
> number of instructions generated.
> 
> 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.

Missing "func-" in the names ...

> 	* 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.

should be vsx-vector-6-p{7,8,9}.c, "git gcc-verify" should catch these.

> ---
>  .../powerpc/vsx-vector-6-func-1op.c           | 141 ++++++++++
>  .../powerpc/vsx-vector-6-func-2lop.c          | 217 +++++++++++++++
>  .../powerpc/vsx-vector-6-func-2op.c           | 133 +++++++++
>  .../powerpc/vsx-vector-6-func-3op.c           | 257 ++++++++++++++++++
>  .../powerpc/vsx-vector-6-func-cmp-all.c       | 211 ++++++++++++++
>  .../powerpc/vsx-vector-6-func-cmp.c           | 121 +++++++++
>  .../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, 1080 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..52c7ae3e983
> --- /dev/null
> +++ b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-1op.c
> @@ -0,0 +1,141 @@
> +/* { dg-do run { target lp64 } } */
> +/* { dg-skip-if "" { powerpc*-*-darwin* } } */
> +/* { dg-options "-O2 -save-temps" } */

I just noticed that we missed an effective target check here to ensure the
support of those bifs during the test run, and since it's a runnable test
case, also need to ensure the generated hw insn supported, it's "vsx_hw"
like:

/* { dg-require-effective-target vsx_hw } */

And adding "-mvsx" to the dg-options.

This is also applied for the other test cases.

But as the discussion on xxlor and the different effective target requirements
on compilation part and run part, I think we can separate each of these cases into
two files, one for compilation and the other for run, for example, for this
case, update FLOAT_TEST by adding one more global variable like

#define FLOAT_TEST(NAME)
  vector float f_##NAME##_result; \
  void ... \
  f_##NAME##_result = vec_##NAME(f_src);\
  }
  // moving the checking code to its main.

move #include <altivec.h>, FLOAT_TEST(NAME), DOUBLE_TEST(NAME) defines
and their uses into vsx-vector-6-func-1op.h.


**For compilation file vsx-vector-6-func-1op.c**:

Include this header file into vsx-vector-6-func-1op.c, which has the

/* { dg-do compile { target lp64 } } */
/* { dg-require-effective-target powerpc_vsx_ok } */
/* { dg-options "-O2 -mvsx" } */

#include "vsx-vector-6-func-1op.h"

Then put the expected insn check here, like 

/* { dg-final { scan-assembler-times {\mxvabssp\M} 1 } } */
...

By organizing it like this, these scan-assembler-times would only focus on what
are generated for bifs (excluding possible noises from main function for running).


**For runnable file vsx-vector-6-func-1op-run.c**:

/* { dg-do compile { target lp64 } } */
/* { dg-require-effective-target vsx_hw } */
/* { dg-options "-O2 -mvsx" } */

#include "vsx-vector-6-func-1op.h"

We can add a new macro to invoke {FLOAT,DOUBLE}_TEST, further check the
{d,f}_##NAME##_result and {d,f}_##NAME##_expected, and use it in main.

This test case can only focus on runtime result checking.


BR,
Kewen

> +
> +/* Functional test of the one operand vector builtins.  */
> +
> +#include <altivec.h>
> +#include <stdio.h>
> +#include <stdlib.h>
> +
> +#define DEBUG 0
> +
> +void abort (void);
> +
> +/* Macro to check the results for the various floating point argument tests.
> + */
> +#define FLOAT_TEST(NAME)                                                  \
> +  void __attribute__ ((noipa))                                            \
> +  float_##NAME (vector float f_src, vector float f_##NAME##_expected)     \
> +  {									  \
> +    vector float 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_TEST (abs)
> +FLOAT_TEST (ceil)
> +FLOAT_TEST (floor)
> +FLOAT_TEST (nearbyint)
> +FLOAT_TEST (rint)
> +FLOAT_TEST (trunc)
> +
> +/* Macro to check the results for the various double point argument tests.  */
> +#define DOUBLE_TEST(NAME)                                                    \
> +  void __attribute__ ((noipa))                                               \
> +  double_##NAME (vector double d_src, vector double d_##NAME##_expected)     \
> +  {									     \
> +    vector double d_result = vec_##NAME(d_src);				     \
> +                                                                             \
> +    if ((d_result[0] != d_##NAME##_expected[0])				     \
> +	|| (d_result[1] != d_##NAME##_expected[1]))			     \
> +      {									     \
> +	if (DEBUG)							     \
> +	  {								     \
> +	    printf("ERROR: vec_%s (double) expected value does not match\n", \
> +		   #NAME);						     \
> +	    printf("   expected[0] = %f; result[0] = %f\n",		     \
> +		   d_##NAME##_expected[0], d_result[0]);		     \
> +	    printf("   expected[1] = %f; result[1] = %f\n",		     \
> +		   d_##NAME##_expected[1], d_result[1]);		     \
> +	  }								     \
> +	else								     \
> +	  abort();							     \
> +      }									     \
> +  }
> +
> +DOUBLE_TEST (abs)
> +DOUBLE_TEST (ceil)
> +DOUBLE_TEST (floor)
> +DOUBLE_TEST (nearbyint)
> +DOUBLE_TEST (rint)
> +DOUBLE_TEST (trunc)
> +DOUBLE_TEST (sqrt)
> +
> +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_src_sqrt = { 125.44, 338.56};
> +  vector double d_abs_src;
> +  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};
> +
> +
> +  /* Floating point argument tests. */
> +  float_abs (f_src, f_abs_expected);
> +  float_ceil (f_src, f_ceil_expected);
> +  float_floor (f_src, f_floor_expected);
> +  float_nearbyint (f_src, f_nearbyint_expected);
> +  float_rint (f_src, f_rint_expected);
> +  float_trunc (f_src, f_trunc_expected);
> +
> +  /* Double argument tests. */
> +  double_abs (d_src, d_abs_expected);
> +  double_ceil (d_src, d_ceil_expected);
> +  double_floor (d_src, d_floor_expected);
> +  double_nearbyint (d_src, d_nearbyint_expected);
> +  double_rint (d_src, d_rint_expected);
> +  double_trunc (d_src, d_trunc_expected);
> +  double_sqrt (d_src_sqrt, d_sqrt_expected);
> +
> +  return 0;
> +}  
> +
> +/* { dg-final { scan-assembler-times {\mxvabssp\M} 1 } } */
> +/* { dg-final { scan-assembler-times {\mxvrspip\M} 1 } } */
> +/* { dg-final { scan-assembler-times {\mxvrspim\M} 1 } } */
> +/* { dg-final { scan-assembler-times {\mxvrspi\M} 1 } } */ 
> +/* { dg-final { scan-assembler-times {\mxvrspic\M} 1 } } */
> +/* { dg-final { scan-assembler-times {\mxvrspiz\M} 1 } } */
> +/* { dg-final { scan-assembler-times {\mxvabsdp\M} 1 } } */
> +/* { dg-final { scan-assembler-times {\mxvrdpip\M} 1 } } */
> +/* { dg-final { scan-assembler-times {\mxvrdpim\M} 1 } } */
> +/* { dg-final { scan-assembler-times {\mxvrdpi\M} 1 } } */
> +/* { dg-final { scan-assembler-times {\mxvrdpic\M} 1 } } */
> +/* { dg-final { scan-assembler-times {\mxvrdpiz\M} 1 } } */
> +/* { dg-final { scan-assembler-times {\mxvsqrtdp\M} 1 } } */
> diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-2lop.c b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-2lop.c
> new file mode 100644
> index 00000000000..8e5fe2312ff
> --- /dev/null
> +++ b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-2lop.c
> @@ -0,0 +1,217 @@
> +/* { dg-do run { target lp64 } } */
> +/* { dg-skip-if "" { powerpc*-*-darwin* } } */
> +/* { dg-options "-O2 -save-temps" } */
> +
> +/* Functional test of the two operand logical vector builtins.  */
> +
> +#include <altivec.h>
> +#include <stdio.h>
> +#include <stdlib.h>
> +
> +#define DEBUG 0
> +
> +union conv_t {
> +  vector float f;
> +  vector unsigned int u;
> +  vector double d;
> +  vector unsigned long ul;
> +} conv_result, conv_exp, conv_src_a, conv_src_b;
> +
> +void abort (void);
> +
> +#define FLOAT_TEST(NAME)                                                    \
> +  void __attribute__ ((noipa))                                              \
> +  float_##NAME (vector float f_src_a, vector float f_src_b,                 \
> +		vector float f_##NAME##_expected)                           \
> +  {                                                                         \
> +    int i;                                                                  \
> +    vector float f_result = vec_##NAME (f_src_a, f_src_b);                  \
> +                                                                            \
> +    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);                                                  \
> +	    for (i = 0; i < 4; i++)                                         \
> +	      {                                                             \
> +	        conv_result.f[i] = f_result[i];                             \
> +	        printf("   expected[%d] = 0x%x; result[%d] = 0x%x\n", i,    \
> +		       conv_exp.u[i], i, conv_result.u[i]);                 \
> +	      }                                                             \
> +	  }                                                                 \
> +        else                                                                \
> +	  abort();                                                          \
> +      }									    \
> +  }
> +
> +FLOAT_TEST (and)
> +FLOAT_TEST (andc)
> +FLOAT_TEST (nor)
> +FLOAT_TEST (or)
> +FLOAT_TEST (xor)
> +
> +#define DOUBLE_TEST(NAME)						     \
> +  void __attribute__ ((noipa))                                               \
> +  double_##NAME (vector double d_src_a, vector double d_src_b,               \
> +                 vector double d_##NAME##_expected)  			     \
> +  {                                                                          \
> +    vector double d_result = vec_##NAME (d_src_a, d_src_b);                  \
> +    int i;                                                                   \
> +                                                                             \
> +    if ((d_result[0] != d_##NAME##_expected[0])			             \
> +        || (d_result[1] != d_##NAME##_expected[1]))                          \
> +      {                                                                      \
> +        if (DEBUG)                                                           \
> +	  {                                                                  \
> +	    printf("ERROR: vec_%s (double) expected value does not match\n", \
> +		   #NAME);                                                   \
> +	    for (i = 0; i < 2; i++)                                          \
> +	      {                                                              \
> +	        conv_result.d[i] = d_result[i];                              \
> +	        printf("   expected[%d] = 0x%lx; result[%d] = 0x%lx\n", i,   \
> +		       conv_exp.ul, i, conv_result.ul);                      \
> +	      }                                                              \
> +	  }                                                                  \
> +        else  								     \
> +	  abort();							     \
> +      }									     \
> +  }
> +
> +DOUBLE_TEST (and)
> +DOUBLE_TEST (andc)
> +DOUBLE_TEST (nor)
> +DOUBLE_TEST (or)
> +DOUBLE_TEST (xor)
> +
> +int
> +main () {
> +  int i;
> +
> +  vector float f_src_a = { 1.0, 2.0, 3.0, 4.0};
> +  vector float f_src_b = { 1.0, 3.0, -3.0, 2.0};
> +  vector float f_and_expected, f_andc_expected, f_nor_expected, f_or_expected;
> +  vector float f_xor_expected;
> +
> +  vector double d_src_a = { 8.0, 10.0};
> +  vector double d_src_b = { 12.0, 2.0};
> +  vector double d_result;
> +  vector double d_and_expected, d_andc_expected, d_nor_expected;
> +  vector double d_or_expected, d_xor_expected;
> +
> +  /* Calculate expected results.  */
> +  /* AND, float */
> +  for (i = 0; i < 4; i++)
> +    {
> +      conv_src_a.f[i] = f_src_a[i];
> +      conv_src_b.f[i] = f_src_b[i];
> +      conv_exp.u[i] = conv_src_a.u[i] & conv_src_b.u[i];
> +      f_and_expected[i] = conv_exp.f[i];
> +    }
> +
> +  /* ANDC, float */
> +  for (i = 0; i < 4; i++)
> +    {
> +      conv_src_a.f[i] = f_src_a[i];
> +      conv_src_b.f[i] = f_src_b[i];
> +      conv_exp.u[i] = conv_src_a.u[i] & ~conv_src_b.u[i];
> +      f_andc_expected[i] = conv_exp.f[i];
> +    }
> +
> +    /* NOR, max */
> +  for (i = 0; i < 4; i++)
> +    {
> +      conv_src_a.f[i] = f_src_a[i];
> +      conv_src_b.f[i] = f_src_b[i];
> +      conv_exp.u[i] = ~(conv_src_a.u[i] | conv_src_b.u[i]);
> +      f_nor_expected[i] = conv_exp.f[i];
> +    }
> +
> +  /* OR, float */
> +  for (i = 0; i < 4; i++)
> +    {
> +      conv_src_a.f[i] = f_src_a[i];
> +      conv_src_b.f[i] = f_src_b[i];
> +      conv_exp.u[i] = conv_src_a.u[i] | conv_src_b.u[i];
> +      f_or_expected[i] = conv_exp.f[i];
> +    }
> +
> +  /* XOR, float */
> +  for (i = 0; i < 4; i++)
> +    {
> +      conv_src_a.f[i] = f_src_a[i];
> +      conv_src_b.f[i] = f_src_b[i];
> +      conv_exp.u[i] = conv_src_a.u[i] ^ conv_src_b.u[i];
> +      f_xor_expected[i] = conv_exp.f[i];
> +    }
> +
> +  /* AND, double */
> +  for (i = 0; i < 2; i++)
> +    {
> +      conv_src_a.d[i] = d_src_a[i];
> +      conv_src_b.d[i] = d_src_b[i];
> +      conv_exp.ul[i] = conv_src_a.ul[i] & conv_src_b.ul[i];
> +      d_and_expected[i] = conv_exp.d[i];
> +    }
> +
> +  /* ANDC, double */
> +  for (i = 0; i < 2; i++)
> +    {
> +      conv_src_a.d[i] = d_src_a[i];
> +      conv_src_b.d[i] = d_src_b[i];
> +      conv_exp.ul[i] = conv_src_a.ul[i] & ~conv_src_b.ul[i];
> +      d_andc_expected[i] = conv_exp.d[i];
> +    }
> +
> +  /* NOR, double */
> +  for (i = 0; i < 2; i++)
> +    {
> +      conv_src_a.d[i] = d_src_a[i];
> +      conv_src_b.d[i] = d_src_b[i];
> +      conv_exp.ul[i] = ~(conv_src_a.ul[i] | conv_src_b.ul[i]);
> +      d_nor_expected[i] = conv_exp.d[i];
> +    }
> +
> +  /* OR, double */
> +  for (i = 0; i < 2; i++)
> +    {
> +      conv_src_a.d[i] = d_src_a[i];
> +      conv_src_b.d[i] = d_src_b[i];
> +      conv_exp.ul[i] = conv_src_a.ul[i] | conv_src_b.ul[i];
> +      d_or_expected[i] = conv_exp.d[i];
> +    }
> +
> +  /* XOR, double */
> +  for (i = 0; i < 2; i++)
> +    {
> +      conv_src_a.d[i] = d_src_a[i];
> +      conv_src_b.d[i] = d_src_b[i];
> +      conv_exp.ul[i] = conv_src_a.ul[i] ^ conv_src_b.ul[i];
> +      d_xor_expected[i] = conv_exp.d[i];
> +    }
> +
> +  /* Run tests.  */
> +  float_and (f_src_a, f_src_b, f_and_expected);
> +  float_andc (f_src_a, f_src_b, f_andc_expected);
> +  float_nor (f_src_a, f_src_b, f_nor_expected);
> +  float_or (f_src_a, f_src_b, f_or_expected);
> +  float_xor (f_src_a, f_src_b, f_xor_expected);
> +
> +  double_and (d_src_a, d_src_b, d_and_expected);
> +  double_andc (d_src_a, d_src_b, d_andc_expected);
> +  double_nor (d_src_a, d_src_b, d_nor_expected);
> +  double_or (d_src_a, d_src_b, d_or_expected);
> +  double_xor (d_src_a, d_src_b, d_xor_expected);
> +
> +  return 0;
> +}
> +
> +/* { dg-final { scan-assembler-times {\mxxland\M} 2 } } */
> +/* { dg-final { scan-assembler-times {\mxxlandc\M} 2 } } */
> +/* { dg-final { scan-assembler-times {\mxxlnor\M} 2 } } */
> +/* { dg-final { scan-assembler-times {\mxxlxor\M} 2 } } */
> +/* { dg-final { scan-assembler-times {\mxxlor\M} 22 { target le }} } */
> +/* { dg-final { scan-assembler-times {\mxxlor\M} 32 { target be }} } */> diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-2op.c b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-2op.c
> new file mode 100644
> index 00000000000..25a651a1ac9
> --- /dev/null
> +++ b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-2op.c
> @@ -0,0 +1,133 @@
> +/* { dg-do run { target lp64 } } */
> +/* { dg-skip-if "" { powerpc*-*-darwin* } } */
> +/* { dg-options "-O2 -save-temps" } */
> +/* Functional test of the two operand vector builtins.  */
> +
> +#include <altivec.h>
> +#include <stdio.h>
> +#include <stdlib.h>
> +
> +#define DEBUG 0
> +
> +#define FLOAT_TEST(NAME)						    \
> +  void __attribute__ ((noipa))                                              \
> +  float_##NAME(vector float f_src_a, vector float f_src_b,		    \
> +	       vector float f_##NAME##_expected)			    \
> +  {									    \
> +    vector float f_result = vec_##NAME (f_src_a, f_src_b);		    \
> +                                                                            \
> +    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_TEST (add)
> +FLOAT_TEST (div)
> +FLOAT_TEST (max)
> +FLOAT_TEST (min)
> +FLOAT_TEST (mul)
> +FLOAT_TEST (sub)
> +
> +#define DOUBLE_TEST(NAME)						    \
> +  void __attribute__ ((noipa))                                              \
> +  double_##NAME(vector double d_src_a, vector double d_src_b,		    \
> +                vector double d_##NAME##_expected)                          \
> +  {									    \
> +    vector double d_result = vec_##NAME (d_src_a, d_src_b);		    \
> +                                                                            \
> +    if ((d_result[0] != d_##NAME##_expected[0])				    \
> +	|| (d_result[1] != d_##NAME##_expected[1]))			    \
> +      {									    \
> +	if (DEBUG)							    \
> +	  {								    \
> +	    printf("ERROR: vec_%s(double) expected value does not match\n", \
> +		   #NAME);						    \
> +	    printf("   expected[0] = %f; result[0] = %f\n",		    \
> +		   d_##NAME##_expected[0], d_result[0]);		    \
> +	    printf("   expected[1] = %f; result[1] = %f\n",		    \
> +		   d_##NAME##_expected[1], d_result[1]);		    \
> +	  }								    \
> +	else								    \
> +	  abort();							    \
> +      }									    \
> +  }
> +
> +DOUBLE_TEST (add)
> +DOUBLE_TEST (div)
> +DOUBLE_TEST (max)
> +DOUBLE_TEST (min)
> +DOUBLE_TEST (mul)
> +DOUBLE_TEST (sub)
> +
> +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, -4.0, 1.0, 4.0};
> +  vector float f_add_expected = { 128.0, 19.0, -337.0, 21.0};
> +  vector float f_div_expected = { 63.0, -5.75, -338, 4.25};
> +  vector float f_max_expected = { 126.0, 23.0, 1.0, 17.0};
> +  vector float f_min_expected = { 2.0, -4.0, -338.0, 4.0};
> +  vector float f_mul_expected = { 252, -92.0, -338, 68.0};
> +  vector float f_sub_expected = { 124.0, 27.0, -339.0, 13.0};
> +
> +  vector double d_src_a = { 125.44, -338.56};
> +  vector double d_src_b = { 4.0, -2.0};
> +  vector double d_add_expected = { 129.44, -340.56};
> +  vector double d_div_expected = { 31.360000, 169.280000};
> +  vector double d_max_expected = { 125.44, -2.0};
> +  vector double d_min_expected = { 4.0, -338.56};
> +  vector double d_mul_expected = { 501.760000, 677.120000};
> +  vector double d_sub_expected = { 121.440000, -336.560000};
> +
> +  /* Two argument float tests.  */
> +  float_add (f_src_a, f_src_b, f_add_expected);
> +  float_div (f_src_a, f_src_b, f_div_expected);
> +  float_max (f_src_a, f_src_b, f_max_expected);
> +  float_min (f_src_a, f_src_b, f_min_expected);
> +  float_mul (f_src_a, f_src_b, f_mul_expected);
> +  float_sub (f_src_a, f_src_b, f_sub_expected);
> +  
> +  /* Two argument double tests.  */
> +  double_add (d_src_a, d_src_b, d_add_expected);
> +  double_div (d_src_a, d_src_b, d_div_expected);
> +  double_max (d_src_a, d_src_b, d_max_expected);
> +  double_min (d_src_a, d_src_b, d_min_expected);
> +  double_mul (d_src_a, d_src_b, d_mul_expected);
> +  double_sub (d_src_a, d_src_b, d_sub_expected);
> +
> +  return 0;
> +}
> +
> +/* { dg-final { scan-assembler-times {\mxvaddsp\M} 1 } } */
> +/* { dg-final { scan-assembler-times {\mxvdivsp\M} 1 } } */
> +/* { dg-final { scan-assembler-times {\mxvmulsp\M} 1 } } */
> +/* { dg-final { scan-assembler-times {\mxvsubsp\M} 1 } } */
> +/* { dg-final { scan-assembler-times {\mxvadddp\M} 1 } } */
> +/* { dg-final { scan-assembler-times {\mxvdivdp\M} 1 } } */
> +/* { dg-final { scan-assembler-times {\mxvmindp\M} 1 } } */
> +/* { dg-final { scan-assembler-times {\mxvmuldp\M} 1 } } */
> +/* { dg-final { scan-assembler-times {\mxvsubdp\M} 1 } } */
> +/* { dg-final { scan-assembler-times {\mxvmaxsp\M} 1 } } */
> +/* { dg-final { scan-assembler-times {\mxvminsp\M} 1 } } */
> +/* { dg-final { scan-assembler-times {\mxvmaxdp\M} 1 } } */
> diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-3op.c b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-3op.c
> new file mode 100644
> index 00000000000..955d4cea4ef
> --- /dev/null
> +++ b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-3op.c
> @@ -0,0 +1,257 @@
> +/* { dg-do run { target lp64 } } */
> +/* { dg-skip-if "" { powerpc*-*-darwin* } } */
> +/* { dg-options "-O2 -save-temps" } */
> +
> +/* Functional test of the three operand vector builtins.  */
> +
> +#include <altivec.h>
> +#include <stdio.h>
> +#include <stdlib.h>
> +
> +#define DEBUG 0
> +
> +#define FLOAT_TEST(NAME)                                                    \
> +  void __attribute__ ((noipa))                                              \
> +  float_##NAME(vector float f_src_a, vector float f_src_b,                  \
> +	       vector float f_src_c, vector float f_##NAME##_expected)      \
> +  {									    \
> +    vector float f_result = vec_##NAME (f_src_a, f_src_b, f_src_c);	    \
> +                                                                            \
> +    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_TEST (madd)
> +FLOAT_TEST (msub)
> +
> +#define DOUBLE_TEST(NAME)                                                    \
> +  void __attribute__ ((noipa))                                               \
> +  double_##NAME(vector double d_src_a, vector double d_src_b,		     \
> +		vector double d_src_c, vector double d_##NAME##_expected)    \
> +  {                                                                          \
> +    vector double d_result = vec_##NAME (d_src_a, d_src_b, d_src_c);	     \
> +                                                                             \
> +    if ((d_result[0] != d_##NAME##_expected[0])				     \
> +        || (d_result[1] != d_##NAME##_expected[1]))			     \
> +      {									     \
> +        if (DEBUG)							     \
> +          {								     \
> +            printf("ERROR: vec_%s (double) expected value does not match\n", \
> +		   #NAME);						     \
> +            printf("   expected[0] = %f; result[0] = %f\n",		     \
> +		   d_##NAME##_expected[0], d_result[0]);		     \
> +            printf("   expected[1] = %f; result[1] = %f\n",		     \
> +		   d_##NAME##_expected[1], d_result[1]);		     \
> +	  }								     \
> +        else								     \
> +          abort();							     \
> +      }									     \
> +  }
> +
> +DOUBLE_TEST (madd)
> +DOUBLE_TEST (msub)
> +
> +void __attribute__ ((noipa))
> +short_tests (vector short ss_src_a, vector short ss_src_b, vector int si_src_c,
> +	     vector unsigned short us_src_a, vector unsigned short us_src_b,
> +	     vector unsigned int ui_src_c, vector int si_expected,
> +	     vector unsigned int ui_expected)
> +{
> +  /* These tests were put into a function to ensure the compiler doesn't try to
> +     compute the results at compile time.  */
> +  vector int si_result;
> +  vector unsigned int ui_result;
> +
> +  /* Vector multiply-sum saturated */
> +  ui_result = vec_msums (us_src_a, us_src_b, ui_src_c);
> +  if ((ui_result[0] != ui_expected[0])
> +      || (ui_result[1] != ui_expected[1])
> +      || (ui_result[2] != ui_expected[2])
> +      || (ui_result[3] != ui_expected[3]))
> +#if DEBUG
> +    {
> +      printf("ERROR: vec_msums (unsigned) expected value does not match\n");
> +      printf("   expected[0] = %d; result[0] = %d\n",
> +	     ui_expected[0], ui_result[0]);
> +      printf("   expected[1] = %d; result[1] = %d\n",
> +	     ui_expected[1], ui_result[1]);
> +      printf("   expected[2] = %d; result[2] = %d\n",
> +	     ui_expected[2], ui_result[2]);
> +      printf("   expected[3] = %d; result[3] = %d\n",
> +	     ui_expected[3], ui_result[3]);
> +    }
> +#else
> +  abort();
> +#endif
> +      
> +  si_result = vec_msums (ss_src_a, ss_src_b, si_src_c);
> +  if ((si_result[0] != si_expected[0])
> +      || (si_result[1] != si_expected[1])
> +      || (si_result[2] != si_expected[2])
> +      || (si_result[3] != si_expected[3]))
> +#if DEBUG
> +    {
> +      printf("ERROR: vec_msums (signed) expected value does not match\n");
> +      printf("   expected[0] = %d; result[0] = %d\n",
> +	     si_expected[0], si_result[0]);
> +      printf("   expected[1] = %d; result[1] = %d\n",
> +	     si_expected[1], si_result[1]);
> +      printf("   expected[2] = %d; result[2] = %d\n",
> +	     si_expected[2], si_result[2]);
> +      printf("   expected[3] = %d; result[3] = %d\n",
> +	     si_expected[3], si_result[3]);
> +    }
> +#else
> +  abort();
> +#endif
> +}
> +
> +void __attribute__ ((noipa))
> +vector_sel_test (vector double d_src_a, vector double d_src_b,
> +		 vector unsigned long long ull_src_c,
> +		 vector bool long long bll_src_c ,
> +		 vector double d_selectb_expected,
> +		 vector double d_selectu_expected)
> +{
> +  vector double d_result;
> +
> +  /* 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_sel (double, unsigned long long) expected value does not match\n");
> +      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_sel (double, bool long long) expected value does not match\n");
> +      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
> +}
> +
> +void __attribute__ ((noipa))
> +vector_permute_test (vector double d_src_a, vector double d_src_b,
> +		     vector unsigned char uc_src_c,
> +		     vector double d_perm_expected)
> +{
> +  vector double d_result;
> +
> +  /* 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_perm (double, unsigned char) expected value does not match\n");
> +      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
> +
> +}
> +
> +void abort (void);
> +
> +int
> +main () {
> +  int i;
> +
> +  vector unsigned char uc_src_c = {0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7,
> +				   0x8, 0x9, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF};
> +  vector short ss_src_a = { 1, 2, 3, 4, 5, 6, 7, 8};
> +  vector short ss_src_b = { -10, 20, 30, 40, 50, 60, 70, 80};
> +  vector int   si_src_c = { 13, -27, 39, 48};
> +  vector int   si_expected = {43, 223, 649, 1178};
> +  vector unsigned short us_src_a = { 31, 32, 33, 34, 1, 2, 3, 4};
> +  vector unsigned short us_src_b = { 11, 7, 30, 90, 39, 48, 28, 64};
> +  vector unsigned int   ui_src_c = { 13, 17, 39, 91};
> +
> +  vector unsigned int   ui_expected = {578, 4067, 174, 431};
> +  vector float f_src_a = { 126.0, 23.0, -338.0, 17.0};
> +  vector float f_src_b = { 2.0, -4.0, 1.0, 4.0};
> +  vector float f_src_c = { 6.0, -8.0, 7.0, 5.0};
> +  vector float f_madd_expected = {  258.0, -100.0, -331.0, 73.0};
> +  vector float f_msub_expected = { 246.0, -84.0, -345.0, 63.0};
> +
> +  vector unsigned long long ull_src_c = {0xFFFFFFFFFFFFFFFF,
> +					 0xFFFFFFFFFFFFFFFF};
> +  vector bool long long bll_src_c = {0, 0};
> +  vector double d_src_a = { 125.44, -338.56};
> +  vector double d_src_b = { 4.0, -2.0};
> +  vector double d_src_c = { 7.0, -3.0};
> +  vector double d_madd_expected = { 508.76, 674.12};
> +  vector double d_msub_expected = { 494.76, 680.12};
> +  vector double d_selectb_expected = { 125.44, -338.56};
> +  vector double d_selectu_expected = { 4.0, -2.0};
> +  vector double d_perm_expected = { 125.44, -338.56};
> +
> +
> +  /* Run tests.  */
> +  short_tests (ss_src_a, ss_src_b, si_src_c, us_src_a, us_src_b,
> +	       ui_src_c, si_expected, ui_expected);
> +
> +  float_madd (f_src_a, f_src_b, f_src_c, f_madd_expected);
> +  float_msub (f_src_a, f_src_b, f_src_c, f_msub_expected);
> +
> +  double_madd (d_src_a, d_src_b, d_src_c, d_madd_expected);
> +  double_msub (d_src_a, d_src_b, d_src_c, d_msub_expected);
> +  
> +  vector_sel_test (d_src_a, d_src_b, ull_src_c, bll_src_c, d_selectb_expected,
> +		   d_selectu_expected);
> +  vector_permute_test (d_src_a, d_src_b, uc_src_c, d_perm_expected);
> +
> +  return 0;
> +}
> +
> +/* { dg-final { scan-assembler-times {\mvmsumshs\M} 1 } } */
> +/* { dg-final { scan-assembler-times {\mvmsumuhs\M} 1 } } */
> +/* { dg-final { scan-assembler-times {\mxvmaddmsp\M} 1 } } */
> +/* { dg-final { scan-assembler-times {\mxvmaddmdp\M} 1 } } */
> +/* { dg-final { scan-assembler-times {\mxvmsubmsp\M} 1 } } */
> +/* { dg-final { scan-assembler-times {\mxvmsubmdp\M} 1 } } */
> +/* { dg-final { scan-assembler-times {\m(?:v|xx)permr?\M} 1 } } */
> +/* { dg-final { scan-assembler-times {\mxxsel\M} 2 } } */
> 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..def18304528
> --- /dev/null
> +++ b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-cmp-all.c
> @@ -0,0 +1,211 @@
> +/* { dg-do run { target lp64 } } */
> +/* { dg-skip-if "" { powerpc*-*-darwin* } } */
> +/* { dg-options "-O2 -save-temps" } */
> +
> +/* Functional test of the vector compare all builtins.  */
> +
> +#include <altivec.h>
> +#include <stdio.h>
> +#include <stdlib.h>
> +#include <stdbool.h>
> +
> +#define DEBUG 0
> +
> +#define FLOAT_1ARG_TEST(NAME)                                                  \
> +  void __attribute__ ((noipa))                                                 \
> +  float_1arg_##NAME (vector float f_src, bool f_##NAME##_expected)             \
> +  {                                                                            \
> +    bool f_result = vec_##NAME (f_src); 		                       \
> +                                                                               \
> +    if (f_result != f_##NAME##_expected)				       \
> +      {									       \
> +	if (DEBUG)							       \
> +	  {								       \
> +	    printf("ERROR: vec_%s (float) expected value does not match\n",    \
> +		   #NAME);						       \
> +	    printf("   expected = %d; result = %d\n",			       \
> +		   f_##NAME##_expected, f_result);			       \
> +	  }								       \
> +	else								       \
> +	  abort();							       \
> +      }									       \
> +  }
> +
> +FLOAT_1ARG_TEST (all_nan)
> +FLOAT_1ARG_TEST (all_numeric)
> +FLOAT_1ARG_TEST (any_nan)
> +FLOAT_1ARG_TEST (any_numeric)
> +
> +#define FLOAT_2ARG_TEST(NAME)						      \
> +  void __attribute__ ((noipa))                                                \
> +  float_2arg_##NAME (vector float f_src_a, vector float f_src_b,              \
> +		     bool f_##NAME##_expected)				      \
> +  {                                                                           \
> +    bool f_result = vec_##NAME (f_src_a, f_src_b);			      \
> +                                                                              \
> +    if (f_result != f_##NAME##_expected)				      \
> +      {									      \
> +	if (DEBUG)							      \
> +	  {								      \
> +	    printf("ERROR: vec_%s (float, float) expected value does not match\n", \
> +		   #NAME);						      \
> +	    printf("   expected = %d; result = %d\n",			      \
> +		   f_##NAME##_expected, f_result);			      \
> +	  }								      \
> +	else								      \
> +	  abort();							      \
> +      }									     \
> +  }
> +		 
> +FLOAT_2ARG_TEST (all_eq)
> +FLOAT_2ARG_TEST (all_gt)
> +FLOAT_2ARG_TEST (all_ge)
> +FLOAT_2ARG_TEST (all_lt)
> +FLOAT_2ARG_TEST (all_le)
> +FLOAT_2ARG_TEST (any_eq)
> +FLOAT_2ARG_TEST (any_gt)
> +FLOAT_2ARG_TEST (any_ge)
> +FLOAT_2ARG_TEST (any_lt)
> +FLOAT_2ARG_TEST (any_le)
> +
> +#define DOUBLE_1ARG_TEST(NAME )						      \
> +  void __attribute__ ((noipa))                                                \
> +  double_1arg_##NAME (vector double d_src, bool d_##NAME##_expected)	      \
> +  {                                                                           \
> +    bool d_result = vec_##NAME (d_src);                                       \
> +                                                                              \
> +  if (d_result != d_##NAME##_expected)                                        \
> +    {                                                                         \
> +      if (DEBUG)                                                              \
> +	{                                                                     \
> +	  printf("ERROR: vec_%s (double) expected value does not match\n",    \
> +		 #NAME);                                                      \
> +	  printf("   expected = %d; result = %d\n",                           \
> +		 d_##NAME##_expected, d_result);                              \
> +	}                                                                     \
> +      else                                                                    \
> +	abort();                                                              \
> +    }									      \
> +  }
> +
> +DOUBLE_1ARG_TEST (all_nan)
> +DOUBLE_1ARG_TEST (all_numeric)
> +DOUBLE_1ARG_TEST (any_nan)
> +DOUBLE_1ARG_TEST (any_numeric)
> +
> +#define DOUBLE_2ARG_TEST(NAME)						      \
> +  void __attribute__ ((noipa))                                                \
> +  double_2arg_##NAME (vector double d_src_a, vector double d_src_b,           \
> +		      bool d_##NAME##_expected)	                              \
> +  {                                                                           \
> +    bool d_result = vec_##NAME (d_src_a, d_src_b);	                      \
> +                                                                              \
> +    if (d_result != d_##NAME##_expected)				      \
> +      {									      \
> +	if (DEBUG)							      \
> +	  {								      \
> +	    printf("ERROR: vec_%s (double, double) expected value does not match\n", \
> +		   #NAME);						      \
> +	    printf("   expected = %d; result = %d\n",			      \
> +		   d_##NAME##_expected, d_result);			      \
> +	  }								      \
> +	else								      \
> +	  abort();							      \
> +	}                                                                     \
> +    }
> +
> +DOUBLE_2ARG_TEST (all_eq)
> +DOUBLE_2ARG_TEST (all_gt)
> +DOUBLE_2ARG_TEST (all_ge)
> +DOUBLE_2ARG_TEST (all_lt)
> +DOUBLE_2ARG_TEST (all_le)
> +DOUBLE_2ARG_TEST (any_eq)
> +DOUBLE_2ARG_TEST (any_gt)
> +DOUBLE_2ARG_TEST (any_ge)
> +DOUBLE_2ARG_TEST (any_lt)
> +DOUBLE_2ARG_TEST (any_le)
> +
> +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_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;
> +
> +  /* Run tests.  */
> +  float_1arg_all_nan (f_src_a, f_all_nan_expected);
> +  float_1arg_all_numeric (f_src_a, f_all_numeric_expected);
> +  float_1arg_any_nan (f_src_a, f_any_nan_expected);
> +  float_1arg_any_numeric (f_src_a, f_any_numeric_expected);
> +
> +  float_2arg_all_eq (f_src_a, f_src_b, f_all_eq_expected);
> +  float_2arg_all_gt (f_src_a, f_src_b, f_all_gt_expected);
> +  float_2arg_all_ge (f_src_a, f_src_b, f_all_ge_expected);
> +  float_2arg_all_lt (f_src_a, f_src_b, f_all_lt_expected);
> +  float_2arg_all_le (f_src_a, f_src_b, f_all_le_expected);
> +  float_2arg_any_eq (f_src_a, f_src_b, f_any_eq_expected);
> +  float_2arg_any_gt (f_src_a, f_src_b, f_any_gt_expected);
> +  float_2arg_any_ge (f_src_a, f_src_b, f_any_ge_expected);
> +  float_2arg_any_lt (f_src_a, f_src_b, f_any_lt_expected);
> +  float_2arg_any_le (f_src_a, f_src_b, f_any_le_expected);
> +
> +  double_1arg_all_nan (d_src_a, d_all_nan_expected);
> +  double_1arg_all_numeric (d_src_a, d_all_numeric_expected);
> +  double_1arg_any_nan (d_src_a, d_any_nan_expected);
> +  double_1arg_any_numeric (d_src_a, d_any_numeric_expected);
> +
> +  double_2arg_all_eq (d_src_a, d_src_b, d_all_eq_expected);
> +  double_2arg_all_gt (d_src_a, d_src_b, d_all_gt_expected);
> +  double_2arg_all_ge (d_src_a, d_src_b, d_all_ge_expected);
> +  double_2arg_all_lt (d_src_a, d_src_b, d_all_lt_expected);
> +  double_2arg_all_le (d_src_a, d_src_b, d_all_le_expected);
> +  double_2arg_any_eq (d_src_a, d_src_b, d_any_eq_expected);
> +  double_2arg_any_gt (d_src_a, d_src_b, d_any_gt_expected);
> +  double_2arg_any_ge (d_src_a, d_src_b, d_any_ge_expected);
> +  double_2arg_any_lt (d_src_a, d_src_b, d_any_lt_expected);
> +  double_2arg_any_le (d_src_a, d_src_b, d_any_le_expected);
> +
> +  return 0;
> +}
> +
> +/* { dg-final { scan-assembler-times {\mxvcmpeqsp\M} 6 } } */
> +/* { dg-final { scan-assembler-times {\mxvcmpgtsp\M} 4 } } */
> +/* { dg-final { scan-assembler-times {\mxvcmpgesp\M} 4 } } */
> +/* { dg-final { scan-assembler-times {\mxvcmpeqdp\M} 6 } } */
> +/* { dg-final { scan-assembler-times {\mxvcmpgedp\M} 4 } } */
> +/* { dg-final { scan-assembler-times {\mxvcmpgtdp\M} 4 } } */
> +
> +
> diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-cmp.c b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-cmp.c
> new file mode 100644
> index 00000000000..80439c23995
> --- /dev/null
> +++ b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-cmp.c
> @@ -0,0 +1,121 @@
> +/* { dg-do run { target lp64 } } */
> +/* { dg-skip-if "" { powerpc*-*-darwin* } } */
> +/* { dg-options "-O2 -save-temps" } */
> +
> +/* Functional test of the vector compare builtins.  */
> +
> +#include <altivec.h>
> +#include <stdio.h>
> +#include <stdlib.h>
> +
> +#define DEBUG 0
> +
> +#define FLOAT_TEST(NAME)                                                    \
> +  void __attribute__ ((noipa))                                              \
> +  float_##NAME (vector float f_src_a, vector float f_src_b, 	            \
> +		vector bool int f_##NAME##_expected)			    \
> +  {                                                                         \
> +    vector bool int f_result = vec_##NAME (f_src_a, f_src_b);		    \
> +                                                                            \
> +    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] = 0x%x; result[0] =0x%x\n",		    \
> +		   f_##NAME##_expected[0], f_result[0]);		    \
> +	    printf("   expected[1] = 0x%x; result[1] = 0x%x\n",		    \
> +		   f_##NAME##_expected[1], f_result[1]);		    \
> +	    printf("   expected[2] = 0x%x; result[2] = 0x%x\n",		    \
> +		   f_##NAME##_expected[2], f_result[2]);		    \
> +	    printf("   expected[3] = 0x%x; result[3] = 0x%x\n",		    \
> +		   f_##NAME##_expected[3], f_result[3]);		    \
> +	  }								    \
> +	else								    \
> +	  abort();							    \
> +      }                                                                     \
> +  }
> +
> +FLOAT_TEST (cmpeq)
> +FLOAT_TEST (cmpgt)
> +FLOAT_TEST (cmpge)
> +FLOAT_TEST (cmplt)
> +FLOAT_TEST (cmple)
> +
> +#define DOUBLE_TEST(NAME)                                                    \
> +  void __attribute__ ((noipa))                                               \
> +  double_##NAME (vector double d_src_a, vector double d_src_b,               \
> +		 vector bool long long d_##NAME##_expected)       	     \
> +  {								             \
> +    vector bool long long d_result = vec_##NAME (d_src_a, d_src_b);          \
> +                                                                             \
> +    if ((d_result[0] != d_##NAME##_expected[0])				     \
> +	|| (d_result[1] != d_##NAME##_expected[1]))			     \
> +      {									     \
> +	if (DEBUG)							     \
> +	  {								     \
> +	    printf("ERROR: vec_%s (double) expected value does not match\n", \
> +		   #NAME);						     \
> +	    printf("   expected[0] = 0x%lx; result[0] = 0x%lx\n",	     \
> +		   d_##NAME##_expected[0], d_result[0]);		     \
> +	    printf("   expected[1] = 0x%lx; result[1] = 0x%lx\n",	     \
> +		   d_##NAME##_expected[1], d_result[1]);		     \
> +	  }								     \
> +	else								     \
> +	  abort();							     \
> +	}                                                                    \
> +    }
> +
> +DOUBLE_TEST (cmpeq)
> +DOUBLE_TEST (cmpgt)
> +DOUBLE_TEST (cmpge)
> +DOUBLE_TEST (cmplt)
> +DOUBLE_TEST (cmple)
> +
> +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};
> +  vector bool int f_cmpeq_expected = {0x0, 0xFFFFFFFF, 0x0, 0x0};
> +  vector bool int f_cmpgt_expected = {0xFFFFFFFF, 0x0, 0x0, 0xFFFFFFFF};
> +  vector bool int f_cmpge_expected = {0xFFFFFFFF, 0xFFFFFFFF, 0x0, 0xFFFFFFFF};
> +  vector bool int f_cmplt_expected = {0x0, 0x0, 0xFFFFFFFF, 0x0}; 
> +  vector bool int f_cmple_expected = {0x0, 0xFFFFFFFF, 0xFFFFFFFF, 0x0}; 
> +
> +  vector double d_src_a = { 125.44, -338.56};
> +  vector double d_src_b = { 4.0, -338.56};
> +  vector bool long long d_cmpeq_expected = {0x0, 0xFFFFFFFFFFFFFFFF};
> +  vector bool long long d_cmpgt_expected = {0xFFFFFFFFFFFFFFFF, 0x0};
> +  vector bool long long d_cmpge_expected = {0xFFFFFFFFFFFFFFFF,
> +					    0xFFFFFFFFFFFFFFFF};
> +  vector bool long long d_cmplt_expected = {0x0, 0x0};
> +  vector bool long long d_cmple_expected = {0x0, 0xFFFFFFFFFFFFFFFF};
> +
> +  float_cmpeq (f_src_a, f_src_b, f_cmpeq_expected);
> +  float_cmpgt (f_src_a, f_src_b, f_cmpgt_expected);
> +  float_cmpge (f_src_a, f_src_b, f_cmpge_expected);
> +  float_cmplt (f_src_a, f_src_b, f_cmplt_expected);
> +  float_cmple (f_src_a, f_src_b, f_cmple_expected);
> + 
> +  double_cmpeq (d_src_a, d_src_b, d_cmpeq_expected);
> +  double_cmpgt (d_src_a, d_src_b, d_cmpgt_expected);
> +  double_cmpge (d_src_a, d_src_b, d_cmpge_expected);
> +  double_cmplt (d_src_a, d_src_b, d_cmplt_expected);
> +  double_cmple (d_src_a, d_src_b, d_cmple_expected);
> +  return 0;
> +}
> +
> +/* { dg-final { scan-assembler-times {\mxvcmpeqsp\M} 1 } } */
> +/* { dg-final { scan-assembler-times {\mxvcmpgtsp\M} 2 } } */
> +/* { dg-final { scan-assembler-times {\mxvcmpgesp\M} 2 } } */
> +/* { dg-final { scan-assembler-times {\mxvcmpeqdp\M} 1 } } */
> +/* { dg-final { scan-assembler-times {\mxvcmpgedp\M} 2 } } */
> +/* { dg-final { scan-assembler-times {\mxvcmpgtdp\M} 2 } } */
> diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-vector-6.h b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6.h
> deleted file mode 100644
> index 0106e8d2901..00000000000
> --- a/gcc/testsuite/gcc.target/powerpc/vsx-vector-6.h
> +++ /dev/null
> @@ -1,154 +0,0 @@
> -/* This test code is included into vsx-vector-6.p7.c, vsx-vector-6.p8.c
> -   and vsx-vector-6.p9.c.  The .c files have the tests for the number
> -   of instructions generated for each cpu type.  */
> -
> -#include <altivec.h>
> -
> -typedef struct {
> -  vector double d;
> -  vector float f;
> -  vector long sl;
> -  vector int si;
> -  vector short ss;
> -  vector char sc;
> -  vector unsigned int ui;
> -  vector unsigned short int us;
> -  vector unsigned char uc;
> -  vector bool long long bll;
> -  vector bool long bl;
> -  vector bool int bi;
> -  vector bool short bs;
> -  vector bool char bc;
> -} opnd_t;
> -
> -void
> -func_1op (opnd_t *dst, opnd_t *src)
> -{
> -  dst[0].d = vec_abs (src[0].d);
> -  dst[1].d = vec_ceil (src[1].d);
> -  dst[2].d = vec_floor (src[2].d);
> -  dst[3].d = vec_nearbyint (src[3].d);
> -  dst[4].d = vec_rint (src[4].d);
> -  dst[5].d = vec_sqrt (src[5].d);
> -  dst[6].d = vec_trunc (src[6].d);
> -  dst[7].f = vec_trunc (src[7].f);
> -}
> -
> -void
> -func_2op (opnd_t *dst, opnd_t *src0, opnd_t *src1)
> -{
> -  dst[0].d = vec_add (src0[0].d, src1[0].d);
> -  dst[1].d = vec_div (src0[1].d, src1[1].d);
> -  dst[2].d = vec_max (src0[2].d, src1[2].d);
> -  dst[3].uc = vec_max (src0[3].uc, src1[3].uc);
> -  dst[4].d = vec_min (src0[4].d, src1[4].d);
> -  dst[5].d = vec_mul (src0[5].d, src1[5].d);
> -  dst[6].d = vec_sub (src0[6].d, src1[6].d);
> -}
> -
> -void
> -func_2lop (opnd_t *dst, opnd_t *src0, opnd_t *src1)
> -{
> -  dst[0].d = vec_and (src0[0].d, src1[0].d);
> -  dst[1].d = vec_and (src0[1].d, src1[1].bl);
> -  dst[2].d = vec_and (src0[2].bl, src1[2].d);
> -
> -  dst[3].d = vec_andc (src0[3].d, src1[3].d);
> -  dst[4].d = vec_andc (src0[4].d, src1[4].bl);
> -  dst[5].d = vec_andc (src0[5].bl, src1[5].d);
> -  dst[6].d = vec_andc (src0[6].bll, src1[6].d);
> -  dst[7].d = vec_andc (src0[7].d, src1[7].bll);
> -  dst[8].bi = vec_andc (src0[8].bi, src1[8].bi);
> -  dst[9].bs = vec_andc (src0[9].bs, src1[9].bs);
> -  dst[10].bc = vec_andc (src0[10].bc, src1[10].bc);
> -  dst[11].f = vec_andc (src0[11].f, src1[11].f);
> -  dst[12].f = vec_andc (src0[12].bi, src1[12].f);
> -  dst[13].f = vec_andc (src0[13].f, src1[13].bi);
> -  dst[14].d = vec_andc (src0[14].bll, src1[14].d);
> -  dst[15].d = vec_andc (src0[15].d, src1[15].bll);
> -
> -  dst[16].d = vec_nor (src0[16].d, src1[16].d);
> -  dst[17].f = vec_nor (src0[17].f, src1[17].f);
> -  dst[18].bi = vec_nor (src0[18].bi, src1[18].bi);
> -  dst[19].bs = vec_nor (src0[19].bs, src1[19].bs);
> -  dst[20].bc = vec_nor (src0[20].bc, src1[20].bc);
> -
> -  dst[21].d = vec_or (src0[21].d, src1[21].d);
> -  dst[22].d = vec_or (src0[22].d, src1[22].bl);
> -  dst[23].d = vec_or (src0[23].bl, src1[23].d);
> -  dst[24].d = vec_or (src0[24].bll, src1[24].d);
> -  dst[25].d = vec_or (src0[25].d, src1[25].bll);
> -  dst[26].f = vec_or (src0[26].f, src1[26].f);
> -  dst[27].bi = vec_or (src0[27].bi, src1[27].bi);
> -  dst[28].bs = vec_or (src0[28].bs, src1[28].bs);
> -  dst[29].bc = vec_or (src0[29].bc, src1[29].bc);
> -
> -  dst[30].d = vec_xor (src0[30].d, src1[30].d);
> -  dst[31].d = vec_xor (src0[31].d, src1[31].bl);
> -  dst[32].d = vec_xor (src0[32].bl, src1[32].d);
> -}
> -
> -void
> -func_cmp (opnd_t *dst, opnd_t *src0, opnd_t *src1)
> -{
> -  dst[0].bl = vec_cmpeq (src0[0].d, src1[0].d);
> -  dst[1].bl = vec_cmpgt (src0[1].d, src1[1].d);
> -  dst[2].bl = vec_cmpge (src0[2].d, src1[2].d);
> -  dst[3].bl = vec_cmplt (src0[3].d, src1[3].d);
> -  dst[4].bl = vec_cmple (src0[4].d, src1[4].d);
> -}
> -
> -void
> -func_all_cmp (int *dst, opnd_t *src0, opnd_t *src1)
> -{
> -  dst[0] = vec_all_eq (src0[0].d, src1[0].d);
> -  dst[1] = vec_all_ge (src0[1].d, src1[1].d);
> -  dst[2] = vec_all_gt (src0[2].d, src1[2].d);
> -  dst[3] = vec_all_le (src0[3].d, src1[3].d);
> -  dst[4] = vec_all_lt (src0[4].d, src1[4].d);
> -  dst[5] = vec_all_nan (src0[5].d);
> -  dst[6] = vec_all_ne (src0[6].d, src1[6].d);
> -  dst[7] = vec_all_nge (src0[7].d, src1[7].d);
> -  dst[8] = vec_all_ngt (src0[8].d, src1[8].d);
> -  dst[9] = vec_all_nle (src0[9].d, src1[9].d);
> -  dst[10] = vec_all_nlt (src0[10].d, src1[10].d);
> -  dst[11] = vec_all_numeric (src0[11].d);
> -  dst[12] = vec_any_eq (src0[12].d, src1[12].d);
> -  dst[13] = vec_any_ge (src0[13].d, src1[13].d);
> -  dst[14] = vec_any_gt (src0[14].d, src1[14].d);
> -  dst[15] = vec_any_le (src0[15].d, src1[15].d);
> -  dst[16] = vec_any_lt (src0[16].d, src1[16].d);
> -  dst[17] = vec_any_nan (src0[17].d);
> -  dst[18] = vec_any_ne (src0[18].d, src1[18].d);
> -  dst[19] = vec_any_nge (src0[19].d, src1[19].d);
> -  dst[20] = vec_any_ngt (src0[20].d, src1[20].d);
> -  dst[21] = vec_any_nle (src0[21].d, src1[21].d);
> -  dst[22] = vec_any_nlt (src0[22].d, src1[22].d);
> -  dst[23] = vec_any_numeric (src0[23].d);
> -}
> -
> -void
> -func_3op (opnd_t *dst, opnd_t *src0, opnd_t *src1, opnd_t *src2)
> -{
> -  dst[0].d = vec_madd (src0[0].d, src1[0].d, src2[0].d);
> -  dst[1].d = vec_msub (src0[1].d, src1[1].d, src2[1].d);
> -  dst[2].d = vec_nmadd (src0[2].d, src1[2].d, src2[2].d);
> -  dst[3].d = vec_nmsub (src0[3].d, src1[3].d, src2[3].d);
> -
> -  dst[4].f = vec_madd (src0[4].f, src1[4].f, src2[4].f);
> -  dst[5].f = vec_msub (src0[5].f, src1[5].f, src2[5].f);
> -  dst[6].f = vec_nmsub (src0[6].f, src1[6].f, src2[6].f);
> -  dst[7].f = vec_nmadd (src0[7].f, src1[7].f, src2[7].f);
> -
> -#if defined (__BIG_ENDIAN__) || defined (_ARCH_PWR9)
> -  dst[8].d = vec_perm (src0[8].d, src1[8].d, src2[8].uc);
> -#else
> -  dst[8].d = vec_perm (src0[8].d, src1[8].d, ~src2[8].uc);
> -#endif
> -
> -  dst[9].d = vec_sel (src0[9].d, src1[9].d, src2[9].d);
> -  dst[10].d = vec_sel (src0[10].d, src1[10].d, src2[10].bl);
> -
> -  dst[11].si = vec_msums(src0[11].ss, src1[11].ss, src2[11].si);
> -  dst[12].ui = vec_msums(src0[12].us, src1[12].us, src2[12].ui);
> -}
> diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-vector-6.p7.c b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6.p7.c
> deleted file mode 100644
> index ff560dd8d4f..00000000000
> --- a/gcc/testsuite/gcc.target/powerpc/vsx-vector-6.p7.c
> +++ /dev/null
> @@ -1,43 +0,0 @@
> -/* { dg-do compile { target lp64 } } */
> -/* { dg-skip-if "" { powerpc*-*-darwin* } } */
> -/* { dg-require-effective-target powerpc_vsx_ok } */
> -/* { dg-options "-O2 -mdejagnu-cpu=power7" } */
> -
> -/* Source code for the test in vsx-vector-6.h */
> -#include "vsx-vector-6.h"
> -
> -/* { dg-final { scan-assembler-times {\mvmaxub\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mvmsumshs\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mvmsumuhs\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mvperm\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvabsdp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvadddp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvcmpeqdp\M} 9 } } */
> -/* { dg-final { scan-assembler-times {\mxvcmpgedp\M} 10 } } */
> -/* { dg-final { scan-assembler-times {\mxvcmpgtdp\M} 10 } } */
> -/* { dg-final { scan-assembler-times {\mxvdivdp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvmadd[am]dp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvmadd[am]sp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvmaxdp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvmindp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvmsub[am]dp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvmsub[am]sp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvmuldp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvnmadd[am]dp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvnmadd[am]sp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvnmsub[am]dp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvnmsub[am]sp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvrdpi\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvrdpic\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvrdpim\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvrdpip\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvrdpiz\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvrspiz\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvsqrtdp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvsubdp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxxland\M} 3 } } */
> -/* { dg-final { scan-assembler-times {\mxxlandc\M} 13 } } */
> -/* { dg-final { scan-assembler-times {\mxxlnor\M} 5 } } */
> -/* { dg-final { scan-assembler-times {\mxxlor\M} 9 } } */
> -/* { dg-final { scan-assembler-times {\mxxlxor\M} 3 } } */
> -/* { dg-final { scan-assembler-times {\mxxsel\M} 2 } } */
> diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-vector-6.p8.c b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6.p8.c
> deleted file mode 100644
> index 49f5bf52af5..00000000000
> --- a/gcc/testsuite/gcc.target/powerpc/vsx-vector-6.p8.c
> +++ /dev/null
> @@ -1,43 +0,0 @@
> -/* { dg-do compile { target lp64 } } */
> -/* { dg-skip-if "" { powerpc*-*-darwin* } } */
> -/* { dg-require-effective-target powerpc_p8vector_ok } */
> -/* { dg-options "-O2 -mdejagnu-cpu=power8" } */
> -
> -/* Source code for the test in vsx-vector-6.h */
> -#include "vsx-vector-6.h"
> -
> -/* { dg-final { scan-assembler-times {\mvmaxub\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mvmsumshs\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mvmsumuhs\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mvperm\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvabsdp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvadddp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvcmpeqdp\M} 9 } } */
> -/* { dg-final { scan-assembler-times {\mxvcmpgedp\M} 10 } } */
> -/* { dg-final { scan-assembler-times {\mxvcmpgtdp\M} 10 } } */
> -/* { dg-final { scan-assembler-times {\mxvdivdp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvmadd[am]dp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvmadd[am]sp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvmaxdp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvmindp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvmsub[am]dp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvmsub[am]sp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvmuldp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvnmadd[am]dp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvnmadd[am]sp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvnmsub[am]dp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvnmsub[am]sp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvrdpi\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvrdpic\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvrdpim\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvrdpip\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvrdpiz\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvrspiz\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvsqrtdp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvsubdp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxxland\M} 3 } } */
> -/* { dg-final { scan-assembler-times {\mxxlandc\M} 13 } } */
> -/* { dg-final { scan-assembler-times {\mxxlnor\M} 5 } } */
> -/* { dg-final { scan-assembler-times {\mxxlor\M} 9 } } */
> -/* { dg-final { scan-assembler-times {\mxxlxor\M} 3 } } */
> -/* { dg-final { scan-assembler-times {\mxxsel\M} 2 } } */
> diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-vector-6.p9.c b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6.p9.c
> deleted file mode 100644
> index 3fdd9f62a4c..00000000000
> --- a/gcc/testsuite/gcc.target/powerpc/vsx-vector-6.p9.c
> +++ /dev/null
> @@ -1,42 +0,0 @@
> -/* { dg-do compile { target lp64 } } */
> -/* { dg-skip-if "" { powerpc*-*-darwin* } } */
> -/* { dg-require-effective-target powerpc_p9vector_ok } */
> -/* { dg-options "-O2 -mdejagnu-cpu=power9" } */
> -
> -/* Source code for the test in vsx-vector-6.h */
> -#include "vsx-vector-6.h"
> -
> -/* { dg-final { scan-assembler-times {\mvmaxub\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mvmsumshs\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mvmsumuhs\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\m(?:v|xx)permr?\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvabsdp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvadddp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvcmpeqdp\M} 9 } } */
> -/* { dg-final { scan-assembler-times {\mxvcmpgedp\M} 10 } } */
> -/* { dg-final { scan-assembler-times {\mxvcmpgtdp\M} 10 } } */
> -/* { dg-final { scan-assembler-times {\mxvdivdp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvmadd[am]dp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvmadd[am]sp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvmaxdp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvmindp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvmsub[am]sp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvmuldp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvnmadd[am]dp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvnmadd[am]sp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvnmsub[am]dp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvnmsub[am]sp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvrdpi\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvrdpic\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvrdpim\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvrdpip\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvrdpiz\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvrspiz\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvsqrtdp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxvmsub[am]dp\M} 1 } } */
> -/* { dg-final { scan-assembler-times {\mxxland\M} 3 } } */
> -/* { dg-final { scan-assembler-times {\mxxlandc\M} 13 } } */
> -/* { dg-final { scan-assembler-times {\mxxlnor\M} 5 } } */
> -/* { dg-final { scan-assembler-times {\mxxlor\M} 9 } } */
> -/* { dg-final { scan-assembler-times {\mxxlxor\M} 3 } } */
> -/* { dg-final { scan-assembler-times {\mxxsel\M} 2 } } */
  

Kewen:

On Tue, 2023-07-04 at 10:49 +0800, Kewen.Lin wrote:
> 

<snip>

> > 
> > The tests are broken up into a seriers of files for related
> > tests.  The
> 
> s/seriers/series/

Fixed

> 
> > new tests are runnable tests to verify the builtin argument types
> > and the
> > functional correctness of each test rather then verifying the type
> > and
> > number of instructions generated.
> > 
> > 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.
> 
> Missing "func-" in the names ...

Fixed.

> 
> > 	* 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.
> 
> should be vsx-vector-6-p{7,8,9}.c, "git gcc-verify" should catch
> these.

Fixed, ran git gcc-verify which found a couple more little file name
typos.
> 
> > ---
> >  .../powerpc/vsx-vector-6-func-1op.c           | 141 ++++++++++
> >  .../powerpc/vsx-vector-6-func-2lop.c          | 217
> > +++++++++++++++
> >  .../powerpc/vsx-vector-6-func-2op.c           | 133 +++++++++
> >  .../powerpc/vsx-vector-6-func-3op.c           | 257
> > ++++++++++++++++++
> >  .../powerpc/vsx-vector-6-func-cmp-all.c       | 211 ++++++++++++++
> >  .../powerpc/vsx-vector-6-func-cmp.c           | 121 +++++++++
> >  .../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, 1080 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..52c7ae3e983
> > --- /dev/null
> > +++ b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-1op.c
> > @@ -0,0 +1,141 @@
> > +/* { dg-do run { target lp64 } } */
> > +/* { dg-skip-if "" { powerpc*-*-darwin* } } */
> > +/* { dg-options "-O2 -save-temps" } */
> 
> I just noticed that we missed an effective target check here to
> ensure the
> support of those bifs during the test run, and since it's a runnable
> test
> case, also need to ensure the generated hw insn supported, it's
> "vsx_hw"
> like:
> 
> /* { dg-require-effective-target vsx_hw } */
> 
> And adding "-mvsx" to the dg-options.

Add the effective-target and -mvsx to all of the tests.

> 
> This is also applied for the other test cases.
> 
> But as the discussion on xxlor and the different effective target
> requirements
> on compilation part and run part, I think we can separate each of
> these cases into
> two files, one for compilation and the other for run, for example,
> for this
> case, update FLOAT_TEST by adding one more global variable like
> 
> #define FLOAT_TEST(NAME)
>   vector float f_##NAME##_result; \
>   void ... \
>   f_##NAME##_result = vec_##NAME(f_src);\
>   }
>   // moving the checking code to its main.
> 
> move #include <altivec.h>, FLOAT_TEST(NAME), DOUBLE_TEST(NAME)
> defines
> and their uses into vsx-vector-6-func-1op.h.
> 
> 
> **For compilation file vsx-vector-6-func-1op.c**:
> 
> Include this header file into vsx-vector-6-func-1op.c, which has the
> 
> /* { dg-do compile { target lp64 } } */
> /* { dg-require-effective-target powerpc_vsx_ok } */
> /* { dg-options "-O2 -mvsx" } */
> 
> #include "vsx-vector-6-func-1op.h"
> 
> Then put the expected insn check here, like 
> 
> /* { dg-final { scan-assembler-times {\mxvabssp\M} 1 } } */
> ...
> 
> By organizing it like this, these scan-assembler-times would only
> focus on what
> are generated for bifs (excluding possible noises from main function
> for running).
> 
> 
> **For runnable file vsx-vector-6-func-1op-run.c**:
> 
> /* { dg-do compile { target lp64 } } */
> /* { dg-require-effective-target vsx_hw } */
> /* { dg-options "-O2 -mvsx" } */
> 
> #include "vsx-vector-6-func-1op.h"
> 
> We can add a new macro to invoke {FLOAT,DOUBLE}_TEST, further check
> the
> {d,f}_##NAME##_result and {d,f}_##NAME##_expected, and use it in
> main.
> 
> This test case can only focus on runtime result checking.

So redid the tests creating the compile and run tests as requested.  I
moved the common stuff, functions to call builtins, include files etc.
in the .h files.  The compile test has the instruction count checks
with the functions that call the builtins included into them.  The run
test has the function calls included in them and then uses macros to
generate the code to check the results.  I did look thru the assembly
code to see that the generated code is actually doing the calls to the
builtins to calculate the results and not being statically computed at
compile time.  I work on a previous version of the patch, I noticed
precomputing of the results by the compiler seemed to happen on some of
the simpler tests like add and subtract when the data setup and
computations were all in the main program.
              
                       Carl 


> 
> 
> BR,
> Kewen
> 
> > 
<snip>