[8/9] Testsuite: split tests for strided accesses

The next patch introduces separate vect_stridedN target selectors
for each tested stride factor N.  At the moment, some tests contain
several independent loops that have different stride factors.
It's easier to make the next change if we put these loops into
separate tests.

Tested on x86_64-linux-gnu and arm-linux-gnueabi.  OK to install?

Richard


gcc/testsuite/
	* gcc.dg/vect/slp-11.c: Split into...
	* gcc.dg/vect/slp-11a.c, gcc.dg/vect/slp-11b.c,
	gcc.dg/vect/slp-11c.c: ...these tests.
	* gcc.dg/vect/slp-12a.c: Split 4-stride loop into...
	* gcc.dg/vect/slp-12c.c: ...this new test.
	* gcc.dg/vect/slp-19.c: Split into...
	* gcc.dg/vect/slp-19a.c, gcc.dg/vect/slp-19b.c,
	gcc.dg/vect/slp-19c.c: ...these new tests.

On Tue, Apr 12, 2011 at 4:19 PM, Richard Sandiford
<richard.sandiford@linaro.org> wrote:
> The next patch introduces separate vect_stridedN target selectors
> for each tested stride factor N.  At the moment, some tests contain
> several independent loops that have different stride factors.
> It's easier to make the next change if we put these loops into
> separate tests.
>
> Tested on x86_64-linux-gnu and arm-linux-gnueabi.  OK to install?

Ok.

Thanks,
Richard.

> Richard
>
>
> gcc/testsuite/
>        * gcc.dg/vect/slp-11.c: Split into...
>        * gcc.dg/vect/slp-11a.c, gcc.dg/vect/slp-11b.c,
>        gcc.dg/vect/slp-11c.c: ...these tests.
>        * gcc.dg/vect/slp-12a.c: Split 4-stride loop into...
>        * gcc.dg/vect/slp-12c.c: ...this new test.
>        * gcc.dg/vect/slp-19.c: Split into...
>        * gcc.dg/vect/slp-19a.c, gcc.dg/vect/slp-19b.c,
>        gcc.dg/vect/slp-19c.c: ...these new tests.
>
> Index: gcc/testsuite/gcc.dg/vect/slp-11.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/vect/slp-11.c  2011-04-12 15:18:24.000000000 +0100
> +++ /dev/null   2011-03-23 08:42:11.268792848 +0000
> @@ -1,113 +0,0 @@
> -/* { dg-require-effective-target vect_int } */
> -
> -#include <stdarg.h>
> -#include "tree-vect.h"
> -
> -#define N 8
> -
> -int
> -main1 ()
> -{
> -  int i;
> -  unsigned int out[N*8], a0, a1, a2, a3, a4, a5, a6, a7, b1, b0, b2, b3, b4, b5, b6, b7;
> -  unsigned int 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};
> -  float out2[N*8];
> -
> -  /* Different operations - not SLPable.  */
> -  for (i = 0; i < N; i++)
> -    {
> -      a0 = in[i*8] + 5;
> -      a1 = in[i*8 + 1] * 6;
> -      a2 = in[i*8 + 2] + 7;
> -      a3 = in[i*8 + 3] + 8;
> -      a4 = in[i*8 + 4] + 9;
> -      a5 = in[i*8 + 5] + 10;
> -      a6 = in[i*8 + 6] + 11;
> -      a7 = in[i*8 + 7] + 12;
> -
> -      b0 = a0 * 3;
> -      b1 = a1 * 2;
> -      b2 = a2 * 12;
> -      b3 = a3 * 5;
> -      b4 = a4 * 8;
> -      b5 = a5 * 4;
> -      b6 = a6 * 3;
> -      b7 = a7 * 2;
> -
> -      out[i*8] = b0 - 2;
> -      out[i*8 + 1] = b1 - 3;
> -      out[i*8 + 2] = b2 - 2;
> -      out[i*8 + 3] = b3 - 1;
> -      out[i*8 + 4] = b4 - 8;
> -      out[i*8 + 5] = b5 - 7;
> -      out[i*8 + 6] = b6 - 3;
> -      out[i*8 + 7] = b7 - 7;
> -    }
> -
> -  /* check results:  */
> -  for (i = 0; i < N; i++)
> -    {
> -      if (out[i*8] !=  (in[i*8] + 5) * 3 - 2
> -         || out[i*8 + 1] != (in[i*8 + 1] * 6) * 2 - 3
> -         || out[i*8 + 2] != (in[i*8 + 2] + 7) * 12 - 2
> -         || out[i*8 + 3] != (in[i*8 + 3] + 8) * 5 - 1
> -         || out[i*8 + 4] != (in[i*8 + 4] + 9) * 8 - 8
> -         || out[i*8 + 5] != (in[i*8 + 5] + 10) * 4 - 7
> -         || out[i*8 + 6] != (in[i*8 + 6] + 11) * 3 - 3
> -         || out[i*8 + 7] != (in[i*8 + 7] + 12) * 2 - 7)
> -       abort ();
> -    }
> -
> -  /* Requires permutation - not SLPable.  */
> -  for (i = 0; i < N*2; i++)
> -    {
> -      out[i*4] = (in[i*4] + 2) * 3;
> -      out[i*4 + 1] = (in[i*4 + 2] + 2) * 7;
> -      out[i*4 + 2] = (in[i*4 + 1] + 7) * 3;
> -      out[i*4 + 3] = (in[i*4 + 3] + 3) * 4;
> -    }
> -
> -  /* check results:  */
> -  for (i = 0; i < N*2; i++)
> -    {
> -      if (out[i*4] !=  (in[i*4] + 2) * 3
> -         || out[i*4 + 1] != (in[i*4 + 2] + 2) * 7
> -         || out[i*4 + 2] != (in[i*4 + 1] + 7) * 3
> -         || out[i*4 + 3] != (in[i*4 + 3] + 3) * 4)
> -        abort ();
> -    }
> -
> -  /* Different operations - not SLPable.  */
> -  for (i = 0; i < N*4; i++)
> -    {
> -      out2[i*2] = ((float) in[i*2] * 2 + 6) ;
> -      out2[i*2 + 1] = (float) (in[i*2 + 1] * 3 + 7);
> -    }
> -
> -  /* check results:  */
> -  for (i = 0; i < N*4; i++)
> -    {
> -      if (out2[i*2] !=  ((float) in[i*2] * 2 + 6)
> -         || out2[i*2 + 1] != (float) (in[i*2 + 1] * 3 + 7))
> -        abort ();
> -    }
> -
> -
> -  return 0;
> -}
> -
> -int main (void)
> -{
> -  check_vect ();
> -
> -  main1 ();
> -
> -  return 0;
> -}
> -
> -/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect"  { target { { vect_uintfloat_cvt && vect_strided } &&  vect_int_mult } } } } */
> -/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect"  { target { { { ! vect_uintfloat_cvt } && vect_strided } &&  vect_int_mult } } } } */
> -/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect"  {target  { ! { vect_int_mult && vect_strided } } } } }  */
> -/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 0  "vect"  } } */
> -/* { dg-final { cleanup-tree-dump "vect" } } */
> -
> Index: gcc/testsuite/gcc.dg/vect/slp-11a.c
> ===================================================================
> --- /dev/null   2011-03-23 08:42:11.268792848 +0000
> +++ gcc/testsuite/gcc.dg/vect/slp-11a.c 2011-04-12 15:18:25.000000000 +0100
> @@ -0,0 +1,75 @@
> +/* { dg-require-effective-target vect_int } */
> +
> +#include <stdarg.h>
> +#include "tree-vect.h"
> +
> +#define N 8
> +
> +int
> +main1 ()
> +{
> +  int i;
> +  unsigned int out[N*8], a0, a1, a2, a3, a4, a5, a6, a7, b1, b0, b2, b3, b4, b5, b6, b7;
> +  unsigned int 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};
> +
> +  /* Different operations - not SLPable.  */
> +  for (i = 0; i < N; i++)
> +    {
> +      a0 = in[i*8] + 5;
> +      a1 = in[i*8 + 1] * 6;
> +      a2 = in[i*8 + 2] + 7;
> +      a3 = in[i*8 + 3] + 8;
> +      a4 = in[i*8 + 4] + 9;
> +      a5 = in[i*8 + 5] + 10;
> +      a6 = in[i*8 + 6] + 11;
> +      a7 = in[i*8 + 7] + 12;
> +
> +      b0 = a0 * 3;
> +      b1 = a1 * 2;
> +      b2 = a2 * 12;
> +      b3 = a3 * 5;
> +      b4 = a4 * 8;
> +      b5 = a5 * 4;
> +      b6 = a6 * 3;
> +      b7 = a7 * 2;
> +
> +      out[i*8] = b0 - 2;
> +      out[i*8 + 1] = b1 - 3;
> +      out[i*8 + 2] = b2 - 2;
> +      out[i*8 + 3] = b3 - 1;
> +      out[i*8 + 4] = b4 - 8;
> +      out[i*8 + 5] = b5 - 7;
> +      out[i*8 + 6] = b6 - 3;
> +      out[i*8 + 7] = b7 - 7;
> +    }
> +
> +  /* check results:  */
> +  for (i = 0; i < N; i++)
> +    {
> +      if (out[i*8] !=  (in[i*8] + 5) * 3 - 2
> +         || out[i*8 + 1] != (in[i*8 + 1] * 6) * 2 - 3
> +         || out[i*8 + 2] != (in[i*8 + 2] + 7) * 12 - 2
> +         || out[i*8 + 3] != (in[i*8 + 3] + 8) * 5 - 1
> +         || out[i*8 + 4] != (in[i*8 + 4] + 9) * 8 - 8
> +         || out[i*8 + 5] != (in[i*8 + 5] + 10) * 4 - 7
> +         || out[i*8 + 6] != (in[i*8 + 6] + 11) * 3 - 3
> +         || out[i*8 + 7] != (in[i*8 + 7] + 12) * 2 - 7)
> +       abort ();
> +    }
> +
> +  return 0;
> +}
> +
> +int main (void)
> +{
> +  check_vect ();
> +
> +  main1 ();
> +
> +  return 0;
> +}
> +
> +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_strided && vect_int_mult } } } } */
> +/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect" { target { ! { vect_strided && vect_int_mult } } } } } */
> +/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 0 "vect" } } */
> +/* { dg-final { cleanup-tree-dump "vect" } } */
> Index: gcc/testsuite/gcc.dg/vect/slp-11b.c
> ===================================================================
> --- /dev/null   2011-03-23 08:42:11.268792848 +0000
> +++ gcc/testsuite/gcc.dg/vect/slp-11b.c 2011-04-12 15:18:25.000000000 +0100
> @@ -0,0 +1,49 @@
> +/* { dg-require-effective-target vect_int } */
> +
> +#include <stdarg.h>
> +#include "tree-vect.h"
> +
> +#define N 8
> +
> +int
> +main1 ()
> +{
> +  int i;
> +  unsigned int out[N*8], a0, a1, a2, a3, a4, a5, a6, a7, b1, b0, b2, b3, b4, b5, b6, b7;
> +  unsigned int 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};
> +
> +  /* Requires permutation - not SLPable.  */
> +  for (i = 0; i < N*2; i++)
> +    {
> +      out[i*4] = (in[i*4] + 2) * 3;
> +      out[i*4 + 1] = (in[i*4 + 2] + 2) * 7;
> +      out[i*4 + 2] = (in[i*4 + 1] + 7) * 3;
> +      out[i*4 + 3] = (in[i*4 + 3] + 3) * 4;
> +    }
> +
> +  /* check results:  */
> +  for (i = 0; i < N*2; i++)
> +    {
> +      if (out[i*4] !=  (in[i*4] + 2) * 3
> +         || out[i*4 + 1] != (in[i*4 + 2] + 2) * 7
> +         || out[i*4 + 2] != (in[i*4 + 1] + 7) * 3
> +         || out[i*4 + 3] != (in[i*4 + 3] + 3) * 4)
> +        abort ();
> +    }
> +
> +  return 0;
> +}
> +
> +int main (void)
> +{
> +  check_vect ();
> +
> +  main1 ();
> +
> +  return 0;
> +}
> +
> +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_strided && vect_int_mult } } } } */
> +/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect" { target { ! { vect_strided && vect_int_mult } } } } } */
> +/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 0 "vect" } } */
> +/* { dg-final { cleanup-tree-dump "vect" } } */
> Index: gcc/testsuite/gcc.dg/vect/slp-11c.c
> ===================================================================
> --- /dev/null   2011-03-23 08:42:11.268792848 +0000
> +++ gcc/testsuite/gcc.dg/vect/slp-11c.c 2011-04-12 15:18:25.000000000 +0100
> @@ -0,0 +1,46 @@
> +/* { dg-require-effective-target vect_int } */
> +
> +#include <stdarg.h>
> +#include "tree-vect.h"
> +
> +#define N 8
> +
> +int
> +main1 ()
> +{
> +  int i;
> +  unsigned int 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};
> +  float out[N*8];
> +
> +  /* Different operations - not SLPable.  */
> +  for (i = 0; i < N*4; i++)
> +    {
> +      out[i*2] = ((float) in[i*2] * 2 + 6) ;
> +      out[i*2 + 1] = (float) (in[i*2 + 1] * 3 + 7);
> +    }
> +
> +  /* check results:  */
> +  for (i = 0; i < N*4; i++)
> +    {
> +      if (out[i*2] !=  ((float) in[i*2] * 2 + 6)
> +         || out[i*2 + 1] != (float) (in[i*2 + 1] * 3 + 7))
> +        abort ();
> +    }
> +
> +
> +  return 0;
> +}
> +
> +int main (void)
> +{
> +  check_vect ();
> +
> +  main1 ();
> +
> +  return 0;
> +}
> +
> +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { { vect_uintfloat_cvt && vect_strided } && vect_int_mult } } } } */
> +/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect" { target { ! { { vect_uintfloat_cvt && vect_strided } && vect_int_mult } } } } } */
> +/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 0  "vect"  } } */
> +/* { dg-final { cleanup-tree-dump "vect" } } */
> Index: gcc/testsuite/gcc.dg/vect/slp-12a.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/vect/slp-12a.c 2011-04-12 15:18:24.000000000 +0100
> +++ gcc/testsuite/gcc.dg/vect/slp-12a.c 2011-04-12 15:18:25.000000000 +0100
> @@ -11,7 +11,7 @@ main1 ()
>   int i;
>   unsigned int out[N*8], a0, a1, a2, a3, a4, a5, a6, a7, b1, b0, b2, b3, b4, b5, b6, b7;
>   unsigned int 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 ia[N], ib[N*2];
> +  unsigned int ia[N];
>
>   for (i = 0; i < N; i++)
>     {
> @@ -61,27 +61,6 @@ main1 ()
>        abort ();
>     }
>
> -  for (i = 0; i < N*2; i++)
> -    {
> -      out[i*4] = (in[i*4] + 2) * 3;
> -      out[i*4 + 1] = (in[i*4 + 1] + 2) * 7;
> -      out[i*4 + 2] = (in[i*4 + 2] + 7) * 3;
> -      out[i*4 + 3] = (in[i*4 + 3] + 7) * 7;
> -
> -      ib[i] = 7;
> -    }
> -
> -  /* check results:  */
> -  for (i = 0; i < N*2; i++)
> -    {
> -      if (out[i*4] !=  (in[i*4] + 2) * 3
> -         || out[i*4 + 1] != (in[i*4 + 1] + 2) * 7
> -         || out[i*4 + 2] != (in[i*4 + 2] + 7) * 3
> -         || out[i*4 + 3] != (in[i*4 + 3] + 7) * 7
> -         || ib[i] != 7)
> -        abort ();
> -    }
> -
>   return 0;
>  }
>
> @@ -94,11 +73,8 @@ int main (void)
>   return 0;
>  }
>
> -/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect"  {target { vect_strided && vect_int_mult} } } } */
> -/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  {target { {! {vect_strided}} && vect_int_mult } } } } */
> -/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect"  {target  { ! vect_int_mult } } } } */
> -/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 2 "vect" {target { vect_strided && vect_int_mult } } } } */
> -/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect" {target { {! {vect_strided}} && vect_int_mult } } } } */
> -/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 0 "vect" {target  { ! vect_int_mult } } } } */
> +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_strided && vect_int_mult } } } } */
> +/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect" { target { ! { vect_strided && vect_int_mult } } } } } */
> +/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect" { target { vect_strided && vect_int_mult } } } } */
> +/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 0 "vect" { target { ! { vect_strided && vect_int_mult } } } } } */
>  /* { dg-final { cleanup-tree-dump "vect" } } */
> -
> Index: gcc/testsuite/gcc.dg/vect/slp-12c.c
> ===================================================================
> --- /dev/null   2011-03-23 08:42:11.268792848 +0000
> +++ gcc/testsuite/gcc.dg/vect/slp-12c.c 2011-04-12 15:18:25.000000000 +0100
> @@ -0,0 +1,53 @@
> +/* { dg-require-effective-target vect_int } */
> +
> +#include <stdarg.h>
> +#include "tree-vect.h"
> +
> +#define N 8
> +
> +int
> +main1 ()
> +{
> +  int i;
> +  unsigned int out[N*8], a0, a1, a2, a3, a4, a5, a6, a7, b1, b0, b2, b3, b4, b5, b6, b7;
> +  unsigned int 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 ia[N*2];
> +
> +  for (i = 0; i < N*2; i++)
> +    {
> +      out[i*4] = (in[i*4] + 2) * 3;
> +      out[i*4 + 1] = (in[i*4 + 1] + 2) * 7;
> +      out[i*4 + 2] = (in[i*4 + 2] + 7) * 3;
> +      out[i*4 + 3] = (in[i*4 + 3] + 7) * 7;
> +
> +      ia[i] = 7;
> +    }
> +
> +  /* check results:  */
> +  for (i = 0; i < N*2; i++)
> +    {
> +      if (out[i*4] !=  (in[i*4] + 2) * 3
> +         || out[i*4 + 1] != (in[i*4 + 1] + 2) * 7
> +         || out[i*4 + 2] != (in[i*4 + 2] + 7) * 3
> +         || out[i*4 + 3] != (in[i*4 + 3] + 7) * 7
> +         || ia[i] != 7)
> +        abort ();
> +    }
> +
> +  return 0;
> +}
> +
> +int main (void)
> +{
> +  check_vect ();
> +
> +  main1 ();
> +
> +  return 0;
> +}
> +
> +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target { vect_int_mult } } } } */
> +/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect"  { target { ! vect_int_mult } } } } */
> +/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect" { target vect_int_mult } } } */
> +/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 0 "vect" { target { ! vect_int_mult } } } } */
> +/* { dg-final { cleanup-tree-dump "vect" } } */
> Index: gcc/testsuite/gcc.dg/vect/slp-19.c
> ===================================================================
> --- gcc/testsuite/gcc.dg/vect/slp-19.c  2011-04-12 15:18:24.000000000 +0100
> +++ /dev/null   2011-03-23 08:42:11.268792848 +0000
> @@ -1,154 +0,0 @@
> -/* { dg-require-effective-target vect_int } */
> -
> -#include <stdarg.h>
> -#include "tree-vect.h"
> -
> -#define N 16
> -
> -int
> -main1 ()
> -{
> -  unsigned int i;
> -  unsigned int out[N*8];
> -  unsigned int 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], a0, a1, a2, a3;
> -
> -  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] = in[i*8 + 2];
> -    }
> -
> -  /* 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] != in[i*8 + 2])
> -       abort ();
> -    }
> -
> -  for (i = 0; i < N*2; i++)
> -    {
> -      a0 = in[i*4] + 1;
> -      a1 = in[i*4 + 1] + 2;
> -      a2 = in[i*4 + 2] + 3;
> -      a3 = in[i*4 + 3] + 4;
> -
> -      out[i*4] = a0;
> -      out[i*4 + 1] = a1;
> -      out[i*4 + 2] = a2;
> -      out[i*4 + 3] = a3;
> -
> -      ia[i] = a2;
> -    }
> -
> -  /* check results:  */
> -  for (i = 0; i < N*2; i++)
> -    {
> -      if (out[i*4] !=  in[i*4] + 1
> -         || out[i*4 + 1] != in[i*4 + 1] + 2
> -         || out[i*4 + 2] != in[i*4 + 2] + 3
> -         || out[i*4 + 3] != in[i*4 + 3] + 4
> -         || ia[i] != in[i*4 + 2] + 3)
> -        abort ();
> -    }
> -
> -  /* The last stmt requires interleaving of not power of 2 size - not
> -     vectorizable.  */
> -  for (i = 0; i < N/2; i++)
> -    {
> -      out[i*12] = in[i*12];
> -      out[i*12 + 1] = in[i*12 + 1];
> -      out[i*12 + 2] = in[i*12 + 2];
> -      out[i*12 + 3] = in[i*12 + 3];
> -      out[i*12 + 4] = in[i*12 + 4];
> -      out[i*12 + 5] = in[i*12 + 5];
> -      out[i*12 + 6] = in[i*12 + 6];
> -      out[i*12 + 7] = in[i*12 + 7];
> -      out[i*12 + 8] = in[i*12 + 8];
> -      out[i*12 + 9] = in[i*12 + 9];
> -      out[i*12 + 10] = in[i*12 + 10];
> -      out[i*12 + 11] = in[i*12 + 11];
> -
> -      ia[i] = in[i*12 + 7];
> -    }
> -
> -  /* check results:  */
> -  for (i = 0; i < N/2; i++)
> -    {
> -      if (out[i*12] !=  in[i*12]
> -         || out[i*12 + 1] != in[i*12 + 1]
> -         || out[i*12 + 2] != in[i*12 + 2]
> -         || out[i*12 + 3] != in[i*12 + 3]
> -         || out[i*12 + 4] != in[i*12 + 4]
> -         || out[i*12 + 5] != in[i*12 + 5]
> -         || out[i*12 + 6] != in[i*12 + 6]
> -         || out[i*12 + 7] != in[i*12 + 7]
> -         || out[i*12 + 8] != in[i*12 + 8]
> -         || out[i*12 + 9] != in[i*12 + 9]
> -         || out[i*12 + 10] != in[i*12 + 10]
> -         || out[i*12 + 11] != in[i*12 + 11]
> -         || ia[i] != in[i*12 + 7])
> -        abort ();
> -    }
> -
> -  /* Hybrid SLP with unrolling by 2.  */
> -  for (i = 0; i < N; i++)
> -    {
> -      out[i*6] = in[i*6];
> -      out[i*6 + 1] = in[i*6 + 1];
> -      out[i*6 + 2] = in[i*6 + 2];
> -      out[i*6 + 3] = in[i*6 + 3];
> -      out[i*6 + 4] = in[i*6 + 4];
> -      out[i*6 + 5] = in[i*6 + 5];
> -
> -      ia[i] = i;
> -    }
> -
> -  /* check results:  */
> -  for (i = 0; i < N/2; i++)
> -    {
> -      if (out[i*6] !=  in[i*6]
> -         || out[i*6 + 1] != in[i*6 + 1]
> -         || out[i*6 + 2] != in[i*6 + 2]
> -         || out[i*6 + 3] != in[i*6 + 3]
> -         || out[i*6 + 4] != in[i*6 + 4]
> -         || out[i*6 + 5] != in[i*6 + 5]
> -         || ia[i] != i)
> -        abort ();
> -    }
> -
> -
> -  return 0;
> -}
> -
> -int main (void)
> -{
> -  check_vect ();
> -
> -  main1 ();
> -
> -  return 0;
> -}
> -
> -/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect" { target  vect_strided  } } } */
> -/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target  { ! { vect_strided } } } } } */
> -/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 3 "vect"  { target  vect_strided  } } } */
> -/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect"  { target { ! { vect_strided } } } } } */
> -/* { dg-final { cleanup-tree-dump "vect" } } */
> -
> Index: gcc/testsuite/gcc.dg/vect/slp-19a.c
> ===================================================================
> --- /dev/null   2011-03-23 08:42:11.268792848 +0000
> +++ gcc/testsuite/gcc.dg/vect/slp-19a.c 2011-04-12 15:18:25.000000000 +0100
> @@ -0,0 +1,61 @@
> +/* { dg-require-effective-target vect_int } */
> +
> +#include <stdarg.h>
> +#include "tree-vect.h"
> +
> +#define N 16
> +
> +int
> +main1 ()
> +{
> +  unsigned int i;
> +  unsigned int out[N*8];
> +  unsigned int 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; 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] = in[i*8 + 2];
> +    }
> +
> +  /* 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] != in[i*8 + 2])
> +       abort ();
> +    }
> +
> +  return 0;
> +}
> +
> +int main (void)
> +{
> +  check_vect ();
> +
> +  main1 ();
> +
> +  return 0;
> +}
> +
> +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_strided } } } */
> +/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect" { target { ! vect_strided } } } } */
> +/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect" { target vect_strided } } } */
> +/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 0 "vect" { target { ! vect_strided } } } } */
> +/* { dg-final { cleanup-tree-dump "vect" } } */
> Index: gcc/testsuite/gcc.dg/vect/slp-19b.c
> ===================================================================
> --- /dev/null   2011-03-23 08:42:11.268792848 +0000
> +++ gcc/testsuite/gcc.dg/vect/slp-19b.c 2011-04-12 15:18:25.000000000 +0100
> @@ -0,0 +1,58 @@
> +/* { dg-require-effective-target vect_int } */
> +
> +#include <stdarg.h>
> +#include "tree-vect.h"
> +
> +#define N 16
> +
> +int
> +main1 ()
> +{
> +  unsigned int i;
> +  unsigned int out[N*8];
> +  unsigned int 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], a0, a1, a2, a3;
> +
> +  for (i = 0; i < N*2; i++)
> +    {
> +      a0 = in[i*4] + 1;
> +      a1 = in[i*4 + 1] + 2;
> +      a2 = in[i*4 + 2] + 3;
> +      a3 = in[i*4 + 3] + 4;
> +
> +      out[i*4] = a0;
> +      out[i*4 + 1] = a1;
> +      out[i*4 + 2] = a2;
> +      out[i*4 + 3] = a3;
> +
> +      ia[i] = a2;
> +    }
> +
> +  /* check results:  */
> +  for (i = 0; i < N*2; i++)
> +    {
> +      if (out[i*4] !=  in[i*4] + 1
> +         || out[i*4 + 1] != in[i*4 + 1] + 2
> +         || out[i*4 + 2] != in[i*4 + 2] + 3
> +         || out[i*4 + 3] != in[i*4 + 3] + 4
> +         || ia[i] != in[i*4 + 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_strided } } } */
> +/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect" { target { ! vect_strided } } } } */
> +/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect" { target vect_strided } } } */
> +/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 0 "vect" { target { ! vect_strided } } } } */
> +/* { dg-final { cleanup-tree-dump "vect" } } */
> Index: gcc/testsuite/gcc.dg/vect/slp-19c.c
> ===================================================================
> --- /dev/null   2011-03-23 08:42:11.268792848 +0000
> +++ gcc/testsuite/gcc.dg/vect/slp-19c.c 2011-04-12 15:18:25.000000000 +0100
> @@ -0,0 +1,95 @@
> +/* { dg-require-effective-target vect_int } */
> +
> +#include <stdarg.h>
> +#include "tree-vect.h"
> +
> +#define N 16
> +
> +int
> +main1 ()
> +{
> +  unsigned int i;
> +  unsigned int out[N*8];
> +  unsigned int 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], a0, a1, a2, a3;
> +
> +  /* The last stmt requires interleaving of not power of 2 size - not
> +     vectorizable.  */
> +  for (i = 0; i < N/2; i++)
> +    {
> +      out[i*12] = in[i*12];
> +      out[i*12 + 1] = in[i*12 + 1];
> +      out[i*12 + 2] = in[i*12 + 2];
> +      out[i*12 + 3] = in[i*12 + 3];
> +      out[i*12 + 4] = in[i*12 + 4];
> +      out[i*12 + 5] = in[i*12 + 5];
> +      out[i*12 + 6] = in[i*12 + 6];
> +      out[i*12 + 7] = in[i*12 + 7];
> +      out[i*12 + 8] = in[i*12 + 8];
> +      out[i*12 + 9] = in[i*12 + 9];
> +      out[i*12 + 10] = in[i*12 + 10];
> +      out[i*12 + 11] = in[i*12 + 11];
> +
> +      ia[i] = in[i*12 + 7];
> +    }
> +
> +  /* check results:  */
> +  for (i = 0; i < N/2; i++)
> +    {
> +      if (out[i*12] !=  in[i*12]
> +         || out[i*12 + 1] != in[i*12 + 1]
> +         || out[i*12 + 2] != in[i*12 + 2]
> +         || out[i*12 + 3] != in[i*12 + 3]
> +         || out[i*12 + 4] != in[i*12 + 4]
> +         || out[i*12 + 5] != in[i*12 + 5]
> +         || out[i*12 + 6] != in[i*12 + 6]
> +         || out[i*12 + 7] != in[i*12 + 7]
> +         || out[i*12 + 8] != in[i*12 + 8]
> +         || out[i*12 + 9] != in[i*12 + 9]
> +         || out[i*12 + 10] != in[i*12 + 10]
> +         || out[i*12 + 11] != in[i*12 + 11]
> +         || ia[i] != in[i*12 + 7])
> +        abort ();
> +    }
> +
> +  /* Hybrid SLP with unrolling by 2.  */
> +  for (i = 0; i < N; i++)
> +    {
> +      out[i*6] = in[i*6];
> +      out[i*6 + 1] = in[i*6 + 1];
> +      out[i*6 + 2] = in[i*6 + 2];
> +      out[i*6 + 3] = in[i*6 + 3];
> +      out[i*6 + 4] = in[i*6 + 4];
> +      out[i*6 + 5] = in[i*6 + 5];
> +
> +      ia[i] = i;
> +    }
> +
> +  /* check results:  */
> +  for (i = 0; i < N/2; i++)
> +    {
> +      if (out[i*6] !=  in[i*6]
> +         || out[i*6 + 1] != in[i*6 + 1]
> +         || out[i*6 + 2] != in[i*6 + 2]
> +         || out[i*6 + 3] != in[i*6 + 3]
> +         || out[i*6 + 4] != in[i*6 + 4]
> +         || out[i*6 + 5] != in[i*6 + 5]
> +         || ia[i] != i)
> +        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" 1 "vect" } } */
> +/* { dg-final { cleanup-tree-dump "vect" } } */
>