slp-13.c: Increase array size, add initialization.

	* gcc.dg/vect/slp-13.c: Increase array size, add initialization.
	* gcc.dg/vect/slp-24.c: Ditto.
	* gcc.dg/vect/slp-3.c: Likewise and fix scans.
	* gcc.dg/vect/slp-34.c: Ditto.
	* gcc.dg/vect/slp-4.c: Ditto.
	* gcc.dg/vect/slp-cond-2.c: Ditto.
	* gcc.dg/vect/slp-multitypes-11.c: Ditto.
	* gcc.dg/vect/vect-1.c: Ditto.
	* gcc.dg/vect/vect-10.c: Ditto.
	* gcc.dg/vect/vect-105.c: Ditto.
	* gcc.dg/vect/vect-112.c: Ditto.
	* gcc.dg/vect/vect-15.c: Ditto.
	* gcc.dg/vect/vect-2.c: Ditto.
	* gcc.dg/vect/vect-31.c: Ditto.
	* gcc.dg/vect/vect-32.c: Ditto.
	* gcc.dg/vect/vect-33.c: Ditto.
	* gcc.dg/vect/vect-34.c: Ditto.
	* gcc.dg/vect/vect-35.c: Ditto.
	* gcc.dg/vect/vect-36.c: Ditto.
	* gcc.dg/vect/vect-6.c: Ditto.
	* gcc.dg/vect/vect-73.c: Ditto.
	* gcc.dg/vect/vect-74.c: Ditto.
	* gcc.dg/vect/vect-75.c: Ditto.
	* gcc.dg/vect/vect-76.c: Ditto.
	* gcc.dg/vect/vect-80.c: Ditto.
	* gcc.dg/vect/vect-85.c: Ditto.
	* gcc.dg/vect/vect-89.c: Ditto.
	* gcc.dg/vect/vect-97.c: Ditto.
	* gcc.dg/vect/vect-98.c: Ditto.
	* gcc.dg/vect/vect-all.c: Ditto.
	* gcc.dg/vect/vect-double-reduc-6.c: Ditto.
	* gcc.dg/vect/vect-iv-8.c: Ditto.
	* gcc.dg/vect/vect-iv-8a.c: Ditto.
	* gcc.dg/vect/vect-outer-1.c: Ditto.
	* gcc.dg/vect/vect-outer-1a.c: Ditto.
	* gcc.dg/vect/vect-outer-1b.c: Ditto.
	* gcc.dg/vect/vect-outer-2.c: Ditto.
	* gcc.dg/vect/vect-outer-2a.c: Ditto.
	* gcc.dg/vect/vect-outer-2c.c: Ditto.
	* gcc.dg/vect/vect-outer-3.c: Ditto.
	* gcc.dg/vect/vect-outer-3a.c: Ditto.
	* gcc.dg/vect/vect-outer-4a.c: Ditto.
	* gcc.dg/vect/vect-outer-4b.c: Ditto.
	* gcc.dg/vect/vect-outer-4c.c: Ditto.
	* gcc.dg/vect/vect-outer-4d.c: Ditto.
	* gcc.dg/vect/vect-outer-4m.c: Ditto.
	* gcc.dg/vect/vect-outer-fir-lb.c: Ditto.
	* gcc.dg/vect/vect-outer-fir.c: Ditto.
	* gcc.dg/vect/vect-over-widen-1.c: Ditto.
	* gcc.dg/vect/vect-over-widen-2.c: Ditto.
	* gcc.dg/vect/vect-over-widen-3.c: Ditto.
	* gcc.dg/vect/vect-over-widen-4.c: Ditto.
	* gcc.dg/vect/vect-reduc-1char.c: Ditto.
	* gcc.dg/vect/vect-reduc-2char.c: Ditto.
	* gcc.dg/vect/vect-reduc-pattern-1b.c: Ditto.
	* gcc.dg/vect/vect-reduc-pattern-1c.c: Ditto.
	* gcc.dg/vect/vect-reduc-pattern-2b.c: Ditto.
	* gcc.dg/vect/vect-shift-2.c: Ditto.
	* gcc.dg/vect/vect-strided-a-u8-i8-gap2.c: Ditto.
	* gcc.dg/vect/vect-strided-a-u8-i8-gap7.c: Ditto.
	* gcc.dg/vect/vect-strided-u8-i8-gap2.c: Ditto.
	* gcc.dg/vect/vect-strided-u8-i8-gap4.c: Ditto.
	* gcc.dg/vect/vect-strided-u8-i8-gap7.c: Ditto.

From-SVN: r182165

126 files changed, 4670 insertions, 665 deletions

diff --git a/gcc/testsuite/gcc.dg/vect/slp-13-big-array.c b/gcc/testsuite/gcc.dg/vect/slp-13-big-array.c
new file mode 100644
index 0000000..c40822b
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/slp-13-big-array.c
@@ -0,0 +1,141 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+volatile int y = 0;
+
+int
+main1 ()
+{
+  int i;
+  unsigned short out[N*8];
+  unsigned short in[N*8];
+  unsigned int in2[N*8];
+  unsigned int out2[N*8];
+
+  for (i = 0; i < N*8; i++)
+    {
+      in[i] = in2[i] = i;
+      if (y) /* Avoid vectorization.  */
+	abort ();
+    }
+
+  /* Induction is not SLPable yet.  */
+  for (i = 0; i < N; i++)
+    {
+      out[i*8] = in[i*8] + i;
+      out[i*8 + 1] = in[i*8 + 1] + i;
+      out[i*8 + 2] = in[i*8 + 2] + i;
+      out[i*8 + 3] = in[i*8 + 3] + i;
+      out[i*8 + 4] = in[i*8 + 4] + i;
+      out[i*8 + 5] = in[i*8 + 5] + i;
+      out[i*8 + 6] = in[i*8 + 6] + i;
+      out[i*8 + 7] = in[i*8 + 7] + i;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*8] !=  in[i*8] + i
+         || out[i*8 + 1] != in[i*8 + 1] + i
+         || out[i*8 + 2] != in[i*8 + 2] + i
+         || out[i*8 + 3] != in[i*8 + 3] + i
+         || out[i*8 + 4] != in[i*8 + 4] + i
+         || out[i*8 + 5] != in[i*8 + 5] + i
+         || out[i*8 + 6] != in[i*8 + 6] + i
+         || out[i*8 + 7] != in[i*8 + 7] + i)
+	abort ();
+    }
+
+  /* Induction is not SLPable yet and strided group size must be a power of 2
+     to get vectorized.  */
+  for (i = 0; i < N/2; i++)
+    {
+      out2[i*12] = in2[i*12] + i;
+      out2[i*12 + 1] = in2[i*12 + 1] + i;
+      out2[i*12 + 2] = in2[i*12 + 2] + i;
+      out2[i*12 + 3] = in2[i*12 + 3] + i;
+      out2[i*12 + 4] = in2[i*12 + 4] + i;
+      out2[i*12 + 5] = in2[i*12 + 5] + i;
+      out2[i*12 + 6] = in2[i*12 + 6] + i;
+      out2[i*12 + 7] = in2[i*12 + 7] + i;
+      out2[i*12 + 8] = in2[i*12 + 8] + i;
+      out2[i*12 + 9] = in2[i*12 + 9] + i;
+      out2[i*12 + 10] = in2[i*12 + 10] + i;
+      out2[i*12 + 11] = in2[i*12 + 11] + i;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N/2; i++)
+    {
+        if (out2[i*12] != in2[i*12] + i
+            || out2[i*12 + 1] != in2[i*12 + 1] + i
+            || out2[i*12 + 2] != in2[i*12 + 2] + i
+            || out2[i*12 + 3] != in2[i*12 + 3] + i
+            || out2[i*12 + 4] != in2[i*12 + 4] + i
+            || out2[i*12 + 5] != in2[i*12 + 5] + i
+            || out2[i*12 + 6] != in2[i*12 + 6] + i
+            || out2[i*12 + 7] != in2[i*12 + 7] + i
+            || out2[i*12 + 8] != in2[i*12 + 8] + i
+            || out2[i*12 + 9] != in2[i*12 + 9] + i
+            || out2[i*12 + 10] != in2[i*12 + 10] + i
+            || out2[i*12 + 11] != in2[i*12 + 11] + i)
+          abort ();
+    }
+
+  /* Not power of 2 but SLPable.  */
+  for (i = 0; i < N/2; i++)
+    {
+      out2[i*12] = in2[i*12] + 1;
+      out2[i*12 + 1] = in2[i*12 + 1] + 2;
+      out2[i*12 + 2] = in2[i*12 + 2] + 3;
+      out2[i*12 + 3] = in2[i*12 + 3] + 4;
+      out2[i*12 + 4] = in2[i*12 + 4] + 5;
+      out2[i*12 + 5] = in2[i*12 + 5] + 6;
+      out2[i*12 + 6] = in2[i*12 + 6] + 7;
+      out2[i*12 + 7] = in2[i*12 + 7] + 8;
+      out2[i*12 + 8] = in2[i*12 + 8] + 9;
+      out2[i*12 + 9] = in2[i*12 + 9] + 10;
+      out2[i*12 + 10] = in2[i*12 + 10] + 11;
+      out2[i*12 + 11] = in2[i*12 + 11] + 12;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N/2; i++)
+    {
+        if (out2[i*12] != in2[i*12] + 1
+            || out2[i*12 + 1] != in2[i*12 + 1] + 2
+            || out2[i*12 + 2] != in2[i*12 + 2] + 3
+            || out2[i*12 + 3] != in2[i*12 + 3] + 4
+            || out2[i*12 + 4] != in2[i*12 + 4] + 5
+            || out2[i*12 + 5] != in2[i*12 + 5] + 6
+            || out2[i*12 + 6] != in2[i*12 + 6] + 7
+            || out2[i*12 + 7] != in2[i*12 + 7] + 8
+            || out2[i*12 + 8] != in2[i*12 + 8] + 9
+            || out2[i*12 + 9] != in2[i*12 + 9] + 10
+            || out2[i*12 + 10] != in2[i*12 + 10] + 11
+            || out2[i*12 + 11] != in2[i*12 + 11] + 12)
+          abort ();
+    }
+
+
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  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 { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc/testsuite/gcc.dg/vect/slp-13.c b/gcc/testsuite/gcc.dg/vect/slp-13.c
index e1c4e41..655e6ad 100644
--- a/gcc/testsuite/gcc.dg/vect/slp-13.c
+++ b/gcc/testsuite/gcc.dg/vect/slp-13.c
@@ -3,25 +3,17 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 64
-volatile int y = 0;
+#define N 8 
 
 int
 main1 ()
 {
   int i;
   unsigned short out[N*8];
-  unsigned short in[N*8];
-  unsigned int in2[N*8];
+  unsigned short in[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 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];
 
-  for (i = 0; i < N*8; i++)
-    {
-      in[i] = in2[i] = i;
-      if (y) /* Avoid vectorization.  */
-	abort ();
-    }
-
   /* Induction is not SLPable yet.  */
   for (i = 0; i < N; i++)
     {
diff --git a/gcc/testsuite/gcc.dg/vect/slp-24-big-array.c b/gcc/testsuite/gcc.dg/vect/slp-24-big-array.c
new file mode 100644
index 0000000..6c8f01c9
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/slp-24-big-array.c
@@ -0,0 +1,99 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+typedef struct {
+   unsigned char a;
+   unsigned char b;
+   unsigned char c;
+   unsigned char d;
+} s;
+
+unsigned char ub[N*2];
+unsigned char uc[N];
+
+volatile int y = 0;
+unsigned char check_diff = 2;
+
+void
+main1 (unsigned char x, unsigned char max_result, unsigned char min_result, s *arr)
+{
+  int i;
+  unsigned char udiff = 2;
+  unsigned char umax = x;
+  unsigned char umin = x;
+  unsigned char ua1[N*2];
+  s *pIn = arr;
+  s out[N];
+
+  for (i = 0; i < N; i++) {
+    udiff += (unsigned char) (ub[i] - uc[i]);
+
+    ua1[2*i+1] = ub[2*i+1];
+    ua1[2*i] = ub[2*i];
+
+    out[i].d = pIn->d - 1;
+    out[i].b = pIn->b - 4;
+    out[i].c = pIn->c - 8;
+    out[i].a = pIn->a - 3;
+
+    pIn++;
+  }
+
+  for (i = 0; i < N; i++) {
+    if (ua1[2*i] != ub[2*i]
+        || ua1[2*i+1] != ub[2*i+1]
+        || out[i].a != arr[i].a - 3
+        || out[i].b != arr[i].b - 4
+        || out[i].c != arr[i].c - 8
+        || out[i].d != arr[i].d - 1)
+      abort ();
+  }
+
+  /* check results:  */
+  if (udiff != check_diff)
+    abort ();
+}
+
+int main (void)
+{
+  int i;
+  s arr[N];
+
+  check_diff = 2;
+  ub[0] = uc[0] = 1;
+  for (i = 1; i < N; i++) {
+    ub[i] = (i%5 == 0)?i*3:i;
+    uc[i] = i;
+    check_diff += (unsigned char) (ub[i] - uc[i]);
+    if (y) /* Avoid vectorization.  */
+      abort ();
+  }
+  for (; i < 2*N; i++) {
+    ub[i] = 0;
+    if (y) /* Avoid vectorization.  */
+      abort ();
+  }
+
+  for (i = 0; i < N; i++)
+    {
+      arr[i].a = i + 9;
+      arr[i].b = i * 2 + 10;
+      arr[i].c = 17;
+      arr[i].d = i+34;
+      if (arr[i].a == 178)
+         abort ();
+    }
+  check_vect ();
+
+  main1 (100, 100, 1, arr);
+  main1 (0, 15, 0, arr);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail { vect_no_align && ilp32 } } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 2 "vect" { xfail { vect_no_align && ilp32 } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/slp-24.c b/gcc/testsuite/gcc.dg/vect/slp-24.c
index 6904222..61c53f0 100644
--- a/gcc/testsuite/gcc.dg/vect/slp-24.c
+++ b/gcc/testsuite/gcc.dg/vect/slp-24.c
@@ -3,7 +3,8 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 64
+#define N 16
+#define DIFF 242
 
 typedef struct {
    unsigned char a;
@@ -12,11 +13,8 @@ typedef struct {
    unsigned char d;
 } s;
 
-unsigned char ub[N*2];
-unsigned char uc[N];
-
-volatile int y = 0;
-unsigned char check_diff = 2;
+unsigned char ub[N*2] = {1,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,1,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+unsigned char uc[N] = {1,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
 
 void
 main1 (unsigned char x, unsigned char max_result, unsigned char min_result, s *arr)
@@ -30,7 +28,7 @@ main1 (unsigned char x, unsigned char max_result, unsigned char min_result, s *a
   s out[N];
 
   for (i = 0; i < N; i++) {
-    udiff += (unsigned char) (ub[i] - uc[i]);
+    udiff += (unsigned char)(ub[i] - uc[i]);
 
     ua1[2*i+1] = ub[2*i+1];
     ua1[2*i] = ub[2*i];
@@ -54,7 +52,7 @@ main1 (unsigned char x, unsigned char max_result, unsigned char min_result, s *a
   }
 
   /* check results:  */
-  if (udiff != check_diff)
+  if (udiff != DIFF)
     abort ();
 }
 
@@ -63,21 +61,6 @@ int main (void)
   int i; 
   s arr[N];
 
-  check_diff = 2;
-  ub[0] = uc[0] = 1;
-  for (i = 1; i < N; i++) {
-    ub[i] = (i%5 == 0)?i*3:i;
-    uc[i] = i;
-    check_diff += (unsigned char) (ub[i] - uc[i]);
-    if (y) /* Avoid vectorization.  */
-      abort ();
-  }
-  for (; i < 2*N; i++) {
-    ub[i] = 0;
-    if (y) /* Avoid vectorization.  */
-      abort ();
-  }
-
   for (i = 0; i < N; i++)
     {
       arr[i].a = i + 9;
diff --git a/gcc/testsuite/gcc.dg/vect/slp-3-big-array.c b/gcc/testsuite/gcc.dg/vect/slp-3-big-array.c
new file mode 100644
index 0000000..4f50f1f
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/slp-3-big-array.c
@@ -0,0 +1,155 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 96
+
+unsigned short in[N*8];
+volatile int y = 0;
+
+int
+main1 ()
+{
+  int i;
+  unsigned short out[N*8];
+
+  for (i = 0; i < N*8; i++)
+    {
+      in[i] = i&63;
+      if (y) /* Avoid vectorization.  */
+	abort ();
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      out[i*8] = in[i*8];
+      out[i*8 + 1] = in[i*8 + 1];
+      out[i*8 + 2] = in[i*8 + 2];
+      out[i*8 + 3] = in[i*8 + 3];
+      out[i*8 + 4] = in[i*8 + 4];
+      out[i*8 + 5] = in[i*8 + 5];
+      out[i*8 + 6] = in[i*8 + 6];
+      out[i*8 + 7] = in[i*8 + 7];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*8] !=  in[i*8]
+         || out[i*8 + 1] != in[i*8 + 1]
+         || out[i*8 + 2] != in[i*8 + 2]
+         || out[i*8 + 3] != in[i*8 + 3]
+         || out[i*8 + 4] != in[i*8 + 4]
+         || out[i*8 + 5] != in[i*8 + 5]
+         || out[i*8 + 6] != in[i*8 + 6]
+         || out[i*8 + 7] != in[i*8 + 7])
+	abort ();
+    }
+
+  for (i = 0; i < N*2; i++)
+    {
+      out[i*4] = in[i*4];
+      out[i*4 + 1] = in[i*4 + 1];
+      out[i*4 + 2] = in[i*4 + 2];
+      out[i*4 + 3] = in[i*4 + 3];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N*2; i++)
+    {
+      if (out[i*4] !=  in[i*4]
+         || out[i*4 + 1] != in[i*4 + 1]
+         || out[i*4 + 2] != in[i*4 + 2]
+         || out[i*4 + 3] != in[i*4 + 3])
+        abort ();
+    }
+
+  for (i = 0; i < N/2; i++)
+    {
+      out[i*16] = in[i*16];
+      out[i*16 + 1] = in[i*16 + 1];
+      out[i*16 + 2] = in[i*16 + 2];
+      out[i*16 + 3] = in[i*16 + 3];
+      out[i*16 + 4] = in[i*16 + 4];
+      out[i*16 + 5] = in[i*16 + 5];
+      out[i*16 + 6] = in[i*16 + 6];
+      out[i*16 + 7] = in[i*16 + 7];
+      out[i*16 + 8] = in[i*16 + 8];
+      out[i*16 + 9] = in[i*16 + 9];
+      out[i*16 + 10] = in[i*16 + 10];
+      out[i*16 + 11] = in[i*16 + 11];
+      out[i*16 + 12] = in[i*16 + 12];
+      out[i*16 + 13] = in[i*16 + 13];
+      out[i*16 + 14] = in[i*16 + 14];
+      out[i*16 + 15] = in[i*16 + 15];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N/2; i++)
+    {
+      if (out[i*16] !=  in[i*16]
+         || out[i*16 + 1] != in[i*16 + 1]
+         || out[i*16 + 2] != in[i*16 + 2]
+         || out[i*16 + 3] != in[i*16 + 3]
+         || out[i*16 + 4] != in[i*16 + 4]
+         || out[i*16 + 5] != in[i*16 + 5]
+         || out[i*16 + 6] != in[i*16 + 6]
+         || out[i*16 + 7] != in[i*16 + 7]
+         || out[i*16 + 8] != in[i*16 + 8]
+         || out[i*16 + 9] != in[i*16 + 9]
+         || out[i*16 + 10] != in[i*16 + 10]
+         || out[i*16 + 11] != in[i*16 + 11]
+         || out[i*16 + 12] != in[i*16 + 12]
+         || out[i*16 + 13] != in[i*16 + 13]
+         || out[i*16 + 14] != in[i*16 + 14]
+         || out[i*16 + 15] != in[i*16 + 15])
+        abort ();
+    }
+
+  /* SLP with unrolling by 8.  */
+  for (i = 0; i < N/4; i++)
+    {
+      out[i*9] = in[i*9];
+      out[i*9 + 1] = in[i*9 + 1];
+      out[i*9 + 2] = in[i*9 + 2];
+      out[i*9 + 3] = in[i*9 + 3];
+      out[i*9 + 4] = in[i*9 + 4];
+      out[i*9 + 5] = in[i*9 + 5];
+      out[i*9 + 6] = in[i*9 + 6];
+      out[i*9 + 7] = in[i*9 + 7];
+      out[i*9 + 8] = in[i*9 + 8];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N/4; i++)
+    {
+      if (out[i*9] !=  in[i*9]
+         || out[i*9 + 1] != in[i*9 + 1]
+         || out[i*9 + 2] != in[i*9 + 2]
+         || out[i*9 + 3] != in[i*9 + 3]
+         || out[i*9 + 4] != in[i*9 + 4]
+         || out[i*9 + 5] != in[i*9 + 5]
+         || out[i*9 + 6] != in[i*9 + 6]
+         || out[i*9 + 7] != in[i*9 + 7]
+         || out[i*9 + 8] != in[i*9 + 8])
+        abort ();
+    }
+
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 4 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 4 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc/testsuite/gcc.dg/vect/slp-3.c b/gcc/testsuite/gcc.dg/vect/slp-3.c
index 6c6a655..7d9bd56 100644
--- a/gcc/testsuite/gcc.dg/vect/slp-3.c
+++ b/gcc/testsuite/gcc.dg/vect/slp-3.c
@@ -3,10 +3,9 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 96
+#define N 12
 
-unsigned short in[N*8];
-volatile int y = 0;
+unsigned short in[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,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};
 
 int
 main1 ()
@@ -14,13 +13,6 @@ main1 ()
   int i;
   unsigned short out[N*8];
 
-  for (i = 0; i < N*8; i++)
-    {
-      in[i] = i&63;
-      if (y) /* Avoid vectorization.  */
-	abort ();
-    }
-
   for (i = 0; i < N; i++)
     {
       out[i*8] = in[i*8];
@@ -149,7 +141,7 @@ int main (void)
   return 0;
 }
 
-/* { dg-final { scan-tree-dump-times "vectorized 4 loops" 1 "vect" } } */
-/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 4 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 3 "vect" } } */
 /* { dg-final { cleanup-tree-dump "vect" } } */
   
diff --git a/gcc/testsuite/gcc.dg/vect/slp-34-big-array.c b/gcc/testsuite/gcc.dg/vect/slp-34-big-array.c
new file mode 100644
index 0000000..53da79e
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/slp-34-big-array.c
@@ -0,0 +1,69 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+unsigned short in[N*8];
+unsigned short in2[N*8];
+volatile int y = 0;
+
+int
+main1 ()
+{
+  int i;
+  unsigned short out[N*8];
+  unsigned short out2[N*8];
+
+  for (i = 0; i < N*8; i++)
+    {
+      in[i] = in2[i] = i;
+      if (y) /* Avoid vectorization.  */
+	abort ();
+    }
+
+  /* SLP with unrolling by 8.  */
+  for (i = 0; i < N; i++)
+    {
+      out[i*3] = in[i*3] + 5;
+      out[i*3 + 1] = in[i*3 + 1] + 6;
+      out[i*3 + 2] = in[i*3 + 2] + 16;
+
+      out2[i*5] = in2[i*5] + 2;
+      out2[i*5 + 1] = in2[i*5 + 1] + 2;
+      out2[i*5 + 2] = in2[i*5 + 2] + 1;
+      out2[i*5 + 3] = in2[i*5 + 3] + 3;
+      out2[i*5 + 4] = in2[i*5 + 4] + 13;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*3] != in[i*3] + 5
+          || out[i*3 + 1] != in[i*3 + 1] + 6
+          || out[i*3 + 2] != in[i*3 + 2] + 16
+          || out2[i*5] != in2[i*5] + 2
+          || out2[i*5 + 1] != in2[i*5 + 1] + 2
+          || out2[i*5 + 2] != in2[i*5 + 2] + 1
+          || out2[i*5 + 3] != in2[i*5 + 3] + 3
+          || out2[i*5 + 4] != in2[i*5 + 4] + 13)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 2 "vect"  } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc/testsuite/gcc.dg/vect/slp-34.c b/gcc/testsuite/gcc.dg/vect/slp-34.c
index 39b28e5..63dbab0 100644
--- a/gcc/testsuite/gcc.dg/vect/slp-34.c
+++ b/gcc/testsuite/gcc.dg/vect/slp-34.c
@@ -3,11 +3,10 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 64
+#define N 8 
 
-unsigned short in[N*8];
-unsigned short in2[N*8];
-volatile int y = 0;
+unsigned short in[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 short 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};
 
 int
 main1 ()
@@ -16,13 +15,6 @@ main1 ()
   unsigned short out[N*8];
   unsigned short out2[N*8];
 
-  for (i = 0; i < N*8; i++)
-    {
-      in[i] = in2[i] = i;
-      if (y) /* Avoid vectorization.  */
-	abort ();
-    }
-
   /* SLP with unrolling by 8.  */
   for (i = 0; i < N; i++)
     {
diff --git a/gcc/testsuite/gcc.dg/vect/slp-4-big-array.c b/gcc/testsuite/gcc.dg/vect/slp-4-big-array.c
new file mode 100644
index 0000000..55607dd
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/slp-4-big-array.c
@@ -0,0 +1,135 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+volatile int y = 0;
+
+int
+main1 ()
+{
+  int i;
+  unsigned short out[N*8];
+  unsigned short in[N*8];
+  unsigned int ia[N*2];
+
+  for (i = 0; i < N*8; i++)
+    {
+      in[i] = i;
+      if (y) /* Avoid vectorization.  */
+	abort ();
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      out[i*8] = in[i*8];
+      out[i*8 + 1] = in[i*8 + 1];
+      out[i*8 + 2] = in[i*8 + 2];
+      out[i*8 + 3] = in[i*8 + 3];
+      out[i*8 + 4] = in[i*8 + 4];
+      out[i*8 + 5] = in[i*8 + 5];
+      out[i*8 + 6] = in[i*8 + 6];
+      out[i*8 + 7] = in[i*8 + 7];
+
+      ia[i] = 7;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i*8] !=  in[i*8]
+         || out[i*8 + 1] != in[i*8 + 1]
+         || out[i*8 + 2] != in[i*8 + 2]
+         || out[i*8 + 3] != in[i*8 + 3]
+         || out[i*8 + 4] != in[i*8 + 4]
+         || out[i*8 + 5] != in[i*8 + 5]
+         || out[i*8 + 6] != in[i*8 + 6]
+         || out[i*8 + 7] != in[i*8 + 7]
+         || ia[i] != 7)
+	abort ();
+    }
+
+  for (i = 0; i < N*2; i++)
+    {
+      out[i*4] = in[i*4];
+      out[i*4 + 1] = in[i*4 + 1];
+      out[i*4 + 2] = in[i*4 + 2];
+      out[i*4 + 3] = in[i*4 + 3];
+
+      ia[i] = 12;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N*2; i++)
+    {
+      if (out[i*4] !=  in[i*4]
+         || out[i*4 + 1] != in[i*4 + 1]
+         || out[i*4 + 2] != in[i*4 + 2]
+         || out[i*4 + 3] != in[i*4 + 3]
+         || ia[i] != 12)
+        abort ();
+    }
+
+  for (i = 0; i < N/2; i++)
+    {
+      out[i*16] = in[i*16];
+      out[i*16 + 1] = in[i*16 + 1];
+      out[i*16 + 2] = in[i*16 + 2];
+      out[i*16 + 3] = in[i*16 + 3];
+      out[i*16 + 4] = in[i*16 + 4];
+      out[i*16 + 5] = in[i*16 + 5];
+      out[i*16 + 6] = in[i*16 + 6];
+      out[i*16 + 7] = in[i*16 + 7];
+      out[i*16 + 8] = in[i*16 + 8];
+      out[i*16 + 9] = in[i*16 + 9];
+      out[i*16 + 10] = in[i*16 + 10];
+      out[i*16 + 11] = in[i*16 + 11];
+      out[i*16 + 12] = in[i*16 + 12];
+      out[i*16 + 13] = in[i*16 + 13];
+      out[i*16 + 14] = in[i*16 + 14];
+      out[i*16 + 15] = in[i*16 + 15];
+
+      ia[i] = 21;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N/2; i++)
+    {
+      if (out[i*16] !=  in[i*16]
+         || out[i*16 + 1] != in[i*16 + 1]
+         || out[i*16 + 2] != in[i*16 + 2]
+         || out[i*16 + 3] != in[i*16 + 3]
+         || out[i*16 + 4] != in[i*16 + 4]
+         || out[i*16 + 5] != in[i*16 + 5]
+         || out[i*16 + 6] != in[i*16 + 6]
+         || out[i*16 + 7] != in[i*16 + 7]
+         || out[i*16 + 8] != in[i*16 + 8]
+         || out[i*16 + 9] != in[i*16 + 9]
+         || out[i*16 + 10] != in[i*16 + 10]
+         || out[i*16 + 11] != in[i*16 + 11]
+         || out[i*16 + 12] != in[i*16 + 12]
+         || out[i*16 + 13] != in[i*16 + 13]
+         || out[i*16 + 14] != in[i*16 + 14]
+         || out[i*16 + 15] != in[i*16 + 15]
+         || ia[i] != 21)
+        abort ();
+    }
+
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect"  } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 3 "vect"  } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc/testsuite/gcc.dg/vect/slp-4.c b/gcc/testsuite/gcc.dg/vect/slp-4.c
index 3622f9d..50ad2bd5 100644
--- a/gcc/testsuite/gcc.dg/vect/slp-4.c
+++ b/gcc/testsuite/gcc.dg/vect/slp-4.c
@@ -3,24 +3,16 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 128
-volatile int y = 0;
+#define N 16 
 
 int
 main1 ()
 {
   int i;
   unsigned short out[N*8];
-  unsigned short in[N*8];
+  unsigned short in[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,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 ia[N*2];
 
-  for (i = 0; i < N*8; i++)
-    {
-      in[i] = i;
-      if (y) /* Avoid vectorization.  */
-	abort ();
-    }
-
   for (i = 0; i < N; i++)
     {
       out[i*8] = in[i*8];
diff --git a/gcc/testsuite/gcc.dg/vect/slp-cond-2-big-array.c b/gcc/testsuite/gcc.dg/vect/slp-cond-2-big-array.c
new file mode 100644
index 0000000..8217b76
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/slp-cond-2-big-array.c
@@ -0,0 +1,127 @@
+/* { dg-require-effective-target vect_cond_mixed } */
+#include "tree-vect.h"
+
+#define N 128
+int d[N], e[N], f[N];
+unsigned char k[N];
+float a[N], b[N];
+
+__attribute__((noinline, noclone)) void
+f1 (void)
+{
+  int i;
+  for (i = 0; i < N/4; i++)
+    {
+      k[4*i] = a[4*i] < b[4*i] ? 17 : 0;
+      k[4*i+1] = a[4*i+1] < b[4*i+1] ? 17 : 0;
+      k[4*i+2] = a[4*i+2] < b[4*i+2] ? 17 : 0;
+      k[4*i+3] = a[4*i+3] < b[4*i+3] ? 17 : 0;
+    }
+}
+
+__attribute__((noinline, noclone)) void
+f2 (void)
+{
+  int i;
+  for (i = 0; i < N/2; ++i)
+    {
+      k[2*i] = a[2*i] < b[2*i] ? 0 : 24;
+      k[2*i+1] = a[2*i+1] < b[2*i+1] ? 7 : 4;
+    }
+}
+
+__attribute__((noinline, noclone)) void
+f3 (void)
+{
+  int i;
+  for (i = 0; i < N/2; ++i)
+    {
+      k[2*i] = a[2*i] < b[2*i] ? 51 : 12;
+      k[2*i+1] = a[2*i+1] > b[2*i+1] ? 51 : 12;
+    }
+}
+
+__attribute__((noinline, noclone)) void
+f4 (void)
+{
+  int i;
+  for (i = 0; i < N/2; ++i)
+    {
+      int d0 = d[2*i], e0 = e[2*i];
+      int d1 = d[2*i+1], e1 = e[2*i+1];
+      f[2*i] = a[2*i] >= b[2*i] ? d0 : e0;
+      f[2*i+1] = a[2*i+1] >= b[2*i+1] ? d1 : e1;
+    }
+}
+
+int
+main ()
+{
+  int i;
+
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    {
+      switch (i % 9)
+	{
+	case 0: asm (""); a[i] = - i - 1; b[i] = i + 1; break;
+	case 1: a[i] = 0; b[i] = 0; break;
+	case 2: a[i] = i + 1; b[i] = - i - 1; break;
+	case 3: a[i] = i; b[i] = i + 7; break;
+	case 4: a[i] = i; b[i] = i; break;
+	case 5: a[i] = i + 16; b[i] = i + 3; break;
+	case 6: a[i] = - i - 5; b[i] = - i; break;
+	case 7: a[i] = - i; b[i] = - i; break;
+	case 8: a[i] = - i; b[i] = - i - 7; break;
+	}
+      d[i] = i;
+      e[i] = 2 * i;
+    }
+
+  f1 ();
+  for (i = 0; i < N; i++)
+    if (k[i] != ((i % 3) == 0 ? 17 : 0))
+      abort ();
+
+  f2 ();
+  for (i = 0; i < N; i++)
+    {
+      switch (i % 9)
+        {
+        case 0:
+	case 6:
+	  if (k[i] != ((i/9 % 2) == 0 ? 0 : 7))
+	    abort ();
+	  break;
+        case 1:
+        case 5:
+        case 7:
+	  if (k[i] != ((i/9 % 2) == 0 ? 4 : 24))
+            abort ();
+          break;
+        case 2:
+        case 4:
+        case 8:
+	  if (k[i] != ((i/9 % 2) == 0 ? 24 : 4))
+            abort ();
+          break;
+        case 3:
+	  if (k[i] != ((i/9 % 2) == 0 ? 7 : 0))
+            abort ();
+          break;
+        }
+    }
+
+  f3 ();
+
+  f4 ();
+  for (i = 0; i < N; i++)
+    if (f[i] != ((i % 3) == 0 ? e[i] : d[i]))
+      abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 3 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/slp-cond-2.c b/gcc/testsuite/gcc.dg/vect/slp-cond-2.c
index 8217b76..c73933f 100644
--- a/gcc/testsuite/gcc.dg/vect/slp-cond-2.c
+++ b/gcc/testsuite/gcc.dg/vect/slp-cond-2.c
@@ -1,7 +1,7 @@
 /* { dg-require-effective-target vect_cond_mixed } */
 #include "tree-vect.h"
 
-#define N 128
+#define N 32
 int d[N], e[N], f[N];
 unsigned char k[N];
 float a[N], b[N];
diff --git a/gcc/testsuite/gcc.dg/vect/slp-multitypes-11-big-array.c b/gcc/testsuite/gcc.dg/vect/slp-multitypes-11-big-array.c
new file mode 100644
index 0000000..b7a7a0b
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/slp-multitypes-11-big-array.c
@@ -0,0 +1,62 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 144
+
+struct s
+{
+  int a;
+  int b;
+  int c;
+};
+
+char in[N*3];
+volatile int y = 0;
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  int i;
+  struct s out[N];
+
+  for (i = 0; i < N; i++)
+    {
+      in[i] = i&127;
+      if (y) /* Avoid vectorization.  */
+	abort ();
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      out[i].a = (int) in[i*3] + 1;
+      out[i].b = (int) in[i*3 + 1] + 2;
+      out[i].c = (int) in[i*3 + 2] + 3;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (out[i].a !=  (int) in[i*3] + 1
+         || out[i].b != (int) in[i*3 + 1] + 2
+         || out[i].c != (int) in[i*3 + 2] + 3)
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target vect_unpack } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect"  { target vect_unpack } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc/testsuite/gcc.dg/vect/slp-multitypes-11.c b/gcc/testsuite/gcc.dg/vect/slp-multitypes-11.c
index 8ead45e..602517b 100644
--- a/gcc/testsuite/gcc.dg/vect/slp-multitypes-11.c
+++ b/gcc/testsuite/gcc.dg/vect/slp-multitypes-11.c
@@ -3,7 +3,7 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 144
+#define N 18 
 
 struct s 
 {
@@ -12,8 +12,7 @@ struct s
   int c;
 };
 
-char in[N*3];
-volatile int y = 0;
+char in[N*3] = {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};
 
 __attribute__ ((noinline)) int
 main1 ()
@@ -23,13 +22,6 @@ main1 ()
 
   for (i = 0; i < N; i++)
     {
-      in[i] = i&127;
-      if (y) /* Avoid vectorization.  */
-	abort ();
-    }
-
-  for (i = 0; i < N; i++)
-    {
       out[i].a = (int) in[i*3] + 1;
       out[i].b = (int) in[i*3 + 1] + 2;
       out[i].c = (int) in[i*3 + 2] + 3;
diff --git a/gcc/testsuite/gcc.dg/vect/vect-1-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-1-big-array.c
new file mode 100644
index 0000000..4c0f532
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-1-big-array.c
@@ -0,0 +1,90 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+/* { dg-require-effective-target vect_float } */
+
+#define N 128
+
+void fbar (float *);
+void ibar (int *);
+void sbar (short *);
+
+/* multiple loops */
+
+foo (int n)
+{
+  float a[N+1];
+  float b[N];
+  float c[N];
+  float d[N];
+  int ia[N];
+  int ib[N];
+  int ic[N];
+  int i,j;
+  int diff = 0;
+  char cb[N];
+  char cc[N];
+  char image[N][N];
+  char block[N][N];
+
+  /* Vectorizable.  */
+  diff = 0;
+  for (i = 0; i < N; i++) {
+    diff += (cb[i] - cc[i]);
+  }
+  ibar (&diff);
+
+
+  /* Vectorizable.  */
+  diff = 0;
+  for (i = 0; i < N; i++) {
+    for (j = 0; j < N; j++) {
+      diff += (image[i][j] - block[i][j]);
+    }
+  }
+  ibar (&diff);
+
+
+  /* Vectorizable.  */
+  for (i = 0; i < N; i++){
+    a[i] = b[i];
+  }
+  fbar (a);
+
+
+  /* Vectorizable.  */
+  for (i = 0; i < N; i++){
+    a[i] = b[i] + c[i] + d[i];
+  }
+  fbar (a);
+
+
+  /* Strided access.  Vectorizable on platforms that support load of strided
+     accesses (extract of even/odd vector elements).  */
+  for (i = 0; i < N/2; i++){
+    a[i] = b[2*i+1] * c[2*i+1] - b[2*i] * c[2*i];
+    d[i] = b[2*i] * c[2*i+1] + b[2*i+1] * c[2*i];
+  }
+  fbar (a);
+
+
+  /* Vectorizable.  */
+  for (i = 0; i < N; i++){
+    a[i] = b[i] + c[i];
+    d[i] = b[i] + c[i];
+    ia[i] = ib[i] + ic[i];
+  }
+  ibar (ia);
+  fbar (a);
+  fbar (d);
+
+  /* Not vetorizable yet (too conservative dependence test).  */
+  for (i = 0; i < N; i++){
+    a[i] = b[i] + c[i];
+    a[i+1] = b[i] + c[i];
+  }
+  fbar (a);
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 6 loops" 1 "vect" { target vect_strided2 } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 5 loops" 1 "vect" { xfail vect_strided2 } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-1.c b/gcc/testsuite/gcc.dg/vect/vect-1.c
index 3fe5122..04392ea 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-1.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-1.c
@@ -2,7 +2,7 @@
 /* { dg-require-effective-target vect_int } */
 /* { dg-require-effective-target vect_float } */
 
-#define N 128
+#define N 16
 
 void fbar (float *);
 void ibar (int *);
diff --git a/gcc/testsuite/gcc.dg/vect/vect-10-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-10-big-array.c
new file mode 100644
index 0000000..ce61619
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-10-big-array.c
@@ -0,0 +1,38 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+#include <stdlib.h>
+
+#define N 128
+
+short a[N];
+short d[N];
+
+volatile int y = 0;
+
+int foo ()
+{
+  int i;
+  short b[N];
+  short c[N];
+  for (i = 0; i < N/2; i++)
+    {
+      b[i] = i*3;
+      c[i] = i;
+
+      /* Avoid vectorization.  */
+      if (y)
+	abort ();
+    }
+
+  /* Strided access pattern.  */
+  for (i = 0; i < N/2; i++)
+    {
+      a[i] = b[2*i+1] * c[2*i+1] - b[2*i] * c[2*i];
+      d[i] = b[2*i] * c[2*i+1] + b[2*i+1] * c[2*i];
+    }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail { ! vect_strided2 } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-10.c b/gcc/testsuite/gcc.dg/vect/vect-10.c
index 393416e..faa500d 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-10.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-10.c
@@ -1,28 +1,16 @@
 /* { dg-do compile } */
 /* { dg-require-effective-target vect_int } */
-#include <stdlib.h>
 
-#define N 128
+#define N 16
 
 short a[N];
 short d[N];
 
-volatile int y = 0;
-
 int foo ()
 {
   int i;
-  short b[N];
-  short c[N];
-  for (i = 0; i < N/2; i++)
-    {
-      b[i] = i*3;
-      c[i] = i;
-
-      /* Avoid vectorization.  */
-      if (y)
-	abort ();
-    }
+  short b[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+  short c[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
 
   /* Strided access pattern.  */
   for (i = 0; i < N/2; i++)
diff --git a/gcc/testsuite/gcc.dg/vect/vect-105-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-105-big-array.c
new file mode 100644
index 0000000..f99a2af
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-105-big-array.c
@@ -0,0 +1,106 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+struct extraction
+{
+  int a[N][N];
+  int b[N][N];
+};
+
+static int a[N][N];
+static int b[N][N];
+static int c[N][N];
+
+volatile int y;
+
+__attribute__ ((noinline))
+int main1 (int x) {
+  int i,j, off;
+  struct extraction *p;
+  p = (struct extraction *) malloc (sizeof (struct extraction));
+  for (i = 0; i < N; i++)
+   {
+    for (j = 0; j < N; j++)
+     {
+       a[i][j] = (i*7 + j*17)%53;
+       b[i][j] = (i*11+ j*13)%41;
+       if (y)
+	 abort (); /* to avoid vectorization.  */
+     }
+   }
+  for (i = 0; i < N; i++)
+   {
+    for (j = 0; j < N; j++)
+     {
+       c[i][j] = a[i][j];
+       if (y)
+	 abort (); /* to avoid vectorization.  */
+     }
+   }
+  for (i = 1; i < N; i++)
+  {
+    for (j = 0; j < N; j++)
+    {
+      off = x + i + j + N+1;
+      if (x + i + j > N*N-1)
+	break;
+      if (off > N*N-1)
+	*(&c[0][0]+x+i+j) = *(&b[0][0] + off - N*N);
+      else
+	*(&c[0][0]+x+i+j) = *(&a[0][0] + off);
+       if (y)
+	 abort (); /* to avoid vectorization.  */
+    }
+  }
+
+  for (i = 0; i < N; i++)
+   {
+    for (j = 0; j < N; j++)
+     {
+       p->a[i][j] = a[i][j];
+       p->b[i][j] = b[i][j];
+       /* Because Y is volatile, the compiler cannot move this check out
+	  of the loop.  */
+       if (y)
+	 abort (); /* to avoid vectorization.  */
+     }
+   }
+
+  /* Vectorizable: distance > number of iterations.  */
+  for (i = 1; i < N; i++)
+  {
+    for (j = 0; j < N; j++)
+    {
+       *((int *)p + x + i + j) = *((int *)p + x + i + j + N+1);
+    }
+  }
+
+  /* check results: */
+  for (i = 0; i < N; i++)
+   {
+    for (j = 0; j < N; j++)
+     {
+       if (p->a[i][j] != c[i][j])
+         abort ();
+     }
+  }
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  return main1 (N);
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 2 "vect" { target vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "possible dependence between data-refs" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc/testsuite/gcc.dg/vect/vect-105.c b/gcc/testsuite/gcc.dg/vect/vect-105.c
index f2e68ae..bbf42af 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-105.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-105.c
@@ -4,7 +4,7 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 16
+#define N 4
 
 struct extraction
 {
@@ -12,51 +12,17 @@ struct extraction
   int b[N][N];
 };
 
-static int a[N][N];
-static int b[N][N];
-static int c[N][N];
+static int a[N][N] = {{1,2,3,11},{4,5,6,12},{7,8,9,13},{34,45,67,83}};
+static int b[N][N] = {{17,28,15,23},{0,2,3,24},{4,31,82,25},{29,31,432,256}};
+static int c[N][N] = {{1,2,3,11},{4,9,13,34},{45,67,83,13},{34,45,67,83}};
 
 volatile int y;
 
 __attribute__ ((noinline))
 int main1 (int x) {
-  int i,j, off;
+  int i,j;
   struct extraction *p;
   p = (struct extraction *) malloc (sizeof (struct extraction));
-  for (i = 0; i < N; i++)
-   {
-    for (j = 0; j < N; j++)
-     {
-       a[i][j] = (i*7 + j*17)%53;
-       b[i][j] = (i*11+ j*13)%41;
-       if (y)
-	 abort (); /* to avoid vectorization.  */
-     }
-   }
-  for (i = 0; i < N; i++)
-   {
-    for (j = 0; j < N; j++)
-     {
-       c[i][j] = a[i][j];
-       if (y)
-	 abort (); /* to avoid vectorization.  */
-     }
-   }
-  for (i = 1; i < N; i++)
-  {
-    for (j = 0; j < N; j++)
-    {
-      off = x + i + j + N+1;
-      if (x + i + j > N*N-1)
-	break;
-      if (off > N*N-1)
-	*(&c[0][0]+x+i+j) = *(&b[0][0] + off - N*N);
-      else
-	*(&c[0][0]+x+i+j) = *(&a[0][0] + off);
-       if (y)
-	 abort (); /* to avoid vectorization.  */
-    }
-  }
 
   for (i = 0; i < N; i++)
    {
@@ -67,7 +33,7 @@ int main1 (int x) {
        /* Because Y is volatile, the compiler cannot move this check out
 	  of the loop.  */
        if (y)
-	 abort (); /* to avoid vectorization.  */
+	 abort (); /* to avoid vectorization  */
      }
    }
 
@@ -76,7 +42,7 @@ int main1 (int x) {
   {
     for (j = 0; j < N; j++)
     {
-       *((int *)p + x + i + j) = *((int *)p + x + i + j + N+1);
+       *((int *)p + x + i + j) = *((int *)p + x + i + j + 5);
     }
   }
 
@@ -86,7 +52,7 @@ int main1 (int x) {
     for (j = 0; j < N; j++)
      {
        if (p->a[i][j] != c[i][j])
-         abort ();
+         abort();
      }
   }
   return 0;
@@ -100,7 +66,7 @@ int main (void)
 }
 
 /* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
-/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 2 "vect" { target vect_no_align } } } */
+/*  { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 2 "vect" { target vect_no_align } } } */
 /* { dg-final { scan-tree-dump-times "possible dependence between data-refs" 0 "vect" } } */
 /* { dg-final { cleanup-tree-dump "vect" } } */
 
diff --git a/gcc/testsuite/gcc.dg/vect/vect-112-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-112-big-array.c
new file mode 100644
index 0000000..a1302c1
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-112-big-array.c
@@ -0,0 +1,50 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+char cb[N];
+char cc[N];
+
+volatile int y = 0;
+
+__attribute__ ((noinline)) int
+main1 (void)
+{
+  int i;
+  int diff = 0;
+  int check_diff = 0;
+  for (i = 0; i < N; i++) {
+    cb[i] = i + 2;
+    cc[i] = i + 1;
+    check_diff += (cb[i] - cc[i]);
+    /* Avoid vectorization.  */
+    if (y)
+      abort ();
+  }
+
+  /* Cross-iteration cycle.  */
+  diff = 0;
+  for (i = 0; i < N; i++) {
+    diff += (cb[i] - cc[i]);
+  }
+
+  /* Check results.  */
+  if (diff != check_diff)
+    abort ();
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_unpack } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
+
diff --git a/gcc/testsuite/gcc.dg/vect/vect-112.c b/gcc/testsuite/gcc.dg/vect/vect-112.c
index a1302c1..4d954d1 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-112.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-112.c
@@ -3,27 +3,16 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 128
+#define N 16
 
-char cb[N];
-char cc[N];
-
-volatile int y = 0;
+char cb[N] = {2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17};
+char cc[N] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
 
 __attribute__ ((noinline)) int
 main1 (void)
 {
   int i;
   int diff = 0;
-  int check_diff = 0;
-  for (i = 0; i < N; i++) {
-    cb[i] = i + 2;
-    cc[i] = i + 1;
-    check_diff += (cb[i] - cc[i]);
-    /* Avoid vectorization.  */
-    if (y)
-      abort ();
-  }
 
   /* Cross-iteration cycle.  */
   diff = 0;
@@ -32,8 +21,8 @@ main1 (void)
   }
 
   /* Check results.  */
-  if (diff != check_diff)
-    abort ();
+  if (diff != 16)
+    abort();
 
   return 0;
 }
diff --git a/gcc/testsuite/gcc.dg/vect/vect-15-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-15-big-array.c
new file mode 100644
index 0000000..912907d
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-15-big-array.c
@@ -0,0 +1,48 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+volatile int y = 0;
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  int i;
+  int a[N];
+  int b[N];
+
+  for (i = 0; i <N; i++)
+    {
+      b[i] = i*3;
+      if (y)
+	abort ();
+    }
+
+  /* Not vectorizable yet (reverse access and forward access).  */
+  for (i = N; i > 0; i--)
+    {
+      a[N-i] = b[i-1];
+    }
+
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (a[i] != b[N-1-i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_perm && vect_hw_misalign } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-15.c b/gcc/testsuite/gcc.dg/vect/vect-15.c
index cbc11c2..ba75991 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-15.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-15.c
@@ -3,23 +3,14 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 128
-
-volatile int y = 0;
+#define N 16
 
 __attribute__ ((noinline))
 int main1 ()
 {
   int i;
   int a[N];
-  int b[N];
-
-  for (i = 0; i <N; i++)
-    {
-      b[i] = i*3;
-      if (y)
-	abort ();
-    }
+  int b[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
 
   /* Not vectorizable yet (reverse access and forward access).  */
   for (i = N; i > 0; i--)
diff --git a/gcc/testsuite/gcc.dg/vect/vect-2-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-2-big-array.c
new file mode 100644
index 0000000..2550270
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-2-big-array.c
@@ -0,0 +1,50 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+char cb[N];
+char ca[N];
+
+volatile int y = 0;
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      cb[i] = i*3;
+      /* To avoid vectorization.  */
+      if (y)
+	abort ();
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      ca[i] = cb[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (ca[i] != cb[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-2.c b/gcc/testsuite/gcc.dg/vect/vect-2.c
index e6399ff..5d4fc91 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-2.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-2.c
@@ -3,13 +3,11 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 128
+#define N 16
 
-char cb[N];
+char cb[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
 char ca[N];
 
-volatile int y = 0;
-
 __attribute__ ((noinline)) 
 int main1 ()
 {  
@@ -17,14 +15,6 @@ int main1 ()
 
   for (i = 0; i < N; i++)
     {
-      cb[i] = i*3;
-      /* To avoid vectorization.  */
-      if (y)
-	abort ();
-    }
-
-  for (i = 0; i < N; i++)
-    {
       ca[i] = cb[i];
     }
 
diff --git a/gcc/testsuite/gcc.dg/vect/vect-31-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-31-big-array.c
new file mode 100644
index 0000000..25d7fdf
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-31-big-array.c
@@ -0,0 +1,90 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 256
+
+struct t{
+  int k[N];
+  int l;
+};
+
+struct s{
+  char a;	/* aligned */
+  char b[N-1];  /* unaligned (offset 1B) */
+  char c[N];    /* aligned (offset NB) */
+  struct t d;   /* aligned (offset 2NB) */
+  struct t e;   /* unaligned (offset 2N+4N+4 B) */
+};
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  int i;
+  struct s tmp;
+
+  /* unaligned */
+  for (i = 0; i < N/2; i++)
+    {
+      tmp.b[i] = 5;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N/2; i++)
+    {
+      if (tmp.b[i] != 5)
+        abort ();
+    }
+
+  /* aligned */
+  for (i = 0; i < N/2; i++)
+    {
+      tmp.c[i] = 6;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N/2; i++)
+    {
+      if (tmp.c[i] != 6)
+        abort ();
+    }
+
+  /* aligned */
+  for (i = 0; i < N/2; i++)
+    {
+      tmp.d.k[i] = 7;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N/2; i++)
+    {
+      if (tmp.d.k[i] != 7)
+        abort ();
+    }
+
+  /* unaligned */
+  for (i = 0; i < N/2; i++)
+    {
+      tmp.e.k[i] = 8;
+    }
+
+  /* check results:  */
+  for (i = 0; i <N/2; i++)
+    {
+      if (tmp.e.k[i] != 8)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 4 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-31.c b/gcc/testsuite/gcc.dg/vect/vect-31.c
index c6861fa..8719fc9 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-31.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-31.c
@@ -3,7 +3,7 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 256
+#define N 32
 
 struct t{
   int k[N];
diff --git a/gcc/testsuite/gcc.dg/vect/vect-32-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-32-big-array.c
new file mode 100644
index 0000000..774a0b0
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-32-big-array.c
@@ -0,0 +1,40 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  struct {
+    char ca[N];
+  } s;
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      s.ca[i] = 5;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (s.ca[i] != 5)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-32.c b/gcc/testsuite/gcc.dg/vect/vect-32.c
index 143ebf5..c869f5e 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-32.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-32.c
@@ -3,7 +3,7 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 128
+#define N 16
  
 __attribute__ ((noinline))
 int main1 ()
diff --git a/gcc/testsuite/gcc.dg/vect/vect-33-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-33-big-array.c
new file mode 100644
index 0000000..2fc7106
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-33-big-array.c
@@ -0,0 +1,44 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+struct test {
+  char ca[N];
+};
+
+extern struct test s;
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      s.ca[i] = 5;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (s.ca[i] != 5)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  return main1 ();
+}
+
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" { target vector_alignment_reachable } } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 1 "vect" { target { {! vector_alignment_reachable} && {! vect_hw_misalign} } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-33.c b/gcc/testsuite/gcc.dg/vect/vect-33.c
index 261d89a..d35bce4 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-33.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-33.c
@@ -4,7 +4,7 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 128
+#define N 16
 struct test {
   char ca[N];
 };
diff --git a/gcc/testsuite/gcc.dg/vect/vect-34-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-34-big-array.c
new file mode 100644
index 0000000..9041bd6
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-34-big-array.c
@@ -0,0 +1,50 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+struct {
+  char ca[N];
+} s;
+char cb[N];
+
+volatile int y = 0;
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      cb[i] = i*3;
+      /* To avoid vectorization.  */
+      if (y)
+	abort ();
+    }
+  for (i = 0; i < N; i++)
+    {
+      s.ca[i] = cb[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (s.ca[i] != cb[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-34.c b/gcc/testsuite/gcc.dg/vect/vect-34.c
index 3f059c6..df18f77 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-34.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-34.c
@@ -3,15 +3,13 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 128
+#define N 16
 
 struct {
   char ca[N];
 } s;
-char cb[N];
-
-volatile int y = 0;
-
+char cb[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+ 
 __attribute__ ((noinline))
 int main1 ()
 {  
@@ -19,13 +17,6 @@ int main1 ()
 
   for (i = 0; i < N; i++)
     {
-      cb[i] = i*3;
-      /* To avoid vectorization.  */
-      if (y)
-	abort ();
-    }
-  for (i = 0; i < N; i++)
-    {
       s.ca[i] = cb[i];
     }
 
diff --git a/gcc/testsuite/gcc.dg/vect/vect-35-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-35-big-array.c
new file mode 100644
index 0000000..73b18cf
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-35-big-array.c
@@ -0,0 +1,50 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  union {
+    unsigned char a[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+    unsigned char b[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+  } s;
+  int i;
+
+  /* Initialization.  */
+  for (i = 0; i < N; i++)
+    {
+      s.b[i] = i;
+    }
+
+  /* Dependence analysis fails cause s.a and s.b may overlap.
+     Use runtime aliasing test with versioning.  */
+  for (i = 0; i < N; i++)
+    {
+      s.a[i] = s.b[i] + 1;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (s.a[i] != i + 1)
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  return main1 ();
+}
+
+
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect"  { xfail { ia64-*-* sparc*-*-* } } } } */
+/* { dg-final { scan-tree-dump-times "can't determine dependence between" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-35.c b/gcc/testsuite/gcc.dg/vect/vect-35.c
index 130e376..0f4284a 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-35.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-35.c
@@ -3,7 +3,7 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 128
+#define N 16
  
 __attribute__ ((noinline))
 int main1 ()
diff --git a/gcc/testsuite/gcc.dg/vect/vect-36-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-36-big-array.c
new file mode 100644
index 0000000..8f2514d
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-36-big-array.c
@@ -0,0 +1,47 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  int i;
+  struct {
+    char ca[N];
+    char cb[N];
+  } s;
+
+
+  for (i = 0; i < N; i++)
+    {
+      s.cb[i] = 3*i;
+      __asm__ volatile ("");
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      s.ca[i] = s.cb[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (s.ca[i] != s.cb[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-36.c b/gcc/testsuite/gcc.dg/vect/vect-36.c
index 34f0d5a..20df394 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-36.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-36.c
@@ -3,7 +3,7 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 128
+#define N 16
  
 __attribute__ ((noinline))
 int main1 ()
diff --git a/gcc/testsuite/gcc.dg/vect/vect-6-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-6-big-array.c
new file mode 100644
index 0000000..14d3faa
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-6-big-array.c
@@ -0,0 +1,79 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+float results1[N];
+float results2[N];
+float a[N] = {0};
+float e[N] = {0};
+float b[N];
+float c[N];
+
+volatile int y = 0;
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  int i;
+
+  for (i=0; i<N; i++)
+    {
+      b[i] = i*3;
+      c[i] = i;
+      results1[i] = 0;
+      results2[i] = 0;
+      /* Avoid vectorization.  */
+      if (y)
+	abort ();
+    }
+  for (i=0; i<N/2; i++)
+    {
+      results1[i] = b[i+N/2] * c[i+N/2] - b[i] * c[i];
+      results2[i+N/2] = b[i] * c[i+N/2] + b[i+N/2] * c[i];
+      /* Avoid vectorization.  */
+      if (y)
+	abort ();
+    }
+
+  for (i = 0; i < N/2; i++)
+    {
+      a[i] = b[i+N/2] * c[i+N/2] - b[i] * c[i];
+      e[i+N/2] = b[i] * c[i+N/2] + b[i+N/2] * c[i];
+    }
+
+  /* check results:  */
+  for (i=0; i<N; i++)
+    {
+      if (a[i] != results1[i] || e[i] != results2[i])
+	abort ();
+    }
+
+
+  for (i = 1; i <=N-4; i++)
+    {
+      a[i+3] = b[i-1];
+    }
+
+  /* check results:  */
+  for (i = 1; i <=N-4; i++)
+    {
+      if (a[i+3] != b[i-1])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-6.c b/gcc/testsuite/gcc.dg/vect/vect-6.c
index 4dcb1be..5f2e0ea 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-6.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-6.c
@@ -3,41 +3,20 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 128
+#define N 16
 
-float results1[N];
-float results2[N];
+float results1[N] = {192.00,240.00,288.00,336.00,384.00,432.00,480.00,528.00,0.00};
+float results2[N] = {0.00,0.00,0.00,0.00,0.00,0.00,0.00,0.00,0.00,54.00,120.00,198.00,288.00,390.00,504.00,630.00};
 float a[N] = {0};
 float e[N] = {0};
-float b[N];
-float c[N];
-
-volatile int y = 0;
+float b[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+float c[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
 
 __attribute__ ((noinline))
 int main1 ()
 {
   int i;
 
-  for (i=0; i<N; i++)
-    {
-      b[i] = i*3;
-      c[i] = i;
-      results1[i] = 0;
-      results2[i] = 0;
-      /* Avoid vectorization.  */
-      if (y)
-	abort ();
-    }
-  for (i=0; i<N/2; i++)
-    {
-      results1[i] = b[i+N/2] * c[i+N/2] - b[i] * c[i];
-      results2[i+N/2] = b[i] * c[i+N/2] + b[i+N/2] * c[i];
-      /* Avoid vectorization.  */
-      if (y)
-	abort ();
-    }
-
   for (i = 0; i < N/2; i++)
     { 
       a[i] = b[i+N/2] * c[i+N/2] - b[i] * c[i];
diff --git a/gcc/testsuite/gcc.dg/vect/vect-73-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-73-big-array.c
new file mode 100644
index 0000000..5f40055
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-73-big-array.c
@@ -0,0 +1,51 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+int ic[N*2];
+int ib[N];
+
+#define ia (ic+N)
+
+volatile int y = 0;
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  int i, j;
+
+  for (i = 0; i < N; i++)
+    {
+      ib[i] = i*3;
+      if (y)
+	abort ();
+    }
+
+  for (i = 0; i < N; i++)
+    {
+       ia[i] = ib[i];
+    }
+
+  /* check results: */
+  for (i = 0; i < N; i++)
+    {
+       if (ia[i] != ib[i])
+         abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-73.c b/gcc/testsuite/gcc.dg/vect/vect-73.c
index 19d8d24..ee3c6e6 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-73.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-73.c
@@ -3,15 +3,13 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 128
+#define N 16
 
 int ic[N*2];
-int ib[N];
+int ib[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
 
 #define ia (ic+N)
 
-volatile int y = 0;
-
 __attribute__ ((noinline))
 int main1 ()
 {
@@ -19,13 +17,6 @@ int main1 ()
 
   for (i = 0; i < N; i++)
     {
-      ib[i] = i*3;
-      if (y)
-	abort ();
-    }
-
-  for (i = 0; i < N; i++)
-    {
        ia[i] = ib[i];
     }
 
@@ -33,7 +24,7 @@ int main1 ()
   for (i = 0; i < N; i++)
     {
        if (ia[i] != ib[i])
-         abort ();
+         abort();
     }
 
   return 0;
diff --git a/gcc/testsuite/gcc.dg/vect/vect-74-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-74-big-array.c
new file mode 100644
index 0000000..5cd926f
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-74-big-array.c
@@ -0,0 +1,68 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+/* Check handling of accesses for which the "initial condition" -
+   the expression that represents the first location accessed - is
+   more involved than just an ssa_name.  */
+
+float a[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+float b[N+4] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__))) = {0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 7.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0};
+float c[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__))) = {0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 7.5, 9.5, 10.5, 11.5, 12.5, 13.5, 14.5, 15.5};
+
+volatile int y = 0;
+
+__attribute__ ((noinline)) int
+main1 (float *__restrict__  pa, float * __restrict__ pb, float * __restrict__ pc)
+{
+  int i;
+  float *q = pb + 4;
+
+  for (i = 0; i < N; i++)
+    {
+      b[i] = i;
+      c[i] = 0.5 + i;
+      if (y)
+	abort ();
+    }
+  for (; i < N+4; i++)
+    {
+      b[i] = i;
+      if (y)
+	abort ();
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      pa[i] = q[i] * pc[i];
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      if (pa[i] != q[i] * pc[i])
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 (a, b, c);
+
+  return 0;
+}
+
+/* Xfail until handling restrict is refined.  See pr29145.  */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* Uncomment when this testcase gets vectorized again:
+ dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 3 "vect" { target vect_no_align } }
+ dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 2 "vect" { xfail vect_no_align } }
+ dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" { xfail vect_no_align } }
+*/
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-74.c b/gcc/testsuite/gcc.dg/vect/vect-74.c
index f8e973e..a680b9f 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-74.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-74.c
@@ -3,7 +3,7 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 128
+#define N 16
 
 /* Check handling of accesses for which the "initial condition" -
    the expression that represents the first location accessed - is
@@ -13,8 +13,6 @@ float a[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
 float b[N+4] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__))) = {0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 7.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0}; 
 float c[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__))) = {0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 7.5, 9.5, 10.5, 11.5, 12.5, 13.5, 14.5, 15.5};
 
-volatile int y = 0;
-
 __attribute__ ((noinline)) int
 main1 (float *__restrict__  pa, float * __restrict__ pb, float * __restrict__ pc)
 {
@@ -23,27 +21,13 @@ main1 (float *__restrict__  pa, float * __restrict__ pb, float * __restrict__ pc
 
   for (i = 0; i < N; i++)
     {
-      b[i] = i;
-      c[i] = 0.5 + i;
-      if (y)
-	abort ();
-    }
-  for (; i < N+4; i++)
-    {
-      b[i] = i;
-      if (y)
-	abort ();
-    }
-
-  for (i = 0; i < N; i++)
-    {
       pa[i] = q[i] * pc[i];
     }
 
   for (i = 0; i < N; i++)
     {
       if (pa[i] != q[i] * pc[i])
-	abort ();
+	abort();
     }
   
   return 0;
diff --git a/gcc/testsuite/gcc.dg/vect/vect-75-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-75-big-array.c
new file mode 100644
index 0000000..1c70cc2
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-75-big-array.c
@@ -0,0 +1,57 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 120
+#define OFF 8
+
+/* Check handling of accesses for which the "initial condition" -
+   the expression that represents the first location accessed - is
+   more involved than just an ssa_name.  */
+
+int ib[N+OFF] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__))) = {0, 1, 3, 5, 7, 11, 13, 17};
+
+volatile int y = 0;
+
+__attribute__ ((noinline))
+int main1 (int *ib)
+{
+  int i;
+  int ia[N];
+
+  for (i = OFF; i < N+OFF; i++)
+    {
+      ib[i] = ib[i%OFF]*(i/OFF);
+      if (y)
+	abort ();
+    }
+  for (i = 0; i < N; i++)
+    {
+      ia[i] = ib[i+OFF];
+    }
+
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+     if (ia[i] != ib[i+OFF])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 (ib);
+  return 0;
+}
+
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/*  { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 1 "vect" { target vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 1 "vect" { xfail vect_no_align } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-75.c b/gcc/testsuite/gcc.dg/vect/vect-75.c
index 1c70cc2..092a301 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-75.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-75.c
@@ -3,16 +3,14 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 120
+#define N 8
 #define OFF 8
 
 /* Check handling of accesses for which the "initial condition" -
    the expression that represents the first location accessed - is
    more involved than just an ssa_name.  */
 
-int ib[N+OFF] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__))) = {0, 1, 3, 5, 7, 11, 13, 17};
-
-volatile int y = 0;
+int ib[N+OFF] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__))) = {0, 1, 3, 5, 7, 11, 13, 17, 0, 2, 6, 10, 14, 22, 26, 34};
 
 __attribute__ ((noinline))
 int main1 (int *ib)
@@ -20,12 +18,6 @@ int main1 (int *ib)
   int i;
   int ia[N];
 
-  for (i = OFF; i < N+OFF; i++)
-    {
-      ib[i] = ib[i%OFF]*(i/OFF);
-      if (y)
-	abort ();
-    }
   for (i = 0; i < N; i++)
     {
       ia[i] = ib[i+OFF];
diff --git a/gcc/testsuite/gcc.dg/vect/vect-76-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-76-big-array.c
new file mode 100644
index 0000000..915f10e
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-76-big-array.c
@@ -0,0 +1,83 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 124
+#define OFF 4
+
+/* Check handling of accesses for which the "initial condition" -
+   the expression that represents the first location accessed - is
+   more involved than just an ssa_name.  */
+
+int ib[N+OFF] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__))) = {0, 1, 3, 5, 7, 11, 13, 17};
+int ic[N+OFF] = {0, 1, 3, 5, 7, 11, 13, 17};
+
+volatile int y = 0;
+
+__attribute__ ((noinline))
+int main1 (int *pib)
+{
+  int i;
+  int ia[N+OFF];
+  for (i = OFF; i < N+OFF; i++)
+    {
+      ib[i] = ib[i%8]*(i/8);
+      ic[i] = ic[i%8]*(i/8);
+      if (y)
+	abort ();
+    }
+
+  for (i = OFF; i < N; i++)
+    {
+      ia[i] = pib[i - OFF];
+    }
+
+
+  /* check results:  */
+  for (i = OFF; i < N; i++)
+    {
+     if (ia[i] != pib[i - OFF])
+        abort ();
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      ia[i] = pib[i - OFF];
+    }
+
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+     if (ia[i] != pib[i - OFF])
+        abort ();
+    }
+
+  for (i = OFF; i < N; i++)
+    {
+      ia[i] = ic[i - OFF];
+    }
+
+
+  /* check results:  */
+  for (i = OFF; i < N; i++)
+    {
+     if (ia[i] != ic[i - OFF])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 (&ib[OFF]);
+  return 0;
+}
+
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-76.c b/gcc/testsuite/gcc.dg/vect/vect-76.c
index edb0790..d771302 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-76.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-76.c
@@ -3,30 +3,21 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 124
+#define N 24
 #define OFF 4
 
 /* Check handling of accesses for which the "initial condition" -
    the expression that represents the first location accessed - is
    more involved than just an ssa_name.  */
 
-int ib[N+OFF] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__))) = {0, 1, 3, 5, 7, 11, 13, 17};
-int ic[N+OFF] = {0, 1, 3, 5, 7, 11, 13, 17};
-
-volatile int y = 0;
+int ib[N+OFF] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__))) = {0, 1, 3, 5, 7, 11, 13, 17, 0, 2, 6, 10};
+int ic[N+OFF] = {0, 1, 3, 5, 7, 11, 13, 17, 0, 2, 6, 10};
 
 __attribute__ ((noinline))
 int main1 (int *pib)
 {
   int i;
   int ia[N+OFF];
-  for (i = OFF; i < N+OFF; i++)
-    {
-      ib[i] = ib[i%8]*(i/8);
-      ic[i] = ic[i%8]*(i/8);
-      if (y)
-	abort ();
-    }
 
   for (i = OFF; i < N; i++)
     {
diff --git a/gcc/testsuite/gcc.dg/vect/vect-80-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-80-big-array.c
new file mode 100644
index 0000000..611d826
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-80-big-array.c
@@ -0,0 +1,71 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+float fa[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+float fb[N+4] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+float fc[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+
+/* Check handling of accesses for which the "initial condition" -
+   the expression that represents the first location accessed - is
+   more involved than just an ssa_name.  */
+
+volatile int y = 0;
+
+__attribute__ ((noinline)) int
+main1 (float * __restrict__ pa, float * __restrict__ pb, float *__restrict__ pc)
+{
+  int i;
+  float *q = pb + 4;
+  for (i = 0; i < N; i++)
+    {
+      fb[i] = i;
+      fc[i] = 0.5+i;
+      if (y)
+	abort ();
+    }
+  for (; i < N+4; i++)
+    {
+      fb[i] = i;
+      if (y)
+	abort ();
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      pa[i] = q[i] * pc[i];
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      if (pa[i] != q[i] * pc[i])
+	abort ();
+    }
+
+  return 0;
+}
+
+
+int main (void)
+{
+  check_vect ();
+
+  main1 (fa, fb, fc);
+
+  return 0;
+}
+
+/* For targets that don't support misaligned loads we version for the
+   all three accesses (peeling to align the store will not force the
+   two loads to be aligned).  */
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* Uncomment when this testcase gets vectorized again:
+ dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 2 "vect" { xfail vect_no_align } }
+ dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" { xfail vect_no_align } }
+ dg-final { scan-tree-dump-times "Alignment of access forced using versioning." 3 "vect" { target vect_no_align } }
+*/
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-80.c b/gcc/testsuite/gcc.dg/vect/vect-80.c
index f5cdbb2..fc0ed1b 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-80.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-80.c
@@ -3,36 +3,21 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 128
+#define N 16
 
 float fa[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
-float fb[N+4] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
-float fc[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+float fb[N+4] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__))) = {0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 7.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0};
+float fc[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__))) = {0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 7.5, 9.5, 10.5, 11.5, 12.5, 13.5, 14.5, 15.5};
 
 /* Check handling of accesses for which the "initial condition" -
    the expression that represents the first location accessed - is
    more involved than just an ssa_name.  */
 
-volatile int y = 0;
-
 __attribute__ ((noinline)) int
 main1 (float * __restrict__ pa, float * __restrict__ pb, float *__restrict__ pc)
 {
   int i;
   float *q = pb + 4;
-  for (i = 0; i < N; i++)
-    {
-      fb[i] = i;
-      fc[i] = 0.5+i;
-      if (y)
-	abort ();
-    }
-  for (; i < N+4; i++)
-    {
-      fb[i] = i;
-      if (y)
-	abort ();
-    }
 
   for (i = 0; i < N; i++)
     {
diff --git a/gcc/testsuite/gcc.dg/vect/vect-85-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-85-big-array.c
new file mode 100644
index 0000000..004114f
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-85-big-array.c
@@ -0,0 +1,49 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+__attribute__ ((noinline))
+int main1 (int *a)
+{
+  int i, j, k;
+  int b[N];
+
+  for (i = 0; i < N; i++)
+    {
+      for (j = 0; j < N; j++)
+        {
+	  k = i + N;
+          a[j] = k;
+        }
+      b[i] = k;
+    }
+
+
+  for (j = 0; j < N; j++)
+    if (a[j] != i + N - 1)
+      abort ();
+
+  for (j = 0; j < N; j++)
+    if (b[j] != j + N)
+      abort ();
+
+  return 0;
+}
+
+int main (void)
+{
+  int a[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+
+  check_vect ();
+
+  main1 (a);
+
+  return 0;
+}
+
+/* Fails for targets that don't vectorize PLUS (e.g alpha).  */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-85.c b/gcc/testsuite/gcc.dg/vect/vect-85.c
index 136ff4a..a5bf5db 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-85.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-85.c
@@ -3,7 +3,7 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 128
+#define N 16
 
 __attribute__ ((noinline))
 int main1 (int *a)
diff --git a/gcc/testsuite/gcc.dg/vect/vect-89-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-89-big-array.c
new file mode 100644
index 0000000..8928663
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-89-big-array.c
@@ -0,0 +1,50 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+struct tmp_struct
+{
+  int x;
+  int y[N];
+};
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  int i, *q;
+  struct tmp_struct tmp, *p;
+
+  p = &tmp;
+  q = p->y;
+
+  for (i = 0; i < N; i++)
+    {
+      *q++ = 5;
+    }
+
+  /* check results: */
+  for (i = 0; i < N; i++)
+    {
+      if (p->y[i] != 5)
+        {
+          abort ();
+        }
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-89.c b/gcc/testsuite/gcc.dg/vect/vect-89.c
index d621785..131efea 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-89.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-89.c
@@ -3,7 +3,7 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 128
+#define N 16
 
 struct tmp_struct
 {
diff --git a/gcc/testsuite/gcc.dg/vect/vect-97-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-97-big-array.c
new file mode 100644
index 0000000..87bacbf
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-97-big-array.c
@@ -0,0 +1,73 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+char x[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+char cb[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+
+volatile int y = 0;
+
+__attribute__ ((noinline))
+int main1 ()
+{
+  struct {
+    char *p;
+    char *q;
+  } s;
+  int i;
+  for (i = 0; i < N; i++)
+    {
+      cb[i] = i*3;
+      if (y)
+	abort ();
+    }
+
+  /* Check that datarefs analysis can determine that the access via pointer
+     s.p is based off array x, which enables us to antialias this access from
+     the access to array cb.  */
+  s.p = x;
+  for (i = 0; i < N; i++)
+    {
+      s.p[i] = cb[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (s.p[i] != cb[i])
+        abort ();
+    }
+
+  /* Check that datarefs analysis can determine that the access via pointer
+     s.p is based off array x, and that the access via pointer s.q is based off
+     array cb, which enables us to antialias these two accesses.  */
+  s.q = cb;
+  for (i = 0; i < N; i++)
+    {
+      s.p[i] = s.q[i];
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (s.p[i] != s.q[i])
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  return main1 ();
+}
+
+
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-97.c b/gcc/testsuite/gcc.dg/vect/vect-97.c
index f8bf4c3..6ea2614 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-97.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-97.c
@@ -3,12 +3,10 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 128
+#define N 16
  
 char x[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
-char cb[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
-
-volatile int y = 0;
+char cb[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__))) = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
 
 __attribute__ ((noinline))
 int main1 ()
@@ -18,12 +16,6 @@ int main1 ()
     char *q;
   } s;
   int i;
-  for (i = 0; i < N; i++)
-    {
-      cb[i] = i*3;
-      if (y)
-	abort ();
-    }
 
   /* Check that datarefs analysis can determine that the access via pointer
      s.p is based off array x, which enables us to antialias this access from
diff --git a/gcc/testsuite/gcc.dg/vect/vect-98-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-98-big-array.c
new file mode 100644
index 0000000..0528d43
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-98-big-array.c
@@ -0,0 +1,57 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+#define DOT16( a, b)   ( a[0]*b[0]   + a[1]*b[1]   + a[2]*b[2]   + a[3]*b[3] + \
+			 a[4]*b[4]   + a[5]*b[5]   + a[6]*b[6]   + a[7]*b[7] + \
+			 a[8]*b[8]   + a[9]*b[9]   + a[10]*b[10] + a[11]*b[11] + \
+			 a[12]*b[12] + a[13]*b[13] + a[14]*b[14] + a[15]*b[15])
+
+volatile int y = 0;
+
+__attribute__ ((noinline))
+int main1 (int ia[][N])
+{
+  int i, j;
+  int ib[N] = {0,3,6,9};
+  int ic[N][N];
+
+  for (i = 0; i < N; i++)
+    {
+	ic[0][i] = DOT16 (ia[i], ib);
+    }
+
+  /* check results: */
+  for (i = 0; i < N; i++)
+    {
+       if (ic[0][i] != DOT16 (ia[i], ib))
+           abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  int ia[N][N];
+  int i,j;
+  for (i = 0; i < N; i++)
+    for (j = 0; j < N; j++)
+      {
+        ia[i][j] = i + j + 1;
+	/* Avoid vectorization.  */
+	if (y)
+	  abort ();
+      }
+
+  check_vect ();
+
+  return main1 (ia);
+}
+
+/* Needs interleaving support.  */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_strided4 } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" { xfail  vect_strided4 } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-98.c b/gcc/testsuite/gcc.dg/vect/vect-98.c
index 987c93b..01c9153 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-98.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-98.c
@@ -3,13 +3,8 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 16
-#define DOT16( a, b)   ( a[0]*b[0]   + a[1]*b[1]   + a[2]*b[2]   + a[3]*b[3] + \
-			 a[4]*b[4]   + a[5]*b[5]   + a[6]*b[6]   + a[7]*b[7] + \
-			 a[8]*b[8]   + a[9]*b[9]   + a[10]*b[10] + a[11]*b[11] + \
-			 a[12]*b[12] + a[13]*b[13] + a[14]*b[14] + a[15]*b[15])
-
-volatile int y = 0;
+#define N 4
+#define DOT4( a, b )  ( a[0]*b[0] + a[1]*b[1] + a[2]*b[2] + a[3]*b[3] )
 
 __attribute__ ((noinline))
 int main1 (int ia[][N])
@@ -20,14 +15,14 @@ int main1 (int ia[][N])
 
   for (i = 0; i < N; i++)
     {
-	ic[0][i] = DOT16 (ia[i], ib);
+	ic[0][i] = DOT4 (ia[i], ib);
     }
 
   /* check results: */  
   for (i = 0; i < N; i++)
     {
-       if (ic[0][i] != DOT16 (ia[i], ib))
-           abort ();
+       if (ic[0][i] != DOT4 (ia[i], ib))
+           abort();
     }
 
   return 0;
@@ -35,16 +30,7 @@ int main1 (int ia[][N])
 
 int main (void)
 { 
-  int ia[N][N];
-  int i,j;
-  for (i = 0; i < N; i++)
-    for (j = 0; j < N; j++)
-      {
-        ia[i][j] = i + j + 1;
-	/* Avoid vectorization.  */
-	if (y)
-	  abort ();
-      }
+  int ia[N][N] = {{1,2,3,4},{2,3,5,7},{2,4,6,8},{22,43,55,77}};
 
   check_vect ();
 
diff --git a/gcc/testsuite/gcc.dg/vect/vect-all-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-all-big-array.c
new file mode 100644
index 0000000..ef5213a
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-all-big-array.c
@@ -0,0 +1,254 @@
+/* { dg-require-effective-target vect_int } */
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+int iadd_results[N];
+float fadd_results[N];
+float fmul_results[N];
+float fresults1[N];
+float fresults2[N];
+
+/****************************************************/
+__attribute__ ((noinline))
+void icheck_results (int *a, int *results)
+{
+  int i;
+  for (i = 0; i < N; i++)
+    {
+      if (a[i] != results[i])
+	abort ();
+    }
+}
+
+__attribute__ ((noinline))
+void fcheck_results (float *a, float *results)
+{
+  int i;
+  for (i = 0; i < N; i++)
+    {
+      if (a[i] != results[i])
+	abort ();
+    }
+}
+
+__attribute__ ((noinline)) void
+fbar_mul (float *a)
+{
+  fcheck_results (a, fmul_results);
+}
+
+__attribute__ ((noinline)) void
+fbar_add (float *a)
+{
+  fcheck_results (a, fadd_results);
+}
+
+__attribute__ ((noinline)) void
+ibar_add (int *a)
+{
+  icheck_results (a, iadd_results);
+}
+
+__attribute__ ((noinline)) void
+fbar1 (float *a)
+{
+  fcheck_results (a, fresults1);
+}
+
+__attribute__ ((noinline)) void
+fbar2 (float *a)
+{
+  fcheck_results (a, fresults2);
+}
+
+float a[N];
+float e[N];
+float b[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+float c[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+float d[N] = {0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30};
+int ic[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+int ib[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+int ia[N];
+char cb[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+char ca[N];
+short sa[N];
+
+volatile int y = 0;
+
+/* All of the loops below are currently vectorizable, except
+   initialization ones.  */
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  int i,j;
+  /* Initialization.  */
+  for (i = 0; i < N; i++)
+    {
+      b[i] = i*3;
+      c[i] = i;
+      d[i] = i*2;
+      ic[i] = i*3;
+      ib[i] = i*3;
+      cb[i] = i*3;
+      fadd_results[i] = b[i] + c[i] + d[i];
+      iadd_results[i] = ib[i] + ic[i];
+      fmul_results[i] = b[i] * c[i];
+      fresults1[i] = 0;
+      fresults2[i] = 0;
+      if (y)
+	abort ();
+    }
+
+  /* Test 1: copy chars.  */
+  for (i = 0; i < N; i++)
+    {
+      ca[i] = cb[i];
+    }
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (ca[i] != cb[i])
+	abort ();
+    }
+
+
+  /* Test 2: fp mult.  */
+  for (i = 0; i < N; i++)
+    {
+      a[i] = b[i] * c[i];
+    }
+  fbar_mul (a);
+
+
+  /* Test 3: mixed types (int, fp), same nunits in vector.  */
+  for (i = 0; i < N; i++)
+    {
+      a[i] = b[i] + c[i] + d[i];
+      e[i] = b[i] + c[i] + d[i];
+      ia[i] = ib[i] + ic[i];
+    }
+  ibar_add (ia);
+  fbar_add (a);
+  fbar_add (e);
+
+  /* Initialization.  */
+  for (i = 0; i < N; i++)
+    {
+      fresults1[i] = a[i];
+      fresults2[i] = e[i];
+      if (y)
+	abort ();
+    }
+  for (i = 0; i < N/2; i++)
+    {
+      fresults1[i] = b[i+N/2] * c[i+N/2] - b[i] * c[i];
+      fresults2[i+N/2] = b[i] * c[i+N/2] + b[i+N/2] * c[i];
+      if (y)
+	abort ();
+    }
+  /* Test 4: access with offset.  */
+  for (i = 0; i < N/2; i++)
+    {
+      a[i] = b[i+N/2] * c[i+N/2] - b[i] * c[i];
+      e[i+N/2] = b[i] * c[i+N/2] + b[i+N/2] * c[i];
+    }
+  fbar1 (a);
+  fbar2 (e);
+
+
+  /* Test 5: access with offset.  */
+  for (i = 1; i <=N-4; i++)
+    {
+      a[i+3] = b[i-1];
+    }
+  /* check results:  */
+  for (i = 1; i <=N-4; i++)
+    {
+      if (a[i+3] != b[i-1])
+	abort ();
+    }
+
+
+  /* Test 6 - loop induction with stride != 1.  */
+  i = 0;
+  j = 0;
+  while (i < 5*N)
+    {
+      a[j] = c[j];
+      i += 5;
+      j++;
+    }
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (a[i] != c[i])
+        abort ();
+    }
+
+
+  /* Test 7 - reverse access.  */
+  for (i = N; i > 0; i--)
+    {
+      a[N-i] = d[N-i];
+    }
+  /* check results:  */
+  for (i = 0; i <N; i++)
+    {
+      if (a[i] != d[i])
+        abort ();
+    }
+
+
+  /* Tests 8,9,10 - constants.  */
+  for (i = 0; i < N; i++)
+    {
+      a[i] = 5.0;
+    }
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (a[i] != 5.0)
+        abort ();
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      sa[i] = 5;
+    }
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (sa[i] != 5)
+        abort ();
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      ia[i] = ib[i] + 5;
+    }
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (ia[i] != ib[i] + 5)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 10 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-all.c b/gcc/testsuite/gcc.dg/vect/vect-all.c
index 79ad599..6adb7bf 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-all.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-all.c
@@ -4,13 +4,13 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 128
+#define N 16
 
-int iadd_results[N];
-float fadd_results[N];
-float fmul_results[N];
-float fresults1[N];
-float fresults2[N];
+int iadd_results[N] = {0,6,12,18,24,30,36,42,48,54,60,66,72,78,84,90};
+float fadd_results[N] = {0.0,6.0,12.0,18.0,24.0,30.0,36.0,42.0,48.0,54.0,60.0,66.0,72.0,78.0,84.0,90.0};
+float fmul_results[N] = {0.0,3.0,12.0,27.0,48.0,75.0,108.0,147.0,192.0,243.0,300.0,363.0,432.0,507.0,588.0,675.0};
+float fresults1[N] = {192.00,240.00,288.00,336.00,384.00,432.00,480.00,528.00,48.00,54.00,60.00,66.00,72.00,78.00,84.00,90.00};
+float fresults2[N] = {0.00,6.00,12.00,18.00,24.00,30.00,36.00,42.00,0.00,54.00,120.00,198.00,288.00,390.00,504.00,630.00};
 
 /****************************************************/
 __attribute__ ((noinline))
@@ -77,32 +77,12 @@ char cb[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
 char ca[N];
 short sa[N];
 
-volatile int y = 0;
-
-/* All of the loops below are currently vectorizable, except
-   initialization ones.  */
+/* All of the loops below are currently vectorizable.  */
 
 __attribute__ ((noinline)) int
 main1 ()
 {
   int i,j;
-  /* Initialization.  */
-  for (i = 0; i < N; i++)
-    {
-      b[i] = i*3;
-      c[i] = i;
-      d[i] = i*2;
-      ic[i] = i*3;
-      ib[i] = i*3;
-      cb[i] = i*3;
-      fadd_results[i] = b[i] + c[i] + d[i];
-      iadd_results[i] = ib[i] + ic[i];
-      fmul_results[i] = b[i] * c[i];
-      fresults1[i] = 0;
-      fresults2[i] = 0;
-      if (y)
-	abort ();
-    }
 
   /* Test 1: copy chars.  */
   for (i = 0; i < N; i++)
@@ -136,21 +116,7 @@ main1 ()
   fbar_add (a);
   fbar_add (e);
 
-  /* Initialization.  */
-  for (i = 0; i < N; i++)
-    {
-      fresults1[i] = a[i];
-      fresults2[i] = e[i];
-      if (y)
-	abort ();
-    }
-  for (i = 0; i < N/2; i++)
-    {
-      fresults1[i] = b[i+N/2] * c[i+N/2] - b[i] * c[i];
-      fresults2[i+N/2] = b[i] * c[i+N/2] + b[i+N/2] * c[i];
-      if (y)
-	abort ();
-    }
+
   /* Test 4: access with offset.  */
   for (i = 0; i < N/2; i++)
     {
diff --git a/gcc/testsuite/gcc.dg/vect/vect-double-reduc-6-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-double-reduc-6-big-array.c
new file mode 100644
index 0000000..abf3f7d
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-double-reduc-6-big-array.c
@@ -0,0 +1,65 @@
+/* { dg-require-effective-target vect_int_mult } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define K 16
+
+int in[2*K][K] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+int out[K];
+int check_result[K];
+
+volatile int y = 0;
+
+__attribute__ ((noinline)) void
+foo ()
+{
+  int sum;
+  int i, j, k;
+
+  for (k = 0; k < K; k++)
+    {
+      sum = 1;
+      for (j = 0; j < K; j++)
+        for (i = 0; i < K; i++)
+	{
+          sum *= in[i+k][j];
+	  /* Avoid vectorization.  */
+	  if (y)
+	    abort ();
+	}
+      check_result[k] = sum;
+    }
+
+  for (k = 0; k < K; k++)
+    {
+      sum = 1;
+      for (j = 0; j < K; j++)
+        for (i = 0; i < K; i++)
+          sum *= in[i+k][j];
+      out[k] = sum;
+    }
+}
+
+int main ()
+{
+  int i, j, k;
+
+  check_vect ();
+
+  for (i = 0; i < 2*K; i++)
+    for (j = 0; j < K; j++)
+      in[i][j] = (i+2)/3;
+
+  foo ();
+
+  for (k = 0; k < K; k++)
+    if (out[k] != check_result[k])
+      abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc/testsuite/gcc.dg/vect/vect-double-reduc-6.c b/gcc/testsuite/gcc.dg/vect/vect-double-reduc-6.c
index 0b49ab7..6b14e3b 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-double-reduc-6.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-double-reduc-6.c
@@ -3,15 +3,13 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define K 16
+#define K 4 
 
 int in[2*K][K] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
 int out[K];
-int check_result[K];
+int check_result[K] = {0,16,256,4096};
 
-volatile int y = 0;
-
-__attribute__ ((noinline)) void
+__attribute__ ((noinline)) void 
 foo ()
 {
   int sum;
@@ -20,21 +18,7 @@ foo ()
   for (k = 0; k < K; k++)
     {
       sum = 1;
-      for (j = 0; j < K; j++)
-        for (i = 0; i < K; i++)
-	{
-          sum *= in[i+k][j];
-	  /* Avoid vectorization.  */
-	  if (y)
-	    abort ();
-	}
-      check_result[k] = sum;
-    }
-
-  for (k = 0; k < K; k++)
-    {
-      sum = 1;
-      for (j = 0; j < K; j++)
+      for (j = 0; j < K; j++) 
         for (i = 0; i < K; i++)
           sum *= in[i+k][j];
       out[k] = sum;
@@ -59,7 +43,7 @@ int main ()
 
   return 0;
 }
-
+        
 /* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" } } */
 /* { dg-final { cleanup-tree-dump "vect" } } */
-
+      
diff --git a/gcc/testsuite/gcc.dg/vect/vect-iv-8-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-iv-8-big-array.c
new file mode 100644
index 0000000..677b7a3
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-iv-8-big-array.c
@@ -0,0 +1,43 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+__attribute__ ((noinline)) int main1 (short X)
+{
+  unsigned char a[N];
+  unsigned short b[N];
+  unsigned int c[N];
+  short myX = X;
+  int i;
+
+  /* vectorization of induction with type conversions.  */
+  for (i = 0; i < N; i++)
+  {
+    a[i] = (unsigned char)X;
+    b[i] = X;
+    c[i] = (unsigned int)X;
+    X++;
+  }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (a[i] != (unsigned char)myX || b[i] != myX || c[i] != (unsigned int)myX++)
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  return main1 (3);
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_pack_trunc && vect_unpack } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-iv-8.c b/gcc/testsuite/gcc.dg/vect/vect-iv-8.c
index 4150ee2..6544988 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-iv-8.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-iv-8.c
@@ -3,7 +3,7 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 128
+#define N 26
  
 __attribute__ ((noinline)) int main1 (short X)
 {  
diff --git a/gcc/testsuite/gcc.dg/vect/vect-iv-8a-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-iv-8a-big-array.c
new file mode 100644
index 0000000..100c751
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-iv-8a-big-array.c
@@ -0,0 +1,43 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+__attribute__ ((noinline)) int main1 (short X)
+{
+  signed char a[N];
+  short b[N];
+  int c[N];
+  short myX = X;
+  int i;
+
+  /* vectorization of induction with type conversions.  */
+  for (i = 0; i < N; i++)
+  {
+    a[i] = (signed char)X;
+    b[i] = X;
+    c[i] = (int)X;
+    X++;
+  }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (a[i] != (signed char)myX || b[i] != myX || c[i] != (int)myX++)
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  return main1 (3);
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_pack_trunc && vect_unpack } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-iv-8a.c b/gcc/testsuite/gcc.dg/vect/vect-iv-8a.c
index 3492030..dc742eb 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-iv-8a.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-iv-8a.c
@@ -3,7 +3,7 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 128
+#define N 26
  
 __attribute__ ((noinline)) int main1 (short X)
 {  
diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-1-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-outer-1-big-array.c
new file mode 100644
index 0000000..804c386
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-outer-1-big-array.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+
+#define N 256
+signed short image[N][N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+signed short block[N][N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+signed short out[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+
+/* Can't do outer-loop vectorization because of non-consecutive access.  */
+
+void
+foo (){
+  int i,j;
+  int diff;
+
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < N; j+=8) {
+      diff += (image[i][j] - block[i][j]);
+    }
+    out[i]=diff;
+  }
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "strided access in outer loop" 1 "vect" { xfail vect_multiple_sizes } } } */
+/* { dg-final { scan-tree-dump-times "strided access in outer loop" 2 "vect" { target vect_multiple_sizes } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-1.c b/gcc/testsuite/gcc.dg/vect/vect-outer-1.c
index e8094db..2ce8f8e 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-outer-1.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-outer-1.c
@@ -1,6 +1,6 @@
 /* { dg-do compile } */
 
-#define N 256
+#define N 64
 signed short image[N][N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
 signed short block[N][N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
 signed short out[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-1a-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-outer-1a-big-array.c
new file mode 100644
index 0000000..9b418fa
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-outer-1a-big-array.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */
+
+#define N 256
+signed short image[N][N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+signed short block[N][N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+
+/* Can't do outer-loop vectorization because of non-consecutive access.  */
+
+int
+foo (){
+  int i,j;
+  int diff = 0;
+
+  for (i = 0; i < N; i++) {
+    for (j = 0; j < N; j+=8) {
+      diff += (image[i][j] - block[i][j]);
+    }
+  }
+  return diff;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "strided access in outer loop" 1 "vect" { xfail vect_multiple_sizes } } } */
+/* { dg-final { scan-tree-dump-times "strided access in outer loop" 2 "vect" { target vect_multiple_sizes } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-1a.c b/gcc/testsuite/gcc.dg/vect/vect-outer-1a.c
index 9b418fa..a9b786e 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-outer-1a.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-outer-1a.c
@@ -1,6 +1,6 @@
 /* { dg-do compile } */
 
-#define N 256
+#define N 64
 signed short image[N][N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
 signed short block[N][N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
 
diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-1b-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-outer-1b-big-array.c
new file mode 100644
index 0000000..48b7180
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-outer-1b-big-array.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+
+#define N 160
+signed short image[N][N];
+signed short block[N][N];
+signed short out[N];
+
+/* Outer-loop cannot get vectorized because of non-consecutive access.  */
+
+void
+foo (){
+  int i,j;
+  int diff;
+
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < N; j+=4) {
+      diff += (image[i][j] - block[i][j]);
+    }
+    out[i]=diff;
+  }
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "strided access in outer loop" 1 "vect" { xfail vect_multiple_sizes } } } */
+/* { dg-final { scan-tree-dump-times "strided access in outer loop" 2 "vect" { target vect_multiple_sizes } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-1b.c b/gcc/testsuite/gcc.dg/vect/vect-outer-1b.c
index 48b7180..815758c 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-outer-1b.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-outer-1b.c
@@ -1,6 +1,6 @@
 /* { dg-do compile } */
 
-#define N 160
+#define N 40
 signed short image[N][N];
 signed short block[N][N];
 signed short out[N];
diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-2-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-outer-2-big-array.c
new file mode 100644
index 0000000..ba3fa87
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-outer-2-big-array.c
@@ -0,0 +1,41 @@
+/* { dg-require-effective-target vect_float } */
+/* { dg-require-effective-target vect_intfloat_cvt } */
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 160
+float image[N][N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+float out[N];
+
+/* Outer-loop vectorization.  */
+
+__attribute__ ((noinline)) void
+foo (){
+  int i,j;
+
+  for (i = 0; i < N; i++) {
+    for (j = 0; j < N; j++) {
+      image[j][i] = j+i;
+    }
+  }
+}
+
+int main (void)
+{
+  check_vect ();
+  int i, j;
+
+  foo ();
+
+  for (i = 0; i < N; i++) {
+    for (j = 0; j < N; j++) {
+      if (image[j][i] != j+i)
+	abort ();
+    }
+  }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-2.c b/gcc/testsuite/gcc.dg/vect/vect-outer-2.c
index ba3fa87..3870197 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-outer-2.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-outer-2.c
@@ -3,7 +3,7 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 160
+#define N 40
 float image[N][N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
 float out[N];
 
diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-2a-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-outer-2a-big-array.c
new file mode 100644
index 0000000..062e1fdd
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-outer-2a-big-array.c
@@ -0,0 +1,42 @@
+/* { dg-require-effective-target vect_float } */
+/* { dg-require-effective-target vect_intfloat_cvt } */
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 160
+float image[N][N][N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+
+__attribute__ ((noinline)) void
+foo (){
+  int i,j,k;
+
+ for (k=0; k<N; k++) {
+  for (i = 0; i < N; i++) {
+    for (j = 0; j < N; j++) {
+      image[k][j][i] = j+i+k;
+    }
+  }
+ }
+}
+
+int main (void)
+{
+  check_vect ();
+  int i, j, k;
+
+  foo ();
+
+ for (k=0; k<N; k++) {
+  for (i = 0; i < N; i++) {
+    for (j = 0; j < N; j++) {
+      if (image[k][j][i] != j+i+k)
+	abort ();
+    }
+  }
+ }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-2a.c b/gcc/testsuite/gcc.dg/vect/vect-outer-2a.c
index 062e1fdd..b8d0e51 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-outer-2a.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-outer-2a.c
@@ -3,7 +3,7 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 160
+#define N 40
 float image[N][N][N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
 
 __attribute__ ((noinline)) void
diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-2c-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-outer-2c-big-array.c
new file mode 100644
index 0000000..cdea72a
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-outer-2c-big-array.c
@@ -0,0 +1,42 @@
+/* { dg-require-effective-target vect_float } */
+/* { dg-require-effective-target vect_intfloat_cvt } */
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 160
+float image[2*N][2*N][N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+
+__attribute__ ((noinline)) void
+foo (){
+  int i,j,k;
+
+ for (k=0; k<N; k++) {
+  for (i = 0; i < N; i++) {
+    for (j = 0; j < N; j+=2) {
+      image[k][j][i] = j+i+k;
+    }
+  }
+ }
+}
+
+int main (void)
+{
+  check_vect ();
+  int i, j, k;
+
+  foo ();
+
+ for (k=0; k<N; k++) {
+  for (i = 0; i < N; i++) {
+    for (j = 0; j < N; j+=2) {
+      if (image[k][j][i] != j+i+k)
+	abort ();
+    }
+  }
+ }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-2c.c b/gcc/testsuite/gcc.dg/vect/vect-outer-2c.c
index cdea72a..0ca8686 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-outer-2c.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-outer-2c.c
@@ -3,7 +3,7 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 160
+#define N 40
 float image[2*N][2*N][N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
 
 __attribute__ ((noinline)) void
diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-3-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-outer-3-big-array.c
new file mode 100644
index 0000000..83b6f99
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-outer-3-big-array.c
@@ -0,0 +1,52 @@
+/* { dg-require-effective-target vect_float } */
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 320
+float image[N][N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+float out[N];
+
+/* Outer-loop vectoriation.  */
+
+__attribute__ ((noinline)) void
+foo (){
+  int i,j;
+  float diff;
+
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < N; j++) {
+      diff += image[j][i];
+    }
+    out[i]=diff;
+  }
+}
+
+int main (void)
+{
+  check_vect ();
+  int i, j;
+  float diff;
+
+  for (i = 0; i < N; i++) {
+    for (j = 0; j < N; j++) {
+      image[i][j]=i+j;
+    }
+  }
+
+  foo ();
+
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < N; j++) {
+      diff += image[j][i];
+    }
+    if (out[i] != diff)
+      abort ();
+  }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-3.c b/gcc/testsuite/gcc.dg/vect/vect-outer-3.c
index 83b6f99..924700c 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-outer-3.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-outer-3.c
@@ -2,7 +2,7 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 320
+#define N 40
 float image[N][N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
 float out[N];
 
diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-3a-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-outer-3a-big-array.c
new file mode 100644
index 0000000..9768a1e
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-outer-3a-big-array.c
@@ -0,0 +1,54 @@
+/* { dg-require-effective-target vect_float } */
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 320
+float image[N][N+1] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
+float out[N];
+
+/* Outer-loop vectorization with misaliged accesses in the inner-loop.  */
+
+__attribute__ ((noinline)) void
+foo (){
+  int i,j;
+  float diff;
+
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < N; j++) {
+      diff += image[j][i];
+    }
+    out[i]=diff;
+  }
+}
+
+int main (void)
+{
+  check_vect ();
+  int i, j;
+  float diff;
+
+  for (i = 0; i < N; i++) {
+    for (j = 0; j < N; j++) {
+      image[i][j]=i+j;
+    }
+  }
+
+  foo ();
+
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < N; j++) {
+      diff += image[j][i];
+    }
+    if (out[i] != diff)
+      abort ();
+  }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { xfail vect_no_align } } } */
+/* { dg-final { scan-tree-dump-times "step doesn't divide the vector-size" 2 "vect" { xfail vect_multiple_sizes } } } */
+/* { dg-final { scan-tree-dump-times "step doesn't divide the vector-size" 3 "vect" { target vect_multiple_sizes } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-3a.c b/gcc/testsuite/gcc.dg/vect/vect-outer-3a.c
index 9768a1e..1759ee3 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-outer-3a.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-outer-3a.c
@@ -2,7 +2,7 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 320
+#define N 40
 float image[N][N+1] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__)));
 float out[N];
 
diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-4a-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-outer-4a-big-array.c
new file mode 100644
index 0000000..af9d2a8
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-outer-4a-big-array.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+
+#define N 512
+#define M 1024
+signed short in[N+M];
+signed short coeff[M];
+signed short out[N];
+
+/* Outer-loop vectorization.  */
+
+void
+foo (){
+  int i,j;
+  int diff;
+
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < M; j+=8) {
+      diff += in[j+i]*coeff[j];
+    }
+    out[i]=diff;
+  }
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { target { vect_widen_mult_hi_to_si && vect_pack_trunc } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-4a.c b/gcc/testsuite/gcc.dg/vect/vect-outer-4a.c
index 3981b94..d7bcc9a 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-outer-4a.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-outer-4a.c
@@ -1,7 +1,7 @@
 /* { dg-do compile } */
 
-#define N 512
-#define M 1024
+#define N 40
+#define M 128
 signed short in[N+M];
 signed short coeff[M];
 signed short out[N];
diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-4b-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-outer-4b-big-array.c
new file mode 100644
index 0000000..703ac94
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-outer-4b-big-array.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+
+#define N 320
+#define M 1024
+signed short in[N+M];
+signed short coeff[M];
+int out[N];
+
+/* Outer-loop vectorization.  */
+
+void
+foo (){
+  int i,j;
+  int diff;
+
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < M; j+=8) {
+      diff += in[j+i]*coeff[j];
+    }
+    out[i]=diff;
+  }
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { target vect_widen_mult_hi_to_si } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-4b.c b/gcc/testsuite/gcc.dg/vect/vect-outer-4b.c
index a903545..407315a 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-outer-4b.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-outer-4b.c
@@ -1,7 +1,7 @@
 /* { dg-do compile } */
 
-#define N 320
-#define M 1024
+#define N 40
+#define M 128
 signed short in[N+M];
 signed short coeff[M];
 int out[N];
diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-4c-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-outer-4c-big-array.c
new file mode 100644
index 0000000..2ce242c
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-outer-4c-big-array.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+
+#define N 320
+#define M 1024
+unsigned short in[N+M];
+unsigned short coeff[M];
+unsigned int out[N];
+
+/* Outer-loop vectorization.  */
+
+void
+foo (){
+  int i,j;
+  unsigned short diff;
+
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < M; j+=8) {
+      diff += in[j+i]*coeff[j];
+    }
+    out[i]=diff;
+  }
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { target { vect_short_mult && { ! vect_no_align } } } } } */
+/* { dg-final { scan-tree-dump-times "zero step in outer loop." 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-4c.c b/gcc/testsuite/gcc.dg/vect/vect-outer-4c.c
index 4b6ffbf..3342b79 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-outer-4c.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-outer-4c.c
@@ -1,7 +1,7 @@
 /* { dg-do compile } */
 
-#define N 320
-#define M 1024
+#define N 40
+#define M 128
 unsigned short in[N+M];
 unsigned short coeff[M];
 unsigned int out[N];
diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-4d-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-outer-4d-big-array.c
new file mode 100644
index 0000000..0d85bed
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-outer-4d-big-array.c
@@ -0,0 +1,51 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 320
+#define M 1024
+float in[N+M];
+float out[N];
+
+/* Outer-loop vectorization.  */
+
+__attribute__ ((noinline)) void
+foo (){
+  int i,j;
+  float diff;
+
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < M; j+=4) {
+      diff += in[j+i];
+    }
+    out[i]=diff;
+  }
+}
+
+int main (void)
+{
+  check_vect ();
+  int i, j;
+  float diff;
+
+  for (i = 0; i < N; i++)
+    in[i] = i;
+
+  foo ();
+
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < M; j+=4) {
+      diff += in[j+i];
+    }
+    if (out[i] != diff)
+      abort ();
+  }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect"  } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-4d.c b/gcc/testsuite/gcc.dg/vect/vect-outer-4d.c
index e70be32..c344fb1 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-outer-4d.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-outer-4d.c
@@ -3,8 +3,8 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 320
-#define M 1024
+#define N 40
+#define M 128
 float in[N+M];
 float out[N];
 
diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-4m-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-outer-4m-big-array.c
new file mode 100644
index 0000000..9a1e02e
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-outer-4m-big-array.c
@@ -0,0 +1,58 @@
+/* { dg-require-effective-target vect_int } */
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 320
+#define M 1024
+unsigned short in[N+M];
+unsigned int out[N];
+
+/* Outer-loop vectorization.  */
+/* Not vectorized due to multiple-types in the inner-loop.  */
+
+__attribute__ ((noinline)) unsigned int
+foo (){
+  int i,j;
+  unsigned int diff;
+  unsigned int s=0;
+
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < M; j+=8) {
+      diff += in[j+i];
+    }
+    s+=((unsigned short)diff>>3);
+  }
+  return s;
+}
+
+int main (void)
+{
+  int i, j;
+  unsigned int diff;
+  unsigned int s=0,sum=0;
+
+  check_vect ();
+
+  for (i = 0; i < N+M; i++) {
+    in[i] = i;
+  }
+
+  sum=foo ();
+
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < M; j+=8) {
+      diff += in[j+i];
+    }
+    s += ((unsigned short)diff>>3);
+  }
+
+  if (s != sum)
+    abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect"  { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-4m.c b/gcc/testsuite/gcc.dg/vect/vect-outer-4m.c
index 1087df0..6e032f1 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-outer-4m.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-outer-4m.c
@@ -2,8 +2,8 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 320
-#define M 1024
+#define N 40
+#define M 128
 unsigned short in[N+M];
 unsigned int out[N];
 
diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-fir-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-outer-fir-big-array.c
new file mode 100644
index 0000000..c69b7d7
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-outer-fir-big-array.c
@@ -0,0 +1,74 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 80
+#define M 256
+float in[N+M];
+float coeff[M];
+float out[N];
+float fir_out[N];
+
+/* Should be vectorized.  Fixed misaligment in the inner-loop.  */
+__attribute__ ((noinline))
+void foo (){
+ int i,j,k;
+ float diff;
+
+ for (i = 0; i < N; i++) {
+  out[i] = 0;
+ }
+
+ for (k = 0; k < 4; k++) {
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = k; j < M; j+=4) {
+      diff += in[j+i]*coeff[j];
+    }
+    out[i] += diff;
+  }
+ }
+
+}
+
+/* Vectorized.  Changing misalignment in the inner-loop.  */
+__attribute__ ((noinline))
+void fir (){
+  int i,j,k;
+  float diff;
+
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < M; j++) {
+      diff += in[j+i]*coeff[j];
+    }
+    fir_out[i] = diff;
+  }
+}
+
+
+int main (void)
+{
+  check_vect ();
+  int i, j;
+  float diff;
+
+  for (i = 0; i < M; i++)
+    coeff[i] = i;
+  for (i = 0; i < N+M; i++)
+    in[i] = i;
+
+  foo ();
+  fir ();
+
+  for (i = 0; i < N; i++) {
+    if (out[i] != fir_out[i])
+      abort ();
+  }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 2 "vect" { xfail vect_no_align } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-fir-lb-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-outer-fir-lb-big-array.c
new file mode 100644
index 0000000..5ac62ac
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-outer-fir-lb-big-array.c
@@ -0,0 +1,78 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 80
+#define M 128
+float in[N+M];
+float coeff[M];
+float out[N];
+float fir_out[N];
+
+/* Vectorized.  Fixed misaligment in the inner-loop.  */
+__attribute__ ((noinline))
+void foo (){
+ int i,j,k;
+ float diff;
+
+ for (i = 0; i < N; i++) {
+  out[i] = 0;
+ }
+
+ for (k = 0; k < 4; k++) {
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    j = k;
+
+    do {
+      diff += in[j+i]*coeff[j];
+      j+=4;
+    } while (j < M);
+
+    out[i] += diff;
+  }
+ }
+
+}
+
+/* Vectorized.  Changing misalignment in the inner-loop.  */
+__attribute__ ((noinline))
+void fir (){
+  int i,j,k;
+  float diff;
+
+  for (i = 0; i < N; i++) {
+    diff = 0;
+    for (j = 0; j < M; j++) {
+      diff += in[j+i]*coeff[j];
+    }
+    fir_out[i] = diff;
+  }
+}
+
+
+int main (void)
+{
+  check_vect ();
+  int i, j;
+  float diff;
+
+  for (i = 0; i < M; i++)
+    coeff[i] = i;
+  for (i = 0; i < N+M; i++)
+    in[i] = i;
+
+  foo ();
+  fir ();
+
+  for (i = 0; i < N; i++) {
+    if (out[i] != fir_out[i])
+      abort ();
+  }
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 2 "vect" { xfail vect_no_align } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-fir-lb.c b/gcc/testsuite/gcc.dg/vect/vect-outer-fir-lb.c
index 5ac62ac..3c1a362 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-outer-fir-lb.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-outer-fir-lb.c
@@ -3,8 +3,8 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 80
-#define M 128
+#define N 40
+#define M 64
 float in[N+M];
 float coeff[M];
 float out[N];
diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-fir.c b/gcc/testsuite/gcc.dg/vect/vect-outer-fir.c
index c81180c..af787b9 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-outer-fir.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-outer-fir.c
@@ -3,8 +3,8 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 80
-#define M 256
+#define N 40
+#define M 128
 float in[N+M];
 float coeff[M];
 float out[N];
diff --git a/gcc/testsuite/gcc.dg/vect/vect-over-widen-1-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-over-widen-1-big-array.c
new file mode 100644
index 0000000..2061594
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-over-widen-1-big-array.c
@@ -0,0 +1,64 @@
+/* { dg-require-effective-target vect_int } */
+/* { dg-require-effective-target vect_shift } */
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 512
+
+/* Modified rgb to rgb conversion from FFmpeg.  */
+__attribute__ ((noinline)) void
+foo (unsigned char *src, unsigned char *dst)
+{
+  unsigned char *s = src;
+  unsigned short *d = (unsigned short *)dst;
+  int i;
+
+  for (i = 0; i < N/4; i++)
+    {
+      const int b = *s++;
+      const int g = *s++;
+      const int r = *s++;
+      const int a = *s++;
+      *d = ((b>>3) | ((g&0xFC)<<3) | ((r&0xF8)<<8) | (a>>5));
+      d++;
+    }
+
+  s = src;
+  d = (unsigned short *)dst;
+  for (i = 0; i < N/4; i++)
+    {
+      const int b = *s++;
+      const int g = *s++;
+      const int r = *s++;
+      const int a = *s++;
+      if (*d != ((b>>3) | ((g&0xFC)<<3) | ((r&0xF8)<<8) | (a>>5)))
+        abort ();
+      d++;
+    }
+}
+
+int main (void)
+{
+  int i;
+  unsigned char in[N], out[N];
+
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    {
+      in[i] = i;
+      out[i] = 255;
+      __asm__ volatile ("");
+    }
+
+  foo (in, out);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vect_recog_over_widening_pattern: detected" 4 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc/testsuite/gcc.dg/vect/vect-over-widen-1.c b/gcc/testsuite/gcc.dg/vect/vect-over-widen-1.c
index 2061594..36f4684 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-over-widen-1.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-over-widen-1.c
@@ -5,7 +5,7 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 512
+#define N 64
 
 /* Modified rgb to rgb conversion from FFmpeg.  */
 __attribute__ ((noinline)) void
diff --git a/gcc/testsuite/gcc.dg/vect/vect-over-widen-2-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-over-widen-2-big-array.c
new file mode 100644
index 0000000..bc738ce
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-over-widen-2-big-array.c
@@ -0,0 +1,65 @@
+/* { dg-require-effective-target vect_int } */
+/* { dg-require-effective-target vect_shift } */
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 512
+
+/* Modified rgb to rgb conversion from FFmpeg.  */
+__attribute__ ((noinline)) void
+foo (unsigned char *src, unsigned char *dst)
+{
+  unsigned char *s = src;
+  int *d = (int *)dst;
+  int i;
+
+  for (i = 0; i < N/4; i++)
+    {
+      const int b = *s++;
+      const int g = *s++;
+      const int r = *s++;
+      const int a = *s++;
+      *d = ((b>>3) | ((g&0xFC)<<3) | ((r&0xF8)<<8) | (a>>5));
+      d++;
+    }
+
+  s = src;
+  d = (int *)dst;
+  for (i = 0; i < N/4; i++)
+    {
+      const int b = *s++;
+      const int g = *s++;
+      const int r = *s++;
+      const int a = *s++;
+      if (*d != ((b>>3) | ((g&0xFC)<<3) | ((r&0xF8)<<8) | (a>>5)))
+        abort ();
+      d++;
+    }
+}
+
+int main (void)
+{
+  int i;
+  unsigned char in[N], out[N];
+
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    {
+      in[i] = i;
+      out[i] = 255;
+      __asm__ volatile ("");
+    }
+
+  foo (in, out);
+
+  return 0;
+}
+
+/* Final value stays in int, so no over-widening is detected at the moment.  */
+/* { dg-final { scan-tree-dump-times "vect_recog_over_widening_pattern: detected" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc/testsuite/gcc.dg/vect/vect-over-widen-2.c b/gcc/testsuite/gcc.dg/vect/vect-over-widen-2.c
index bc738ce..fecc5ef 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-over-widen-2.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-over-widen-2.c
@@ -5,7 +5,7 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 512
+#define N 64
 
 /* Modified rgb to rgb conversion from FFmpeg.  */
 __attribute__ ((noinline)) void
diff --git a/gcc/testsuite/gcc.dg/vect/vect-over-widen-3-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-over-widen-3-big-array.c
new file mode 100644
index 0000000..d828c83
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-over-widen-3-big-array.c
@@ -0,0 +1,64 @@
+/* { dg-require-effective-target vect_int } */
+/* { dg-require-effective-target vect_shift } */
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+/* Modified rgb to rgb conversion from FFmpeg.  */
+__attribute__ ((noinline)) void
+foo (unsigned char *src, unsigned char *dst)
+{
+  unsigned char *s = src;
+  unsigned short *d = (unsigned short *)dst;
+  int i;
+
+  for (i = 0; i < N/4; i++)
+    {
+      const int b = *s++;
+      const int g = *s++;
+      const int r = *s++;
+      const int a = *s++;
+      *d = ((b>>3) | ((g&0xFFC)<<3) | ((r+0xF8)>>8) | (a<<9));
+      d++;
+    }
+
+  s = src;
+  d = (unsigned short *)dst;
+  for (i = 0; i < N/4; i++)
+    {
+      const int b = *s++;
+      const int g = *s++;
+      const int r = *s++;
+      const int a = *s++;
+      if (*d != ((b>>3) | ((g&0xFFC)<<3) | ((r+0xF8)>>8) | (a<<9)))
+        abort ();
+      d++;
+    }
+}
+
+int main (void)
+{
+  int i;
+  unsigned char in[N], out[N];
+
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    {
+      in[i] = i;
+      out[i] = 255;
+      __asm__ volatile ("");
+    }
+
+  foo (in, out);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vect_recog_over_widening_pattern: detected" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc/testsuite/gcc.dg/vect/vect-over-widen-3.c b/gcc/testsuite/gcc.dg/vect/vect-over-widen-3.c
index d828c83..ed36688 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-over-widen-3.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-over-widen-3.c
@@ -5,7 +5,7 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 128
+#define N 64
 
 /* Modified rgb to rgb conversion from FFmpeg.  */
 __attribute__ ((noinline)) void
diff --git a/gcc/testsuite/gcc.dg/vect/vect-over-widen-4-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-over-widen-4-big-array.c
new file mode 100644
index 0000000..d296dc9
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-over-widen-4-big-array.c
@@ -0,0 +1,68 @@
+/* { dg-require-effective-target vect_int } */
+/* { dg-require-effective-target vect_shift } */
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 512
+
+/* Modified rgb to rgb conversion from FFmpeg.  */
+__attribute__ ((noinline)) int
+foo (unsigned char *src, unsigned char *dst)
+{
+  unsigned char *s = src;
+  unsigned short *d = (unsigned short *)dst, res;
+  int i, result = 0;
+
+  for (i = 0; i < N/4; i++)
+    {
+      const int b = *s++;
+      const int g = *s++;
+      const int r = *s++;
+      const int a = *s++;
+      res = ((b>>3) | ((g&0xFC)<<3) | ((r&0xF8)<<8) | (a>>5));
+      *d = res;
+      result += res;
+      d++;
+    }
+
+  s = src;
+  d = (unsigned short *)dst;
+  for (i = 0; i < N/4; i++)
+    {
+      const int b = *s++;
+      const int g = *s++;
+      const int r = *s++;
+      const int a = *s++;
+      if (*d != ((b>>3) | ((g&0xFC)<<3) | ((r&0xF8)<<8) | (a>>5)))
+        abort ();
+      d++;
+    }
+
+  return result;
+}
+
+int main (void)
+{
+  int i;
+  unsigned char in[N], out[N];
+
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    {
+      in[i] = i;
+      out[i] = 255;
+      __asm__ volatile ("");
+    }
+
+  foo (in, out);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vect_recog_over_widening_pattern: detected" 4 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc/testsuite/gcc.dg/vect/vect-over-widen-4.c b/gcc/testsuite/gcc.dg/vect/vect-over-widen-4.c
index d296dc9..c1291e3 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-over-widen-4.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-over-widen-4.c
@@ -5,7 +5,7 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 512
+#define N 64
 
 /* Modified rgb to rgb conversion from FFmpeg.  */
 __attribute__ ((noinline)) int
diff --git a/gcc/testsuite/gcc.dg/vect/vect-reduc-1char-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-reduc-1char-big-array.c
new file mode 100644
index 0000000..7462cb3
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-reduc-1char-big-array.c
@@ -0,0 +1,71 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 256
+
+unsigned char ub[N];
+unsigned char uc[N];
+unsigned char diff;
+
+volatile int y = 0;
+
+__attribute__ ((noinline)) void
+main1 (unsigned char x, unsigned char max_result, unsigned char min_result)
+{
+  int i;
+  unsigned char udiff = 2;
+  unsigned char umax = x;
+  unsigned char umin = x;
+
+  diff = 2;
+  for (i = 0; i < N; i++) {
+    ub[i] = i;
+    uc[i] = i;
+    if (i%16 == 0)
+      {
+	ub[i] = i+2;
+	diff += 2;
+      }
+    if (uc[i] > max_result)
+      max_result = uc[i];
+    if (uc[i] < min_result)
+      min_result = uc[i];
+
+    /* Avoid vectorization.  */
+    if (y)
+      abort ();
+  }
+  for (i = 0; i < N; i++) {
+    udiff += (unsigned char) (ub[i] - uc[i]);
+  }
+
+  for (i = 0; i < N; i++) {
+    umax = umax < uc[i] ? uc[i] : umax;
+  }
+
+  for (i = 0; i < N; i++) {
+    umin = umin > uc[i] ? uc[i] : umin;
+  }
+
+  /* check results:  */
+  if (udiff != diff)
+    abort ();
+  if (umax != max_result)
+    abort ();
+  if (umin != min_result)
+    abort ();
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 (100, 100, 1);
+  main1 (0, 15, 0);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" { xfail vect_no_int_max } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-reduc-1char.c b/gcc/testsuite/gcc.dg/vect/vect-reduc-1char.c
index 7462cb3..5a1c03d 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-reduc-1char.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-reduc-1char.c
@@ -3,13 +3,11 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 256
+#define N 16
+#define DIFF 242
 
-unsigned char ub[N];
-unsigned char uc[N];
-unsigned char diff;
-
-volatile int y = 0;
+unsigned char ub[N] = {1,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
+unsigned char uc[N] = {1,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
 
 __attribute__ ((noinline)) void
 main1 (unsigned char x, unsigned char max_result, unsigned char min_result)
@@ -19,26 +17,8 @@ main1 (unsigned char x, unsigned char max_result, unsigned char min_result)
   unsigned char umax = x;
   unsigned char umin = x;
 
-  diff = 2;
-  for (i = 0; i < N; i++) {
-    ub[i] = i;
-    uc[i] = i;
-    if (i%16 == 0)
-      {
-	ub[i] = i+2;
-	diff += 2;
-      }
-    if (uc[i] > max_result)
-      max_result = uc[i];
-    if (uc[i] < min_result)
-      min_result = uc[i];
-
-    /* Avoid vectorization.  */
-    if (y)
-      abort ();
-  }
   for (i = 0; i < N; i++) {
-    udiff += (unsigned char) (ub[i] - uc[i]);
+    udiff += (unsigned char)(ub[i] - uc[i]);
   }
 
   for (i = 0; i < N; i++) {
@@ -50,7 +30,7 @@ main1 (unsigned char x, unsigned char max_result, unsigned char min_result)
   }
 
   /* check results:  */
-  if (udiff != diff)
+  if (udiff != DIFF)
     abort ();
   if (umax != max_result)
     abort ();
@@ -59,9 +39,9 @@ main1 (unsigned char x, unsigned char max_result, unsigned char min_result)
 }
 
 int main (void)
-{
+{ 
   check_vect ();
-
+  
   main1 (100, 100, 1);
   main1 (0, 15, 0);
   return 0;
diff --git a/gcc/testsuite/gcc.dg/vect/vect-reduc-2char-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-reduc-2char-big-array.c
new file mode 100644
index 0000000..7004e9e
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-reduc-2char-big-array.c
@@ -0,0 +1,69 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 256
+volatile int y = 0;
+
+__attribute__ ((noinline))
+void main1 (signed char x, signed char max_result, signed char min_result)
+{
+  int i;
+  signed char b[N];
+  signed char c[N];
+  signed char check_diff = 2;
+  signed char diff = 2;
+  signed char max = x;
+  signed char min = x;
+
+  check_diff = 2;
+  for (i = 0; i < N; i++) {
+    b[i] = i;
+    c[i] = i;
+    if (i%16 == 0)
+      {
+	c[i] = i + 1;
+	check_diff += 1;
+      }
+    if (c[i] > max_result)
+      max_result = c[i];
+    if (c[i] < min_result)
+      min_result = c[i];
+    /* Avoid vectorization.  */
+    if (y)
+      abort ();
+  }
+
+  for (i = 0; i < N; i++) {
+    diff += (signed char) (c[i] - b[i]);
+  }
+
+  for (i = 0; i < N; i++) {
+    max = max < c[i] ? c[i] : max;
+  }
+
+  for (i = 0; i < N; i++) {
+    min = min > c[i] ? c[i] : min;
+  }
+
+  /* check results:  */
+  if (diff != check_diff)
+    abort ();
+  if (max != max_result)
+    abort ();
+  if (min != min_result)
+    abort ();
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 (100, 100, 1);
+  main1 (0, 15, 0);
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-reduc-2char.c b/gcc/testsuite/gcc.dg/vect/vect-reduc-2char.c
index 7004e9e..6d01f03 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-reduc-2char.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-reduc-2char.c
@@ -3,40 +3,21 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 256
-volatile int y = 0;
+#define N 16
+#define DIFF 121
 
 __attribute__ ((noinline))
 void main1 (signed char x, signed char max_result, signed char min_result)
 {
   int i;
-  signed char b[N];
-  signed char c[N];
-  signed char check_diff = 2;
+  signed char b[N] = {1,2,3,6,8,10,12,14,16,18,20,22,24,26,28,30};
+  signed char c[N] = {1,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
   signed char diff = 2;
   signed char max = x;
   signed char min = x;
 
-  check_diff = 2;
   for (i = 0; i < N; i++) {
-    b[i] = i;
-    c[i] = i;
-    if (i%16 == 0)
-      {
-	c[i] = i + 1;
-	check_diff += 1;
-      }
-    if (c[i] > max_result)
-      max_result = c[i];
-    if (c[i] < min_result)
-      min_result = c[i];
-    /* Avoid vectorization.  */
-    if (y)
-      abort ();
-  }
-
-  for (i = 0; i < N; i++) {
-    diff += (signed char) (c[i] - b[i]);
+    diff += (signed char)(b[i] - c[i]);
   }
 
   for (i = 0; i < N; i++) {
@@ -48,7 +29,7 @@ void main1 (signed char x, signed char max_result, signed char min_result)
   }
 
   /* check results:  */
-  if (diff != check_diff)
+  if (diff != DIFF)
     abort ();
   if (max != max_result)
     abort ();
@@ -57,9 +38,9 @@ void main1 (signed char x, signed char max_result, signed char min_result)
 }
 
 int main (void)
-{
+{ 
   check_vect ();
-
+  
   main1 (100, 100, 1);
   main1 (0, 15, 0);
   return 0;
diff --git a/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-1b-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-1b-big-array.c
new file mode 100644
index 0000000..1967e3d
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-1b-big-array.c
@@ -0,0 +1,49 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+unsigned char udata_ch[N];
+#define SUM N*(N-1)
+
+volatile int y = 0;
+
+__attribute__ ((noinline)) int
+foo ()
+{
+  int i;
+  unsigned int intsum = 0;
+
+  for (i = 0; i < N; i++)
+    {
+      udata_ch[i] = i*2;
+      /* Avoid vectorization.  */
+      if (y)
+	abort ();
+    }
+
+  /* widenning sum: sum chars into int.  */
+  for (i = 0; i < N; i++)
+    {
+      intsum += udata_ch[i];
+    }
+
+  /* check results:  */
+  if (intsum != SUM)
+    abort ();
+
+  return 0;
+}
+
+int
+main (void)
+{
+  check_vect ();
+  return foo ();
+}
+
+/* { dg-final { scan-tree-dump-times "vect_recog_widen_sum_pattern: detected" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_widen_sum_qi_to_si || vect_unpack } } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" { target { { ! vect_widen_sum_qi_to_si } && { ! vect_unpack } } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-1b.c b/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-1b.c
index 1967e3d..6effa87 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-1b.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-1b.c
@@ -3,11 +3,10 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 128
-unsigned char udata_ch[N];
-#define SUM N*(N-1)
-
-volatile int y = 0;
+#define N 16
+unsigned char udata_ch[N] =
+  { 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28 };
+#define SUM 210
 
 __attribute__ ((noinline)) int
 foo ()
@@ -15,14 +14,6 @@ foo ()
   int i;
   unsigned int intsum = 0;
 
-  for (i = 0; i < N; i++)
-    {
-      udata_ch[i] = i*2;
-      /* Avoid vectorization.  */
-      if (y)
-	abort ();
-    }
-
   /* widenning sum: sum chars into int.  */
   for (i = 0; i < N; i++)
     {
diff --git a/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-1c-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-1c-big-array.c
new file mode 100644
index 0000000..5394ade
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-1c-big-array.c
@@ -0,0 +1,49 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+unsigned char udata_ch[N];
+#define SUM N*(N-1)
+
+volatile int y = 0;
+
+__attribute__ ((noinline)) int
+foo ()
+{
+  int i;
+  unsigned short shortsum = 0;
+
+  for (i = 0; i < N; i++)
+    {
+      udata_ch[i] = i*2;
+      /* Avoid vectorization.  */
+      if (y)
+	abort ();
+    }
+
+  /* widenning sum: sum chars into short.  */
+  for (i = 0; i < N; i++)
+    {
+      shortsum += udata_ch[i];
+    }
+
+  /* check results:  */
+  if (shortsum != SUM)
+    abort ();
+
+  return 0;
+}
+
+int
+main (void)
+{
+  check_vect ();
+  return foo ();
+}
+
+/* { dg-final { scan-tree-dump-times "vect_recog_widen_sum_pattern: detected" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_widen_sum_qi_to_hi } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" { target { ! vect_widen_sum_qi_to_hi } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-1c.c b/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-1c.c
index 5394ade..872e6e8 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-1c.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-1c.c
@@ -3,11 +3,10 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 128
-unsigned char udata_ch[N];
-#define SUM N*(N-1)
-
-volatile int y = 0;
+#define N 16
+unsigned char udata_ch[N] =
+  { 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28 };
+#define SUM 210
 
 __attribute__ ((noinline)) int
 foo ()
@@ -15,14 +14,6 @@ foo ()
   int i;
   unsigned short shortsum = 0;
 
-  for (i = 0; i < N; i++)
-    {
-      udata_ch[i] = i*2;
-      /* Avoid vectorization.  */
-      if (y)
-	abort ();
-    }
-
   /* widenning sum: sum chars into short.  */
   for (i = 0; i < N; i++)
     {
diff --git a/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-2b-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-2b-big-array.c
new file mode 100644
index 0000000..fa0100b
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-2b-big-array.c
@@ -0,0 +1,50 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+signed char data_ch[N];
+
+volatile int y = 0;
+
+__attribute__ ((noinline)) int
+foo ()
+{
+  int i;
+  signed int intsum = 0;
+  signed int check_intsum = 0;
+
+  for (i = 0; i < N; i++)
+    {
+      data_ch[i] = i*2;
+      check_intsum += data_ch[i];
+      /* Avoid vectorization.  */
+      if (y)
+	abort ();
+    }
+
+  /* widenning sum: sum chars into int.  */
+  for (i = 0; i < N; i++)
+    {
+      intsum += data_ch[i];
+    }
+
+  /* check results:  */
+  if (intsum != check_intsum)
+    abort ();
+
+  return 0;
+}
+
+int
+main (void)
+{
+  check_vect ();
+  return foo ();
+}
+
+/* { dg-final { scan-tree-dump-times "vect_recog_widen_sum_pattern: detected" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_widen_sum_qi_to_si && vect_unpack } } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" { target { { ! vect_widen_sum_qi_to_si } && { ! vect_unpack } } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-2b.c b/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-2b.c
index fa0100b..53d5f0d 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-2b.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-reduc-pattern-2b.c
@@ -3,26 +3,16 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 128
-signed char data_ch[N];
-
-volatile int y = 0;
+#define N 16
+signed char data_ch[N] =
+  { 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28 };
+#define SUM 210
 
 __attribute__ ((noinline)) int
 foo ()
 {
   int i;
   signed int intsum = 0;
-  signed int check_intsum = 0;
-
-  for (i = 0; i < N; i++)
-    {
-      data_ch[i] = i*2;
-      check_intsum += data_ch[i];
-      /* Avoid vectorization.  */
-      if (y)
-	abort ();
-    }
 
   /* widenning sum: sum chars into int.  */
   for (i = 0; i < N; i++)
@@ -31,7 +21,7 @@ foo ()
     }
 
   /* check results:  */
-  if (intsum != check_intsum)
+  if (intsum != SUM)
     abort ();
 
   return 0;
diff --git a/gcc/testsuite/gcc.dg/vect/vect-shift-2-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-shift-2-big-array.c
new file mode 100644
index 0000000..0e1acfb
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-shift-2-big-array.c
@@ -0,0 +1,190 @@
+/* { dg-require-effective-target vect_shift } */
+/* { dg-require-effective-target vect_int } */
+/* Check the standard integer types for left and right shifts to see if the
+   compiler replaced a scalar instruction with a vector instruction whether the
+   correct value is generated.  */
+
+#ifdef TRACE
+#endif
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#ifndef ALIGN
+#define ALIGN __attribute__((__aligned__(__BIGGEST_ALIGNMENT__)))
+#endif
+
+#ifndef NOINLINE
+#define NOINLINE __attribute__((__noinline__))
+#endif
+
+#ifdef TRACE
+#define TRACE_FUNC(PREFIX, NAME) printf (#PREFIX #NAME "\n")
+#define TRACE_DONE()  printf ("done!\n")
+#define TRACE_ABORT(I,E,G)						\
+do {									\
+  printf ("Element %d, expected 0x%lx, got 0x%lx\n",			\
+	  I, (long)(E), (long)(G));					\
+  abort ();								\
+} while (0)
+
+#else
+#define TRACE_FUNC(PREFIX, A)
+#define TRACE_DONE()
+#define TRACE_ABORT(I,E,G) abort ()
+#endif
+
+#define NAME(A,B) A ## B
+
+#define VECT_TESTS(PREFIX, TYPE, N)					\
+ /* Restrict the optimizer from optimizing the setup loops.  */		\
+volatile TYPE NAME (PREFIX, zero) = 0;					\
+									\
+TYPE NAME (PREFIX, a)[N] ALIGN;						\
+TYPE NAME (PREFIX, b)[N] ALIGN;						\
+TYPE NAME (PREFIX, c)[N] ALIGN;						\
+TYPE NAME (PREFIX, d)[N] ALIGN;						\
+									\
+static void NOINLINE							\
+NAME (PREFIX, lshift_2) (void)						\
+{									\
+  int i;								\
+									\
+  TRACE_FUNC (PREFIX, lshift_2);					\
+  for (i = 0; i < N; i++)						\
+    NAME (PREFIX, a)[i] = NAME (PREFIX, b)[i] << 2;			\
+}									\
+									\
+static void NOINLINE							\
+NAME (PREFIX, lshift_var) (int shift)					\
+{									\
+  int i;								\
+									\
+  TRACE_FUNC (PREFIX, lshift_var);					\
+  for (i = 0; i < N; i++)						\
+    NAME (PREFIX, a)[i] = NAME (PREFIX, b)[i] << shift;			\
+}									\
+									\
+static void NOINLINE							\
+NAME (PREFIX, lshift_vect) (void)					\
+{									\
+  int i;								\
+									\
+  TRACE_FUNC (PREFIX, lshift_vect);					\
+  for (i = 0; i < N; i++)						\
+    NAME (PREFIX, a)[i] = NAME (PREFIX, b)[i] << NAME (PREFIX, c)[i];	\
+}									\
+									\
+static void NOINLINE							\
+NAME (PREFIX, rshift_2) (void)						\
+{									\
+  int i;								\
+									\
+  TRACE_FUNC (PREFIX, rshift_2);					\
+  for (i = 0; i < N; i++)						\
+    NAME (PREFIX, a)[i] = NAME (PREFIX, b)[i] >> 2;			\
+}									\
+									\
+static void NOINLINE							\
+NAME (PREFIX, rshift_var) (int shift)					\
+{									\
+  int i;								\
+									\
+  TRACE_FUNC (PREFIX, rshift_var);					\
+  for (i = 0; i < N; i++)						\
+    NAME (PREFIX, a)[i] = NAME (PREFIX, b)[i] >> shift;			\
+}									\
+									\
+static void NOINLINE							\
+NAME (PREFIX, rshift_vect) (void)					\
+{									\
+  int i;								\
+									\
+  TRACE_FUNC (PREFIX, rshift_vect);					\
+  for (i = 0; i < N; i++)						\
+    NAME (PREFIX, a)[i] = NAME (PREFIX, b)[i] >> NAME (PREFIX, c)[i];	\
+}									\
+									\
+static void NOINLINE							\
+NAME (PREFIX, check) (void)						\
+{									\
+  int i;								\
+									\
+  TRACE_FUNC (PREFIX, check);						\
+  for (i = 0; i < N; i++)						\
+    if (NAME (PREFIX, a)[i] != NAME (PREFIX, d)[i])			\
+      TRACE_ABORT (i, NAME (PREFIX, d)[i], NAME (PREFIX, a)[i]);	\
+}									\
+									\
+static void NOINLINE							\
+NAME (PREFIX, tests) (void)						\
+{									\
+  int i;								\
+									\
+  TRACE_FUNC (PREFIX, tests);						\
+  for (i = 0; i < N; i++)						\
+    {									\
+      NAME (PREFIX, b)[i] = (i + NAME (PREFIX, zero));			\
+      NAME (PREFIX, c)[i] = 2;						\
+      NAME (PREFIX, d)[i] = (i + NAME (PREFIX, zero)) << 2;		\
+    }									\
+									\
+  NAME (PREFIX, lshift_2) ();						\
+  NAME (PREFIX, check) ();						\
+									\
+  NAME (PREFIX, lshift_var) (2);					\
+  NAME (PREFIX, check) ();						\
+									\
+  NAME (PREFIX, lshift_vect) ();					\
+  NAME (PREFIX, check) ();						\
+									\
+  for (i = 0; i < N; i++)						\
+    {									\
+      NAME (PREFIX, b)[i] = ((i + NAME (PREFIX, zero)) << 4)		\
+	| (((TYPE)0x80) << ((sizeof (TYPE) * 8) - 8));			\
+      NAME (PREFIX, c)[i] = 2;						\
+      NAME (PREFIX, d)[i] = (TYPE)((NAME (PREFIX, b)[i]			\
+				    + NAME (PREFIX, zero)) >> 2);	\
+    }									\
+									\
+  NAME (PREFIX, rshift_2) ();						\
+  NAME (PREFIX, check) ();						\
+									\
+  NAME (PREFIX, rshift_var) (2);					\
+  NAME (PREFIX, check) ();						\
+									\
+  NAME (PREFIX, rshift_vect) ();					\
+  NAME (PREFIX, check) ();						\
+}
+
+VECT_TESTS (uc_, unsigned char,  128)
+VECT_TESTS (us_, unsigned short, 256)
+VECT_TESTS (ui_, unsigned int,   256)
+VECT_TESTS (ul_, unsigned long,  256)
+
+VECT_TESTS (sc_, signed char,    128)
+VECT_TESTS (ss_, short,          256)
+VECT_TESTS (si_, int,            256)
+VECT_TESTS (sl_, long,           256)
+
+int main ()
+{
+  int i;
+
+  check_vect ();
+
+  uc_tests ();
+  us_tests ();
+  ui_tests ();
+  ul_tests ();
+
+  sc_tests ();
+  ss_tests ();
+  si_tests ();
+  sl_tests ();
+
+  TRACE_DONE ();
+  return 0;
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-shift-2.c b/gcc/testsuite/gcc.dg/vect/vect-shift-2.c
index 0e1acfb..83211eb 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-shift-2.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-shift-2.c
@@ -157,15 +157,15 @@ NAME (PREFIX, tests) (void)						\
   NAME (PREFIX, check) ();						\
 }
 
-VECT_TESTS (uc_, unsigned char,  128)
-VECT_TESTS (us_, unsigned short, 256)
-VECT_TESTS (ui_, unsigned int,   256)
-VECT_TESTS (ul_, unsigned long,  256)
-
-VECT_TESTS (sc_, signed char,    128)
-VECT_TESTS (ss_, short,          256)
-VECT_TESTS (si_, int,            256)
-VECT_TESTS (sl_, long,           256)
+VECT_TESTS(uc_, unsigned char,  16)
+VECT_TESTS(us_, unsigned short, 32)
+VECT_TESTS(ui_, unsigned int,   32)
+VECT_TESTS(ul_, unsigned long,  32)
+
+VECT_TESTS(sc_, signed char,    16)
+VECT_TESTS(ss_, short,          32)
+VECT_TESTS(si_, int,            32)
+VECT_TESTS(sl_, long,           32)
 
 int main ()
 {
diff --git a/gcc/testsuite/gcc.dg/vect/vect-strided-a-u8-i8-gap2-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-strided-a-u8-i8-gap2-big-array.c
new file mode 100644
index 0000000..6e3c9f1
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-strided-a-u8-i8-gap2-big-array.c
@@ -0,0 +1,92 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+typedef struct {
+   unsigned char a;
+   unsigned char b;
+   unsigned char c;
+   unsigned char d;
+   unsigned char e;
+   unsigned char f;
+   unsigned char g;
+   unsigned char h;
+} s;
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  int i;
+  s arr[N];
+  s *ptr = arr;
+  s check_res[N];
+  s res[N];
+
+  for (i = 0; i < N; i++)
+    {
+      arr[i].a = i;
+      arr[i].b = i * 2;
+      arr[i].c = 17;
+      arr[i].d = i+34;
+      arr[i].e = i + 5;
+      arr[i].f = i * 2 + 2;
+      arr[i].g = i - 3;
+      arr[i].h = 56;
+
+      check_res[i].c = arr[i].a;
+      check_res[i].a = arr[i].f + arr[i].a;
+      check_res[i].d = arr[i].f - arr[i].a;
+      check_res[i].b = arr[i].f;
+      check_res[i].f = arr[i].a;
+      check_res[i].e = arr[i].f - arr[i].a;
+      check_res[i].h = arr[i].f;
+      check_res[i].g = arr[i].f - arr[i].a;
+
+      if (arr[i].a == 178)
+         abort ();
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      res[i].c = ptr->a;
+      res[i].a = ptr->f + ptr->a;
+      res[i].d = ptr->f - ptr->a;
+      res[i].b = ptr->f;
+      res[i].f = ptr->a;
+      res[i].e = ptr->f - ptr->a;
+      res[i].h = ptr->f;
+      res[i].g = ptr->f - ptr->a;
+      ptr++;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].a != check_res[i].a
+	  || res[i].b != check_res[i].b
+	  || res[i].c != check_res[i].c
+	  || res[i].d != check_res[i].d
+	  || res[i].e != check_res[i].e
+	  || res[i].f != check_res[i].f
+	  || res[i].g != check_res[i].g
+	  || res[i].h != check_res[i].h)
+          abort ();
+   }
+}
+
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_strided8 } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc/testsuite/gcc.dg/vect/vect-strided-a-u8-i8-gap2.c b/gcc/testsuite/gcc.dg/vect/vect-strided-a-u8-i8-gap2.c
index f20d158..4fb5494 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-strided-a-u8-i8-gap2.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-strided-a-u8-i8-gap2.c
@@ -3,7 +3,7 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 128
+#define N 16 
 
 typedef struct {
    unsigned char a;
@@ -22,7 +22,6 @@ main1 ()
   int i;
   s arr[N];
   s *ptr = arr;
-  s check_res[N];
   s res[N];
 
   for (i = 0; i < N; i++)
@@ -35,16 +34,6 @@ main1 ()
       arr[i].f = i * 2 + 2;
       arr[i].g = i - 3;
       arr[i].h = 56;
-
-      check_res[i].c = arr[i].a;
-      check_res[i].a = arr[i].f + arr[i].a;
-      check_res[i].d = arr[i].f - arr[i].a;
-      check_res[i].b = arr[i].f;
-      check_res[i].f = arr[i].a;
-      check_res[i].e = arr[i].f - arr[i].a;
-      check_res[i].h = arr[i].f;
-      check_res[i].g = arr[i].f - arr[i].a;
-
       if (arr[i].a == 178)
          abort();
     }
@@ -56,23 +45,23 @@ main1 ()
       res[i].d = ptr->f - ptr->a;
       res[i].b = ptr->f;
       res[i].f = ptr->a;
-      res[i].e = ptr->f - ptr->a;
-      res[i].h = ptr->f;
+      res[i].e = ptr->f - ptr->a; 
+      res[i].h = ptr->f;   
       res[i].g = ptr->f - ptr->a;
-      ptr++;
-    }
-
+      ptr++; 
+    } 
+   
   /* check results:  */
   for (i = 0; i < N; i++)
-    {
-      if (res[i].a != check_res[i].a
-	  || res[i].b != check_res[i].b
-	  || res[i].c != check_res[i].c
-	  || res[i].d != check_res[i].d
-	  || res[i].e != check_res[i].e
-	  || res[i].f != check_res[i].f
-	  || res[i].g != check_res[i].g
-	  || res[i].h != check_res[i].h)
+    { 
+      if (res[i].c != arr[i].a
+          || res[i].a != arr[i].f + arr[i].a
+          || res[i].d != arr[i].f - arr[i].a
+          || res[i].b != arr[i].f
+          || res[i].f != arr[i].a
+          || res[i].e != arr[i].f - arr[i].a
+          || res[i].h != arr[i].f
+          || res[i].g != arr[i].f - arr[i].a)
           abort();
    }
 }
@@ -89,4 +78,4 @@ int main (void)
 
 /* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_strided8 } } } */
 /* { dg-final { cleanup-tree-dump "vect" } } */
-
+  
diff --git a/gcc/testsuite/gcc.dg/vect/vect-strided-a-u8-i8-gap7-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-strided-a-u8-i8-gap7-big-array.c
new file mode 100644
index 0000000..5a44631
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-strided-a-u8-i8-gap7-big-array.c
@@ -0,0 +1,101 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+typedef struct {
+   unsigned char a;
+   unsigned char b;
+   unsigned char c;
+   unsigned char d;
+   unsigned char e;
+   unsigned char f;
+   unsigned char g;
+   unsigned char h;
+} s;
+
+__attribute__ ((noinline)) int
+main1 ()
+{
+  int i;
+  s arr[N];
+  s *ptr = arr;
+  s check_res[N];
+  s res[N];
+  unsigned char u, t, s, x, y, z, w;
+
+  for (i = 0; i < N; i++)
+    {
+      arr[i].a = i;
+      arr[i].b = i * 2;
+      arr[i].c = 17;
+      arr[i].d = i+34;
+      arr[i].e = i * 3 + 5;
+      arr[i].f = i * 5;
+      arr[i].g = i - 3;
+      arr[i].h = 67;
+
+      u = arr[i].b - arr[i].a;
+      t = arr[i].d - arr[i].c;
+      check_res[i].c = u + t;
+      x = arr[i].b + arr[i].d;
+      check_res[i].a = arr[i].a + x;
+      check_res[i].d = u + t;
+      s = arr[i].h - arr[i].a;
+      check_res[i].b = s + t;
+      check_res[i].f = arr[i].f + arr[i].h;
+      check_res[i].e = arr[i].b + arr[i].e;
+      check_res[i].h = arr[i].d;
+      check_res[i].g = u + t;
+
+      if (arr[i].a == 178)
+         abort ();
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      u = ptr->b - ptr->a;
+      t = ptr->d - ptr->c;
+      res[i].c = u + t;
+      x = ptr->b + ptr->d;
+      res[i].a = ptr->a + x;
+      res[i].d = u + t;
+      s = ptr->h - ptr->a;
+      res[i].b = s + t;
+      res[i].f = ptr->f + ptr->h;
+      res[i].e = ptr->b + ptr->e;
+      res[i].h = ptr->d;
+      res[i].g = u + t;
+      ptr++;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].a != check_res[i].a
+	  || res[i].b != check_res[i].b
+	  || res[i].c != check_res[i].c
+	  || res[i].d != check_res[i].d
+	  || res[i].e != check_res[i].e
+	  || res[i].f != check_res[i].f
+	  || res[i].g != check_res[i].g
+	  || res[i].h != check_res[i].h)
+         abort ();
+   }
+}
+
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_strided8 } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc/testsuite/gcc.dg/vect/vect-strided-a-u8-i8-gap7.c b/gcc/testsuite/gcc.dg/vect/vect-strided-a-u8-i8-gap7.c
index 28a9c58..cc09fa6 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-strided-a-u8-i8-gap7.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-strided-a-u8-i8-gap7.c
@@ -3,7 +3,7 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 128
+#define N 16 
 
 typedef struct {
    unsigned char a;
@@ -22,7 +22,6 @@ main1 ()
   int i;
   s arr[N];
   s *ptr = arr;
-  s check_res[N];
   s res[N];
   unsigned char u, t, s, x, y, z, w;
 
@@ -36,20 +35,6 @@ main1 ()
       arr[i].f = i * 5;
       arr[i].g = i - 3;
       arr[i].h = 67;
-
-      u = arr[i].b - arr[i].a;
-      t = arr[i].d - arr[i].c;
-      check_res[i].c = u + t;
-      x = arr[i].b + arr[i].d;
-      check_res[i].a = arr[i].a + x;
-      check_res[i].d = u + t;
-      s = arr[i].h - arr[i].a;
-      check_res[i].b = s + t;
-      check_res[i].f = arr[i].f + arr[i].h;
-      check_res[i].e = arr[i].b + arr[i].e;
-      check_res[i].h = arr[i].d;
-      check_res[i].g = u + t;
-
       if (arr[i].a == 178)
          abort();
     }
@@ -74,14 +59,14 @@ main1 ()
   /* check results:  */
   for (i = 0; i < N; i++)
     { 
-      if (res[i].a != check_res[i].a
-	  || res[i].b != check_res[i].b
-	  || res[i].c != check_res[i].c
-	  || res[i].d != check_res[i].d
-	  || res[i].e != check_res[i].e
-	  || res[i].f != check_res[i].f
-	  || res[i].g != check_res[i].g
-	  || res[i].h != check_res[i].h)
+      if (res[i].c != arr[i].b - arr[i].a + arr[i].d - arr[i].c
+          || res[i].a != arr[i].a + arr[i].b + arr[i].d
+          || res[i].d != arr[i].b - arr[i].a + arr[i].d - arr[i].c
+          || res[i].b != arr[i].h - arr[i].a + arr[i].d - arr[i].c
+          || res[i].f != arr[i].f + arr[i].h
+          || res[i].e != arr[i].b + arr[i].e
+          || res[i].h != arr[i].d
+          || res[i].g != arr[i].b - arr[i].a + arr[i].d - arr[i].c)
          abort();
    }
 }
diff --git a/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8-gap2-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8-gap2-big-array.c
new file mode 100644
index 0000000..cc1b949
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8-gap2-big-array.c
@@ -0,0 +1,94 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+typedef struct {
+   unsigned char a;
+   unsigned char b;
+   unsigned char c;
+   unsigned char d;
+   unsigned char e;
+   unsigned char f;
+   unsigned char g;
+   unsigned char h;
+} s;
+
+s check_res[N];
+
+__attribute__ ((noinline)) int
+main1 (s *arr)
+{
+  int i;
+  s *ptr = arr;
+  s res[N];
+
+  for (i = 0; i < N; i++)
+    {
+      res[i].c = ptr->b;
+      res[i].a = ptr->f + ptr->b;
+      res[i].d = ptr->f - ptr->b;
+      res[i].b = ptr->f;
+      res[i].f = ptr->b;
+      res[i].e = ptr->f - ptr->b;
+      res[i].h = ptr->f;
+      res[i].g = ptr->f - ptr->b;
+      ptr++;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].a != check_res[i].a
+	  || res[i].b != check_res[i].b
+	  || res[i].c != check_res[i].c
+	  || res[i].d != check_res[i].d
+	  || res[i].e != check_res[i].e
+	  || res[i].f != check_res[i].f
+	  || res[i].g != check_res[i].g
+	  || res[i].h != check_res[i].h)
+          abort ();
+   }
+}
+
+
+int main (void)
+{
+  int i;
+  s arr[N];
+
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    {
+      arr[i].a = i;
+      arr[i].b = i * 2;
+      arr[i].c = 17;
+      arr[i].d = i+34;
+      arr[i].e = i + 5;
+      arr[i].f = i * 2 + 2;
+      arr[i].g = i - 3;
+      arr[i].h = 56;
+
+      check_res[i].c = arr[i].b;
+      check_res[i].a = arr[i].f + arr[i].b;
+      check_res[i].d = arr[i].f - arr[i].b;
+      check_res[i].b = arr[i].f;
+      check_res[i].f = arr[i].b;
+      check_res[i].e = arr[i].f - arr[i].b;
+      check_res[i].h = arr[i].f;
+      check_res[i].g = arr[i].f - arr[i].b;
+      if (arr[i].a == 178)
+         abort ();
+    }
+
+  main1 (arr);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_strided8 } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8-gap2.c b/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8-gap2.c
index cc1b949..349e869 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8-gap2.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8-gap2.c
@@ -3,7 +3,7 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 128
+#define N 16 
 
 typedef struct {
    unsigned char a;
@@ -16,8 +16,6 @@ typedef struct {
    unsigned char h;
 } s;
 
-s check_res[N];
-
 __attribute__ ((noinline)) int
 main1 (s *arr)
 {
@@ -32,24 +30,24 @@ main1 (s *arr)
       res[i].d = ptr->f - ptr->b;
       res[i].b = ptr->f;
       res[i].f = ptr->b;
-      res[i].e = ptr->f - ptr->b;
-      res[i].h = ptr->f;
+      res[i].e = ptr->f - ptr->b; 
+      res[i].h = ptr->f;   
       res[i].g = ptr->f - ptr->b;
-      ptr++;
-    }
-
+      ptr++; 
+    } 
+   
   /* check results:  */
   for (i = 0; i < N; i++)
-    {
-      if (res[i].a != check_res[i].a
-	  || res[i].b != check_res[i].b
-	  || res[i].c != check_res[i].c
-	  || res[i].d != check_res[i].d
-	  || res[i].e != check_res[i].e
-	  || res[i].f != check_res[i].f
-	  || res[i].g != check_res[i].g
-	  || res[i].h != check_res[i].h)
-          abort ();
+    { 
+      if (res[i].c != arr[i].b
+          || res[i].a != arr[i].f + arr[i].b
+          || res[i].d != arr[i].f - arr[i].b
+          || res[i].b != arr[i].f
+          || res[i].f != arr[i].b
+          || res[i].e != arr[i].f - arr[i].b
+          || res[i].h != arr[i].f
+          || res[i].g != arr[i].f - arr[i].b)
+          abort();
    }
 }
 
@@ -58,11 +56,11 @@ int main (void)
 {
   int i;
   s arr[N];
-
+  
   check_vect ();
 
   for (i = 0; i < N; i++)
-    {
+    { 
       arr[i].a = i;
       arr[i].b = i * 2;
       arr[i].c = 17;
@@ -71,18 +69,9 @@ int main (void)
       arr[i].f = i * 2 + 2;
       arr[i].g = i - 3;
       arr[i].h = 56;
-
-      check_res[i].c = arr[i].b;
-      check_res[i].a = arr[i].f + arr[i].b;
-      check_res[i].d = arr[i].f - arr[i].b;
-      check_res[i].b = arr[i].f;
-      check_res[i].f = arr[i].b;
-      check_res[i].e = arr[i].f - arr[i].b;
-      check_res[i].h = arr[i].f;
-      check_res[i].g = arr[i].f - arr[i].b;
       if (arr[i].a == 178)
-         abort ();
-    }
+         abort(); 
+    } 
 
   main1 (arr);
 
@@ -91,4 +80,4 @@ int main (void)
 
 /* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_strided8 } } } */
 /* { dg-final { cleanup-tree-dump "vect" } } */
-
+  
diff --git a/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8-gap4-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8-gap4-big-array.c
new file mode 100644
index 0000000..916fdf4
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8-gap4-big-array.c
@@ -0,0 +1,116 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+typedef struct {
+   unsigned char a;
+   unsigned char b;
+   unsigned char c;
+   unsigned char d;
+   unsigned char e;
+   unsigned char f;
+   unsigned char g;
+   unsigned char h;
+} s;
+
+s check_res[N];
+
+__attribute__ ((noinline)) int
+main1 (s *arr)
+{
+  int i;
+  s *ptr = arr;
+  s res[N];
+  unsigned char x;
+
+  for (i = 0; i < N; i++)
+    {
+      res[i].c = ptr->b + ptr->c;
+      x = ptr->c + ptr->f;
+      res[i].a = x + ptr->b;
+      res[i].d = ptr->b + ptr->c;
+      res[i].b = ptr->c;
+      res[i].f = ptr->f + ptr->e;
+      res[i].e = ptr->b + ptr->e;
+      res[i].h = ptr->c;
+      res[i].g = ptr->b + ptr->c;
+      ptr++;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].a != check_res[i].a
+	  || res[i].b != check_res[i].b
+	  || res[i].c != check_res[i].c
+	  || res[i].d != check_res[i].d
+	  || res[i].e != check_res[i].e
+	  || res[i].f != check_res[i].f
+	  || res[i].g != check_res[i].g
+	  || res[i].h != check_res[i].h)
+          abort ();
+   }
+
+  ptr = arr;
+  /* Not vectorizable: gap in store.  */
+  for (i = 0; i < N; i++)
+    {
+      res[i].a = ptr->b;
+      res[i].b = ptr->c;
+      ptr++;
+    }
+
+  /* Check results.  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].a != arr[i].b
+	  || res[i].b != arr[i].c)
+          abort ();
+    }
+
+}
+
+
+int main (void)
+{
+  int i;
+  s arr[N];
+  unsigned char x;
+
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    {
+      arr[i].a = i;
+      arr[i].b = i * 2;
+      arr[i].c = 17;
+      arr[i].d = i+34;
+      arr[i].e = i * 3 + 5;
+      arr[i].f = i * 5;
+      arr[i].g = i - 3;
+      arr[i].h = 56;
+
+      check_res[i].c = arr[i].b + arr[i].c;
+      x = arr[i].c + arr[i].f;
+      check_res[i].a = x + arr[i].b;
+      check_res[i].d = arr[i].b + arr[i].c;
+      check_res[i].b = arr[i].c;
+      check_res[i].f = arr[i].f + arr[i].e;
+      check_res[i].e = arr[i].b + arr[i].e;
+      check_res[i].h = arr[i].c;
+      check_res[i].g = arr[i].b + arr[i].c;
+
+      if (arr[i].a == 178)
+         abort ();
+    }
+  main1 (arr);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_strided8 } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8-gap4.c b/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8-gap4.c
index 92255d4..537bcc8 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8-gap4.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8-gap4.c
@@ -3,7 +3,7 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 128
+#define N 16 
 
 typedef struct {
    unsigned char a;
@@ -16,8 +16,6 @@ typedef struct {
    unsigned char h;
 } s;
 
-s check_res[N];
-
 __attribute__ ((noinline)) int
 main1 (s *arr)
 {
@@ -34,39 +32,39 @@ main1 (s *arr)
       res[i].d = ptr->b + ptr->c;
       res[i].b = ptr->c;
       res[i].f = ptr->f + ptr->e;
-      res[i].e = ptr->b + ptr->e;
-      res[i].h = ptr->c;
+      res[i].e = ptr->b + ptr->e; 
+      res[i].h = ptr->c;   
       res[i].g = ptr->b + ptr->c;
-      ptr++;
-    }
-
+      ptr++; 
+    } 
+   
   /* check results:  */
   for (i = 0; i < N; i++)
-    {
-      if (res[i].a != check_res[i].a
-	  || res[i].b != check_res[i].b
-	  || res[i].c != check_res[i].c
-	  || res[i].d != check_res[i].d
-	  || res[i].e != check_res[i].e
-	  || res[i].f != check_res[i].f
-	  || res[i].g != check_res[i].g
-	  || res[i].h != check_res[i].h)
+    { 
+      if (res[i].c != arr[i].b + arr[i].c
+          || res[i].a != arr[i].c + arr[i].f + arr[i].b
+          || res[i].d != arr[i].b + arr[i].c
+          || res[i].b != arr[i].c
+          || res[i].f != arr[i].f + arr[i].e
+          || res[i].e != arr[i].b + arr[i].e
+          || res[i].h != arr[i].c
+          || res[i].g != arr[i].b + arr[i].c)
           abort ();
    }
 
   ptr = arr;
   /* Not vectorizable: gap in store. */
   for (i = 0; i < N; i++)
-    {
+    { 
       res[i].a = ptr->b;
       res[i].b = ptr->c;
-      ptr++;
+      ptr++; 
     }
-
+  
   /* Check results.  */
   for (i = 0; i < N; i++)
     {
-      if (res[i].a != arr[i].b
+      if (res[i].a != arr[i].b 
 	  || res[i].b != arr[i].c)
           abort ();
     }
@@ -78,12 +76,11 @@ int main (void)
 {
   int i;
   s arr[N];
-  unsigned char x;
-
+  
   check_vect ();
 
   for (i = 0; i < N; i++)
-    {
+    { 
       arr[i].a = i;
       arr[i].b = i * 2;
       arr[i].c = 17;
@@ -92,20 +89,10 @@ int main (void)
       arr[i].f = i * 5;
       arr[i].g = i - 3;
       arr[i].h = 56;
-
-      check_res[i].c = arr[i].b + arr[i].c;
-      x = arr[i].c + arr[i].f;
-      check_res[i].a = x + arr[i].b;
-      check_res[i].d = arr[i].b + arr[i].c;
-      check_res[i].b = arr[i].c;
-      check_res[i].f = arr[i].f + arr[i].e;
-      check_res[i].e = arr[i].b + arr[i].e;
-      check_res[i].h = arr[i].c;
-      check_res[i].g = arr[i].b + arr[i].c;
-
       if (arr[i].a == 178)
-         abort ();
-    }
+         abort(); 
+    } 
+
   main1 (arr);
 
   return 0;
@@ -113,4 +100,4 @@ int main (void)
 
 /* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_strided8 } } } */
 /* { dg-final { cleanup-tree-dump "vect" } } */
-
+  
diff --git a/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8-gap7-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8-gap7-big-array.c
new file mode 100644
index 0000000..ecacefa
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8-gap7-big-array.c
@@ -0,0 +1,105 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+typedef struct {
+   unsigned char a;
+   unsigned char b;
+   unsigned char c;
+   unsigned char d;
+   unsigned char e;
+   unsigned char f;
+   unsigned char g;
+   unsigned char h;
+} s;
+
+s check_res[N];
+
+__attribute__ ((noinline)) int
+main1 (s *arr)
+{
+  int i;
+  s *ptr = arr;
+  s res[N];
+  unsigned char u, t, s, x, y, z, w;
+
+  for (i = 0; i < N; i++)
+    {
+      u = ptr->b - ptr->a;
+      t = ptr->d - ptr->c;
+      res[i].c = u + t;
+      x = ptr->b + ptr->d;
+      res[i].a = ptr->a + x;
+      res[i].d = u + t;
+      s = ptr->h - ptr->a;
+      res[i].b = s + t;
+      res[i].f = ptr->f + ptr->h;
+      res[i].e = ptr->b + ptr->e;
+      res[i].h = ptr->d;
+      res[i].g = u + t;
+      ptr++;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].a != check_res[i].a
+	  || res[i].b != check_res[i].b
+	  || res[i].c != check_res[i].c
+	  || res[i].d != check_res[i].d
+	  || res[i].e != check_res[i].e
+	  || res[i].f != check_res[i].f
+	  || res[i].g != check_res[i].g
+	  || res[i].h != check_res[i].h)
+         abort ();
+   }
+}
+
+
+int main (void)
+{
+  int i;
+  s arr[N];
+  unsigned char u, t, s, x, y, z, w;
+
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    {
+      arr[i].a = i;
+      arr[i].b = i * 2;
+      arr[i].c = 17;
+      arr[i].d = i+34;
+      arr[i].e = i * 3 + 5;
+      arr[i].f = i * 5;
+      arr[i].g = i - 3;
+      arr[i].h = 67;
+
+      u = arr[i].b - arr[i].a;
+      t = arr[i].d - arr[i].c;
+      check_res[i].c = u + t;
+      x = arr[i].b + arr[i].d;
+      check_res[i].a = arr[i].a + x;
+      check_res[i].d = u + t;
+      s = arr[i].h - arr[i].a;
+      check_res[i].b = s + t;
+      check_res[i].f = arr[i].f + arr[i].h;
+      check_res[i].e = arr[i].b + arr[i].e;
+      check_res[i].h = arr[i].d;
+      check_res[i].g = u + t;
+
+      if (arr[i].a == 178)
+         abort ();
+    }
+
+  main1 (arr);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_strided8 } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8-gap7.c b/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8-gap7.c
index 0e3c052..76cb66d 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8-gap7.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8-gap7.c
@@ -3,7 +3,7 @@
 #include <stdarg.h>
 #include "tree-vect.h"
 
-#define N 128
+#define N 16 
 
 typedef struct {
    unsigned char a;
@@ -16,8 +16,6 @@ typedef struct {
    unsigned char h;
 } s;
 
-s check_res[N];
-
 __attribute__ ((noinline)) int
 main1 (s *arr)
 {
@@ -46,14 +44,14 @@ main1 (s *arr)
   /* check results:  */
   for (i = 0; i < N; i++)
     { 
-      if (res[i].a != check_res[i].a
-	  || res[i].b != check_res[i].b
-	  || res[i].c != check_res[i].c
-	  || res[i].d != check_res[i].d
-	  || res[i].e != check_res[i].e
-	  || res[i].f != check_res[i].f
-	  || res[i].g != check_res[i].g
-	  || res[i].h != check_res[i].h)
+      if (res[i].c != arr[i].b - arr[i].a + arr[i].d - arr[i].c
+          || res[i].a != arr[i].a + arr[i].b + arr[i].d
+          || res[i].d != arr[i].b - arr[i].a + arr[i].d - arr[i].c
+          || res[i].b != arr[i].h - arr[i].a + arr[i].d - arr[i].c
+          || res[i].f != arr[i].f + arr[i].h
+          || res[i].e != arr[i].b + arr[i].e
+          || res[i].h != arr[i].d
+          || res[i].g != arr[i].b - arr[i].a + arr[i].d - arr[i].c)
          abort();
    }
 }
@@ -63,7 +61,6 @@ int main (void)
 {
   int i;
   s arr[N];
-  unsigned char u, t, s, x, y, z, w;
   
   check_vect ();
 
@@ -77,20 +74,6 @@ int main (void)
       arr[i].f = i * 5;
       arr[i].g = i - 3;
       arr[i].h = 67;
-
-      u = arr[i].b - arr[i].a;
-      t = arr[i].d - arr[i].c;
-      check_res[i].c = u + t;
-      x = arr[i].b + arr[i].d;
-      check_res[i].a = arr[i].a + x;
-      check_res[i].d = u + t;
-      s = arr[i].h - arr[i].a;
-      check_res[i].b = s + t;
-      check_res[i].f = arr[i].f + arr[i].h;
-      check_res[i].e = arr[i].b + arr[i].e;
-      check_res[i].h = arr[i].d;
-      check_res[i].g = u + t;
-
       if (arr[i].a == 178)
          abort(); 
     }