gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vzip.c

   1 #include <arm_neon.h>
   2 #include "arm-neon-ref.h"
   3 #include "compute-ref-data.h"
   4
   5 /* Expected results splitted in several chunks.  */
   6 /* Chunk 0.  */
   7 VECT_VAR_DECL(expected0,int,8,8) [] = { 0xf0, 0xf4, 0x11, 0x11,
   8                                         0xf1, 0xf5, 0x11, 0x11 };
   9 VECT_VAR_DECL(expected0,int,16,4) [] = { 0xfff0, 0xfff2,
  10                                          0x22, 0x22 };
  11 VECT_VAR_DECL(expected0,int,32,2) [] = { 0xfffffff0, 0xfffffff1 };
  12 VECT_VAR_DECL(expected0,int,64,1) [] = { 0x3333333333333333 };
  13 VECT_VAR_DECL(expected0,uint,8,8) [] = { 0xf0, 0xf4, 0x55, 0x55,
  14                                          0xf1, 0xf5, 0x55, 0x55 };
  15 VECT_VAR_DECL(expected0,uint,16,4) [] = { 0xfff0, 0xfff2,
  16                                           0x66, 0x66 };
  17 VECT_VAR_DECL(expected0,uint,32,2) [] = { 0xfffffff0, 0xfffffff1 };
  18 VECT_VAR_DECL(expected0,uint,64,1) [] = { 0x3333333333333333 };
  19 VECT_VAR_DECL(expected0,poly,8,8) [] = { 0xf0, 0xf4, 0x55, 0x55,
  20                                          0xf1, 0xf5, 0x55, 0x55 };
  21 VECT_VAR_DECL(expected0,poly,16,4) [] = { 0xfff0, 0xfff2,
  22                                           0x66, 0x66 };
  23 VECT_VAR_DECL(expected0,hfloat,32,2) [] = { 0xc1800000, 0xc1700000 };
  24 VECT_VAR_DECL(expected0,int,8,16) [] = { 0xf0, 0xf8, 0x11, 0x11,
  25                                          0xf1, 0xf9, 0x11, 0x11,
  26                                          0xf2, 0xfa, 0x11, 0x11,
  27                                          0xf3, 0xfb, 0x11, 0x11 };
  28 VECT_VAR_DECL(expected0,int,16,8) [] = { 0xfff0, 0xfff4, 0x22, 0x22,
  29                                          0xfff1, 0xfff5, 0x22, 0x22 };
  30 VECT_VAR_DECL(expected0,int,32,4) [] = { 0xfffffff0, 0xfffffff2,
  31                                          0x33, 0x33 };
  32 VECT_VAR_DECL(expected0,int,64,2) [] = { 0x3333333333333333,
  33                                          0x3333333333333333 };
  34 VECT_VAR_DECL(expected0,uint,8,16) [] = { 0xf0, 0xf8, 0x55, 0x55,
  35                                           0xf1, 0xf9, 0x55, 0x55,
  36                                           0xf2, 0xfa, 0x55, 0x55,
  37                                           0xf3, 0xfb, 0x55, 0x55 };
  38 VECT_VAR_DECL(expected0,uint,16,8) [] = { 0xfff0, 0xfff4, 0x66, 0x66,
  39                                           0xfff1, 0xfff5, 0x66, 0x66 };
  40 VECT_VAR_DECL(expected0,uint,32,4) [] = { 0xfffffff0, 0xfffffff2,
  41                                           0x77, 0x77 };
  42 VECT_VAR_DECL(expected0,uint,64,2) [] = { 0x3333333333333333,
  43                                           0x3333333333333333 };
  44 VECT_VAR_DECL(expected0,poly,8,16) [] = { 0xf0, 0xf8, 0x55, 0x55,
  45                                           0xf1, 0xf9, 0x55, 0x55,
  46                                           0xf2, 0xfa, 0x55, 0x55,
  47                                           0xf3, 0xfb, 0x55, 0x55 };
  48 VECT_VAR_DECL(expected0,poly,16,8) [] = { 0xfff0, 0xfff4, 0x66, 0x66,
  49                                           0xfff1, 0xfff5, 0x66, 0x66 };
  50 VECT_VAR_DECL(expected0,hfloat,32,4) [] = { 0xc1800000, 0xc1600000,
  51                                             0x42073333, 0x42073333 };
  52
  53 /* Chunk 1.  */
  54 VECT_VAR_DECL(expected1,int,8,8) [] = { 0xf2, 0xf6, 0x11, 0x11,
  55                                         0xf3, 0xf7, 0x11, 0x11 };
  56 VECT_VAR_DECL(expected1,int,16,4) [] = { 0xfff1, 0xfff3,
  57                                          0x22, 0x22 };
  58 VECT_VAR_DECL(expected1,int,32,2) [] = { 0x33, 0x33 };
  59 VECT_VAR_DECL(expected1,int,64,1) [] = { 0x3333333333333333 };
  60 VECT_VAR_DECL(expected1,uint,8,8) [] = { 0xf2, 0xf6, 0x55, 0x55,
  61                                          0xf3, 0xf7, 0x55, 0x55 };
  62 VECT_VAR_DECL(expected1,uint,16,4) [] = { 0xfff1, 0xfff3,
  63                                           0x66, 0x66 };
  64 VECT_VAR_DECL(expected1,uint,32,2) [] = { 0x77, 0x77 };
  65 VECT_VAR_DECL(expected1,uint,64,1) [] = { 0x3333333333333333 };
  66 VECT_VAR_DECL(expected1,poly,8,8) [] = { 0xf2, 0xf6, 0x55, 0x55,
  67                                          0xf3, 0xf7, 0x55, 0x55 };
  68 VECT_VAR_DECL(expected1,poly,16,4) [] = { 0xfff1, 0xfff3,
  69                                           0x66, 0x66 };
  70 VECT_VAR_DECL(expected1,hfloat,32,2) [] = { 0x42066666, 0x42066666 };
  71 VECT_VAR_DECL(expected1,int,8,16) [] = { 0xf4, 0xfc, 0x11, 0x11,
  72                                          0xf5, 0xfd, 0x11, 0x11,
  73                                          0xf6, 0xfe, 0x11, 0x11,
  74                                          0xf7, 0xff, 0x11, 0x11 };
  75 VECT_VAR_DECL(expected1,int,16,8) [] = { 0xfff2, 0xfff6, 0x22, 0x22,
  76                                          0xfff3, 0xfff7, 0x22, 0x22 };
  77 VECT_VAR_DECL(expected1,int,32,4) [] = { 0xfffffff1, 0xfffffff3,
  78                                          0x33, 0x33 };
  79 VECT_VAR_DECL(expected1,int,64,2) [] = { 0x3333333333333333,
  80                                          0x3333333333333333 };
  81 VECT_VAR_DECL(expected1,uint,8,16) [] = { 0xf4, 0xfc, 0x55, 0x55,
  82                                           0xf5, 0xfd, 0x55, 0x55,
  83                                           0xf6, 0xfe, 0x55, 0x55,
  84                                           0xf7, 0xff, 0x55, 0x55 };
  85 VECT_VAR_DECL(expected1,uint,16,8) [] = { 0xfff2, 0xfff6, 0x66, 0x66,
  86                                           0xfff3, 0xfff7, 0x66, 0x66 };
  87 VECT_VAR_DECL(expected1,uint,32,4) [] = { 0xfffffff1, 0xfffffff3,
  88                                           0x77, 0x77 };
  89 VECT_VAR_DECL(expected1,uint,64,2) [] = { 0x3333333333333333,
  90                                           0x3333333333333333 };
  91 VECT_VAR_DECL(expected1,poly,8,16) [] = { 0xf4, 0xfc, 0x55, 0x55,
  92                                           0xf5, 0xfd, 0x55, 0x55,
  93                                           0xf6, 0xfe, 0x55, 0x55,
  94                                           0xf7, 0xff, 0x55, 0x55 };
  95 VECT_VAR_DECL(expected1,poly,16,8) [] = { 0xfff2, 0xfff6, 0x66, 0x66,
  96                                           0xfff3, 0xfff7, 0x66, 0x66 };
  97 VECT_VAR_DECL(expected1,hfloat,32,4) [] = { 0xc1700000, 0xc1500000,
  98                                             0x42073333, 0x42073333 };
  99
 100 #ifndef INSN_NAME
 101 #define INSN_NAME vzip
 102 #define TEST_MSG "VZIP/VZIPQ"
 103 #endif
 104
 105 #define FNNAME1(NAME) exec_ ## NAME
 106 #define FNNAME(NAME) FNNAME1(NAME)
 107
 108 void FNNAME (INSN_NAME) (void)
 109 {
 110   /* In this case, output variables are arrays of vectors.  */
 111 #define DECL_VZIP(T1, W, N)                                             \
 112   VECT_ARRAY_TYPE(T1, W, N, 2) VECT_ARRAY_VAR(result_vec, T1, W, N, 2); \
 113   VECT_VAR_DECL(result_bis, T1, W, N)[2 * N]
 114
 115   /* We need to use a temporary result buffer (result_bis), because
 116      the one used for other tests is not large enough. A subset of the
 117      result data is moved from result_bis to result, and it is this
 118      subset which is used to check the actual behaviour. The next
 119      macro enables to move another chunk of data from result_bis to
 120      result.  */
 121 #define TEST_VZIP(INSN, Q, T1, T2, W, N)                                \
 122   VECT_ARRAY_VAR(result_vec, T1, W, N, 2) =                             \
 123     INSN##Q##_##T2##W(VECT_VAR(vector1, T1, W, N),                      \
 124                       VECT_VAR(vector2, T1, W, N));                     \
 125   vst2##Q##_##T2##W(VECT_VAR(result_bis, T1, W, N),                     \
 126                     VECT_ARRAY_VAR(result_vec, T1, W, N, 2));           \
 127   memcpy(VECT_VAR(result, T1, W, N), VECT_VAR(result_bis, T1, W, N),    \
 128          sizeof(VECT_VAR(result, T1, W, N)));
 129
 130   /* Overwrite "result" with the contents of "result_bis"[X].  */
 131 #define TEST_EXTRA_CHUNK(T1, W, N, X)                                   \
 132   memcpy(VECT_VAR(result, T1, W, N), &(VECT_VAR(result_bis, T1, W, N)[X*N]), \
 133          sizeof(VECT_VAR(result, T1, W, N)));
 134
 135   DECL_VARIABLE_ALL_VARIANTS(vector1);
 136   DECL_VARIABLE_ALL_VARIANTS(vector2);
 137
 138   /* We don't need 64 bits variants.  */
 139 #define DECL_ALL_VZIP()                         \
 140   DECL_VZIP(int, 8, 8);                         \
 141   DECL_VZIP(int, 16, 4);                        \
 142   DECL_VZIP(int, 32, 2);                        \
 143   DECL_VZIP(uint, 8, 8);                        \
 144   DECL_VZIP(uint, 16, 4);                       \
 145   DECL_VZIP(uint, 32, 2);                       \
 146   DECL_VZIP(poly, 8, 8);                        \
 147   DECL_VZIP(poly, 16, 4);                       \
 148   DECL_VZIP(float, 32, 2);                      \
 149   DECL_VZIP(int, 8, 16);                        \
 150   DECL_VZIP(int, 16, 8);                        \
 151   DECL_VZIP(int, 32, 4);                        \
 152   DECL_VZIP(uint, 8, 16);                       \
 153   DECL_VZIP(uint, 16, 8);                       \
 154   DECL_VZIP(uint, 32, 4);                       \
 155   DECL_VZIP(poly, 8, 16);                       \
 156   DECL_VZIP(poly, 16, 8);                       \
 157   DECL_VZIP(float, 32, 4)
 158
 159   DECL_ALL_VZIP();
 160
 161   /* Initialize input "vector" from "buffer".  */
 162   TEST_MACRO_ALL_VARIANTS_2_5(VLOAD, vector1, buffer);
 163   VLOAD(vector1, buffer, , float, f, 32, 2);
 164   VLOAD(vector1, buffer, q, float, f, 32, 4);
 165
 166   /* Choose arbitrary initialization values.  */
 167   VDUP(vector2, , int, s, 8, 8, 0x11);
 168   VDUP(vector2, , int, s, 16, 4, 0x22);
 169   VDUP(vector2, , int, s, 32, 2, 0x33);
 170   VDUP(vector2, , uint, u, 8, 8, 0x55);
 171   VDUP(vector2, , uint, u, 16, 4, 0x66);
 172   VDUP(vector2, , uint, u, 32, 2, 0x77);
 173   VDUP(vector2, , poly, p, 8, 8, 0x55);
 174   VDUP(vector2, , poly, p, 16, 4, 0x66);
 175   VDUP(vector2, , float, f, 32, 2, 33.6f);
 176
 177   VDUP(vector2, q, int, s, 8, 16, 0x11);
 178   VDUP(vector2, q, int, s, 16, 8, 0x22);
 179   VDUP(vector2, q, int, s, 32, 4, 0x33);
 180   VDUP(vector2, q, uint, u, 8, 16, 0x55);
 181   VDUP(vector2, q, uint, u, 16, 8, 0x66);
 182   VDUP(vector2, q, uint, u, 32, 4, 0x77);
 183   VDUP(vector2, q, poly, p, 8, 16, 0x55);
 184   VDUP(vector2, q, poly, p, 16, 8, 0x66);
 185   VDUP(vector2, q, float, f, 32, 4, 33.8f);
 186
 187 #define TEST_ALL_VZIP(INSN)                     \
 188   TEST_VZIP(INSN, , int, s, 8, 8);              \
 189   TEST_VZIP(INSN, , int, s, 16, 4);             \
 190   TEST_VZIP(INSN, , int, s, 32, 2);             \
 191   TEST_VZIP(INSN, , uint, u, 8, 8);             \
 192   TEST_VZIP(INSN, , uint, u, 16, 4);            \
 193   TEST_VZIP(INSN, , uint, u, 32, 2);            \
 194   TEST_VZIP(INSN, , poly, p, 8, 8);             \
 195   TEST_VZIP(INSN, , poly, p, 16, 4);            \
 196   TEST_VZIP(INSN, , float, f, 32, 2);           \
 197   TEST_VZIP(INSN, q, int, s, 8, 16);            \
 198   TEST_VZIP(INSN, q, int, s, 16, 8);            \
 199   TEST_VZIP(INSN, q, int, s, 32, 4);            \
 200   TEST_VZIP(INSN, q, uint, u, 8, 16);           \
 201   TEST_VZIP(INSN, q, uint, u, 16, 8);           \
 202   TEST_VZIP(INSN, q, uint, u, 32, 4);           \
 203   TEST_VZIP(INSN, q, poly, p, 8, 16);           \
 204   TEST_VZIP(INSN, q, poly, p, 16, 8);           \
 205   TEST_VZIP(INSN, q, float, f, 32, 4)
 206
 207 #define TEST_ALL_EXTRA_CHUNKS()                 \
 208   TEST_EXTRA_CHUNK(int, 8, 8, 1);               \
 209   TEST_EXTRA_CHUNK(int, 16, 4, 1);              \
 210   TEST_EXTRA_CHUNK(int, 32, 2, 1);              \
 211   TEST_EXTRA_CHUNK(uint, 8, 8, 1);              \
 212   TEST_EXTRA_CHUNK(uint, 16, 4, 1);             \
 213   TEST_EXTRA_CHUNK(uint, 32, 2, 1);             \
 214   TEST_EXTRA_CHUNK(poly, 8, 8, 1);              \
 215   TEST_EXTRA_CHUNK(poly, 16, 4, 1);             \
 216   TEST_EXTRA_CHUNK(float, 32, 2, 1);            \
 217   TEST_EXTRA_CHUNK(int, 8, 16, 1);              \
 218   TEST_EXTRA_CHUNK(int, 16, 8, 1);              \
 219   TEST_EXTRA_CHUNK(int, 32, 4, 1);              \
 220   TEST_EXTRA_CHUNK(uint, 8, 16, 1);             \
 221   TEST_EXTRA_CHUNK(uint, 16, 8, 1);             \
 222   TEST_EXTRA_CHUNK(uint, 32, 4, 1);             \
 223   TEST_EXTRA_CHUNK(poly, 8, 16, 1);             \
 224   TEST_EXTRA_CHUNK(poly, 16, 8, 1);             \
 225   TEST_EXTRA_CHUNK(float, 32, 4, 1)
 226
 227   clean_results ();
 228
 229   /* Execute the tests.  */
 230   TEST_ALL_VZIP(INSN_NAME);
 231
 232   CHECK_RESULTS_NAMED (TEST_MSG, expected0, "(chunk 0)");
 233
 234   TEST_ALL_EXTRA_CHUNKS();
 235   CHECK_RESULTS_NAMED (TEST_MSG, expected1, "(chunk 1)");
 236 }
 237
 238 int main (void)
 239 {
 240   FNNAME (INSN_NAME) ();
 241
 242   return 0;
 243 }