1  /* { dg-do run } */
       2  /* { dg-options "-O2 -ftree-vectorize" } */
       3  
       4  #include "cond_umax_1.c"
       5  
       6  #define N 99
       7  
       8  #define TEST_REGREG_OPS(TYPE)                                                  \
       9    {                                                                            \
      10      TYPE x[N], y[N];                                                           \
      11      TYPE pred[N];                                                              \
      12      for (int i = 0; i < N; ++i)                                                \
      13        {                                                                        \
      14  	x[i] = i % 13;                                                         \
      15  	y[i] = i * i;                                                          \
      16  	pred[i] = i % 3;                                                       \
      17        }                                                                        \
      18      varith_##TYPE##_reg (x, y, pred, N);                                       \
      19      for (int i = 0; i < N; ++i)                                                \
      20        {                                                                        \
      21  	TYPE expected = i % 3 != 1 ? (x[i] > y[i] ? x[i] : y[i]) : 4;          \
      22  	if (x[i] != expected)                                                  \
      23  	  __builtin_abort ();                                                  \
      24  	asm volatile ("" ::: "memory");                                        \
      25        }                                                                        \
      26    }
      27  
      28  #define TEST_IMMEDIATE_OPS(VALUE, TYPE)                                        \
      29    {                                                                            \
      30      TYPE x[N], y[N];                                                           \
      31      TYPE pred[N];                                                              \
      32      for (int i = 0; i < N; ++i)                                                \
      33        {                                                                        \
      34  	x[i] = i * i;                                                          \
      35  	pred[i] = i % 3;                                                       \
      36        }                                                                        \
      37      varithimm_##VALUE##_##TYPE (x, pred, N);                                   \
      38      for (int i = 0; i < N; ++i)                                                \
      39        {                                                                        \
      40  	TYPE expected                                                          \
      41  	  = i % 3 != 1 ? (x[i] > (TYPE) VALUE ? x[i] : (TYPE) VALUE) : 4;      \
      42  	if (x[i] != expected)                                                  \
      43  	  __builtin_abort ();                                                  \
      44  	asm volatile ("" ::: "memory");                                        \
      45        }                                                                        \
      46    }
      47  
      48  int
      49  main (void)
      50  {
      51    TEST_ALL (TEST_REGREG_OPS, TEST_IMMEDIATE_OPS)
      52    return 0;
      53  }