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