* doc/c-tree.texi: Document new tree codes.

        * doc/md.texi: Document new optabs.
        * tree-pretty-print.c (dump_generic_node): Handle print of new tree
        codes.
        * optabs.c (optab_for_tree_code, init_optabs): Handle new optabs.
        * optabs.h (optab_index): Add new.
        (vec_extract_even_optab, vec_extract_odd_optab,
        vec_interleave_high_optab, vec_interleave_low_optab): New optabs.
        * genopinit.c (vec_extract_even_optab, vec_extract_odd_optab,
        vec_interleave_high_optab, vec_interleave_low_optab): Initialize
        new optabs.
        * expr.c (expand_expr_real_1): Add implementation for new tree codes.
        * tree-vectorizer.c (new_stmt_vec_info): Initialize new fields.
        * tree-vectorizer.h (stmt_vec_info): Add new fields for interleaving
        along with macros for their access.
        * tree-data-ref.h (first_location_in_loop, data_reference): Update
        comment.
        * tree-vect-analyze.c (toplev.h): Include.
        (vect_determine_vectorization_factor): Fix indentation.
        (vect_insert_into_interleaving_chain,
        vect_update_interleaving_chain, vect_equal_offsets): New functions.
        (vect_analyze_data_ref_dependence): Add argument for interleaving
        check. Check for interleaving if it's true.
        (vect_check_dependences): New function.
        (vect_analyze_data_ref_dependences): Call vect_check_dependences for
        every ddr. Call vect_analyze_data_ref_dependence with new argument.
        (vect_update_misalignment_for_peel): Update for interleaving.
        (vect_verify_datarefs_alignment): Check only first data-ref for
        interleaving.
        (vect_enhance_data_refs_alignment): Update for interleaving. Check
        only first data-ref for interleaving.
        (vect_analyze_data_ref_access): Check interleaving, update
        interleaving data.
        (vect_analyze_data_refs): Call compute_data_dependences_for_loop
        with different parameters.
        * tree.def (VEC_EXTRACT_EVEN_EXPR, VEC_EXTRACT_ODD_EXPR,
        VEC_INTERLEAVE_HIGH_EXPR, VEC_INTERLEAVE_LOW_EXPR): New tree codes.
        * tree-inline.c (estimate_num_insns_1): Add cases for new codes.
        * tree-vect-transform.c (vect_create_addr_base_for_vector_ref):
        Update step in case of interleaving.
        (vect_strided_store_supported, vect_permute_store_chain): New
        functions.
        (vectorizable_store): Handle strided stores.
        (vect_strided_load_supported, vect_permute_load_chain,
        vect_transform_strided_load): New functions.
        (vectorizable_load): Handle strided loads.
        (vect_transform_stmt): Add argument. Handle strided stores. Check
        that vectorized stmt exists for patterns.
        (vect_gen_niters_for_prolog_loop): Update calculation for
        interleaving.
        (vect_transform_loop): Remove stmt_vec_info for strided stores after
        whole chain vectorization.
        * config/rs6000/altivec.md (UNSPEC_EXTEVEN, UNSPEC_EXTODD,
        UNSPEC_INTERHI, UNSPEC_INTERLO): New constants.
        (vpkuhum_nomode, vpkuwum_nomode, vec_extract_even<mode>,
        vec_extract_odd<mode>, altivec_vmrghsf, altivec_vmrglsf,
        vec_interleave_high<mode>, vec_interleave_low<mode>): Implement.



git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@119088 138bc75d-0d04-0410-961f-82ee72b054a4

25 files changed, 1624 insertions, 7 deletions

diff --git a/gcc/testsuite/gcc.dg/vect/vect-1.c b/gcc/testsuite/gcc.dg/vect/vect-1.c
index 6df6af078f5..1ec195c5352 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-1.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-1.c
@@ -59,7 +59,8 @@ foo (int n)
   fbar (a);
 
 
-  /* Not vectorizable yet (access pattern).  */
+  /* 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];
@@ -85,6 +86,6 @@ foo (int n)
   fbar (a);
 }
 
-/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" } } */
-/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 4 loops" 1 "vect" { target vect_extract_even_odd } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" { xfail vect_extract_even_odd } } } */
 /* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-107.c b/gcc/testsuite/gcc.dg/vect/vect-107.c
index f8031afad11..e4f823f310d 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-107.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-107.c
@@ -14,7 +14,8 @@ main1 (void)
   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};
 
-  /* Strided access pattern.  */
+  /* 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];
@@ -38,5 +39,6 @@ int main (void)
   return main1 ();
 }
 
-/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_extract_even_odd } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect" { xfail vect_extract_even_odd } } } */
 /* { 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 e1548bbc73b..56437e26d82 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-98.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-98.c
@@ -36,6 +36,7 @@ int main (void)
   return main1 (ia);
 }
 
-/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail *-*-* } } } */
-/* { dg-final { scan-tree-dump-times "not vectorized: complicated access pattern" 1 "vect" } } */
+/* Needs interleaving support.  */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" { xfail  { vect_interleave && vect_extract_even_odd } } } } */
 /* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect-strided-a-mult.c b/gcc/testsuite/gcc.dg/vect/vect-strided-a-mult.c
new file mode 100644
index 00000000000..f269c9d8075
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-strided-a-mult.c
@@ -0,0 +1,76 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+typedef struct {
+   unsigned short a;
+   unsigned short b;
+} s;
+
+typedef struct {
+   unsigned int a;
+   unsigned int b;
+} ii;
+
+int
+main1 ()
+{
+  s arr[N];
+  s *ptr = arr;
+  ii iarr[N];
+  ii *iptr = iarr;
+  s res[N];
+  ii ires[N];
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      arr[i].a = i;
+      arr[i].b = i * 2;
+      iarr[i].a = i;
+      iarr[i].b = i * 3;
+      if (arr[i].a == 178)
+         abort();
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      ires[i].a = iptr->b - iptr->a;
+      ires[i].b = iptr->b + iptr->a;
+      res[i].b = ptr->b - ptr->a;
+      res[i].a = ptr->b + ptr->a;
+      iptr++;
+      ptr++;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].b != arr[i].b - arr[i].a
+          || ires[i].a != iarr[i].b - iarr[i].a
+          || res[i].a != arr[i].b + arr[i].a
+          || ires[i].b != iarr[i].b +  iarr[i].a
+)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}   
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc/testsuite/gcc.dg/vect/vect-strided-a-u16-i2.c b/gcc/testsuite/gcc.dg/vect/vect-strided-a-u16-i2.c
new file mode 100644
index 00000000000..6cc62b47f34
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-strided-a-u16-i2.c
@@ -0,0 +1,60 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128 
+
+typedef struct {
+   unsigned short a;
+   unsigned short b;
+} s;
+
+int
+main1 ()
+{
+  s arr[N];
+  s *ptr = arr;
+  s res[N];
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      arr[i].a = i;
+      arr[i].b = i * 2;
+      if (arr[i].a == 178)
+         abort();
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      res[i].a = ptr->b - ptr->a;
+      res[i].b = ptr->b + ptr->a;
+      ptr++;
+    }
+  
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].a != arr[i].b - arr[i].a
+          || res[i].b != arr[i].a + arr[i].b)
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+  
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc/testsuite/gcc.dg/vect/vect-strided-a-u16-i4.c b/gcc/testsuite/gcc.dg/vect/vect-strided-a-u16-i4.c
new file mode 100644
index 00000000000..140f963e2ab
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-strided-a-u16-i4.c
@@ -0,0 +1,73 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128 
+
+typedef struct {
+   unsigned short a;
+   unsigned short b;
+   unsigned short c;
+   unsigned short d;
+} s;
+
+int
+main1 ()
+{
+  s arr[N];
+  s *ptr = arr;
+  s res[N];
+  int i;
+  unsigned short 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;
+      if (arr[i].a == 178)
+         abort();
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      x = ptr->b - ptr->a;
+      y = ptr->d - ptr->c;
+      res[i].c = x + y;
+      z =  ptr->a + ptr->c;
+      w = ptr->b + ptr->d;
+      res[i].a = z + w;
+      res[i].d = x + y;
+      res[i].b = x + y;
+      ptr++;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].c != arr[i].b - arr[i].a + arr[i].d - arr[i].c
+          || res[i].a != arr[i].a + arr[i].c + 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].b - arr[i].a + arr[i].d - arr[i].c)
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+  
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc/testsuite/gcc.dg/vect/vect-strided-a-u16-mult.c b/gcc/testsuite/gcc.dg/vect/vect-strided-a-u16-mult.c
new file mode 100644
index 00000000000..5d45bf84c9d
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-strided-a-u16-mult.c
@@ -0,0 +1,67 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+typedef struct {
+   unsigned short a;
+   unsigned short b;
+} s;
+
+int
+main1 ()
+{
+  s arr[N];
+  s *ptr = arr;
+  unsigned int iarr[N];
+  unsigned int *iptr = iarr;
+  s res[N];
+  unsigned int ires[N];
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      arr[i].a = i;
+      arr[i].b = i * 2;
+      iarr[i] = i * 3;
+      if (arr[i].a == 178)
+         abort();
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      ires[i] = *iptr;
+      res[i].b = ptr->b - ptr->a;
+      res[i].a = ptr->b + ptr->a;
+      iptr++;
+      ptr++;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].b != arr[i].b - arr[i].a
+          || ires[i] != iarr[i]
+          || res[i].a != arr[i].b + arr[i].a)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc/testsuite/gcc.dg/vect/vect-strided-a-u32-mult.c b/gcc/testsuite/gcc.dg/vect/vect-strided-a-u32-mult.c
new file mode 100644
index 00000000000..0fd0fdbd5bc
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-strided-a-u32-mult.c
@@ -0,0 +1,67 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+typedef struct {
+   unsigned int a;
+   unsigned int b;
+} ii;
+
+int
+main1 ()
+{
+  unsigned short arr[N];
+  unsigned short *ptr = arr;
+  ii iarr[N];
+  ii *iptr = iarr;
+  unsigned short res[N];
+  ii ires[N];
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      arr[i] = i;
+      iarr[i].a = i;
+      iarr[i].b = i * 3;
+      if (arr[i] == 178)
+         abort();
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      ires[i].a = iptr->b - iptr->a;
+      ires[i].b = iptr->b + iptr->a;
+      res[i] = *ptr;
+      iptr++;
+      ptr++;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i] != arr[i]
+          || ires[i].a != iarr[i].b - iarr[i].a
+          || ires[i].b != iarr[i].b +  iarr[i].a)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc/testsuite/gcc.dg/vect/vect-strided-a-u8-i2-gap.c b/gcc/testsuite/gcc.dg/vect/vect-strided-a-u8-i2-gap.c
new file mode 100644
index 00000000000..671b7d2b6db
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-strided-a-u8-i2-gap.c
@@ -0,0 +1,74 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64 
+
+typedef struct {
+   unsigned char a;
+   unsigned char b;
+} s;
+
+int
+main1 ()
+{
+  s arr[N];
+  s *ptr = arr;
+  s res[N];
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      arr[i].a = i;
+      arr[i].b = i * 2;
+      if (arr[i].a == 178)
+         abort();
+    }
+
+  for (i = 0; i < N; i++)
+    {
+      res[i].a = ptr->a;
+      res[i].b = ptr->a;
+      ptr++;
+    }
+  
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].a != arr[i].a
+          || res[i].b != arr[i].a)
+	abort ();
+    }
+
+  ptr = arr;
+  /* Not vectorizable: gap in store.  */ 
+  for (i = 0; i < N; i++)
+    {
+      res[i].a = ptr->b;
+      ptr++;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].a != arr[i].b)
+        abort ();
+    }
+
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { 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
new file mode 100644
index 00000000000..ce567955ae5
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-strided-a-u8-i8-gap2.c
@@ -0,0 +1,82 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 16 
+
+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;
+
+int
+main1 ()
+{
+  int i;
+  s arr[N];
+  s *ptr = arr;
+  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;
+      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].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();
+   }
+}
+
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { 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
new file mode 100644
index 00000000000..740d0568dce
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-strided-a-u8-i8-gap7.c
@@ -0,0 +1,86 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16 
+
+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;
+
+int
+main1 ()
+{
+  int i;
+  s arr[N];
+  s *ptr = arr;
+  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;
+      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].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();
+   }
+}
+
+
+int main (void)
+{
+  check_vect ();
+
+  main1 ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc/testsuite/gcc.dg/vect/vect-strided-float.c b/gcc/testsuite/gcc.dg/vect/vect-strided-float.c
new file mode 100644
index 00000000000..f2e4484563b
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-strided-float.c
@@ -0,0 +1,44 @@
+/* { dg-require-effective-target vect_float } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+int
+main1 (void)
+{
+  int i;
+  float a[N*2];
+  float b[N*2] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57,60,63,66,69,72,75,78,81,84,87,90,93};
+  float c[N*2] = {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};
+
+  /* Strided access pattern.  */
+  for (i = 0; i < N/2; i++)
+    {
+      a[i*2] = b[2*i+1] * c[2*i+1] - b[2*i] * c[2*i];
+      a[i*2+1] = b[2*i+8] * c[2*i+9] + b[2*i+9] * c[2*i+8];
+    }
+
+  /* Check results.  */
+  for (i = 0; i < N/2; i++)
+    {
+      if (a[i*2] != b[2*i+1] * c[2*i+1] - b[2*i] * c[2*i]
+	  || a[i*2+1] != b[2*i+8] * c[2*i+9] + b[2*i+9] * c[2*i+8])
+	abort();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  check_vect ();
+  return main1 ();
+}
+
+/* Needs interleaving support.  */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect" { xfail { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc/testsuite/gcc.dg/vect/vect-strided-mult-char-ls.c b/gcc/testsuite/gcc.dg/vect/vect-strided-mult-char-ls.c
new file mode 100644
index 00000000000..29d752d3c55
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-strided-mult-char-ls.c
@@ -0,0 +1,76 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 32 
+
+typedef struct {
+   unsigned char a;
+   unsigned char b;
+} s;
+
+typedef struct {
+   unsigned int a;
+   unsigned int b;
+} ii;
+
+int
+main1 (s *arr, ii *iarr)
+{
+  s *ptr = arr;
+  ii *iptr = iarr;
+  s res[N];
+  ii ires[N];
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      ires[i].a = iptr->b;
+      ires[i].b = iptr->a;
+      res[i].b = ptr->b - ptr->a;
+      res[i].a = ptr->b + ptr->a;
+      iptr++;
+      ptr++;
+    }
+  
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].b != arr[i].b - arr[i].a 
+          || ires[i].a != iarr[i].b
+          || res[i].a != arr[i].b + arr[i].a
+          || ires[i].b != iarr[i].a
+)
+	abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+  s arr[N];
+  ii iarr[N];
+  
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    {
+      arr[i].a = i;
+      arr[i].b = i * 2;
+      iarr[i].a = i;
+      iarr[i].b = i * 3;
+      if (arr[i].a == 178)
+         abort();
+    }
+
+  main1 (arr, iarr);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc/testsuite/gcc.dg/vect/vect-strided-mult.c b/gcc/testsuite/gcc.dg/vect/vect-strided-mult.c
new file mode 100644
index 00000000000..823444ebeb4
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-strided-mult.c
@@ -0,0 +1,76 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+typedef struct {
+   unsigned short a;
+   unsigned short b;
+} s;
+
+typedef struct {
+   unsigned int a;
+   unsigned int b;
+} ii;
+
+int
+main1 (s *arr, ii *iarr)
+{
+  s *ptr = arr;
+  ii *iptr = iarr;
+  s res[N];
+  ii ires[N];
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      ires[i].a = iptr->b - iptr->a;
+      ires[i].b = iptr->b + iptr->a;
+      res[i].b = ptr->b - ptr->a;
+      res[i].a = ptr->b + ptr->a;
+      iptr++;
+      ptr++;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].b != arr[i].b - arr[i].a
+          || ires[i].a != iarr[i].b - iarr[i].a
+          || res[i].a != arr[i].b + arr[i].a
+          || ires[i].b != iarr[i].b +  iarr[i].a
+)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+  s arr[N];
+  ii iarr[N];
+
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    {
+      arr[i].a = i;
+      arr[i].b = i * 2;
+      iarr[i].a = i;
+      iarr[i].b = i * 3;
+      if (arr[i].a == 178)
+         abort();
+    }
+
+  main1 (arr, iarr); 
+  
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc/testsuite/gcc.dg/vect/vect-strided-u16-i2.c b/gcc/testsuite/gcc.dg/vect/vect-strided-u16-i2.c
new file mode 100644
index 00000000000..3c76410f3e0
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-strided-u16-i2.c
@@ -0,0 +1,60 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128 
+
+typedef struct {
+   unsigned short a;
+   unsigned short b;
+} s;
+
+int
+main1 (s *arr)
+{
+  s *ptr = arr;
+  s res[N];
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      res[i].a = ptr->b - ptr->a;
+      res[i].b = ptr->b + ptr->a;
+      ptr++;
+    }
+  
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].a != arr[i].b - arr[i].a
+          || res[i].b != arr[i].a + arr[i].b)
+	abort ();
+    }
+
+  return 0;
+}
+
+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;
+      if (arr[i].a == 178)
+         abort(); 
+    } 
+
+  main1 (arr);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc/testsuite/gcc.dg/vect/vect-strided-u16-i4.c b/gcc/testsuite/gcc.dg/vect/vect-strided-u16-i4.c
new file mode 100644
index 00000000000..199e3633c77
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-strided-u16-i4.c
@@ -0,0 +1,73 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128 
+
+typedef struct {
+   unsigned short a;
+   unsigned short b;
+   unsigned short c;
+   unsigned short d;
+} s;
+
+int
+main1 (s *arr)
+{
+  int i;
+  s *ptr = arr;
+  s res[N];
+  unsigned short x, y, z, w;
+
+  for (i = 0; i < N; i++)
+    {
+      x = ptr->b - ptr->a;
+      y = ptr->d - ptr->c;
+      res[i].c = x + y;
+      z =  ptr->a + ptr->c;
+      w = ptr->b + ptr->d;
+      res[i].a = z + w;
+      res[i].d = x + y;
+      res[i].b = x + y;
+      ptr++;
+    }
+  
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].c != arr[i].b - arr[i].a + arr[i].d - arr[i].c
+          || res[i].a != arr[i].a + arr[i].c + 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].b - arr[i].a + arr[i].d - arr[i].c)
+	abort ();
+    }
+
+  return 0;
+}
+
+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;
+      if (arr[i].a == 178)
+         abort(); 
+    } 
+
+  main1 (arr);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc/testsuite/gcc.dg/vect/vect-strided-u32-i4.c b/gcc/testsuite/gcc.dg/vect/vect-strided-u32-i4.c
new file mode 100644
index 00000000000..e872b97571a
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-strided-u32-i4.c
@@ -0,0 +1,68 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128 
+
+typedef struct {
+   int a;
+   int b;
+   int c;
+   int d;
+} s;
+
+int
+main1 (s *arr)
+{
+  int i;
+  s *ptr = arr;
+  s res[N];
+
+  for (i = 0; i < N; i++)
+    {
+      res[i].c = ptr->b - ptr->a + ptr->d - ptr->c;
+      res[i].a = ptr->a + ptr->c + ptr->b + ptr->d;
+      res[i].d = ptr->b - ptr->a + ptr->d - ptr->c;
+      res[i].b = ptr->b - ptr->a + ptr->d - ptr->c;
+      ptr++;
+    }
+  
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].c != arr[i].b - arr[i].a + arr[i].d - arr[i].c
+          || res[i].a != arr[i].a + arr[i].c + 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].b - arr[i].a + arr[i].d - arr[i].c)
+	abort ();
+    }
+
+  return 0;
+}
+
+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;
+      if (arr[i].a == 178)
+         abort(); 
+    } 
+
+  main1 (arr);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc/testsuite/gcc.dg/vect/vect-strided-u32-i8.c b/gcc/testsuite/gcc.dg/vect/vect-strided-u32-i8.c
new file mode 100644
index 00000000000..7e8888f128c
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-strided-u32-i8.c
@@ -0,0 +1,82 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128 
+
+typedef struct {
+   int a;
+   int b;
+   int c;
+   int d;
+   int e;
+   int f;
+   int g;
+   int h;
+} s;
+
+int
+main1 (s *arr)
+{
+  int i;
+  s *ptr = arr;
+  s res[N];
+
+  for (i = 0; i < N; i++)
+    {
+      res[i].c = ptr->b - ptr->a + ptr->d - ptr->c;
+      res[i].a = ptr->a + ptr->g + ptr->b + ptr->d;
+      res[i].d = ptr->b - ptr->a + ptr->d - ptr->c;
+      res[i].b = ptr->h - ptr->a + ptr->d - ptr->c;
+      res[i].f = ptr->f + ptr->h;
+      res[i].e = ptr->b - ptr->e; 
+      res[i].h = ptr->d - ptr->g;   
+      res[i].g = ptr->b - ptr->a + ptr->d - ptr->c;
+      ptr++; 
+    } 
+   
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    { 
+      if (res[i].c != arr[i].b - arr[i].a + arr[i].d - arr[i].c
+          || res[i].a != arr[i].a + arr[i].g + 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 - arr[i].g
+          || res[i].g != arr[i].b - arr[i].a + arr[i].d - arr[i].c)
+         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 * 3 + 5;
+      arr[i].f = i * 5;
+      arr[i].g = i - 3;
+      arr[i].h = 56;
+      if (arr[i].a == 178)
+         abort(); 
+    } 
+
+  main1 (arr);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc/testsuite/gcc.dg/vect/vect-strided-u32-mult.c b/gcc/testsuite/gcc.dg/vect/vect-strided-u32-mult.c
new file mode 100644
index 00000000000..188bef86f98
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-strided-u32-mult.c
@@ -0,0 +1,66 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 128
+
+typedef struct {
+   unsigned int a;
+   unsigned int b;
+} ii;
+
+int
+main1 (unsigned short *arr, ii *iarr)
+{
+  unsigned short *ptr = arr;
+  ii *iptr = iarr;
+  unsigned short res[N];
+  ii ires[N];
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      ires[i].a = iptr->b - iptr->a;
+      ires[i].b = iptr->b + iptr->a;
+      res[i] = *ptr;
+      iptr++;
+      ptr++;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i] != arr[i]
+          || ires[i].a != iarr[i].b - iarr[i].a
+          || ires[i].b != iarr[i].b +  iarr[i].a)
+        abort ();
+    }
+
+  return 0;
+}
+
+int main (void)
+{
+  int i;
+  unsigned short arr[N];
+  ii iarr[N];
+
+  check_vect ();
+
+  for (i = 0; i < N; i++)
+    {
+      arr[i] = i;
+      iarr[i].a = i;
+      iarr[i].b = i * 3;
+      if (arr[i] == 178)
+         abort();
+    }
+  main1 (arr, iarr); 
+    
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i2-gap.c b/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i2-gap.c
new file mode 100644
index 00000000000..86e86158e0c
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i2-gap.c
@@ -0,0 +1,76 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64 
+
+typedef struct {
+   unsigned char a;
+   unsigned char b;
+} s;
+
+int
+main1 (s *arr)
+{
+  s *ptr = arr;
+  s res[N];
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      res[i].a = ptr->b;
+      res[i].b = ptr->b;
+      ptr++;
+    }
+  
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].a != arr[i].b
+          || res[i].b != arr[i].b)
+	abort ();
+    }
+
+  ptr = arr;
+  /* Not vectorizable: gap in store.  */ 
+  for (i = 0; i < N; i++)
+    {
+      res[i].a = ptr->b;
+      ptr++;
+    }
+
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].a != arr[i].b)
+        abort ();
+    }
+
+
+  return 0;
+}
+
+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;
+      if (arr[i].a == 178)
+         abort(); 
+    } 
+
+  main1 (arr);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i2.c b/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i2.c
new file mode 100644
index 00000000000..b9dcbba6b6b
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i2.c
@@ -0,0 +1,59 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 64
+
+typedef struct {
+   unsigned char a;
+   unsigned char b;
+} s;
+
+int
+main1 (s *arr)
+{
+  s *ptr = arr;
+  s res[N];
+  int i;
+
+  for (i = 0; i < N; i++)
+    {
+      res[i].a = ptr->b - ptr->a;
+      res[i].b = ptr->b + ptr->a;
+      ptr++;
+    }
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    {
+      if (res[i].a != arr[i].b - arr[i].a
+          || res[i].b != arr[i].a + arr[i].b)
+	abort ();
+    }
+
+  return 0;
+}
+
+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;
+      if (arr[i].a == 178)
+         abort(); 
+    } 
+
+  main1 (arr);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { 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
new file mode 100644
index 00000000000..8827ee10178
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8-gap2.c
@@ -0,0 +1,84 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 16 
+
+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;
+
+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].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();
+   }
+}
+
+
+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;
+      if (arr[i].a == 178)
+         abort(); 
+    } 
+
+  main1 (arr);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { 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
new file mode 100644
index 00000000000..c176b3264f4
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8-gap4.c
@@ -0,0 +1,85 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16 
+
+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;
+
+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].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();
+   }
+}
+
+
+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 * 3 + 5;
+      arr[i].f = i * 5;
+      arr[i].g = i - 3;
+      arr[i].h = 56;
+      if (arr[i].a == 178)
+         abort(); 
+    } 
+
+  main1 (arr);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { 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
new file mode 100644
index 00000000000..317fe039f6c
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8-gap7.c
@@ -0,0 +1,88 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16 
+
+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;
+
+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].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();
+   }
+}
+
+
+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 * 3 + 5;
+      arr[i].f = i * 5;
+      arr[i].g = i - 3;
+      arr[i].h = 67;
+      if (arr[i].a == 178)
+         abort(); 
+    } 
+
+  main1 (arr);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+  
diff --git a/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8.c b/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8.c
new file mode 100644
index 00000000000..77a67e0dcfc
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-strided-u8-i8.c
@@ -0,0 +1,91 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "tree-vect.h"
+
+#define N 32 
+
+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;
+
+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;
+      s =  ptr->a + ptr->g;
+      x = ptr->b + ptr->d;
+      res[i].a = s + x;
+      res[i].d = u + t;
+      s = ptr->h - ptr->a;
+      x = ptr->d - ptr->c;
+      res[i].b = s + x;
+      res[i].f = ptr->f + ptr->h;
+      res[i].e = ptr->b + ptr->e; 
+      res[i].h = ptr->d - ptr->g;   
+      res[i].g = u + t;
+      ptr++; 
+    } 
+   
+  /* check results:  */
+  for (i = 0; i < N; i++)
+    { 
+      if (res[i].c != arr[i].b - arr[i].a + arr[i].d - arr[i].c
+          || res[i].a != arr[i].a + arr[i].g + 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 - arr[i].g
+          || res[i].g != arr[i].b - arr[i].a + arr[i].d - arr[i].c
+       )
+          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;
+      arr[i].f = i + 5;
+      arr[i].g = i + 3;
+      arr[i].h = 67;
+      if (arr[i].a == 178)
+         abort(); 
+    } 
+
+  main1 (arr);
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_interleave && vect_extract_even_odd } } } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+