gcc/testsuite/gcc.dg/vect/slp-21.c

   1 /* { dg-require-effective-target vect_int } */
   2
   3 #include <stdarg.h>
   4 #include <stdio.h>
   5 #include "tree-vect.h"
   6
   7 #define N 128
   8
   9 int
  10 main1 ()
  11 {
  12   unsigned short i;
  13   unsigned short out[N*8], out2[N*8], b0, b1, b2, b3, b4, a0, a1, a2, a3, b5;
  14   unsigned short in[N*8];
  15
  16   for (i = 0; i < N*8; i++)
  17     {
  18       in[i] = i;
  19     }
  20
  21   /* Different operations in both cases - vectorization with interleaving.  */
  22   for (i = 0; i < N; i++)
  23     {
  24       a0 = in[i*4];
  25       a1 = in[i*4 + 1];
  26       a2 = in[i*4 + 2];
  27       a3 = in[i*4 + 3];
  28
  29       b0 = a0 * 8;
  30       b1 = a1 + 7;
  31       b2 = a2 + 6;
  32       b3 = a3 * 5;
  33
  34       b4 = a2 + 4;
  35       b5 = a3 + 3;
  36
  37       out[i*4] = b0;
  38       out[i*4 + 1] = b1;
  39       out[i*4 + 2] = b2;
  40       out[i*4 + 3] = b3;
  41
  42       out2[i*4] = b0;
  43       out2[i*4 + 1] = b1;
  44       out2[i*4 + 2] = b4;
  45       out2[i*4 + 3] = b5;
  46     }
  47
  48   /* check results:  */
  49   for (i = 0; i < N; i++)
  50     {
  51       a0 = in[i*4];
  52       a1 = in[i*4 + 1];
  53       a2 = in[i*4 + 2];
  54       a3 = in[i*4 + 3];
  55
  56       b0 = a0 * 8;
  57       b1 = a1 + 7;
  58       b2 = a2 + 6;
  59       b3 = a3 * 5;
  60
  61       b4 = a2 + 4;
  62       b5 = a3 + 3;
  63
  64       if (out[i*4] != b0
  65          || out[i*4 + 1] != b1
  66          || out[i*4 + 2] != b2
  67          || out[i*4 + 3] != b3)
  68         abort ();
  69
  70       if (out2[i*4] != b0
  71          || out2[i*4 + 1] != b1
  72          || out2[i*4 + 2] != b4
  73          || out2[i*4 + 3] != b5)
  74         abort ();
  75     }
  76
  77   /* Different operations in the first case - vectorization with interleaving.  */
  78   for (i = 0; i < N; i++)
  79     {
  80       a0 = in[i*4];
  81       a1 = in[i*4 + 1];
  82       a2 = in[i*4 + 2];
  83       a3 = in[i*4 + 3];
  84
  85       b0 = a0 + 8;
  86       b1 = a1 + 7;
  87       b2 = a2 + 6;
  88       b3 = a3 * 5;
  89
  90       b4 = a2 + 4;
  91       b5 = a3 + 3;
  92
  93       out[i*4] = b0;
  94       out[i*4 + 1] = b1;
  95       out[i*4 + 2] = b2;
  96       out[i*4 + 3] = b3;
  97
  98       out2[i*4] = b0;
  99       out2[i*4 + 1] = b1;
 100       out2[i*4 + 2] = b4;
 101       out2[i*4 + 3] = b5;
 102     }
 103
 104   /* check results:  */
 105   for (i = 0; i < N; i++)
 106     {
 107       a0 = in[i*4];
 108       a1 = in[i*4 + 1];
 109       a2 = in[i*4 + 2];
 110       a3 = in[i*4 + 3];
 111
 112       b0 = a0 + 8;
 113       b1 = a1 + 7;
 114       b2 = a2 + 6;
 115       b3 = a3 * 5;
 116
 117       b4 = a2 + 4;
 118       b5 = a3 + 3;
 119
 120       if (out[i*4] != b0
 121          || out[i*4 + 1] != b1
 122          || out[i*4 + 2] != b2
 123          || out[i*4 + 3] != b3)
 124         abort ();
 125
 126       if (out2[i*4] != b0
 127          || out2[i*4 + 1] != b1
 128          || out2[i*4 + 2] != b4
 129          || out2[i*4 + 3] != b5)
 130         abort ();
 131     }
 132
 133
 134   /* Different operations in the second case - vectorization with interleaving.  */
 135   for (i = 0; i < N; i++)
 136     {
 137       a0 = in[i*4];
 138       a1 = in[i*4 + 1];
 139       a2 = in[i*4 + 2];
 140       a3 = in[i*4 + 3];
 141
 142       b0 = a0 + 8;
 143       b1 = a1 + 7;
 144       b2 = a2 + 6;
 145       b3 = a3 + 5;
 146
 147       b4 = a2 * 4;
 148       b5 = a3 + 3;
 149
 150       out[i*4] = b0;
 151       out[i*4 + 1] = b1;
 152       out[i*4 + 2] = b2;
 153       out[i*4 + 3] = b3;
 154
 155       out2[i*4] = b0;
 156       out2[i*4 + 1] = b1;
 157       out2[i*4 + 2] = b4;
 158       out2[i*4 + 3] = b5;
 159     }
 160
 161   /* check results:  */
 162   for (i = 0; i < N; i++)
 163     {
 164       a0 = in[i*4];
 165       a1 = in[i*4 + 1];
 166       a2 = in[i*4 + 2];
 167       a3 = in[i*4 + 3];
 168
 169       b0 = a0 + 8;
 170       b1 = a1 + 7;
 171       b2 = a2 + 6;
 172       b3 = a3 + 5;
 173
 174       b4 = a2 * 4;
 175       b5 = a3 + 3;
 176
 177       if (out[i*4] != b0
 178          || out[i*4 + 1] != b1
 179          || out[i*4 + 2] != b2
 180          || out[i*4 + 3] != b3)
 181         abort ();
 182
 183       if (out2[i*4] != b0
 184          || out2[i*4 + 1] != b1
 185          || out2[i*4 + 2] != b4
 186          || out2[i*4 + 3] != b5)
 187         abort ();
 188     }
 189
 190
 191   return 0;
 192 }
 193
 194 int main (void)
 195 {
 196   check_vect ();
 197
 198   main1 ();
 199
 200   return 0;
 201 }
 202
 203 /* { dg-final { scan-tree-dump-times "vectorized 4 loops" 1 "vect"  { target vect_strided } } } */
 204 /* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect"  { target  { ! { vect_strided } } } } } */
 205 /* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 2 "vect" { target vect_strided }  } } */
 206 /* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 0 "vect"  { target { ! { vect_strided } } } } } */
 207 /* { dg-final { cleanup-tree-dump "vect" } } */
 208