gcc/testsuite/gcc.dg/vect/slp-cond-3.c

   1 /* { dg-require-effective-target vect_condition } */
   2
   3 #include "tree-vect.h"
   4
   5 #define N 128
   6
   7 /* Comparison in int, then/else and result in unsigned char.  */
   8
   9 static inline unsigned char
  10 foo (int x, int y, int a, int b)
  11 {
  12   if (x >= y)
  13     return a;
  14   else
  15     return b;
  16 }
  17
  18 __attribute__((noinline, noclone)) void
  19 bar (unsigned char * __restrict__ a, unsigned char * __restrict__ b,
  20      unsigned char * __restrict__ c, unsigned char * __restrict__ d,
  21      unsigned char * __restrict__ e, int w)
  22 {
  23   int i;
  24   for (i = 0; i < N/16; i++, a += 16, b += 16, c += 16, d += 16, e += 16)
  25     {
  26       e[0] = foo (c[0], d[0], a[0] * w, b[0] * w);
  27       e[1] = foo (c[1], d[1], a[1] * w, b[1] * w);
  28       e[2] = foo (c[2], d[2], a[2] * w, b[2] * w);
  29       e[3] = foo (c[3], d[3], a[3] * w, b[3] * w);
  30       e[4] = foo (c[4], d[4], a[4] * w, b[4] * w);
  31       e[5] = foo (c[5], d[5], a[5] * w, b[5] * w);
  32       e[6] = foo (c[6], d[6], a[6] * w, b[6] * w);
  33       e[7] = foo (c[7], d[7], a[7] * w, b[7] * w);
  34       e[8] = foo (c[8], d[8], a[8] * w, b[8] * w);
  35       e[9] = foo (c[9], d[9], a[9] * w, b[9] * w);
  36       e[10] = foo (c[10], d[10], a[10] * w, b[10] * w);
  37       e[11] = foo (c[11], d[11], a[11] * w, b[11] * w);
  38       e[12] = foo (c[12], d[12], a[12] * w, b[12] * w);
  39       e[13] = foo (c[13], d[13], a[13] * w, b[13] * w);
  40       e[14] = foo (c[14], d[14], a[14] * w, b[14] * w);
  41       e[15] = foo (c[15], d[15], a[15] * w, b[15] * w);
  42     }
  43 }
  44
  45
  46 unsigned char a[N], b[N], c[N], d[N], e[N];
  47
  48 int main ()
  49 {
  50   int i;
  51
  52   check_vect ();
  53
  54   for (i = 0; i < N; i++)
  55     {
  56       a[i] = i;
  57       b[i] = 5;
  58       e[i] = 0;
  59
  60       switch (i % 9)
  61         {
  62         case 0: asm (""); c[i] = i; d[i] = i + 1; break;
  63         case 1: c[i] = 0; d[i] = 0; break;
  64         case 2: c[i] = i + 1; d[i] = i - 1; break;
  65         case 3: c[i] = i; d[i] = i + 7; break;
  66         case 4: c[i] = i; d[i] = i; break;
  67         case 5: c[i] = i + 16; d[i] = i + 3; break;
  68         case 6: c[i] = i - 5; d[i] = i; break;
  69         case 7: c[i] = i; d[i] = i; break;
  70         case 8: c[i] = i; d[i] = i - 7; break;
  71         }
  72     }
  73
  74   bar (a, b, c, d, e, 2);
  75   for (i = 0; i < N; i++)
  76     if (e[i] != ((i % 3) == 0 ? 10 : 2 * i))
  77       abort ();
  78
  79   return 0;
  80 }
  81
  82 /* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect" } } */
  83