gcc/testsuite/gcc.target/aarch64/sve/reduc_2_run.c

   1 /* { dg-do run { target { aarch64_sve_hw } } } */
   2 /* { dg-options "-O2 -ftree-vectorize -ffast-math" } */
   3
   4 #include "reduc_2.c"
   5
   6 #define NROWS 53
   7
   8 /* -ffast-math fuzz for PLUS.  */
   9 #define CMP__Float16(X, Y) ((X) >= (Y) * 0.875 && (X) <= (Y) * 1.125)
  10 #define CMP_float(X, Y) ((X) == (Y))
  11 #define CMP_double(X, Y) ((X) == (Y))
  12 #define CMP_int8_t(X, Y) ((X) == (Y))
  13 #define CMP_int16_t(X, Y) ((X) == (Y))
  14 #define CMP_int32_t(X, Y) ((X) == (Y))
  15 #define CMP_int64_t(X, Y) ((X) == (Y))
  16 #define CMP_uint8_t(X, Y) ((X) == (Y))
  17 #define CMP_uint16_t(X, Y) ((X) == (Y))
  18 #define CMP_uint32_t(X, Y) ((X) == (Y))
  19 #define CMP_uint64_t(X, Y) ((X) == (Y))
  20
  21 #define INIT_MATRIX(TYPE)                               \
  22   TYPE mat[NROWS][NUM_ELEMS (TYPE)];                    \
  23   TYPE r[NROWS];                                        \
  24   for (int i = 0; i < NROWS; i++)                       \
  25     for (int j = 0; j < NUM_ELEMS (TYPE); j++)          \
  26       {                                                 \
  27         mat[i][j] = i + (j * 2) * (j & 1 ? 1 : -1);     \
  28         asm volatile ("" ::: "memory");                 \
  29       }
  30
  31 #define TEST_REDUC_PLUS(TYPE)                           \
  32   {                                                     \
  33     INIT_MATRIX (TYPE);                                 \
  34     reduc_plus_##TYPE (mat, r, NROWS);                  \
  35     for (int i = 0; i < NROWS; i++)                     \
  36       {                                                 \
  37         volatile TYPE r2 = 0;                           \
  38         for (int j = 0; j < NUM_ELEMS (TYPE); ++j)      \
  39           r2 += mat[i][j];                              \
  40         if (!CMP_##TYPE (r[i], r2))                     \
  41           __builtin_abort ();                           \
  42       }                                                 \
  43     }
  44
  45 #define TEST_REDUC_MAXMIN(TYPE, NAME, CMP_OP)           \
  46   {                                                     \
  47     INIT_MATRIX (TYPE);                                 \
  48     reduc_##NAME##_##TYPE (mat, r, NROWS);              \
  49     for (int i = 0; i < NROWS; i++)                     \
  50       {                                                 \
  51         volatile TYPE r2 = mat[i][0];                   \
  52         for (int j = 0; j < NUM_ELEMS (TYPE); ++j)      \
  53           r2 = mat[i][j] CMP_OP r2 ? mat[i][j] : r2;    \
  54         if (r[i] != r2)                                 \
  55           __builtin_abort ();                           \
  56       }                                                 \
  57     }
  58
  59 #define TEST_REDUC_BITWISE(TYPE, NAME, BIT_OP)          \
  60   {                                                     \
  61     INIT_MATRIX (TYPE);                                 \
  62     reduc_##NAME##_##TYPE (mat, r, NROWS);              \
  63     for (int i = 0; i < NROWS; i++)                     \
  64       {                                                 \
  65         volatile TYPE r2 = mat[i][0];                   \
  66         for (int j = 0; j < NUM_ELEMS (TYPE); ++j)      \
  67           r2 BIT_OP mat[i][j];                          \
  68         if (r[i] != r2)                                 \
  69           __builtin_abort ();                           \
  70       }                                                 \
  71     }
  72
  73 int main ()
  74 {
  75   TEST_PLUS (TEST_REDUC_PLUS)
  76   TEST_MAXMIN (TEST_REDUC_MAXMIN)
  77
  78   return 0;
  79 }