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
+
+  /* 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
+
+
+  /* ABS, double */
+  d_result = vec_abs (d_src);
+
+  if ((d_result[0] != d_abs_expected[0]) || (d_result[1] != d_abs_expected[1]))
+#if DEBUG
+    {
+      printf("ERROR: vec_abs (double) expected value does not match\n");
+      printf("   expected[0] = %f; result[0] = %f\n",
+	     d_abs_expected[0], d_result[0]);
+      printf("   expected[1] = %f; result[1] = %f\n",
+	     d_abs_expected[1], d_result[1]);
+    }
+#else
+  abort();
+#endif
+
+  /* CEIL, double */
+  d_result = vec_ceil (d_src);
+
+  if ((d_result[0] != d_ceil_expected[0])
+      || (d_result[1] != d_ceil_expected[1]))
+#if DEBUG
+    {
+      printf("ERROR: vec_ceil (double) expected value does not match\n");
+      printf("   expected[0] = %f; result[0] = %f\n",
+	     d_ceil_expected[0], d_result[0]);
+      printf("   expected[1] = %f; result[1] = %f\n",
+	     d_ceil_expected[1], d_result[1]);
+    }
+#else
+  abort();
+#endif
+
+  /* Floor, double */
+  d_result = vec_floor (d_src);
+
+  if ((d_result[0] != d_floor_expected[0])
+      || (d_result[1] != d_floor_expected[1]))
+#if DEBUG
+    {
+      printf("ERROR: vec_floor (double) expected value does not match\n");
+      printf("   expected[0] = %f; result[0] = %f\n",
+	     d_floor_expected[0], d_result[0]);
+      printf("   expected[1] = %f; result[1] = %f\n",
+	     d_floor_expected[1], d_result[1]);
+    }
+#else
+  abort();
+#endif
+
+  /* Nearby int, double */
+  d_result = vec_nearbyint (d_src);
+
+  if ((d_result[0] != d_nearbyint_expected[0])
+      || (d_result[1] != d_nearbyint_expected[1]))
+#if DEBUG
+    {
+      printf("ERROR: vec_nearbyint (double) expected value does not match\n");
+      printf("   expected[0] = %f; result[0] = %f\n",
+	     d_nearbyint_expected[0], d_result[0]);
+      printf("   expected[1] = %f; result[1] = %f\n",
+	     d_nearbyint_expected[1], d_result[1]);
+    }
+#else
+  abort();
+#endif
+
+  /* Round int, double */
+  d_result = vec_rint (d_src);
+
+  if ((d_result[0] != d_rint_expected[0])
+      || (d_result[1] != d_rint_expected[1]))
+#if DEBUG
+    {
+      printf("ERROR: vec_rint (double) expected value does not match\n");
+      printf("   expected[0] = %f; result[0] = %f\n",
+	     d_rint_expected[0], d_result[0]);
+      printf("   expected[1] = %f; result[1] = %f\n",
+	     d_rint_expected[1], d_result[1]);
+    }
+#else
+  abort();
+#endif
+
+  /* Square root, double */
+  d_result = vec_sqrt (vec_abs(d_src));
+
+  if ((d_result[0] != d_sqrt_expected[0])
+      || (d_result[1] != d_sqrt_expected[1]))
+#if DEBUG
+    {
+      printf("ERROR: vec_sqrt (double) expected value does not match\n");
+      printf("   expected[0] = %f; result[0] = %f\n",
+	     d_sqrt_expected[0], d_result[0]);
+      printf("   expected[1] = %f; result[1] = %f\n",
+	     d_sqrt_expected[1], d_result[1]);
+    }
+#else
+  abort();
+#endif
+
+  /* Truncate, double */
+  d_result = vec_trunc (d_src);
+
+  if ((d_result[0] != d_trunc_expected[0])
+      || (d_result[1] != d_trunc_expected[1]))
+#if DEBUG
+    {
+      printf("ERROR: vec_trunc (double) expected value does not match\n");
+      printf("   expected[0] = %f; result[0] = %f\n",
+	     d_trunc_expected[0], d_result[0]);
+      printf("   expected[1] = %f; result[1] = %f\n",
+	     d_trunc_expected[1], d_result[1]);
+    }
+#else
+  abort();
+#endif
+
+  return 0;
+}  
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..1055a8d7252
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-2lop.c
@@ -0,0 +1,305 @@
+/* { dg-do compile { target lp64 } } */
+/* { dg-skip-if "" { powerpc*-*-darwin* } } */
+/* { dg-options "-O2 -mdejagnu-cpu=power7" } */
+
+/* Functional test of the two operand logical vector builtins.  */
+
+#include <altivec.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define DEBUG 0
+
+void abort (void);
+
+int
+main () {
+  int i;
+
+  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;
+
+  
+  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_result;
+  vector float f_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_expected;
+
+  /* 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_expected[i] = conv_exp.f[i];
+    }
+
+  f_result = vec_and (f_src_a, f_src_b);
+  if ((f_result[0] != f_expected[0])
+      || (f_result[1] != f_expected[1])
+      || (f_result[2] != f_expected[2])
+      || (f_result[3] != f_expected[3]))
+    {
+#if DEBUG
+      printf("ERROR: vec_and (float) expected value does not match\n");
+      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();
+#endif
+    }
+
+  /* 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_expected[i] = conv_exp.f[i];
+    }
+
+  f_result = vec_andc (f_src_a, f_src_b);
+
+  if ((f_result[0] != f_expected[0])
+      || (f_result[1] != f_expected[1])
+      || (f_result[2] != f_expected[2])
+      || (f_result[3] != f_expected[3]))
+    {
+#if DEBUG
+      printf("ERROR: vec_andc (float) expected value does not match\n");
+      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();
+#endif
+    }
+
+  /* NOR, max */
+  f_result = vec_nor (f_src_a, f_src_b);
+  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_expected[i] = conv_exp.f[i];
+    }
+
+  if ((f_result[0] != f_expected[0])
+      || (f_result[1] != f_expected[1])
+      || (f_result[2] != f_expected[2])
+      || (f_result[3] != f_expected[3]))
+    {
+#if DEBUG
+      printf("ERROR: vec_nor (float) expected value does not match\n");
+      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();
+#endif
+    }
+
+  /* OR, float */
+  f_result = vec_or (f_src_a, f_src_b);
+  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_expected[i] = conv_exp.f[i];
+    }
+
+  if ((f_result[0] != f_expected[0])
+      || (f_result[1] != f_expected[1])
+      || (f_result[2] != f_expected[2])
+      || (f_result[3] != f_expected[3]))
+    {
+#if DEBUG
+      printf("ERROR: vec_or (float) expected value does not match\n");
+      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);
+	}
+#else
+      abort();
+#endif
+    }
+
+  /* XOR, float */
+  f_result = vec_xor (f_src_a, f_src_b);
+  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_expected[i] = conv_exp.f[i];
+    }
+
+  if ((f_result[0] != f_expected[0])
+      || (f_result[1] != f_expected[1])
+      || (f_result[2] != f_expected[2])
+      || (f_result[3] != f_expected[3]))
+    {
+#if DEBUG
+      printf("ERROR: vec_xor (float) expected value does not match\n");
+      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);
+	}
+#else
+      abort();
+#endif
+    }
+
+  /* AND, double */
+  d_result = vec_and (d_src_a, d_src_b);
+  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_expected[i] = conv_exp.d[i];
+    }
+
+  if ((d_result[0] != d_expected[0]) || (d_result[1] != d_expected[1]))
+    {
+#if DEBUG
+      printf("ERROR: vec_and (double) expected value does not match\n");
+      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();
+#endif
+    }
+
+  /* ANDC, double */
+  d_result = vec_andc (d_src_a, d_src_b);
+  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_expected[i] = conv_exp.d[i];
+    }
+
+  if ((d_result[0] != d_expected[0]) || (d_result[1] != d_expected[1]))
+    {
+#if DEBUG
+      printf("ERROR: vec_andc (double) expected value does not match\n");
+      for (i = 0; i < 4; i++)
+	{
+	  conv_result.d[i] = d_result[i];
+	  printf("   expected[%d] = 0x%lx; result[%d] = 0x%lx\n", i,
+		 conv_exp.ul[i], i, conv_result.ul);
+	}
+#else
+      abort();
+#endif
+    }
+
+  /* NOR, double */
+  d_result = vec_nor (d_src_a, d_src_b);
+  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_expected[i] = conv_exp.d[i];
+    }
+
+  if ((d_result[0] != d_expected[0]) || (d_result[1] != d_expected[1]))
+    {
+#if DEBUG
+      printf("ERROR: vec_nor (double) expected value does not match\n");
+      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();
+#endif
+    }
+
+  /* OR, double */
+  d_result = vec_or (d_src_a, d_src_b);
+  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_expected[i] = conv_exp.d[i];
+    }
+
+  if ((d_result[0] != d_expected[0]) || (d_result[1] != d_expected[1]))
+    {
+#if DEBUG
+      printf("ERROR: vec_or (double) expected value does not match\n");
+      for (i = 0; i < 2; i++)
+	{
+	  conv_result.f[i] = f_result[i];
+	  printf("   expected[%d] = 0x%lx; result[%d] = 0x%lx\n", i,
+		 conv_exp.ul, i, conv_result.ul);
+	}
+#else
+      abort();
+#endif
+    }
+
+  /* XOR, double */
+  d_result = vec_xor (d_src_a, d_src_b);
+  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_expected[i] = conv_exp.d[i];
+    }
+
+  if ((d_result[0] != d_expected[0]) || (d_result[1] != d_expected[1]))
+    {
+#if DEBUG
+      printf("ERROR: vec_xor (double) expected value does not match\n");
+      for (i = 0; i < 2; i++)
+	{
+	  conv_result.d[i] = f_result[i];
+	  printf("   expected[%d] = 0x%lx; result[%d] = 0x%lx\n", i,
+		 conv_exp.ul, i, conv_result.ul);
+	}
+#else
+      abort();
+#endif
+    }
+
+  return 0;
+}
+
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..0ee703b8e04
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-2op.c
@@ -0,0 +1,278 @@
+/* { dg-do compile { target lp64 } } */
+/* { dg-skip-if "" { powerpc*-*-darwin* } } */
+/* { dg-options "-O2 -mdejagnu-cpu=power7" } */
+/* Functional test of the two 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_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_result;
+  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_result;
+  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};
+
+  /* Add, float */
+  f_result = vec_add (f_src_a, f_src_b);
+
+  if ((f_result[0] != f_add_expected[0])
+      || (f_result[1] != f_add_expected[1])
+      || (f_result[2] != f_add_expected[2])
+      || (f_result[3] != f_add_expected[3]))
+#if DEBUG
+    {
+      printf("ERROR: vec_add (float) expected value does not match\n");
+      printf("   expected[0] = %f; result[0] = %f\n",
+	     f_add_expected[0], f_result[0]);
+      printf("   expected[1] = %f; result[1] = %f\n",
+	     f_add_expected[1], f_result[1]);
+      printf("   expected[2] = %f; result[2] = %f\n",
+	     f_add_expected[2], f_result[2]);
+      printf("   expected[3] = %f; result[3] = %f\n",
+	     f_add_expected[3], f_result[3]);
+    }
+#else
+  abort();
+#endif
+
+  /* Divide, float */
+  f_result = vec_div (f_src_a, f_src_b);
+
+  if ((f_result[0] != f_div_expected[0])
+      || (f_result[1] != f_div_expected[1])
+      || (f_result[2] != f_div_expected[2])
+      || (f_result[3] != f_div_expected[3]))
+#if DEBUG
+    {
+      printf("ERROR: vec_div (float) expected value does not match\n");
+      printf("   expected[0] = %f; result[0] = %f\n",
+	     f_div_expected[0], f_result[0]);
+      printf("   expected[1] = %f; result[1] = %f\n",
+	     f_div_expected[1], f_result[1]);
+      printf("   expected[2] = %f; result[2] = %f\n",
+	     f_div_expected[2], f_result[2]);
+      printf("   expected[3] = %f; result[3] = %f\n",
+	     f_div_expected[3], f_result[3]);
+    }
+#else
+  abort();
+#endif
+
+  /* Floor, max */
+  f_result = vec_max (f_src_a, f_src_b);
+
+  if ((f_result[0] != f_max_expected[0])
+      || (f_result[1] != f_max_expected[1])
+      || (f_result[2] != f_max_expected[2])
+      || (f_result[3] != f_max_expected[3]))
+#if DEBUG
+    {
+      printf("ERROR: vec_max(float) expected value does not match\n");
+      printf("   expected[0] = %f; result[0] = %f\n",
+	     f_max_expected[0], f_result[0]);
+      printf("   expected[1] = %f; result[1] = %f\n",
+	     f_max_expected[1], f_result[1]);
+      printf("   expected[2] = %f; result[2] = %f\n",
+	     f_max_expected[2], f_result[2]);
+      printf("   expected[3] = %f; result[3] = %f\n",
+	     f_max_expected[3], f_result[3]);
+    }
+#else
+  abort();
+#endif
+
+  /* Minimum, float */
+  f_result = vec_min (f_src_a, f_src_b);
+
+  if ((f_result[0] != f_min_expected[0])
+      || (f_result[1] != f_min_expected[1])
+      || (f_result[2] != f_min_expected[2])
+      || (f_result[3] != f_min_expected[3]))
+#if DEBUG
+    {
+      printf("ERROR: vec_min (float) expected value does not match\n");
+      printf("   expected[0] = %f; result[0] = %f\n",
+	     f_min_expected[0], f_result[0]);
+      printf("   expected[1] = %f; result[1] = %f\n",
+	     f_min_expected[1], f_result[1]);
+      printf("   expected[2] = %f; result[2] = %f\n",
+	     f_min_expected[2], f_result[2]);
+      printf("   expected[3] = %f; result[3] = %f\n",
+	     f_min_expected[3], f_result[3]);
+    }
+#else
+  abort();
+#endif
+
+  /* Multiply, float */
+  f_result = vec_mul (f_src_a, f_src_b);
+
+  if ((f_result[0] != f_mul_expected[0])
+      || (f_result[1] != f_mul_expected[1])
+      || (f_result[2] != f_mul_expected[2])
+      || (f_result[3] != f_mul_expected[3]))
+#if DEBUG
+    {
+      printf("ERROR: vec_mult (float) expected value does not match\n");
+      printf("   expected[0] = %f; result[0] = %f\n",
+	     f_mul_expected[0], f_result[0]);
+      printf("   expected[1] = %f; result[1] = %f\n",
+	     f_mul_expected[1], f_result[1]);
+      printf("   expected[2] = %f; result[2] = %f\n",
+	     f_mul_expected[2], f_result[2]);
+      printf("   expected[3] = %f; result[3] = %f\n",
+	     f_mul_expected[3], f_result[3]);
+    }
+#else
+  abort();
+#endif
+
+    /* Subtract, float */
+  f_result = vec_sub (f_src_a, f_src_b);
+
+  if ((f_result[0] != f_sub_expected[0])
+      || (f_result[1] != f_sub_expected[1])
+      || (f_result[2] != f_sub_expected[2])
+      || (f_result[3] != f_sub_expected[3]))
+#if DEBUG
+    {
+      printf("ERROR: vec_sub (float) expected value does not match\n");
+      printf("   expected[0] = %f; result[0] = %f\n",
+	     f_sub_expected[0], f_result[0]);
+      printf("   expected[1] = %f; result[1] = %f\n",
+	     f_sub_expected[1], f_result[1]);
+      printf("   expected[2] = %f; result[2] = %f\n",
+	     f_sub_expected[2], f_result[2]);
+      printf("   expected[3] = %f; result[3] = %f\n",
+	     f_sub_expected[3], f_result[3]);
+    }
+#else
+  abort();
+#endif
+
+
+
+  /* Add, double */
+  d_result = vec_add (d_src_a, d_src_b);
+
+  if ((d_result[0] != d_add_expected[0]) || (d_result[1] != d_add_expected[1]))
+#if DEBUG
+    {
+      printf("ERROR: vec_add (double) expected value does not match\n");
+      printf("   expected[0] = %f; result[0] = %f\n",
+	     d_add_expected[0], d_result[0]);
+      printf("   expected[1] = %f; result[1] = %f\n",
+	     d_add_expected[1], d_result[1]);
+    }
+#else
+  abort();
+#endif
+
+  /* Divide, double */
+  d_result = vec_div (d_src_a, d_src_b);
+
+  if ((d_result[0] != d_div_expected[0])
+      || (d_result[1] != d_div_expected[1]))
+#if DEBUG
+    {
+      printf("ERROR: vec_div (double) expected value does not match\n");
+      printf("   expected[0] = %f; result[0] = %f\n",
+	     d_div_expected[0], d_result[0]);
+      printf("   expected[1] = %f; result[1] = %f\n",
+	     d_div_expected[1], d_result[1]);
+    }
+#else
+  abort();
+#endif
+
+  /* Max */
+  d_result = vec_max (d_src_a, d_src_b);
+
+  if ((d_result[0] != d_max_expected[0])
+      || (d_result[1] != d_max_expected[1]))
+#if DEBUG
+    {
+      printf("ERROR: vec_max (double) expected value does not match\n");
+      printf("   expected[0] = %f; result[0] = %f\n",
+	     d_max_expected[0], d_result[0]);
+      printf("   expected[1] = %f; result[1] = %f\n",
+	     d_max_expected[1], d_result[1]);
+    }
+#else
+  abort();
+#endif
+
+  /* Nearby min */
+  d_result = vec_min (d_src_a, d_src_b);
+
+  if ((d_result[0] != d_min_expected[0]) || (d_result[1] != d_min_expected[1]))
+#if DEBUG
+    {
+      printf("ERROR: vec_min (double) expected value does not match\n");
+      printf("   expected[0] = %f; result[0] = %f\n",
+	     d_min_expected[0], d_result[0]);
+      printf("   expected[1] = %f; result[1] = %f\n",
+	     d_min_expected[1], d_result[1]);
+    }
+#else
+  abort();
+#endif
+
+  /* Multiply, double */
+  d_result = vec_mul (d_src_a, d_src_b);
+
+  if ((d_result[0] != d_mul_expected[0])
+      || (d_result[1] != d_mul_expected[1]))
+#if DEBUG
+    {
+      printf("ERROR: vec_mul (double) expected value does not match\n");
+      printf("   expected[0] = %f; result[0] = %f\n",
+	     d_mul_expected[0], d_result[0]);
+      printf("   expected[1] = %f; result[1] = %f\n",
+	     d_mul_expected[1], d_result[1]);
+    }
+#else
+  abort();
+#endif
+
+  /* Subract root, double */
+  d_result = vec_sub (d_src_a, d_src_b);
+
+  if ((d_result[0] != d_sub_expected[0])
+      || (d_result[1] != d_sub_expected[1]))
+#if DEBUG
+    {
+      printf("ERROR: vec_sub (double) expected value does not match\n");
+      printf("   expected[0] = %f; result[0] = %f\n",
+	     d_sub_expected[0], d_result[0]);
+      printf("   expected[1] = %f; result[1] = %f\n",
+	     d_sub_expected[1], d_result[1]);
+    }
+#else
+  abort();
+#endif
+
+  return 0;
+}
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..a2127455f79
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-3op.c
@@ -0,0 +1,229 @@
+/* { dg-do compile { target lp64 } } */
+/* { dg-skip-if "" { powerpc*-*-darwin* } } */
+/* { dg-options "-O2 -mdejagnu-cpu=power7" } */
+
+/* Functional test of the three operand vector builtins.  */
+
+#include <altivec.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define DEBUG 0
+
+void abort (void);
+
+int
+main () {
+  int i;
+
+  //  vector unsigned char uc_src_c = {0xF, 0xE, 0xD, 0xC, 0xB, 0xA, 0x9, 0x8,
+  //				   0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1, 0x0};
+  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_result;
+  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_result;
+  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_result;
+  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_result;
+  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};
+
+  /* Vecotr 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
+      
+  /* Add, float */
+  f_result = vec_madd (f_src_a, f_src_b, f_src_c);
+
+  if ((f_result[0] != f_madd_expected[0])
+      || (f_result[1] != f_madd_expected[1])
+      || (f_result[2] != f_madd_expected[2])
+      || (f_result[3] != f_madd_expected[3]))
+#if DEBUG
+    {
+      printf("ERROR: vec_madd (float) expected value does not match\n");
+      printf("   expected[0] = %f; result[0] = %f\n",
+	     f_madd_expected[0], f_result[0]);
+      printf("   expected[1] = %f; result[1] = %f\n",
+	     f_madd_expected[1], f_result[1]);
+      printf("   expected[2] = %f; result[2] = %f\n",
+	     f_madd_expected[2], f_result[2]);
+      printf("   expected[3] = %f; result[3] = %f\n",
+	     f_madd_expected[3], f_result[3]);
+    }
+#else
+  abort();
+#endif
+
+  /* Subtract, float */
+  f_result = vec_msub (f_src_a, f_src_b, f_src_c);
+
+  if ((f_result[0] != f_msub_expected[0])
+      || (f_result[1] != f_msub_expected[1])
+      || (f_result[2] != f_msub_expected[2])
+      || (f_result[3] != f_msub_expected[3]))
+#if DEBUG
+    {
+      printf("ERROR: vec_msub (float) expected value does not match\n");
+      printf("   expected[0] = %f; result[0] = %f\n",
+	     f_msub_expected[0], f_result[0]);
+      printf("   expected[1] = %f; result[1] = %f\n",
+	     f_msub_expected[1], f_result[1]);
+      printf("   expected[2] = %f; result[2] = %f\n",
+	     f_msub_expected[2], f_result[2]);
+      printf("   expected[3] = %f; result[3] = %f\n",
+	     f_msub_expected[3], f_result[3]);
+    }
+#else
+  abort();
+#endif
+
+
+  /* Add, double */
+  d_result = vec_madd (d_src_a, d_src_b, d_src_c);
+
+  if ((d_result[0] != d_madd_expected[0])
+      || (d_result[1] != d_madd_expected[1]))
+#if DEBUG
+    {
+      printf("ERROR: vec_madd (double) expected value does not match\n");
+      printf("   expected[0] = %f; result[0] = %f\n",
+	     d_madd_expected[0], d_result[0]);
+      printf("   expected[1] = %f; result[1] = %f\n",
+	     d_madd_expected[1], d_result[1]);
+    }
+#else
+  abort();
+#endif
+
+  /* Subract root, double */
+  d_result = vec_msub (d_src_a, d_src_b, d_src_c);
+
+  if ((d_result[0] != d_msub_expected[0])
+      || (d_result[1] != d_msub_expected[1]))
+#if DEBUG
+    {
+      printf("ERROR: vec_msub (double) expected value does not match\n");
+      printf("   expected[0] = %f; result[0] = %f\n",
+	     d_msub_expected[0], d_result[0]);
+      printf("   expected[1] = %f; result[1] = %f\n",
+	     d_msub_expected[1], d_result[1]);
+    }
+#else
+  abort();
+#endif
+
+  /* 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");
+      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");
+      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");
+      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");
+      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");
+      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");
+      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");
+      printf("   expected = %d; result = %d\n", f_any_nan_expected, f_result);
+    }
+#else
+  abort();
+#endif
+
+  /* Any numeric, float */
+  f_result = vec_any_numeric (f_src_a);
+
+  if (f_result != f_any_numeric_expected)
+#if DEBUG
+    {
+      printf("ERROR: vec_any_numeric (float) expected value does not match\n");
+      printf("   expected = %d; result = %d\n", f_any_numeric_expected,
+	     f_result);
+    }
+#else
+  abort();
+#endif
+
+  /* Compare all equal, double */
+  d_result = vec_all_eq (d_src_a, d_src_b);
+
+  if (d_result != d_all_eq_expected)
+#if DEBUG
+    {
+      printf("ERROR: vec_all_eq (double) expected value does not match\n");
+      printf("   expected] = %d; result = %d\n", d_all_eq_expected, d_result);
+    }
+#else
+  abort();
+#endif
+
+  /* Compare all greater than, double */
+  d_result = vec_all_gt (d_src_a, d_src_b);
+
+  if (d_result != d_all_gt_expected)
+#if DEBUG
+    {
+      printf("ERROR: vec_all_gt (double) expected value does not match\n");
+      printf("   expected = %d; result = %d\n", d_all_gt_expected, d_result);
+    }
+#else
+  abort();
+#endif
+
+  /* Compare all greater than or equal, double */
+  d_result = vec_all_ge (d_src_a, d_src_b);
+
+  if (d_result != d_all_ge_expected)
+#if DEBUG
+    {
+      printf("ERROR: vec_all_ge (double) expected value does not match\n");
+      printf("   expected] = %d; result = %d\n", d_all_gt_expected, d_result);
+    }
+#else
+  abort();
+#endif
+
+  /* Compare all less than, double */
+  d_result = vec_all_lt (d_src_a, d_src_b);
+
+  if (d_result != d_all_lt_expected)
+#if DEBUG
+    {
+      printf("ERROR: vec_all_lt (double) expected value does not match\n");
+      printf("   expected = %d; result = %d\n", d_all_lt_expected, d_result);
+    }
+#else
+  abort();
+#endif
+
+  /* Compare all less than or equal, double */
+  d_result = vec_all_le (d_src_a, d_src_b);
+
+  if (d_result != d_all_le_expected)
+#if DEBUG
+    {
+      printf("ERROR: vec_all_le (double) expected value does not match\n");
+      printf("   expected = %d; result = %d\n", d_all_le_expected, d_result);
+    }
+#else
+  abort();
+#endif
+
+    /* All NaN, double */
+  d_result = vec_all_nan (d_src_a);
+
+  if (d_result != d_all_nan_expected)
+#if DEBUG
+    {
+      printf("ERROR: vec_all_nan (double) expected value does not match\n");
+      printf("   expected = %d; result = %d\n", d_all_nan_expected, d_result);
+    }
+#else
+  abort();
+#endif
+
+  /* All numeric double */
+  d_result = vec_all_numeric (d_src_a);
+
+  if (d_result != d_all_numeric_expected)
+#if DEBUG
+    {
+      printf("ERROR: vec_all_numeric (double) expected value does not match\n");
+      printf("   expected = %d; result = %d\n", d_all_numeric_expected,
+	     d_result);
+    }
+#else
+  abort();
+#endif
+
+  /* Compare any equal, double */
+  d_result = vec_any_eq (d_src_a, d_src_b);
+
+  if (d_result != d_any_eq_expected)
+#if DEBUG
+    {
+      printf("ERROR: vec_any_eq (double) expected value does not match\n");
+      printf("   expected] = %d; result = %d\n", d_any_eq_expected, d_result);
+    }
+#else
+  abort();
+#endif
+
+  /* Compare any greater than, double */
+  d_result = vec_any_gt (d_src_a, d_src_b);
+
+  if (d_result != d_any_gt_expected)
+#if DEBUG
+    {
+      printf("ERROR: vec_any_gt (double) expected value does not match\n");
+      printf("   expected = %d; result = %d\n", d_any_gt_expected, d_result);
+    }
+#else
+  abort();
+#endif
+
+  /* Compare any greater than or equal, double */
+  d_result = vec_any_ge (d_src_a, d_src_b);
+
+  if (d_result != d_any_ge_expected)
+#if DEBUG
+    {
+      printf("ERROR: vec_any_ge (double) expected value does not match\n");
+      printf("   expected] = %d; result = %d\n", d_any_gt_expected, d_result);
+    }
+#else
+  abort();
+#endif
+
+  /* Compare any less than, double */
+  d_result = vec_any_lt (d_src_a, d_src_b);
+
+  if (d_result != d_any_lt_expected)
+#if DEBUG
+    {
+      printf("ERROR: vec_any_lt (double) expected value does not match\n");
+      printf("   expected = %d; result = %d\n", d_any_lt_expected, d_result);
+    }
+#else
+  abort();
+#endif
+
+  /* Compare any less than or equal, double */
+  d_result = vec_any_le (d_src_a, d_src_b);
+
+  if (d_result != d_any_le_expected)
+#if DEBUG
+    {
+      printf("ERROR: vec_any_le (double) expected value does not match\n");
+      printf("   expected = %d; result = %d\n", d_any_le_expected, d_result);
+    }
+#else
+  abort();
+#endif
+
+    /* Any NaN, float */
+  d_result = vec_any_nan (d_src_a);
+
+  if (d_result != d_any_nan_expected)
+#if DEBUG
+    {
+      printf("ERROR: vec_any_nan (double) expected value does not match\n");
+      printf("   expected = %d; result = %d\n", d_any_nan_expected, d_result);
+    }
+#else
+  abort();
+#endif
+
+  /* Any numeric, double */
+  d_result = vec_any_numeric (d_src_a);
+
+  if (d_result != d_any_numeric_expected)
+#if DEBUG
+    {
+      printf("ERROR: vec_any_numeric (double) expected value does not match\n");
+      printf("   expected = %d; result = %d\n", d_any_numeric_expected,
+	     d_result);
+    }
+#else
+  abort();
+#endif
+
+  return 0;
+}
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..3c2c1861754
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-cmp.c
@@ -0,0 +1,237 @@
+/* { dg-do compile { target lp64 } } */
+/* { dg-skip-if "" { powerpc*-*-darwin* } } */
+/* { dg-options "-O2 -mdejagnu-cpu=power7" } */
+
+/* Functional test of the vector compare builtins.  */
+
+#include <altivec.h>
+#include <stdio.h>
+#include <stdlib.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};
+  vector bool int f_result;
+  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_result;
+  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};
+
+  /* Compare equal, float */
+  f_result = vec_cmpeq (f_src_a, f_src_b);
+
+  if ((f_result[0] != f_cmpeq_expected[0])
+      || (f_result[1] != f_cmpeq_expected[1])
+      || (f_result[2] != f_cmpeq_expected[2])
+      || (f_result[3] != f_cmpeq_expected[3]))
+#if DEBUG
+    {
+      printf("ERROR: vec_cmpeq (float) expected value does not match\n");
+      printf("   expected[0] = 0x%x; result[0] =0x%x\n",
+	     f_cmpeq_expected[0], f_result[0]);
+      printf("   expected[1] = 0x%x; result[1] = 0x%x\n",
+	     f_cmpeq_expected[1], f_result[1]);
+      printf("   expected[2] = 0x%x; result[2] = 0x%x\n",
+	     f_cmpeq_expected[2], f_result[2]);
+      printf("   expected[3] = 0x%x; result[3] = 0x%x\n",
+	     f_cmpeq_expected[3], f_result[3]);
+    }
+#else
+  abort();
+#endif
+
+  /* Compare greater than, float */
+  f_result = vec_cmpgt (f_src_a, f_src_b);
+
+  if ((f_result[0] != f_cmpgt_expected[0])
+      || (f_result[1] != f_cmpgt_expected[1])
+      || (f_result[2] != f_cmpgt_expected[2])
+      || (f_result[3] != f_cmpgt_expected[3]))
+#if DEBUG
+    {
+      printf("ERROR: vec_cmpgt (float) expected value does not match\n");
+      printf("   expected[0] = 0x%x; result[0] = 0x%x\n",
+	     f_cmpgt_expected[0], f_result[0]);
+      printf("   expected[1] = 0x%x; result[1] = 0x%x\n",
+	     f_cmpgt_expected[1], f_result[1]);
+      printf("   expected[2] = 0x%x; result[2] = 0x%x\n",
+	     f_cmpgt_expected[2], f_result[2]);
+      printf("   expected[3] = 0x%x; result[3] = 0x%x\n",
+	     f_cmpgt_expected[3], f_result[3]);
+    }
+#else
+  abort();
+#endif
+
+  /* Compare greater than or equal, float */
+  f_result = vec_cmpge (f_src_a, f_src_b);
+
+  if ((f_result[0] != f_cmpge_expected[0])
+      || (f_result[1] != f_cmpge_expected[1])
+      || (f_result[2] != f_cmpge_expected[2])
+      || (f_result[3] != f_cmpge_expected[3]))
+#if DEBUG
+    {
+      printf("ERROR: vec_cmpge(float) expected value does not match\n");
+      printf("   expected[0] = 0x%x; result[0] = 0x%x\n",
+	     f_cmpge_expected[0], f_result[0]);
+      printf("   expected[1] = 0x%x; result[1] = 0x%x\n",
+	     f_cmpge_expected[1], f_result[1]);
+      printf("   expected[2] = 0x%x; result[2] = 0x%x\n",
+	     f_cmpge_expected[2], f_result[2]);
+      printf("   expected[3] = 0x%x; result[3] = 0x%x\n",
+	     f_cmpge_expected[3], f_result[3]);
+    }
+#else
+  abort();
+#endif
+
+  /* Compare less than, float */
+  f_result = vec_cmplt (f_src_a, f_src_b);
+
+  if ((f_result[0] != f_cmplt_expected[0])
+      || (f_result[1] != f_cmplt_expected[1])
+      || (f_result[2] != f_cmplt_expected[2])
+      || (f_result[3] != f_cmplt_expected[3]))
+#if DEBUG
+    {
+      printf("ERROR: vec_cmplt (float) expected value does not match\n");
+      printf("   expected[0] = 0x%x; result[0] = 0x%x\n",
+	     f_cmplt_expected[0], f_result[0]);
+      printf("   expected[1] = 0x%x; result[1] = 0x%x\n",
+	     f_cmplt_expected[1], f_result[1]);
+      printf("   expected[2] = 0x%x; result[2] = 0x%x\n",
+	     f_cmplt_expected[2], f_result[2]);
+      printf("   expected[3] = 0x%x; result[3] = 0x%x\n",
+	     f_cmplt_expected[3], f_result[3]);
+    }
+#else
+  abort();
+#endif
+
+  /* Compare less than or equal, float */
+  f_result = vec_cmple (f_src_a, f_src_b);
+
+  if ((f_result[0] != f_cmple_expected[0])
+      || (f_result[1] != f_cmple_expected[1])
+      || (f_result[2] != f_cmple_expected[2])
+      || (f_result[3] != f_cmple_expected[3]))
+#if DEBUG
+    {
+      printf("ERROR: vec_cmple (float) expected value does not match\n");
+      printf("   expected[0] = 0x%x; result[0] = 0x%x\n",
+	     f_cmple_expected[0], f_result[0]);
+      printf("   expected[1] = 0x%x; result[1] = 0x%x\n",
+	     f_cmple_expected[1], f_result[1]);
+      printf("   expected[2] = 0x%x; result[2] = 0x%x\n",
+	     f_cmple_expected[2], f_result[2]);
+      printf("   expected[3] = 0x%x; result[3] = 0x%x\n",
+	     f_cmple_expected[3], f_result[3]);
+    }
+#else
+  abort();
+#endif
+
+
+  /* Compare equal, double */
+  d_result = vec_cmpeq (d_src_a, d_src_b);
+
+  if ((d_result[0] != d_cmpeq_expected[0]) || (d_result[1] != d_cmpeq_expected[1]))
+#if DEBUG
+    {
+      printf("ERROR: vec_cmpeq (double) expected value does not match\n");
+      printf("   expected[0] = 0x%lx; result[0] = 0x%lx\n",
+	     d_cmpeq_expected[0], d_result[0]);
+      printf("   expected[1] = 0x%lx; result[1] = 0x%lx\n",
+	     d_cmpeq_expected[1], d_result[1]);
+    }
+#else
+  abort();
+#endif
+
+  /* Compare greater than, double */
+  d_result = vec_cmpgt (d_src_a, d_src_b);
+
+  if ((d_result[0] != d_cmpgt_expected[0])
+      || (d_result[1] != d_cmpgt_expected[1]))
+#if DEBUG
+    {
+      printf("ERROR: vec_cmpgt (double) expected value does not match\n");
+      printf("   expected[0] = 0x%lx; result[0] = 0x%lx\n",
+	     d_cmpgt_expected[0], d_result[0]);
+      printf("   expected[1] = 0x%lx; result[1] = 0x%lx\n",
+	     d_cmpgt_expected[1], d_result[1]);
+    }
+#else
+  abort();
+#endif
+
+  /* Compare greater than or equal, double */
+  d_result = vec_cmpge (d_src_a, d_src_b);
+
+  if ((d_result[0] != d_cmpge_expected[0])
+      || (d_result[1] != d_cmpge_expected[1]))
+#if DEBUG
+    {
+      printf("ERROR: vec_cmpge (double) expected value does not match\n");
+      printf("   expected[0] = 0x%lx; result[0] = 0x%lx\n",
+	     d_cmpgt_expected[0], d_result[0]);
+      printf("   expected[1] = 0x%lx; result[1] = 0x%lx\n",
+	     d_cmpgt_expected[1], d_result[1]);
+    }
+#else
+  abort();
+#endif
+
+  /* Compare less than, double */
+  d_result = vec_cmplt (d_src_a, d_src_b);
+
+  if ((d_result[0] != d_cmplt_expected[0])
+      || (d_result[1] != d_cmplt_expected[1]))
+#if DEBUG
+    {
+      printf("ERROR: vec_cmplt (double) expected value does not match\n");
+      printf("   expected[0] = 0x%lx; result[0] = 0x%lx\n",
+	     d_cmplt_expected[0], d_result[0]);
+      printf("   expected[1] = 0x%lx; result[1] = 0x%lx\n",
+	     d_cmplt_expected[1], d_result[1]);
+    }
+#else
+  abort();
+#endif
+
+  /* Compare less than or equal, double */
+  d_result = vec_cmple (d_src_a, d_src_b);
+
+  if ((d_result[0] != d_cmple_expected[0])
+      || (d_result[1] != d_cmple_expected[1]))
+#if DEBUG
+    {
+      printf("ERROR: vec_cmple (double) expected value does not match\n");
+      printf("   expected[0] = 0x%lx; result[0] = 0x%lx\n",
+	     d_cmple_expected[0], d_result[0]);
+      printf("   expected[1] = 0x%lx; result[1] = 0x%lx\n",
+	     d_cmple_expected[1], d_result[1]);
+    }
+#else
+  abort();
+#endif
+  return 0;
+}
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 } } */
