gcc/testsuite/gcc.target/aarch64/vect-vaddv.c

   1 /* { dg-do run } */
   2 /* { dg-options "-O3 --save-temps -ffast-math" } */
   3
   4 #include <arm_neon.h>
   5
   6 extern void abort (void);
   7 extern float fabsf (float);
   8 extern double fabs (double);
   9
  10 #define NUM_TESTS 16
  11 #define DELTA 0.000001
  12
  13 int8_t input_int8[] = {1, 56, 2, -9, -90, 23, 54, 76,
  14                        -4, 34, 110, -110, 6, 4, 75, -34};
  15 int16_t input_int16[] = {1, 56, 2, -9, -90, 23, 54, 76,
  16                          -4, 34, 110, -110, 6, 4, 75, -34};
  17 int32_t input_int32[] = {1, 56, 2, -9, -90, 23, 54, 76,
  18                          -4, 34, 110, -110, 6, 4, 75, -34};
  19 int64_t input_int64[] = {1, 56, 2, -9, -90, 23, 54, 76,
  20                          -4, 34, 110, -110, 6, 4, 75, -34};
  21
  22 uint8_t input_uint8[] = {1, 56, 2, 9, 90, 23, 54, 76,
  23                          4, 34, 110, 110, 6, 4, 75, 34};
  24 uint16_t input_uint16[] = {1, 56, 2, 9, 90, 23, 54, 76,
  25                            4, 34, 110, 110, 6, 4, 75, 34};
  26 uint32_t input_uint32[] = {1, 56, 2, 9, 90, 23, 54, 76,
  27                            4, 34, 110, 110, 6, 4, 75, 34};
  28
  29 uint64_t input_uint64[] = {1, 56, 2, 9, 90, 23, 54, 76,
  30                            4, 34, 110, 110, 6, 4, 75, 34};
  31
  32 float input_float32[] = {0.1f, -0.1f, 0.4f, 10.3f,
  33                          200.0f, -800.0f, -13.0f, -0.5f,
  34                          7.9f, -870.0f, 10.4f, 310.11f,
  35                          0.0f, -865.0f, -2213.0f, -1.5f};
  36
  37 double input_float64[] = {0.1, -0.1, 0.4, 10.3,
  38                           200.0, -800.0, -13.0, -0.5,
  39                           7.9, -870.0, 10.4, 310.11,
  40                           0.0, -865.0, -2213.0, -1.5};
  41
  42 #define EQUALF(a, b) (fabsf (a - b) < DELTA)
  43 #define EQUALD(a, b) (fabs (a - b) < DELTA)
  44 #define EQUALL(a, b) (a == b)
  45
  46 #define TEST(SUFFIX, Q, TYPE, LANES, FLOAT)                             \
  47 int                                                                     \
  48 test_vaddv##SUFFIX##_##TYPE##x##LANES##_t (void)                        \
  49 {                                                                       \
  50   int i, j;                                                             \
  51   int moves = (NUM_TESTS - LANES) + 1;                                  \
  52   TYPE##_t out_l[NUM_TESTS];                                            \
  53   TYPE##_t out_v[NUM_TESTS];                                            \
  54                                                                         \
  55   /* Calculate linearly.  */                                            \
  56   for (i = 0; i < moves; i++)                                           \
  57     {                                                                   \
  58       out_l[i] = input_##TYPE[i];                                       \
  59       for (j = 1; j < LANES; j++)                                       \
  60         out_l[i] += input_##TYPE[i + j];                                \
  61     }                                                                   \
  62                                                                         \
  63   /* Calculate using vector reduction intrinsics.  */                   \
  64   for (i = 0; i < moves; i++)                                           \
  65     {                                                                   \
  66       TYPE##x##LANES##_t t1 = vld1##Q##_##SUFFIX (input_##TYPE + i);    \
  67       out_v[i] = vaddv##Q##_##SUFFIX (t1);                              \
  68     }                                                                   \
  69                                                                         \
  70   /* Compare.  */                                                       \
  71   for (i = 0; i < moves; i++)                                           \
  72     {                                                                   \
  73       if (!EQUAL##FLOAT (out_v[i], out_l[i]))                           \
  74         return 0;                                                       \
  75     }                                                                   \
  76   return 1;                                                             \
  77 }
  78
  79 #define BUILD_VARIANTS(TYPE, STYPE, W32, W64, F)        \
  80 TEST (STYPE,  , TYPE, W32, F)                           \
  81 TEST (STYPE, q, TYPE, W64, F)                           \
  82
  83 BUILD_VARIANTS (int8, s8, 8, 16, L)
  84 BUILD_VARIANTS (uint8, u8, 8, 16, L)
  85 /* { dg-final { scan-assembler "addv\\tb\[0-9\]+, v\[0-9\]+\.8b" } } */
  86 /* { dg-final { scan-assembler "addv\\tb\[0-9\]+, v\[0-9\]+\.16b" } } */
  87 BUILD_VARIANTS (int16, s16, 4, 8, L)
  88 BUILD_VARIANTS (uint16, u16, 4, 8, L)
  89 /* { dg-final { scan-assembler "addv\\th\[0-9\]+, v\[0-9\]+\.4h" } } */
  90 /* { dg-final { scan-assembler "addv\\th\[0-9\]+, v\[0-9\]+\.8h" } } */
  91 BUILD_VARIANTS (int32, s32, 2, 4, L)
  92 BUILD_VARIANTS (uint32, u32, 2, 4, L)
  93 /* { dg-final { scan-assembler "addp\\tv\[0-9\]+\.2s, v\[0-9\]+\.2s, v\[0-9\]+\.2s" } } */
  94 /* { dg-final { scan-assembler "addv\\ts\[0-9\]+, v\[0-9\]+\.4s" } } */
  95 TEST (s64, q, int64, 2, D)
  96 TEST (u64, q, uint64, 2, D)
  97 /* { dg-final { scan-assembler "addp\\td\[0-9\]+\, v\[0-9\]+\.2d" } } */
  98
  99 BUILD_VARIANTS (float32, f32, 2, 4, F)
 100 /* { dg-final { scan-assembler "faddp\\ts\[0-9\]+, v\[0-9\]+\.2s" } } */
 101 /* { dg-final { scan-assembler "faddp\\tv\[0-9\]+\.4s, v\[0-9\]+\.4s, v\[0-9\]+\.4s" } } */
 102 TEST (f64, q, float64, 2, D)
 103 /* { dg-final { scan-assembler "faddp\\td\[0-9\]+\, v\[0-9\]+\.2d" } } */
 104
 105 #undef TEST
 106 #define TEST(SUFFIX, Q, TYPE, LANES, FLOAT)             \
 107 {                                                       \
 108   if (!test_vaddv##SUFFIX##_##TYPE##x##LANES##_t ())    \
 109     abort ();                                           \
 110 }
 111
 112 int
 113 main (int argc, char **argv)
 114 {
 115 BUILD_VARIANTS (int8, s8, 8, 16, L)
 116 BUILD_VARIANTS (uint8, u8, 8, 16, L)
 117 BUILD_VARIANTS (int16, s16, 4, 8, L)
 118 BUILD_VARIANTS (uint16, u16, 4, 8, L)
 119 BUILD_VARIANTS (int32, s32, 2, 4, L)
 120 BUILD_VARIANTS (uint32, u32, 2, 4, L)
 121
 122 BUILD_VARIANTS (float32, f32, 2, 4, F)
 123 TEST (f64, q, float64, 2, D)
 124
 125   return 0;
 126 }
 127
 128 /* { dg-final { cleanup-saved-temps } } */