From 3acaf2e51caf356a9afc763cfd70b91d1ab094b5 Mon Sep 17 00:00:00 2001
From: Edward Smith-Rowland <3dw4rd@verizon.net>
Date: Thu, 20 Jul 2017 14:54:44 +0000
Subject: Merged revisions r232323 through r250392 to the branch

git-svn-id: https://gcc.gnu.org/svn/gcc/branches/tr29124@250393 138bc75d-0d04-0410-961f-82ee72b054a4
---
 gcc/testsuite/gcc.dg/vect/bb-slp-pr65935.c         |  4 +-
 gcc/testsuite/gcc.dg/vect/bb-slp-pr80705.c         | 44 +++++++++++
 .../gcc.dg/vect/costmodel/ppc/costmodel-slp-34.c   |  2 +-
 .../vect/costmodel/x86_64/costmodel-alignpeel.c    |  9 +++
 gcc/testsuite/gcc.dg/vect/no-scevccp-outer-13.c    |  1 +
 gcc/testsuite/gcc.dg/vect/no-scevccp-outer-7.c     |  1 +
 .../gcc.dg/vect/no-section-anchors-vect-68.c       |  2 +-
 gcc/testsuite/gcc.dg/vect/pr49352.c                |  2 +-
 gcc/testsuite/gcc.dg/vect/pr65947-1.c              |  4 +-
 gcc/testsuite/gcc.dg/vect/pr65947-10.c             |  2 +-
 gcc/testsuite/gcc.dg/vect/pr65947-12.c             |  2 +-
 gcc/testsuite/gcc.dg/vect/pr65947-13.c             |  2 +-
 gcc/testsuite/gcc.dg/vect/pr65947-14.c             | 44 +++++++++++
 gcc/testsuite/gcc.dg/vect/pr65947-2.c              |  2 +-
 gcc/testsuite/gcc.dg/vect/pr65947-3.c              |  2 +-
 gcc/testsuite/gcc.dg/vect/pr65947-4.c              |  4 +-
 gcc/testsuite/gcc.dg/vect/pr65947-5.c              |  4 +-
 gcc/testsuite/gcc.dg/vect/pr65947-6.c              |  2 +-
 gcc/testsuite/gcc.dg/vect/pr65947-8.c              |  2 +-
 gcc/testsuite/gcc.dg/vect/pr65947-9.c              | 19 +++--
 gcc/testsuite/gcc.dg/vect/pr66278.c                | 19 +++++
 gcc/testsuite/gcc.dg/vect/pr66623.c                | 86 ++++++++++++++++++++++
 gcc/testsuite/gcc.dg/vect/pr80815-1.c              | 38 ++++++++++
 gcc/testsuite/gcc.dg/vect/pr80815-2.c              | 46 ++++++++++++
 gcc/testsuite/gcc.dg/vect/pr80815-3.c              | 45 +++++++++++
 gcc/testsuite/gcc.dg/vect/pr80928.c                | 37 ++++++++++
 gcc/testsuite/gcc.dg/vect/pr81136.c                | 16 ++++
 gcc/testsuite/gcc.dg/vect/pr81196.c                | 19 +++++
 gcc/testsuite/gcc.dg/vect/pr81410.c                | 38 ++++++++++
 gcc/testsuite/gcc.dg/vect/slp-13-big-array.c       | 13 ++--
 gcc/testsuite/gcc.dg/vect/slp-13.c                 | 13 ++--
 gcc/testsuite/gcc.dg/vect/slp-43.c                 |  9 ++-
 gcc/testsuite/gcc.dg/vect/slp-45.c                 |  9 ++-
 gcc/testsuite/gcc.dg/vect/slp-perm-8.c             |  4 +-
 gcc/testsuite/gcc.dg/vect/slp-perm-9.c             |  1 +
 gcc/testsuite/gcc.dg/vect/slp-reduc-8.c            | 48 ++++++++++++
 gcc/testsuite/gcc.dg/vect/vect-103.c               |  2 +-
 gcc/testsuite/gcc.dg/vect/vect-104.c               |  1 +
 gcc/testsuite/gcc.dg/vect/vect-44.c                |  6 +-
 gcc/testsuite/gcc.dg/vect/vect-50.c                |  8 +-
 gcc/testsuite/gcc.dg/vect/vect-82.c                |  2 +-
 gcc/testsuite/gcc.dg/vect/vect-82_64.c             |  2 +-
 gcc/testsuite/gcc.dg/vect/vect-83.c                |  2 +-
 gcc/testsuite/gcc.dg/vect/vect-83_64.c             |  2 +-
 gcc/testsuite/gcc.dg/vect/vect-cond-2.c            |  4 +-
 gcc/testsuite/gcc.dg/vect/vect-pr69848.c           |  2 +-
 gcc/testsuite/gcc.dg/vect/vect-profile-1.c         | 35 +++++++++
 gcc/testsuite/gcc.dg/vect/vect-reduc-11.c          | 46 ++++++++++++
 48 files changed, 644 insertions(+), 63 deletions(-)
 create mode 100644 gcc/testsuite/gcc.dg/vect/bb-slp-pr80705.c
 create mode 100644 gcc/testsuite/gcc.dg/vect/costmodel/x86_64/costmodel-alignpeel.c
 create mode 100644 gcc/testsuite/gcc.dg/vect/pr65947-14.c
 create mode 100644 gcc/testsuite/gcc.dg/vect/pr66278.c
 create mode 100644 gcc/testsuite/gcc.dg/vect/pr66623.c
 create mode 100644 gcc/testsuite/gcc.dg/vect/pr80815-1.c
 create mode 100644 gcc/testsuite/gcc.dg/vect/pr80815-2.c
 create mode 100644 gcc/testsuite/gcc.dg/vect/pr80815-3.c
 create mode 100644 gcc/testsuite/gcc.dg/vect/pr80928.c
 create mode 100644 gcc/testsuite/gcc.dg/vect/pr81136.c
 create mode 100644 gcc/testsuite/gcc.dg/vect/pr81196.c
 create mode 100644 gcc/testsuite/gcc.dg/vect/pr81410.c
 create mode 100644 gcc/testsuite/gcc.dg/vect/slp-reduc-8.c
 create mode 100644 gcc/testsuite/gcc.dg/vect/vect-profile-1.c
 create mode 100644 gcc/testsuite/gcc.dg/vect/vect-reduc-11.c

(limited to 'gcc/testsuite/gcc.dg/vect')

diff --git a/gcc/testsuite/gcc.dg/vect/bb-slp-pr65935.c b/gcc/testsuite/gcc.dg/vect/bb-slp-pr65935.c
index a6c75c7c77f..0e4f1a71b6b 100644
--- a/gcc/testsuite/gcc.dg/vect/bb-slp-pr65935.c
+++ b/gcc/testsuite/gcc.dg/vect/bb-slp-pr65935.c
@@ -57,4 +57,6 @@ int main()
   return 0;
 }
 
-/* { dg-final { scan-tree-dump-times "basic block vectorized" 1 "slp1" } } */
+/* We should also be able to use 2-lane SLP to initialize the real and
+   imaginary components in the first loop of main.  */
+/* { dg-final { scan-tree-dump-times "basic block vectorized" 2 "slp1" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/bb-slp-pr80705.c b/gcc/testsuite/gcc.dg/vect/bb-slp-pr80705.c
new file mode 100644
index 00000000000..189e3d14bdf
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/bb-slp-pr80705.c
@@ -0,0 +1,44 @@
+/* { dg-do compile } */
+/* { dg-require-profiling "-fprofile-generate" } */
+/* { dg-additional-options "-fprofile-generate" } */
+
+extern int isspace (int);
+
+int foo(const char *txt, char *buf)
+{
+  const char *s;
+  char *d;
+  int ws = 1;
+  for (s=txt, d=buf; *s; )
+    {
+      if (*s=='/' && *(s+1)=='/') {
+
+	  s += 2;
+	  while (*s && *s!='\r' && *s!='\n')
+	    s++;
+      }
+      else if (*s=='"') {
+
+	  s++;
+	  while (*s && *s!='\r' && *s!='\n' && *s!='"')
+	    if (*s++=='\\')
+	      s++;
+	  if (*s=='"')
+	    s++;
+      }
+      else {
+	  if (*s && !isspace(*s))
+	    ws = 0;
+
+
+	  *d++ = *s++;
+
+      }
+    }
+  *d = '\0';
+
+  return ws;
+}
+
+/* { dg-final { scan-tree-dump "base object not addressable" "slp1" } } */
+/* { dg-final { scan-tree-dump-not "MEM\[^\r\n\]*__gcov\[^\r\n\]* = vect_cst" "slp1" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-slp-34.c b/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-slp-34.c
index f181bd845db..c092848dfc9 100644
--- a/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-slp-34.c
+++ b/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-slp-34.c
@@ -1,5 +1,5 @@
 /* { dg-require-effective-target vect_int } */
-/* { dg-skip-if "cost too high" { powerpc*le-*-* } { "*" } { "" } } */
+/* { dg-skip-if "cost too high" { powerpc*le-*-* } } */
 
 #include <stdarg.h>
 #include "../../tree-vect.h"
diff --git a/gcc/testsuite/gcc.dg/vect/costmodel/x86_64/costmodel-alignpeel.c b/gcc/testsuite/gcc.dg/vect/costmodel/x86_64/costmodel-alignpeel.c
new file mode 100644
index 00000000000..9e20b4a72c9
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/costmodel/x86_64/costmodel-alignpeel.c
@@ -0,0 +1,9 @@
+/* { dg-do compile } */
+
+void func(double * __restrict__ v1, double * v2, unsigned n)
+{
+  for (unsigned i = 0; i < n; ++i)
+    v1[i] = v2[i];
+}
+
+/* { dg-final { scan-tree-dump-not "Alignment of access forced using peeling" "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-13.c b/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-13.c
index 04166494fbc..c5e373f8210 100644
--- a/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-13.c
+++ b/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-13.c
@@ -1,4 +1,5 @@
 /* { dg-require-effective-target vect_int } */
+/* { dg-additional-options "--param max-completely-peel-times=1" } */
 
 #include <stdarg.h>
 #include "tree-vect.h"
diff --git a/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-7.c b/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-7.c
index 906b450dcbb..224148d2b1e 100644
--- a/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-7.c
+++ b/gcc/testsuite/gcc.dg/vect/no-scevccp-outer-7.c
@@ -1,4 +1,5 @@
 /* { dg-require-effective-target vect_int } */
+/* { dg-additional-options "--param max-completely-peel-times=1" } */
 
 #include <stdarg.h>
 #include "tree-vect.h"
diff --git a/gcc/testsuite/gcc.dg/vect/no-section-anchors-vect-68.c b/gcc/testsuite/gcc.dg/vect/no-section-anchors-vect-68.c
index 5a4e4e95eb6..726c0de652f 100644
--- a/gcc/testsuite/gcc.dg/vect/no-section-anchors-vect-68.c
+++ b/gcc/testsuite/gcc.dg/vect/no-section-anchors-vect-68.c
@@ -1,5 +1,5 @@
 /* { dg-require-effective-target vect_int } */
-/* { dg-skip-if "AArch64 tiny code model does not support programs larger than 1MiB" {aarch64_tiny} {"*"} {""} } */
+/* { dg-skip-if "AArch64 tiny code model does not support programs larger than 1MiB" {aarch64_tiny} } */
 /* { dg-add-options bind_pic_locally } */
 
 #include <stdarg.h>
diff --git a/gcc/testsuite/gcc.dg/vect/pr49352.c b/gcc/testsuite/gcc.dg/vect/pr49352.c
index 82233b51945..b784b8a0964 100644
--- a/gcc/testsuite/gcc.dg/vect/pr49352.c
+++ b/gcc/testsuite/gcc.dg/vect/pr49352.c
@@ -1,7 +1,7 @@
 /* PR tree-optimization/49352 */
 /* { dg-do compile } */
 /* { dg-additional-options "-O2 -fcompare-debug" } */
-/* { dg-xfail-if "" { powerpc-ibm-aix* } { "*" } { "" } } */
+/* { dg-xfail-if "" { powerpc-ibm-aix* } } */
 
 int
 foo (int *x, int *y, int n)
diff --git a/gcc/testsuite/gcc.dg/vect/pr65947-1.c b/gcc/testsuite/gcc.dg/vect/pr65947-1.c
index 93ca4dbcc21..9072f11a104 100644
--- a/gcc/testsuite/gcc.dg/vect/pr65947-1.c
+++ b/gcc/testsuite/gcc.dg/vect/pr65947-1.c
@@ -40,5 +40,5 @@ main (void)
   return 0;
 }
 
-/* { dg-final { scan-tree-dump-times "LOOP VECTORIZED" 2 "vect" { xfail { ! vect_max_reduc } } } } */
-/* { dg-final { scan-tree-dump-times "condition expression based on integer induction." 4 "vect" { xfail { ! vect_max_reduc } } } } */
+/* { dg-final { scan-tree-dump-times "LOOP VECTORIZED" 2 "vect" } } */
+/* { dg-final { scan-tree-dump-times "condition expression based on integer induction." 4 "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/pr65947-10.c b/gcc/testsuite/gcc.dg/vect/pr65947-10.c
index 9bdfd6db518..a8a674f40f0 100644
--- a/gcc/testsuite/gcc.dg/vect/pr65947-10.c
+++ b/gcc/testsuite/gcc.dg/vect/pr65947-10.c
@@ -40,6 +40,6 @@ main (void)
   return 0;
 }
 
-/* { dg-final { scan-tree-dump-times "LOOP VECTORIZED" 2 "vect" { xfail { ! vect_max_reduc } } } } */
+/* { dg-final { scan-tree-dump-times "LOOP VECTORIZED" 2 "vect" } } */
 /* { dg-final { scan-tree-dump-not "condition expression based on integer induction." "vect" } } */
 
diff --git a/gcc/testsuite/gcc.dg/vect/pr65947-12.c b/gcc/testsuite/gcc.dg/vect/pr65947-12.c
index 2f37aaf01ec..8e2c46f1a6b 100644
--- a/gcc/testsuite/gcc.dg/vect/pr65947-12.c
+++ b/gcc/testsuite/gcc.dg/vect/pr65947-12.c
@@ -41,5 +41,5 @@ main (void)
   return 0;
 }
 
-/* { dg-final { scan-tree-dump-times "LOOP VECTORIZED" 2 "vect" { xfail { ! vect_max_reduc } } } } */
+/* { dg-final { scan-tree-dump-times "LOOP VECTORIZED" 2 "vect" } } */
 /* { dg-final { scan-tree-dump-not "condition expression based on integer induction." "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/pr65947-13.c b/gcc/testsuite/gcc.dg/vect/pr65947-13.c
index e1b626e45a3..061777af34c 100644
--- a/gcc/testsuite/gcc.dg/vect/pr65947-13.c
+++ b/gcc/testsuite/gcc.dg/vect/pr65947-13.c
@@ -41,5 +41,5 @@ main (void)
   return 0;
 }
 
-/* { dg-final { scan-tree-dump-times "LOOP VECTORIZED" 2 "vect" { xfail { ! vect_max_reduc } } } } */
+/* { dg-final { scan-tree-dump-times "LOOP VECTORIZED" 2 "vect" } } */
 /* { dg-final { scan-tree-dump-not "condition expression based on integer induction." "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/pr65947-14.c b/gcc/testsuite/gcc.dg/vect/pr65947-14.c
new file mode 100644
index 00000000000..a28e80bb9fc
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/pr65947-14.c
@@ -0,0 +1,44 @@
+/* { dg-require-effective-target vect_condition } */
+
+#include "tree-vect.h"
+
+extern void abort (void) __attribute__ ((noreturn));
+
+#define N 27
+
+/* Condition reduction with matches only in even lanes at runtime.  */
+
+int
+condition_reduction (int *a, int min_v)
+{
+  int last = N + 96;
+
+  for (int i = 0; i < N; i++)
+    if (a[i] > min_v)
+      last = i;
+
+  return last;
+}
+
+int
+main (void)
+{
+  int a[N] = {
+  47, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+  1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+  21, 22, 23, 24, 25, 26, 27
+  };
+
+  check_vect ();
+
+  int ret = condition_reduction (a, 46);
+
+  /* loop should have found a value of 0, not default N + 96.  */
+  if (ret != 0)
+    abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "LOOP VECTORIZED" 2 "vect" } } */
+/* { dg-final { scan-tree-dump-times "condition expression based on integer induction." 4 "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/pr65947-2.c b/gcc/testsuite/gcc.dg/vect/pr65947-2.c
index 6a36db131e4..d72fffa6720 100644
--- a/gcc/testsuite/gcc.dg/vect/pr65947-2.c
+++ b/gcc/testsuite/gcc.dg/vect/pr65947-2.c
@@ -41,5 +41,5 @@ main (void)
   return 0;
 }
 
-/* { dg-final { scan-tree-dump-times "LOOP VECTORIZED" 2 "vect" { xfail { ! vect_max_reduc } } } } */
+/* { dg-final { scan-tree-dump-times "LOOP VECTORIZED" 2 "vect" } } */
 /* { dg-final { scan-tree-dump-not "condition expression based on integer induction." "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/pr65947-3.c b/gcc/testsuite/gcc.dg/vect/pr65947-3.c
index 1323ed07c80..98945ba505d 100644
--- a/gcc/testsuite/gcc.dg/vect/pr65947-3.c
+++ b/gcc/testsuite/gcc.dg/vect/pr65947-3.c
@@ -51,5 +51,5 @@ main (void)
   return 0;
 }
 
-/* { dg-final { scan-tree-dump-times "LOOP VECTORIZED" 2 "vect" { xfail { ! vect_max_reduc } } } } */
+/* { dg-final { scan-tree-dump-times "LOOP VECTORIZED" 2 "vect" } } */
 /* { dg-final { scan-tree-dump-not "condition expression based on integer induction." "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/pr65947-4.c b/gcc/testsuite/gcc.dg/vect/pr65947-4.c
index d754b8d3ccb..695889d743b 100644
--- a/gcc/testsuite/gcc.dg/vect/pr65947-4.c
+++ b/gcc/testsuite/gcc.dg/vect/pr65947-4.c
@@ -40,6 +40,6 @@ main (void)
   return 0;
 }
 
-/* { dg-final { scan-tree-dump-times "LOOP VECTORIZED" 2 "vect" { xfail { ! vect_max_reduc } } } } */
-/* { dg-final { scan-tree-dump-times "condition expression based on integer induction." 4 "vect" { xfail { ! vect_max_reduc } } } } */
+/* { dg-final { scan-tree-dump-times "LOOP VECTORIZED" 2 "vect" } } */
+/* { dg-final { scan-tree-dump-times "condition expression based on integer induction." 4 "vect" } } */
 
diff --git a/gcc/testsuite/gcc.dg/vect/pr65947-5.c b/gcc/testsuite/gcc.dg/vect/pr65947-5.c
index b2af501f40d..04d9b38d58a 100644
--- a/gcc/testsuite/gcc.dg/vect/pr65947-5.c
+++ b/gcc/testsuite/gcc.dg/vect/pr65947-5.c
@@ -41,6 +41,6 @@ main (void)
   return 0;
 }
 
-/* { dg-final { scan-tree-dump-times "LOOP VECTORIZED" 1 "vect" { xfail { ! vect_max_reduc } } } } */
-/* { dg-final { scan-tree-dump "loop size is greater than data size" "vect" { xfail { ! vect_max_reduc } } } } */
+/* { dg-final { scan-tree-dump-times "LOOP VECTORIZED" 1 "vect" } } */
+/* { dg-final { scan-tree-dump "loop size is greater than data size" "vect" } } */
 /* { dg-final { scan-tree-dump-not "condition expression based on integer induction." "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/pr65947-6.c b/gcc/testsuite/gcc.dg/vect/pr65947-6.c
index 12dc852a32f..caa4a14120a 100644
--- a/gcc/testsuite/gcc.dg/vect/pr65947-6.c
+++ b/gcc/testsuite/gcc.dg/vect/pr65947-6.c
@@ -40,5 +40,5 @@ main (void)
   return 0;
 }
 
-/* { dg-final { scan-tree-dump-times "LOOP VECTORIZED" 2 "vect" { xfail { ! vect_max_reduc } } } } */
+/* { dg-final { scan-tree-dump-times "LOOP VECTORIZED" 2 "vect" } } */
 /* { dg-final { scan-tree-dump-not "condition expression based on integer induction." "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/pr65947-8.c b/gcc/testsuite/gcc.dg/vect/pr65947-8.c
index 293118582aa..f0f1ac29699 100644
--- a/gcc/testsuite/gcc.dg/vect/pr65947-8.c
+++ b/gcc/testsuite/gcc.dg/vect/pr65947-8.c
@@ -42,4 +42,4 @@ main (void)
 }
 
 /* { dg-final { scan-tree-dump-not "LOOP VECTORIZED" "vect" } } */
-/* { dg-final { scan-tree-dump "multiple types in double reduction or condition reduction" "vect" { xfail { ! vect_max_reduc } } } } */
+/* { dg-final { scan-tree-dump "multiple types in double reduction or condition reduction" "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/pr65947-9.c b/gcc/testsuite/gcc.dg/vect/pr65947-9.c
index d5a76e9fc0d..d769af9ec73 100644
--- a/gcc/testsuite/gcc.dg/vect/pr65947-9.c
+++ b/gcc/testsuite/gcc.dg/vect/pr65947-9.c
@@ -9,10 +9,10 @@ extern void abort (void) __attribute__ ((noreturn));
 /* Condition reduction with maximum possible loop size.  Will fail to
    vectorize because the vectorisation requires a slot for default values.  */
 
-char
+signed char __attribute__((noinline,noclone))
 condition_reduction (char *a, char min_v)
 {
-  char last = -72;
+  signed char last = -72;
 
   for (int i = 0; i < N; i++)
     if (a[i] < min_v)
@@ -21,10 +21,10 @@ condition_reduction (char *a, char min_v)
   return last;
 }
 
-char
-main (void)
+int
+main ()
 {
-  char a[N] = {
+  signed char a[N] = {
   11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
   1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
   21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
@@ -34,13 +34,16 @@ main (void)
 
   check_vect ();
 
-  char ret = condition_reduction (a, 16);
-
+  signed char ret = condition_reduction (a, 16);
   if (ret != 10)
     abort ();
 
+  ret = condition_reduction (a, 1);
+  if (ret != -72)
+    abort ();
+
   return 0;
 }
 
 /* { dg-final { scan-tree-dump-not "LOOP VECTORIZED" "vect" } } */
-/* { dg-final { scan-tree-dump "loop size is greater than data size" "vect" { xfail { ! vect_max_reduc } } } } */
+/* { dg-final { scan-tree-dump "loop size is greater than data size" "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/pr66278.c b/gcc/testsuite/gcc.dg/vect/pr66278.c
new file mode 100644
index 00000000000..3e0e2ec5e2b
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/pr66278.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+#define N 101
+
+typedef unsigned int __uint32_t;
+
+int main(int argc, char **argv)
+{
+  __uint32_t array[N][N][N];
+
+  const unsigned int next = argc == 3 ? 0 : 1;
+
+  for (unsigned i = next; i < N;  i++)
+    array[3][3][i] = array[3][3][i] - 10;
+
+  return array[3][3][argc];
+}
+
+/* { dg-final { scan-tree-dump-times "LOOP VECTORIZED" 1 "vect" } } */
+/* { dg-require-effective-target vect_int } */
diff --git a/gcc/testsuite/gcc.dg/vect/pr66623.c b/gcc/testsuite/gcc.dg/vect/pr66623.c
new file mode 100644
index 00000000000..f90c673f82d
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/pr66623.c
@@ -0,0 +1,86 @@
+/* { dg-require-effective-target vect_float } */
+
+#include "tree-vect.h"
+
+extern void abort (void);
+
+#define OP *
+#define INIT 1.0
+
+float __attribute__((noinline,noclone))
+foo (float *__restrict__ i)
+{
+  float l = INIT;
+  int a;
+  int b;
+
+  for (a = 0; a < 4; a++)
+    for (b = 0; b < 4; b++)
+      l = l OP i[b];
+
+  return l;
+}
+
+float __attribute__((noinline,noclone))
+foo_ref (float *__restrict__ i)
+{
+  float l = INIT;
+
+  l = l OP i[0];
+  l = l OP i[1];
+  l = l OP i[2];
+  l = l OP i[3];
+
+  l = l OP i[0];
+  l = l OP i[1];
+  l = l OP i[2];
+  l = l OP i[3];
+
+  l = l OP i[0];
+  l = l OP i[1];
+  l = l OP i[2];
+  l = l OP i[3];
+
+  l = l OP i[0];
+  l = l OP i[1];
+  l = l OP i[2];
+  l = l OP i[3];
+
+  return l;
+}
+
+union u
+{
+  float f;
+  unsigned int u;
+};
+
+int
+main (void)
+{
+  union u res, res2;
+  float a[4];
+
+  if (sizeof (float) != sizeof (unsigned int))
+    return 0;
+
+  check_vect ();
+
+  a[0] = 0.01;
+  a[1] = 0.01;
+  a[2] = 0.01;
+  a[3] = 1.0;
+
+  res.f = foo_ref (a);
+
+  res2.f = foo (a);
+
+  if (res.u != res2.u)
+    abort ();
+
+  return 0;
+}
+
+/* need -ffast-math to vectorize this loop.  */
+/* ARM NEON passes -ffast-math to these tests, so expect this to fail.  */
+/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect" { xfail arm_neon_ok } } } */
diff --git a/gcc/testsuite/gcc.dg/vect/pr80815-1.c b/gcc/testsuite/gcc.dg/vect/pr80815-1.c
new file mode 100644
index 00000000000..98c06c0bb03
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/pr80815-1.c
@@ -0,0 +1,38 @@
+/* { dg-require-effective-target vect_int } */
+
+#include "tree-vect.h"
+int arr[2048];
+
+__attribute__ ((noinline)) int
+foo (int *a, int *b)
+{
+  int i;
+  int *a1 = a;
+  int *a0 = a1 - 512;
+  for (i = 0; i < 500; i++)
+    {
+      *b = *a0 + *a1;
+      b++;
+      a0--;
+      a1--;
+    }
+  return 0;
+}
+
+int main (void)
+{
+  int *a = &arr[1027];
+  int *b = &arr[1024];
+
+  int i;
+  for (i = 0; i < 2048; i++)
+    arr[i] = i;
+
+  foo (a, b);
+
+  if (arr[1026] != 2053 || arr[1027] != 2054)
+    abort ();
+
+  return 0;
+}
+
diff --git a/gcc/testsuite/gcc.dg/vect/pr80815-2.c b/gcc/testsuite/gcc.dg/vect/pr80815-2.c
new file mode 100644
index 00000000000..83557daa696
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/pr80815-2.c
@@ -0,0 +1,46 @@
+/* { dg-require-effective-target vect_int } */
+
+#include "tree-vect.h"
+int arr[2048];
+int res[100] = { 13198, 13224, 12735, 12760, 12270, 12294,
+		 11803, 11826, 11334, 11356, 10863, 10884,
+		 10390, 10410, 9915, 9934, 9438, 9456,
+		 8959, 8976, 8478, 8494, 7995, 8010,
+		 7510, 7524, 7023, 7036, 6534, 6546,
+		 6043, 6054, 5550, 5560, 5055, 5064,
+		 4558, 4566, 4059, 4066, 3558, 3564,
+		 3055, 3060, 2550, 2554, 2043, 0};
+
+__attribute__ ((noinline)) int
+foo (int *a, int *b)
+{
+  int i;
+  int *a1 = a;
+  int *a0 = a1 - 512;
+  for (i = 0; i < 50; i++)
+    {
+      *b = *a0 + *a1;
+      b--;
+      a0--;
+      a1--;
+    }
+  return 0;
+}
+
+int main (void)
+{
+  int *a = &arr[1024];
+  int *b = &arr[1022];
+
+  int i;
+  for (i = 0; i < 2048; i++)
+    arr[i] = i;
+
+  foo (a, b);
+
+  for (i = 973; i < 1020; i++)
+    if (arr[i] != res[i - 973])
+      abort ();
+
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/vect/pr80815-3.c b/gcc/testsuite/gcc.dg/vect/pr80815-3.c
new file mode 100644
index 00000000000..dae01fa7af7
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/pr80815-3.c
@@ -0,0 +1,45 @@
+/* { dg-require-effective-target vect_int } */
+
+#include "tree-vect.h"
+int arr[2048];
+int res[100] = { 2148, 2146, 2144, 2142, 2140, 2138, 2136, 2134, 2132, 2130,
+		 2128, 2126, 2124, 2122, 2120, 2118, 2116, 2114, 2112, 2110,
+		 2108, 2106, 2104, 2102, 2100, 2098, 2096, 2094, 2092, 2090,
+		 2088, 2086, 2084, 2082, 2080, 2078, 2076, 2074, 2072, 2070,
+		 2068, 2066, 2064, 2062, 2060, 2058, 2056, 2054, 3078, 2050};
+
+__attribute__ ((noinline)) int
+foo (int *a, int *b, int len)
+{
+  int i;
+  int *a1 = a;
+  int *a0 = a1 - 4;
+  for (i = 0; i < len; i++)
+    {
+      *b = *a0 + *a1;
+      b--;
+      a0++;
+      a1++;
+    }
+  return 0;
+}
+
+int main (void)
+{
+  int *a = &arr[1027];
+  int *b = &arr[1024];
+
+  int i;
+  for (i = 0; i < 2048; i++)
+    arr[i] = i;
+
+  foo (a, b, 50);
+
+  for (i = 975; i < 1025; i++)
+    if (arr[i] != res[i - 975])
+      abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump "improved number of alias checks from \[0-9\]* to 1" "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/pr80928.c b/gcc/testsuite/gcc.dg/vect/pr80928.c
new file mode 100644
index 00000000000..e6c1f1ab5a7
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/pr80928.c
@@ -0,0 +1,37 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+
+#include "tree-vect.h"
+
+int a[1020];
+
+void __attribute__((noinline))
+foo ()
+{
+  for (int i = 0; i < 1020; i += 5)
+    {
+      a[i] = i;
+      a[i+1] = i;
+      a[i+2] = i;
+      a[i+3] = i;
+      a[i+4] = i;
+    }
+}
+
+int main ()
+{
+  check_vect ();
+
+  foo ();
+
+  /* check results */
+  for (int i = 0; i < 1020; ++i)
+    if (a[i] != ((i + 4) / 5) * 5)
+      abort ();
+
+  return 0;
+}
+
+/* Make sure we are not triggering hybrid SLP due to the IV update.  */
+/* { dg-final { scan-tree-dump "Loop contains only SLP stmts" "vect" } } */
+/* { dg-final { scan-tree-dump "vectorized 1 loops" "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/pr81136.c b/gcc/testsuite/gcc.dg/vect/pr81136.c
new file mode 100644
index 00000000000..24bd8fa3b19
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/pr81136.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+
+struct __attribute__((aligned (32)))
+{
+  char misaligner;
+  int foo[100];
+  int bar[100];
+} *a;
+
+void
+fn1 (int n)
+{
+  int *b = a->foo;
+  for (int i = 0; i < n; i++)
+    a->bar[i] = b[i];
+}
diff --git a/gcc/testsuite/gcc.dg/vect/pr81196.c b/gcc/testsuite/gcc.dg/vect/pr81196.c
new file mode 100644
index 00000000000..46d7a9ebc57
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/pr81196.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+/* { dg-require-effective-target vect_perm_short } */
+
+void f(short*p){
+  p=(short*)__builtin_assume_aligned(p,64);
+  short*q=p+256;
+  for(;p!=q;++p,--q){
+    short t=*p;*p=*q;*q=t;
+  }
+}
+void b(short*p){
+  p=(short*)__builtin_assume_aligned(p,64);
+  short*q=p+256;
+  for(;p<q;++p,--q){
+    short t=*p;*p=*q;*q=t;
+  }
+}
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 2 "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/pr81410.c b/gcc/testsuite/gcc.dg/vect/pr81410.c
new file mode 100644
index 00000000000..929850f2391
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/pr81410.c
@@ -0,0 +1,38 @@
+/* { dg-do run } */
+/* { dg-require-effective-target vect_long_long } */
+
+#include "tree-vect.h"
+
+typedef long long uint64_t;
+uint64_t x[24];
+uint64_t y[16];
+uint64_t z[8];
+
+void __attribute__((noinline)) foo()
+{
+  for (int i = 0; i < 8; ++i)
+    {
+      y[2*i] = x[3*i];
+      y[2*i + 1] = x[3*i + 1];
+      z[i] = 1;
+    }
+}
+
+int main()
+{
+  check_vect ();
+
+  for (int i = 0; i < 24; ++i)
+    {
+      x[i] = i;
+      __asm__ volatile ("" : : : "memory");
+    }
+  foo ();
+  for (int i = 0; i < 8; ++i)
+    if (y[2*i] != 3*i || y[2*i+1] != 3*i + 1)
+      __builtin_abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump "vectorized 1 loops" "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/slp-13-big-array.c b/gcc/testsuite/gcc.dg/vect/slp-13-big-array.c
index 4520fb15f20..5540387b028 100644
--- a/gcc/testsuite/gcc.dg/vect/slp-13-big-array.c
+++ b/gcc/testsuite/gcc.dg/vect/slp-13-big-array.c
@@ -22,7 +22,7 @@ main1 ()
 	abort ();
     }
 
-  /* Induction is not SLPable yet.  */
+  /* Induction is SLPable.  */
   for (i = 0; i < N; i++)
     {
       out[i*8] = in[i*8] + i;
@@ -49,8 +49,7 @@ main1 ()
 	abort ();
     }
 
-  /* Induction is not SLPable yet and strided group size must be a power of 2
-     to get vectorized.  */
+  /* Induction is SLPable.  */
   for (i = 0; i < N/2; i++)
     {
       out2[i*12] = in2[i*12] + i;
@@ -134,7 +133,7 @@ int main (void)
   return 0;
 }
 
-/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" { target { vect_interleave && vect_extract_even_odd } } } } */
-/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 3 "vect" { xfail *-*-* }  } } */
-/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect" } } */
-
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" { target { { vect_interleave && vect_extract_even_odd } && { ! vect_pack_trunc } } } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 2 "vect" { target { ! vect_pack_trunc } } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" { target { { vect_interleave && vect_extract_even_odd } && vect_pack_trunc } } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 3 "vect" { target vect_pack_trunc } } } */
diff --git a/gcc/testsuite/gcc.dg/vect/slp-13.c b/gcc/testsuite/gcc.dg/vect/slp-13.c
index 2394874d36c..e7482667e2a 100644
--- a/gcc/testsuite/gcc.dg/vect/slp-13.c
+++ b/gcc/testsuite/gcc.dg/vect/slp-13.c
@@ -14,7 +14,7 @@ main1 ()
   unsigned int in2[N*8] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63};
   unsigned int out2[N*8];
 
-  /* Induction is not SLPable yet.  */
+  /* Induction is SLPable.  */
   for (i = 0; i < N; i++)
     {
       out[i*8] = in[i*8] + i;
@@ -41,8 +41,7 @@ main1 ()
 	abort ();
     }
 
-  /* Induction is not SLPable yet and strided group size must be a power of 2 
-     to get vectorized.  */
+  /* Induction is SLPable.  */
   for (i = 0; i < N/2; i++)
     {
       out2[i*12] = in2[i*12] + i;
@@ -126,7 +125,7 @@ int main (void)
   return 0;
 }
 
-/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" { target { vect_interleave && vect_extract_even_odd } } } } */
-/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 3 "vect" { xfail *-*-* }  } } */
-/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect" } } */
-  
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" { target { { vect_interleave && vect_extract_even_odd } && { ! vect_pack_trunc } } } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 2 "vect" { target { ! vect_pack_trunc } } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" { target { { vect_interleave && vect_extract_even_odd } && vect_pack_trunc } } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 3 "vect" { target vect_pack_trunc } } } */
diff --git a/gcc/testsuite/gcc.dg/vect/slp-43.c b/gcc/testsuite/gcc.dg/vect/slp-43.c
index fea3aadb341..880a2961ae1 100644
--- a/gcc/testsuite/gcc.dg/vect/slp-43.c
+++ b/gcc/testsuite/gcc.dg/vect/slp-43.c
@@ -4,13 +4,16 @@
 #include <string.h>
 #include "tree-vect.h"
 
+/* AVX512BW has V64QImode, make char_1 vectorizable with that.  */
+#define MAX_VEC_ELEMENTS 64
+
 #define FOO(T,N) \
 void __attribute__((noinline,noclone)) \
 foo_ ## T ## _ ## N (T * __restrict__ in_, T * __restrict__ out_, int s) \
 { \
   T *in = __builtin_assume_aligned (in_, __BIGGEST_ALIGNMENT__); \
   T *out = __builtin_assume_aligned (out_, __BIGGEST_ALIGNMENT__); \
-  for (int i = 0; i < 16; i++) \
+  for (int i = 0; i < MAX_VEC_ELEMENTS; i++) \
     { \
       for (int j = 0; j < N; ++j) \
         out[j] = in[j]; \
@@ -23,9 +26,9 @@ foo_ ## T ## _ ## N (T * __restrict__ in_, T * __restrict__ out_, int s) \
  do { \
   memset (out, 0, 4096); \
   foo_ ## T ## _ ## N ((T *)in, (T *)out, 1); \
-  if (memcmp (in, out, sizeof (T) * 16 * N) != 0) \
+  if (memcmp (in, out, sizeof (T) * MAX_VEC_ELEMENTS * N) != 0) \
     __builtin_abort (); \
-  for (int i = sizeof (T) * 16 * N; i < 4096; ++i) \
+  for (int i = sizeof (T) * MAX_VEC_ELEMENTS * N; i < 4096; ++i) \
     if (out[i] != 0) \
       __builtin_abort (); \
  } while (0)
diff --git a/gcc/testsuite/gcc.dg/vect/slp-45.c b/gcc/testsuite/gcc.dg/vect/slp-45.c
index a8300a44670..20a9f815292 100644
--- a/gcc/testsuite/gcc.dg/vect/slp-45.c
+++ b/gcc/testsuite/gcc.dg/vect/slp-45.c
@@ -4,13 +4,16 @@
 #include <string.h>
 #include "tree-vect.h"
 
+/* AVX512BW has V64QImode, make char_1 vectorizable with that.  */
+#define MAX_VEC_ELEMENTS 64
+
 #define FOO(T,N) \
 void __attribute__((noinline,noclone)) \
 foo_ ## T ## _ ## N (T * __restrict__ in_, T * __restrict__ out_, int s) \
 { \
   T *in = __builtin_assume_aligned (in_, __BIGGEST_ALIGNMENT__); \
   T *out = __builtin_assume_aligned (out_, __BIGGEST_ALIGNMENT__); \
-  for (int i = 0; i < 16; i++) \
+  for (int i = 0; i < MAX_VEC_ELEMENTS; i++) \
     { \
       for (int j = 0; j < N; ++j) \
         out[j] = in[j]; \
@@ -23,9 +26,9 @@ foo_ ## T ## _ ## N (T * __restrict__ in_, T * __restrict__ out_, int s) \
  do { \
   memset (out, 0, 4096); \
   foo_ ## T ## _ ## N ((T *)in, (T *)out, 1); \
-  if (memcmp (in, out, sizeof (T) * 16 * N) != 0) \
+  if (memcmp (in, out, sizeof (T) * MAX_VEC_ELEMENTS * N) != 0) \
     __builtin_abort (); \
-  for (int i = sizeof (T) * 16 * N; i < 4096; ++i) \
+  for (int i = sizeof (T) * MAX_VEC_ELEMENTS * N; i < 4096; ++i) \
     if (out[i] != 0) \
       __builtin_abort (); \
  } while (0)
diff --git a/gcc/testsuite/gcc.dg/vect/slp-perm-8.c b/gcc/testsuite/gcc.dg/vect/slp-perm-8.c
index d5fa1e8023f..f804dcc8163 100644
--- a/gcc/testsuite/gcc.dg/vect/slp-perm-8.c
+++ b/gcc/testsuite/gcc.dg/vect/slp-perm-8.c
@@ -41,6 +41,7 @@ int main (int argc, const char* argv[])
       check_results[3*i] = 9 * i + 6;
       check_results[3*i+1] = 9 * i + 15;
       check_results[3*i+2] = 9 * i + 4;
+      __asm__ volatile ("" : : : "memory");
     }
 
   foo (input, output);
@@ -52,8 +53,7 @@ int main (int argc, const char* argv[])
   return 0;
 }
 
-/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 2 "vect" { target { vect_perm_byte && vect_char_mult } } } } */
-/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_perm_byte && {! vect_char_mult } } } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_perm_byte } } } } */
 /* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect" { target { vect_perm_byte && {! vect_load_lanes } } } } } */
 /* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 0 "vect" { target vect_load_lanes } } } */
 /* { dg-final { scan-tree-dump "note: Built SLP cancelled: can use load/store-lanes" "vect" { target { vect_perm_byte && vect_load_lanes } } } } */
diff --git a/gcc/testsuite/gcc.dg/vect/slp-perm-9.c b/gcc/testsuite/gcc.dg/vect/slp-perm-9.c
index 781096e9f66..4d9c11dcc47 100644
--- a/gcc/testsuite/gcc.dg/vect/slp-perm-9.c
+++ b/gcc/testsuite/gcc.dg/vect/slp-perm-9.c
@@ -42,6 +42,7 @@ int main (int argc, const char* argv[])
       check_results[3*i] = 9 * i + 6;
       check_results[3*i+1] = 9 * i + 15;
       check_results[3*i+2] = 9 * i + 4;
+      __asm__ volatile ("" : : : "memory");
     }
 
   foo (input, output);
diff --git a/gcc/testsuite/gcc.dg/vect/slp-reduc-8.c b/gcc/testsuite/gcc.dg/vect/slp-reduc-8.c
new file mode 100644
index 00000000000..618c800e577
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/slp-reduc-8.c
@@ -0,0 +1,48 @@
+/* { dg-require-effective-target vect_int } */
+
+#include "tree-vect.h"
+
+static int a[512], b[512];
+
+void __attribute__((noinline,noclone))
+foo (int *sum1p, int *sum2p, int *sum3p)
+{
+  int sum1 = 0;
+  int sum2 = 0;
+  int sum3 = 0;
+  /* Check that we vectorize a reduction chain and a SLP reduction
+     at the same time.  */
+  for (int i = 0; i < 256; ++i)
+    {
+      sum1 += a[2*i];
+      sum1 += a[2*i + 1];
+      sum2 += b[2*i];
+      sum3 += b[2*i + 1];
+    }
+  *sum1p = sum1;
+  *sum2p = sum2;
+  *sum3p = sum3;
+}
+
+int main()
+{
+  check_vect ();
+
+  for (int i = 0; i < 256; ++i)
+    {
+      a[2*i] = i;
+      a[2*i + 1] = i/2;
+      b[2*i] = i + 1;
+      b[2*i + 1] = i/2 + 1;
+      __asm__ volatile ("" : : : "memory");
+    }
+  int sum1, sum2, sum3;
+  foo (&sum1, &sum2, &sum3);
+  if (sum1 != 48896 || sum2 != 32896 || sum3 != 16512)
+    abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump "Loop contains only SLP stmts" "vect" } } */
+/* { dg-final { scan-tree-dump "vectorized 1 loops" "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-103.c b/gcc/testsuite/gcc.dg/vect/vect-103.c
index fb2a8578c5d..e0fd1b61e02 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-103.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-103.c
@@ -55,5 +55,5 @@ int main (void)
 }
 
 /* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
-/* { dg-final { scan-tree-dump-times "dependence distance modulo vf == 0" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "accesses have the same alignment" 1 "vect" } } */
 
diff --git a/gcc/testsuite/gcc.dg/vect/vect-104.c b/gcc/testsuite/gcc.dg/vect/vect-104.c
index 9667b55566c..c7478382915 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-104.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-104.c
@@ -1,4 +1,5 @@
 /* { dg-require-effective-target vect_int } */
+/* { dg-additional-options "--param max-completely-peel-times=1" } */
 
 #include <stdlib.h>
 #include <stdarg.h>
diff --git a/gcc/testsuite/gcc.dg/vect/vect-44.c b/gcc/testsuite/gcc.dg/vect/vect-44.c
index 186f9cfc9e2..f4efb17c0eb 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-44.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-44.c
@@ -1,6 +1,6 @@
 /* { dg-require-effective-target vect_float } */
+/* { dg-additional-options "--param vect-max-peeling-for-alignment=0" } */
 
-#include <stdarg.h>
 #include "tree-vect.h"
 
 #define N 256
@@ -65,7 +65,7 @@ int main (void)
    two loads to be aligned).  */
 
 /* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
-/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 2 "vect" { xfail { vect_no_align && { ! vect_hw_misalign } } } } } */
-/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" { xfail { { vect_no_align && { ! vect_hw_misalign } } || {! vector_alignment_reachable} } } } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 3 "vect" { xfail { vect_no_align && { ! vect_hw_misalign } } } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 0 "vect" { xfail { { vect_no_align && { ! vect_hw_misalign } } || {! vector_alignment_reachable} } } } } */
 /* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning." 3 "vect" { target { vect_no_align && { ! vect_hw_misalign } } } } } */
 /* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning." 1 "vect" { target { {! vector_alignment_reachable} && {{! vect_no_align} && {! vect_hw_misalign} } } } } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-50.c b/gcc/testsuite/gcc.dg/vect/vect-50.c
index 78bfd8d3920..cadbcbb9015 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-50.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-50.c
@@ -1,6 +1,6 @@
 /* { dg-require-effective-target vect_float } */
+/* { dg-additional-options "--param vect-max-peeling-for-alignment=0" } */
 
-#include <stdarg.h>
 #include "tree-vect.h"
 
 #define N 256
@@ -61,8 +61,8 @@ int main (void)
    align the store will not force the two loads to be aligned).  */
 
 /* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
-/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 2 "vect" { xfail { vect_no_align && { ! vect_hw_misalign } } } } } */
-/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 2 "vect" { target vect_hw_misalign } } } */
-/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" { xfail { { vect_no_align && { ! vect_hw_misalign } } || {! vector_alignment_reachable} } } } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 3 "vect" { xfail { vect_no_align && { ! vect_hw_misalign } } } } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 3 "vect" { target vect_hw_misalign } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 0 "vect" { xfail { { vect_no_align && { ! vect_hw_misalign } } || {! vector_alignment_reachable} } } } } */
 /* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning." 3 "vect" { target { vect_no_align && { ! vect_hw_misalign } } } } } */
 /* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning." 1 "vect" { target { {! vector_alignment_reachable} && { {! vect_no_align } && {! vect_hw_misalign } } } } } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-82.c b/gcc/testsuite/gcc.dg/vect/vect-82.c
index 7f4578e1e31..fcafb36c063 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-82.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-82.c
@@ -1,4 +1,4 @@
-/* { dg-skip-if "powerpc and integer vectorization only" { ! { powerpc*-*-* && vect_int } } { "*" } { "" }  } */
+/* { dg-skip-if "powerpc and integer vectorization only" { ! { powerpc*-*-* && vect_int } }  } */
 
 #include <stdarg.h>
 #include "tree-vect.h"
diff --git a/gcc/testsuite/gcc.dg/vect/vect-82_64.c b/gcc/testsuite/gcc.dg/vect/vect-82_64.c
index 8dc9d96f7ae..358a85a838f 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-82_64.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-82_64.c
@@ -1,7 +1,7 @@
 /* { dg-do run { target { { powerpc*-*-* && lp64 } && powerpc_altivec_ok } } } */
 /* { dg-do compile { target { { powerpc*-*-* && ilp32 } && powerpc_altivec_ok } } } */
 /* { dg-additional-options "-mpowerpc64 -maltivec" } */
-/* { dg-skip-if "" { powerpc-ibm-aix* } { "*" } { "" } } */
+/* { dg-skip-if "" { powerpc-ibm-aix* } } */
 
 #include <stdarg.h>
 #include "tree-vect.h"
diff --git a/gcc/testsuite/gcc.dg/vect/vect-83.c b/gcc/testsuite/gcc.dg/vect/vect-83.c
index 49beb31c609..a300a0a08c4 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-83.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-83.c
@@ -1,4 +1,4 @@
-/* { dg-skip-if "powerpc and integer vectorization only" { ! { powerpc*-*-* && vect_int } } { "*" } { "" }  } */
+/* { dg-skip-if "powerpc and integer vectorization only" { ! { powerpc*-*-* && vect_int } }  } */
 
 #include <stdarg.h>
 #include "tree-vect.h"
diff --git a/gcc/testsuite/gcc.dg/vect/vect-83_64.c b/gcc/testsuite/gcc.dg/vect/vect-83_64.c
index fe985cb84bb..a5e897e093d 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-83_64.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-83_64.c
@@ -1,7 +1,7 @@
 /* { dg-do run { target { { powerpc*-*-* && lp64 } && powerpc_altivec_ok } } } */
 /* { dg-do compile { target { { powerpc*-*-* && ilp32 } && powerpc_altivec_ok } } } */
 /* { dg-additional-options "-mpowerpc64 -maltivec" } */
-/* { dg-skip-if "" { powerpc-ibm-aix* } { "*" } { "" } } */
+/* { dg-skip-if "" { powerpc-ibm-aix* } } */
 
 #include <stdarg.h>
 #include "tree-vect.h"
diff --git a/gcc/testsuite/gcc.dg/vect/vect-cond-2.c b/gcc/testsuite/gcc.dg/vect/vect-cond-2.c
index 646eac12a38..094cfe76701 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-cond-2.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-cond-2.c
@@ -39,6 +39,4 @@ int main (void)
   return 0;
 }
 
-/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail { ! vect_max_reduc } } } } */
-
-
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-pr69848.c b/gcc/testsuite/gcc.dg/vect/vect-pr69848.c
index 779a657b34e..c08f1e2f5c0 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-pr69848.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-pr69848.c
@@ -34,4 +34,4 @@ int main (void)
 
   return 0;
 }
-/* { dg-final { scan-tree-dump "vectorized 1 loops" "vect" { xfail { ! vect_max_reduc } } } } */
+/* { dg-final { scan-tree-dump "vectorized 1 loops" "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-profile-1.c b/gcc/testsuite/gcc.dg/vect/vect-profile-1.c
new file mode 100644
index 00000000000..93d7ad13147
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-profile-1.c
@@ -0,0 +1,35 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+/* { dg-additional-options "-fdump-tree-vect-details-blocks" } */
+
+/* At least one of these should correspond to a full vector.  */
+
+void
+f1 (int *x)
+{
+  for (int j = 0; j < 2; ++j)
+    x[j] += 1;
+}
+
+void
+f2 (int *x)
+{
+  for (int j = 0; j < 4; ++j)
+    x[j] += 1;
+}
+
+void
+f3 (int *x)
+{
+  for (int j = 0; j < 8; ++j)
+    x[j] += 1;
+}
+
+void
+f4 (int *x)
+{
+  for (int j = 0; j < 16; ++j)
+    x[j] += 1;
+}
+
+/* { dg-final { scan-tree-dump {goto <bb [0-9]+>; \[0+.0*%\]} vect } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-reduc-11.c b/gcc/testsuite/gcc.dg/vect/vect-reduc-11.c
new file mode 100644
index 00000000000..29408edcfce
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-reduc-11.c
@@ -0,0 +1,46 @@
+/* { dg-do run } */
+/* { dg-require-effective-target vect_int } */
+
+#include "tree-vect.h"
+
+int x[1024], y[1024], z[1024];
+
+int __attribute__((noinline,noclone))
+foo (int n)
+{
+  int sum = 0;
+  /* Can vectorize this.  */
+  for (int i = 0; i < n; ++i)
+    sum = (y[i] - (x[i] - sum));
+  return sum;
+}
+
+int __attribute__((noinline,noclone))
+bar (int n)
+{
+  int sum = 0;
+  /* Cannot vectorize this, sum is negated.  */
+  for (int i = 0; i < n; ++i)
+    sum = z[i] - (y[i] - (x[i] - sum));
+  return sum;
+}
+
+int
+main()
+{
+  check_vect ();
+  for (int i = 0; i < 1024; ++i)
+    {
+      x[i] = i;
+      y[i] = i + 1;
+      z[i] = 0;
+      __asm__ volatile ("" : : : "memory");
+    }
+  if (foo (1024) != 1024)
+    __builtin_abort ();
+  if (bar (1023) != -1 || bar (1024) != 0)
+    __builtin_abort ();
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
-- 
cgit v1.2.3