gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/arm-neon-ref.h

   1 /* This file defines helper operations shared by all the tests.  */
   2
   3 #ifndef _ARM_NEON_REF_H_
   4 #define _ARM_NEON_REF_H_
   5
   6 #include <stdio.h>
   7 #include <inttypes.h>
   8
   9 /* helper type, to help write floating point results in integer form.  */
  10 typedef uint32_t hfloat32_t;
  11
  12 extern void abort(void);
  13 extern void *memset(void *, int, size_t);
  14 extern void *memcpy(void *, const void *, size_t);
  15 extern size_t strlen(const char *);
  16
  17 /* Various string construction helpers.  */
  18
  19 /*
  20   The most useful at user-level are VECT_VAR and VECT_VAR_DECL, which
  21    construct variable names or declarations, such as:
  22    VECT_VAR(expected, int, 16, 4) -> expected_int16x4
  23    VECT_VAR_DECL(expected, int, 16, 4) -> int16x4_t expected_int16x4
  24 */
  25
  26 #define xSTR(X) #X
  27 #define STR(X) xSTR(X)
  28
  29 #define xNAME1(V,T) V ## _ ##  T
  30 #define xNAME(V,T) xNAME1(V,T)
  31
  32 /* VAR(foo,int,16) -> foo_int16 */
  33 #define VAR(V,T,W) xNAME(V,T##W)
  34 /* VAR_DECL(foo,int,16) -> int16_t foo_int16 */
  35 #define VAR_DECL(V, T, W) T##W##_t VAR(V,T,W)
  36
  37 /* VECT_NAME(int,16,4) ->  int16x4 */
  38 #define VECT_NAME(T, W, N) T##W##x##N
  39 /* VECT_ARRAY_NAME(int,16,4,2) -> int16x4x2 */
  40 #define VECT_ARRAY_NAME(T, W, N, L) T##W##x##N##x##L
  41 /* VECT_TYPE(int,16,4) -> int16x4_t */
  42 #define VECT_TYPE(T, W, N) xNAME(VECT_NAME(T,W,N),t)
  43 /* VECT_ARRAY_TYPE(int,16,4,2) -> int16x4x2_t */
  44 #define VECT_ARRAY_TYPE(T, W, N, L) xNAME(VECT_ARRAY_NAME(T,W,N,L),t)
  45
  46 /* VECT_VAR(foo,int,16,4) -> foo_int16x4 */
  47 #define VECT_VAR(V,T,W,N) xNAME(V,VECT_NAME(T,W,N))
  48 /* VECT_VAR_DECL(foo,int,16,4) -> int16_t foo_int16x4 */
  49 #define VECT_VAR_DECL(V, T, W, N) T##W##_t VECT_VAR(V,T,W,N)
  50
  51 /* Array declarations.  */
  52 /* ARRAY(foo,int,16,4) -> int16_t foo_int16x4[4] */
  53 #define ARRAY(V, T, W, N) VECT_VAR_DECL(V,T,W,N)[N]
  54
  55 /* Arrays of vectors.  */
  56 /* VECT_ARRAY_VAR(foo,int,16,4,2) -> foo_int16x4x2 */
  57 #define VECT_ARRAY_VAR(V,T,W,N,L) xNAME(V,VECT_ARRAY_NAME(T,W,N,L))
  58 /* VECT_ARRAY(foo,int,16,4,2) -> int16_t foo_int16x4x2[4*2] */
  59 #define VECT_ARRAY(V, T, W, N, L) T##W##_t VECT_ARRAY_VAR(V,T,W,N,L)[N*L]
  60
  61 /* Check results vs expected values. Operates on one vector.  */
  62 #define CHECK(MSG,T,W,N,FMT,EXPECTED,COMMENT)                           \
  63   {                                                                     \
  64     int i;                                                              \
  65     for(i=0; i<N ; i++)                                                 \
  66       {                                                                 \
  67         if (VECT_VAR(result, T, W, N)[i] !=                             \
  68             VECT_VAR(EXPECTED, T, W, N)[i]) {                           \
  69           fprintf(stderr,                                               \
  70                   "ERROR in %s (%s line %d in buffer '%s') at type %s " \
  71                   "index %d: got 0x%" FMT " != 0x%" FMT " %s\n",        \
  72                   MSG, __FILE__, __LINE__,                              \
  73                   STR(EXPECTED),                                        \
  74                   STR(VECT_NAME(T, W, N)),                              \
  75                   i,                                                    \
  76                   VECT_VAR(result, T, W, N)[i],                         \
  77                   VECT_VAR(EXPECTED, T, W, N)[i],                       \
  78                   strlen(COMMENT) > 0 ? COMMENT : "");                  \
  79           abort();                                                      \
  80         }                                                               \
  81       }                                                                 \
  82   }
  83
  84 /* Floating-point variant.  */
  85 #define CHECK_FP(MSG,T,W,N,FMT,EXPECTED,COMMENT)                        \
  86   {                                                                     \
  87     int i;                                                              \
  88     for(i=0; i<N ; i++)                                                 \
  89       {                                                                 \
  90         union fp_operand {                                              \
  91           uint##W##_t i;                                                \
  92           float##W##_t f;                                               \
  93         } tmp_res, tmp_exp;                                             \
  94         tmp_res.f = VECT_VAR(result, T, W, N)[i];                       \
  95         tmp_exp.i = VECT_VAR(EXPECTED, h##T, W, N)[i];                  \
  96         if (tmp_res.i != tmp_exp.i) {                                   \
  97           fprintf(stderr,                                               \
  98                   "ERROR in %s (%s line %d in buffer '%s') at type %s " \
  99                   "index %d: got 0x%" FMT " != 0x%" FMT " %s\n",        \
 100                   MSG, __FILE__, __LINE__,                              \
 101                   STR(EXPECTED),                                        \
 102                   STR(VECT_NAME(T, W, N)),                              \
 103                   i,                                                    \
 104                   tmp_res.i,                                            \
 105                   tmp_exp.i,                                            \
 106                   strlen(COMMENT) > 0 ? COMMENT : "");                  \
 107           abort();                                                      \
 108         }                                                               \
 109       }                                                                 \
 110   }
 111
 112 /* Clean buffer with a non-zero pattern to help diagnose buffer
 113    overflows.  */
 114 #define CLEAN_PATTERN_8  0x33
 115
 116 #define CLEAN(VAR,T,W,N)                                                \
 117   memset(VECT_VAR(VAR, T, W, N),                                        \
 118          CLEAN_PATTERN_8,                                               \
 119          sizeof(VECT_VAR(VAR, T, W, N)));
 120
 121 /* Define output buffers, one of each size.  */
 122 static ARRAY(result, int, 8, 8);
 123 static ARRAY(result, int, 16, 4);
 124 static ARRAY(result, int, 32, 2);
 125 static ARRAY(result, int, 64, 1);
 126 static ARRAY(result, uint, 8, 8);
 127 static ARRAY(result, uint, 16, 4);
 128 static ARRAY(result, uint, 32, 2);
 129 static ARRAY(result, uint, 64, 1);
 130 static ARRAY(result, poly, 8, 8);
 131 static ARRAY(result, poly, 16, 4);
 132 static ARRAY(result, float, 32, 2);
 133 static ARRAY(result, int, 8, 16);
 134 static ARRAY(result, int, 16, 8);
 135 static ARRAY(result, int, 32, 4);
 136 static ARRAY(result, int, 64, 2);
 137 static ARRAY(result, uint, 8, 16);
 138 static ARRAY(result, uint, 16, 8);
 139 static ARRAY(result, uint, 32, 4);
 140 static ARRAY(result, uint, 64, 2);
 141 static ARRAY(result, poly, 8, 16);
 142 static ARRAY(result, poly, 16, 8);
 143 static ARRAY(result, float, 32, 4);
 144
 145 /* Declare expected results, one of each size. They are defined and
 146    initialized in each test file.  */
 147 extern ARRAY(expected, int, 8, 8);
 148 extern ARRAY(expected, int, 16, 4);
 149 extern ARRAY(expected, int, 32, 2);
 150 extern ARRAY(expected, int, 64, 1);
 151 extern ARRAY(expected, uint, 8, 8);
 152 extern ARRAY(expected, uint, 16, 4);
 153 extern ARRAY(expected, uint, 32, 2);
 154 extern ARRAY(expected, uint, 64, 1);
 155 extern ARRAY(expected, poly, 8, 8);
 156 extern ARRAY(expected, poly, 16, 4);
 157 extern ARRAY(expected, hfloat, 32, 2);
 158 extern ARRAY(expected, int, 8, 16);
 159 extern ARRAY(expected, int, 16, 8);
 160 extern ARRAY(expected, int, 32, 4);
 161 extern ARRAY(expected, int, 64, 2);
 162 extern ARRAY(expected, uint, 8, 16);
 163 extern ARRAY(expected, uint, 16, 8);
 164 extern ARRAY(expected, uint, 32, 4);
 165 extern ARRAY(expected, uint, 64, 2);
 166 extern ARRAY(expected, poly, 8, 16);
 167 extern ARRAY(expected, poly, 16, 8);
 168 extern ARRAY(expected, hfloat, 32, 4);
 169
 170 /* Check results. Operates on all possible vector types.  */
 171 #define CHECK_RESULTS(test_name,comment)                                \
 172   {                                                                     \
 173     CHECK(test_name, int, 8, 8, PRIx8, expected, comment);              \
 174     CHECK(test_name, int, 16, 4, PRIx16, expected, comment);            \
 175     CHECK(test_name, int, 32, 2, PRIx32, expected, comment);            \
 176     CHECK(test_name, int, 64, 1, PRIx64, expected, comment);            \
 177     CHECK(test_name, uint, 8, 8, PRIx8, expected, comment);             \
 178     CHECK(test_name, uint, 16, 4, PRIx16, expected, comment);           \
 179     CHECK(test_name, uint, 32, 2, PRIx32, expected, comment);           \
 180     CHECK(test_name, uint, 64, 1, PRIx64, expected, comment);           \
 181     CHECK(test_name, poly, 8, 8, PRIx8, expected, comment);             \
 182     CHECK(test_name, poly, 16, 4, PRIx16, expected, comment);           \
 183     CHECK_FP(test_name, float, 32, 2, PRIx32, expected, comment);       \
 184                                                                         \
 185     CHECK(test_name, int, 8, 16, PRIx8, expected, comment);             \
 186     CHECK(test_name, int, 16, 8, PRIx16, expected, comment);            \
 187     CHECK(test_name, int, 32, 4, PRIx32, expected, comment);            \
 188     CHECK(test_name, int, 64, 2, PRIx64, expected, comment);            \
 189     CHECK(test_name, uint, 8, 16, PRIx8, expected, comment);            \
 190     CHECK(test_name, uint, 16, 8, PRIx16, expected, comment);           \
 191     CHECK(test_name, uint, 32, 4, PRIx32, expected, comment);           \
 192     CHECK(test_name, uint, 64, 2, PRIx64, expected, comment);           \
 193     CHECK(test_name, poly, 8, 16, PRIx8, expected, comment);            \
 194     CHECK(test_name, poly, 16, 8, PRIx16, expected, comment);           \
 195     CHECK_FP(test_name, float, 32, 4, PRIx32, expected, comment);       \
 196   }                                                                     \
 197
 198 #define CHECK_RESULTS_NAMED(test_name,EXPECTED,comment)                 \
 199   {                                                                     \
 200     CHECK(test_name, int, 8, 8, PRIx8, EXPECTED, comment);              \
 201     CHECK(test_name, int, 16, 4, PRIx16, EXPECTED, comment);            \
 202     CHECK(test_name, int, 32, 2, PRIx32, EXPECTED, comment);            \
 203     CHECK(test_name, int, 64, 1, PRIx64, EXPECTED, comment);            \
 204     CHECK(test_name, uint, 8, 8, PRIx8, EXPECTED, comment);             \
 205     CHECK(test_name, uint, 16, 4, PRIx16, EXPECTED, comment);           \
 206     CHECK(test_name, uint, 32, 2, PRIx32, EXPECTED, comment);           \
 207     CHECK(test_name, uint, 64, 1, PRIx64, EXPECTED, comment);           \
 208     CHECK(test_name, poly, 8, 8, PRIx8, EXPECTED, comment);             \
 209     CHECK(test_name, poly, 16, 4, PRIx16, EXPECTED, comment);           \
 210     CHECK_FP(test_name, float, 32, 2, PRIx32, EXPECTED, comment);       \
 211                                                                         \
 212     CHECK(test_name, int, 8, 16, PRIx8, EXPECTED, comment);             \
 213     CHECK(test_name, int, 16, 8, PRIx16, EXPECTED, comment);            \
 214     CHECK(test_name, int, 32, 4, PRIx32, EXPECTED, comment);            \
 215     CHECK(test_name, int, 64, 2, PRIx64, EXPECTED, comment);            \
 216     CHECK(test_name, uint, 8, 16, PRIx8, EXPECTED, comment);            \
 217     CHECK(test_name, uint, 16, 8, PRIx16, EXPECTED, comment);           \
 218     CHECK(test_name, uint, 32, 4, PRIx32, EXPECTED, comment);           \
 219     CHECK(test_name, uint, 64, 2, PRIx64, EXPECTED, comment);           \
 220     CHECK(test_name, poly, 8, 16, PRIx8, EXPECTED, comment);            \
 221     CHECK(test_name, poly, 16, 8, PRIx16, EXPECTED, comment);           \
 222     CHECK_FP(test_name, float, 32, 4, PRIx32, EXPECTED, comment);       \
 223   }                                                                     \
 224
 225
 226
 227 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
 228
 229 typedef union {
 230   struct {
 231     int _xxx:27;
 232     unsigned int QC:1;
 233     int V:1;
 234     int C:1;
 235     int Z:1;
 236     int N:1;
 237   } b;
 238   unsigned int word;
 239 } _ARM_FPSCR;
 240
 241 #else /* __ORDER_BIG_ENDIAN__ */
 242
 243 typedef union {
 244   struct {
 245     int N:1;
 246     int Z:1;
 247     int C:1;
 248     int V:1;
 249     unsigned int QC:1;
 250     int _dnm:27;
 251   } b;
 252   unsigned int word;
 253 } _ARM_FPSCR;
 254
 255 #endif /* __ORDER_BIG_ENDIAN__ */
 256
 257 #define Neon_Cumulative_Sat  __read_neon_cumulative_sat()
 258 /* We need a fake dependency to ensure correct ordering of asm
 259    statements to preset the QC flag value, and Neon operators writing
 260    to QC. */
 261 #define Set_Neon_Cumulative_Sat(x, depend)      \
 262   __set_neon_cumulative_sat((x), (depend))
 263
 264 #if defined(__aarch64__)
 265 static volatile int __read_neon_cumulative_sat (void) {
 266     _ARM_FPSCR _afpscr_for_qc;
 267     asm volatile ("mrs %0,fpsr" : "=r" (_afpscr_for_qc));
 268     return _afpscr_for_qc.b.QC;
 269 }
 270 #define __set_neon_cumulative_sat(x, depend) {                          \
 271     _ARM_FPSCR _afpscr_for_qc;                                          \
 272     asm volatile ("mrs %0,fpsr" : "=r" (_afpscr_for_qc));               \
 273     _afpscr_for_qc.b.QC = x;                                            \
 274     asm volatile ("msr fpsr,%1" : "=X" (depend) : "r" (_afpscr_for_qc)); \
 275   }
 276 #else
 277 static volatile int __read_neon_cumulative_sat (void) {
 278     _ARM_FPSCR _afpscr_for_qc;
 279     asm volatile ("vmrs %0,fpscr" : "=r" (_afpscr_for_qc));
 280     return _afpscr_for_qc.b.QC;
 281 }
 282
 283 #define __set_neon_cumulative_sat(x, depend) {                          \
 284     _ARM_FPSCR _afpscr_for_qc;                                          \
 285     asm volatile ("vmrs %0,fpscr" : "=r" (_afpscr_for_qc));             \
 286     _afpscr_for_qc.b.QC = x;                                            \
 287     asm volatile ("vmsr fpscr,%1" : "=X" (depend) : "r" (_afpscr_for_qc)); \
 288   }
 289 #endif
 290
 291 /* Declare expected cumulative saturation results, one for each
 292    size. They are defined and initialized in relevant test files.  */
 293 extern int VECT_VAR(expected_cumulative_sat, int, 8, 8);
 294 extern int VECT_VAR(expected_cumulative_sat, int, 16, 4);
 295 extern int VECT_VAR(expected_cumulative_sat, int, 32, 2);
 296 extern int VECT_VAR(expected_cumulative_sat, int, 64, 1);
 297 extern int VECT_VAR(expected_cumulative_sat, uint, 8, 8);
 298 extern int VECT_VAR(expected_cumulative_sat, uint, 16, 4);
 299 extern int VECT_VAR(expected_cumulative_sat, uint, 32, 2);
 300 extern int VECT_VAR(expected_cumulative_sat, uint, 64, 1);
 301 extern int VECT_VAR(expected_cumulative_sat, int, 8, 16);
 302 extern int VECT_VAR(expected_cumulative_sat, int, 16, 8);
 303 extern int VECT_VAR(expected_cumulative_sat, int, 32, 4);
 304 extern int VECT_VAR(expected_cumulative_sat, int, 64, 2);
 305 extern int VECT_VAR(expected_cumulative_sat, uint, 8, 16);
 306 extern int VECT_VAR(expected_cumulative_sat, uint, 16, 8);
 307 extern int VECT_VAR(expected_cumulative_sat, uint, 32, 4);
 308 extern int VECT_VAR(expected_cumulative_sat, uint, 64, 2);
 309
 310 /* Check cumulative saturation flag vs expected value.  */
 311 #define CHECK_CUMULATIVE_SAT(MSG,T,W,N,EXPECTED,COMMENT)                \
 312   {                                                                     \
 313     if (Neon_Cumulative_Sat !=                                          \
 314         VECT_VAR(EXPECTED, T, W, N)) {                                  \
 315       fprintf(stderr,                                                   \
 316               "ERROR in %s (%s line %d in cumulative_sat '%s') at type %s: " \
 317               "got %d expected %d%s\n",                                 \
 318               MSG, __FILE__, __LINE__,                                  \
 319               STR(EXPECTED),                                            \
 320               STR(VECT_NAME(T, W, N)),                                  \
 321               Neon_Cumulative_Sat,                                      \
 322               VECT_VAR(EXPECTED, T, W, N),                              \
 323               strlen(COMMENT) > 0 ? " " COMMENT : "");                  \
 324       abort();                                                          \
 325     }                                                                   \
 326   }
 327
 328 #define CHECK_CUMULATIVE_SAT_NAMED(test_name,EXPECTED,comment)          \
 329   {                                                                     \
 330     CHECK_CUMULATIVE_SAT(test_name, int, 8, 8, PRIx8, EXPECTED, comment); \
 331     CHECK_CUMULATIVE_SAT(test_name, int, 16, 4, PRIx16, EXPECTED, comment); \
 332     CHECK_CUMULATIVE_SAT(test_name, int, 32, 2, PRIx32, EXPECTED, comment); \
 333     CHECK_CUMULATIVE_SAT(test_name, int, 64, 1, PRIx64, EXPECTED, comment); \
 334     CHECK_CUMULATIVE_SAT(test_name, uint, 8, 8, PRIx8, EXPECTED, comment); \
 335     CHECK_CUMULATIVE_SAT(test_name, uint, 16, 4, PRIx16, EXPECTED, comment); \
 336     CHECK_CUMULATIVE_SAT(test_name, uint, 32, 2, PRIx32, EXPECTED, comment); \
 337     CHECK_CUMULATIVE_SAT(test_name, uint, 64, 1, PRIx64, EXPECTED, comment); \
 338     CHECK_CUMULATIVE_SAT(test_name, poly, 8, 8, PRIx8, EXPECTED, comment); \
 339     CHECK_CUMULATIVE_SAT(test_name, poly, 16, 4, PRIx16, EXPECTED, comment); \
 340     CHECK_CUMULATIVE_SAT_FP(test_name, float, 32, 2, PRIx32, EXPECTED, comment); \
 341                                                                         \
 342     CHECK_CUMULATIVE_SAT(test_name, int, 8, 16, PRIx8, EXPECTED, comment); \
 343     CHECK_CUMULATIVE_SAT(test_name, int, 16, 8, PRIx16, EXPECTED, comment); \
 344     CHECK_CUMULATIVE_SAT(test_name, int, 32, 4, PRIx32, EXPECTED, comment); \
 345     CHECK_CUMULATIVE_SAT(test_name, int, 64, 2, PRIx64, EXPECTED, comment); \
 346     CHECK_CUMULATIVE_SAT(test_name, uint, 8, 16, PRIx8, EXPECTED, comment); \
 347     CHECK_CUMULATIVE_SAT(test_name, uint, 16, 8, PRIx16, EXPECTED, comment); \
 348     CHECK_CUMULATIVE_SAT(test_name, uint, 32, 4, PRIx32, EXPECTED, comment); \
 349     CHECK_CUMULATIVE_SAT(test_name, uint, 64, 2, PRIx64, EXPECTED, comment); \
 350     CHECK_CUMULATIVE_SAT(test_name, poly, 8, 16, PRIx8, EXPECTED, comment); \
 351     CHECK_CUMULATIVE_SAT(test_name, poly, 16, 8, PRIx16, EXPECTED, comment); \
 352     CHECK_CUMULATIVE_SAT_FP(test_name, float, 32, 4, PRIx32, EXPECTED, comment); \
 353   }                                                                     \
 354
 355
 356 /* Clean output buffers before execution.  */
 357 static void clean_results (void)
 358 {
 359   CLEAN(result, int, 8, 8);
 360   CLEAN(result, int, 16, 4);
 361   CLEAN(result, int, 32, 2);
 362   CLEAN(result, int, 64, 1);
 363   CLEAN(result, uint, 8, 8);
 364   CLEAN(result, uint, 16, 4);
 365   CLEAN(result, uint, 32, 2);
 366   CLEAN(result, uint, 64, 1);
 367   CLEAN(result, poly, 8, 8);
 368   CLEAN(result, poly, 16, 4);
 369   CLEAN(result, float, 32, 2);
 370
 371   CLEAN(result, int, 8, 16);
 372   CLEAN(result, int, 16, 8);
 373   CLEAN(result, int, 32, 4);
 374   CLEAN(result, int, 64, 2);
 375   CLEAN(result, uint, 8, 16);
 376   CLEAN(result, uint, 16, 8);
 377   CLEAN(result, uint, 32, 4);
 378   CLEAN(result, uint, 64, 2);
 379   CLEAN(result, poly, 8, 16);
 380   CLEAN(result, poly, 16, 8);
 381   CLEAN(result, float, 32, 4);
 382 }
 383
 384
 385 /* Helpers to declare variables of various types.   */
 386 #define DECL_VARIABLE(VAR, T1, W, N)            \
 387   VECT_TYPE(T1, W, N) VECT_VAR(VAR, T1, W, N)
 388
 389 /* Declare only 64 bits signed variants.  */
 390 #define DECL_VARIABLE_64BITS_SIGNED_VARIANTS(VAR)       \
 391   DECL_VARIABLE(VAR, int, 8, 8);                        \
 392   DECL_VARIABLE(VAR, int, 16, 4);                       \
 393   DECL_VARIABLE(VAR, int, 32, 2);                       \
 394   DECL_VARIABLE(VAR, int, 64, 1)
 395
 396 /* Declare only 64 bits unsigned variants.  */
 397 #define DECL_VARIABLE_64BITS_UNSIGNED_VARIANTS(VAR)     \
 398   DECL_VARIABLE(VAR, uint, 8, 8);                       \
 399   DECL_VARIABLE(VAR, uint, 16, 4);                      \
 400   DECL_VARIABLE(VAR, uint, 32, 2);                      \
 401   DECL_VARIABLE(VAR, uint, 64, 1)
 402
 403 /* Declare only 128 bits signed variants.  */
 404 #define DECL_VARIABLE_128BITS_SIGNED_VARIANTS(VAR)      \
 405   DECL_VARIABLE(VAR, int, 8, 16);                       \
 406   DECL_VARIABLE(VAR, int, 16, 8);                       \
 407   DECL_VARIABLE(VAR, int, 32, 4);                       \
 408   DECL_VARIABLE(VAR, int, 64, 2)
 409
 410 /* Declare only 128 bits unsigned variants.  */
 411 #define DECL_VARIABLE_128BITS_UNSIGNED_VARIANTS(VAR)    \
 412   DECL_VARIABLE(VAR, uint, 8, 16);                      \
 413   DECL_VARIABLE(VAR, uint, 16, 8);                      \
 414   DECL_VARIABLE(VAR, uint, 32, 4);                      \
 415   DECL_VARIABLE(VAR, uint, 64, 2)
 416
 417 /* Declare all 64 bits variants.  */
 418 #define DECL_VARIABLE_64BITS_VARIANTS(VAR)      \
 419   DECL_VARIABLE_64BITS_SIGNED_VARIANTS(VAR);    \
 420   DECL_VARIABLE_64BITS_UNSIGNED_VARIANTS(VAR);  \
 421   DECL_VARIABLE(VAR, poly, 8, 8);               \
 422   DECL_VARIABLE(VAR, poly, 16, 4);              \
 423   DECL_VARIABLE(VAR, float, 32, 2)
 424
 425 /* Declare all 128 bits variants.  */
 426 #define DECL_VARIABLE_128BITS_VARIANTS(VAR)     \
 427   DECL_VARIABLE_128BITS_SIGNED_VARIANTS(VAR);   \
 428   DECL_VARIABLE_128BITS_UNSIGNED_VARIANTS(VAR); \
 429   DECL_VARIABLE(VAR, poly, 8, 16);              \
 430   DECL_VARIABLE(VAR, poly, 16, 8);              \
 431   DECL_VARIABLE(VAR, float, 32, 4)
 432
 433 /* Declare all variants.  */
 434 #define DECL_VARIABLE_ALL_VARIANTS(VAR)         \
 435   DECL_VARIABLE_64BITS_VARIANTS(VAR);           \
 436   DECL_VARIABLE_128BITS_VARIANTS(VAR)
 437
 438 /* Declare all signed variants.  */
 439 #define DECL_VARIABLE_SIGNED_VARIANTS(VAR)      \
 440   DECL_VARIABLE_64BITS_SIGNED_VARIANTS(VAR);    \
 441   DECL_VARIABLE_128BITS_SIGNED_VARIANTS(VAR)
 442
 443 /* Declare all unsigned variants.  */
 444 #define DECL_VARIABLE_UNSIGNED_VARIANTS(VAR)    \
 445   DECL_VARIABLE_64BITS_UNSIGNED_VARIANTS(VAR);  \
 446   DECL_VARIABLE_128BITS_UNSIGNED_VARIANTS(VAR)
 447
 448 /* Helpers to initialize vectors.  */
 449 #define VDUP(VAR, Q, T1, T2, W, N, V)                   \
 450   VECT_VAR(VAR, T1, W, N) = vdup##Q##_n_##T2##W(V)
 451
 452 #define VSET_LANE(VAR, Q, T1, T2, W, N, L, V)                           \
 453   VECT_VAR(VAR, T1, W, N) = vset##Q##_lane_##T2##W(V,                   \
 454                                                    VECT_VAR(VAR, T1, W, N), \
 455                                                    L)
 456
 457 /* We need to load initial values first, so rely on VLD1.  */
 458 #define VLOAD(VAR, BUF, Q, T1, T2, W, N)                                \
 459   VECT_VAR(VAR, T1, W, N) = vld1##Q##_##T2##W(VECT_VAR(BUF, T1, W, N))
 460
 461 /* Helpers to call macros with 1 constant and 5 variable
 462    arguments.  */
 463 #define TEST_MACRO_64BITS_SIGNED_VARIANTS_1_5(MACRO, VAR)       \
 464   MACRO(VAR, , int, s, 8, 8);                                   \
 465   MACRO(VAR, , int, s, 16, 4);                                  \
 466   MACRO(VAR, , int, s, 32, 2);                                  \
 467   MACRO(VAR, , int, s, 64, 1)
 468
 469 #define TEST_MACRO_64BITS_UNSIGNED_VARIANTS_1_5(MACRO, VAR)     \
 470   MACRO(VAR, , uint, u, 8, 8);                                  \
 471   MACRO(VAR, , uint, u, 16, 4);                                 \
 472   MACRO(VAR, , uint, u, 32, 2);                                 \
 473   MACRO(VAR, , uint, u, 64, 1)
 474
 475 #define TEST_MACRO_128BITS_SIGNED_VARIANTS_1_5(MACRO, VAR)      \
 476   MACRO(VAR, q, int, s, 8, 16);                                 \
 477   MACRO(VAR, q, int, s, 16, 8);                                 \
 478   MACRO(VAR, q, int, s, 32, 4);                                 \
 479   MACRO(VAR, q, int, s, 64, 2)
 480
 481 #define TEST_MACRO_128BITS_UNSIGNED_VARIANTS_1_5(MACRO,VAR)     \
 482   MACRO(VAR, q, uint, u, 8, 16);                                \
 483   MACRO(VAR, q, uint, u, 16, 8);                                \
 484   MACRO(VAR, q, uint, u, 32, 4);                                \
 485   MACRO(VAR, q, uint, u, 64, 2)
 486
 487 #define TEST_MACRO_64BITS_VARIANTS_1_5(MACRO, VAR)      \
 488   TEST_MACRO_64BITS_SIGNED_VARIANTS_1_5(MACRO, VAR);    \
 489   TEST_MACRO_64BITS_UNSIGNED_VARIANTS_1_5(MACRO, VAR)
 490
 491 #define TEST_MACRO_128BITS_VARIANTS_1_5(MACRO, VAR)     \
 492   TEST_MACRO_128BITS_SIGNED_VARIANTS_1_5(MACRO, VAR);   \
 493   TEST_MACRO_128BITS_UNSIGNED_VARIANTS_1_5(MACRO, VAR)
 494
 495 #define TEST_MACRO_ALL_VARIANTS_1_5(MACRO, VAR) \
 496   TEST_MACRO_64BITS_VARIANTS_1_5(MACRO, VAR);   \
 497   TEST_MACRO_128BITS_VARIANTS_1_5(MACRO, VAR)
 498
 499 #define TEST_MACRO_SIGNED_VARIANTS_1_5(MACRO, VAR)      \
 500   TEST_MACRO_64BITS_SIGNED_VARIANTS_1_5(MACRO, VAR);    \
 501   TEST_MACRO_128BITS_SIGNED_VARIANTS_1_5(MACRO, VAR)
 502
 503 /* Helpers to call macros with 2 constant and 5 variable
 504    arguments.  */
 505 #define TEST_MACRO_64BITS_SIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2)        \
 506   MACRO(VAR1, VAR2, , int, s, 8, 8);                                    \
 507   MACRO(VAR1, VAR2, , int, s, 16, 4);                                   \
 508   MACRO(VAR1, VAR2, , int, s, 32, 2);                                   \
 509   MACRO(VAR1, VAR2 , , int, s, 64, 1)
 510
 511 #define TEST_MACRO_64BITS_UNSIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2)      \
 512   MACRO(VAR1, VAR2, , uint, u, 8, 8);                                   \
 513   MACRO(VAR1, VAR2, , uint, u, 16, 4);                                  \
 514   MACRO(VAR1, VAR2, , uint, u, 32, 2);                                  \
 515   MACRO(VAR1, VAR2, , uint, u, 64, 1)
 516
 517 #define TEST_MACRO_128BITS_SIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2)       \
 518   MACRO(VAR1, VAR2, q, int, s, 8, 16);                                  \
 519   MACRO(VAR1, VAR2, q, int, s, 16, 8);                                  \
 520   MACRO(VAR1, VAR2, q, int, s, 32, 4);                                  \
 521   MACRO(VAR1, VAR2, q, int, s, 64, 2)
 522
 523 #define TEST_MACRO_128BITS_UNSIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2)     \
 524   MACRO(VAR1, VAR2, q, uint, u, 8, 16);                                 \
 525   MACRO(VAR1, VAR2, q, uint, u, 16, 8);                                 \
 526   MACRO(VAR1, VAR2, q, uint, u, 32, 4);                                 \
 527   MACRO(VAR1, VAR2, q, uint, u, 64, 2)
 528
 529 #define TEST_MACRO_64BITS_VARIANTS_2_5(MACRO, VAR1, VAR2)       \
 530   TEST_MACRO_64BITS_SIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2);     \
 531   TEST_MACRO_64BITS_UNSIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2);   \
 532   MACRO(VAR1, VAR2, , poly, p, 8, 8);                           \
 533   MACRO(VAR1, VAR2, , poly, p, 16, 4)
 534
 535 #define TEST_MACRO_128BITS_VARIANTS_2_5(MACRO, VAR1, VAR2)      \
 536   TEST_MACRO_128BITS_SIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2);    \
 537   TEST_MACRO_128BITS_UNSIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2);  \
 538   MACRO(VAR1, VAR2, q, poly, p, 8, 16);                         \
 539   MACRO(VAR1, VAR2, q, poly, p, 16, 8)
 540
 541 #define TEST_MACRO_ALL_VARIANTS_2_5(MACRO, VAR1, VAR2)  \
 542   TEST_MACRO_64BITS_VARIANTS_2_5(MACRO, VAR1, VAR2);    \
 543   TEST_MACRO_128BITS_VARIANTS_2_5(MACRO, VAR1, VAR2)
 544
 545 #define TEST_MACRO_SIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2)       \
 546   TEST_MACRO_64BITS_SIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2);     \
 547   TEST_MACRO_128BITS_SIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2)
 548
 549 #endif /* _ARM_NEON_REF_H_ */