gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vshuffle.inc

   1 #define FNNAME1(NAME) exec_ ## NAME
   2 #define FNNAME(NAME) FNNAME1(NAME)
   3
   4 void FNNAME (INSN_NAME) (void)
   5 {
   6   /* In this case, output variables are arrays of vectors.  */
   7 #define DECL_VSHUFFLE(T1, W, N)                                         \
   8   VECT_ARRAY_TYPE(T1, W, N, 2) VECT_ARRAY_VAR(result_vec, T1, W, N, 2); \
   9   VECT_VAR_DECL(result_bis, T1, W, N)[2 * N]
  10
  11   /* We need to use a temporary result buffer (result_bis), because
  12      the one used for other tests is not large enough. A subset of the
  13      result data is moved from result_bis to result, and it is this
  14      subset which is used to check the actual behaviour. The next
  15      macro enables to move another chunk of data from result_bis to
  16      result.  */
  17 #define TEST_VSHUFFLE(INSN, Q, T1, T2, W, N)                            \
  18   VECT_ARRAY_VAR(result_vec, T1, W, N, 2) =                             \
  19     INSN##Q##_##T2##W(VECT_VAR(vector1, T1, W, N),                      \
  20                       VECT_VAR(vector2, T1, W, N));                     \
  21   vst2##Q##_##T2##W(VECT_VAR(result_bis, T1, W, N),                     \
  22                     VECT_ARRAY_VAR(result_vec, T1, W, N, 2));           \
  23   memcpy(VECT_VAR(result, T1, W, N), VECT_VAR(result_bis, T1, W, N),    \
  24          sizeof(VECT_VAR(result, T1, W, N)));
  25
  26   /* Overwrite "result" with the contents of "result_bis"[X].  */
  27 #define TEST_EXTRA_CHUNK(T1, W, N, X)                                   \
  28   memcpy(VECT_VAR(result, T1, W, N), &(VECT_VAR(result_bis, T1, W, N)[X*N]), \
  29          sizeof(VECT_VAR(result, T1, W, N)));
  30
  31   DECL_VARIABLE_ALL_VARIANTS(vector1);
  32   DECL_VARIABLE_ALL_VARIANTS(vector2);
  33
  34   /* We don't need 64 bits variants.  */
  35 #define DECL_ALL_VSHUFFLE()                             \
  36   DECL_VSHUFFLE(int, 8, 8);                             \
  37   DECL_VSHUFFLE(int, 16, 4);                            \
  38   DECL_VSHUFFLE(int, 32, 2);                            \
  39   DECL_VSHUFFLE(uint, 8, 8);                            \
  40   DECL_VSHUFFLE(uint, 16, 4);                           \
  41   DECL_VSHUFFLE(uint, 32, 2);                           \
  42   DECL_VSHUFFLE(poly, 8, 8);                            \
  43   DECL_VSHUFFLE(poly, 16, 4);                           \
  44   DECL_VSHUFFLE(float, 32, 2);                          \
  45   DECL_VSHUFFLE(int, 8, 16);                            \
  46   DECL_VSHUFFLE(int, 16, 8);                            \
  47   DECL_VSHUFFLE(int, 32, 4);                            \
  48   DECL_VSHUFFLE(uint, 8, 16);                           \
  49   DECL_VSHUFFLE(uint, 16, 8);                           \
  50   DECL_VSHUFFLE(uint, 32, 4);                           \
  51   DECL_VSHUFFLE(poly, 8, 16);                           \
  52   DECL_VSHUFFLE(poly, 16, 8);                           \
  53   DECL_VSHUFFLE(float, 32, 4)
  54
  55   DECL_ALL_VSHUFFLE();
  56
  57   /* Initialize input "vector" from "buffer".  */
  58   TEST_MACRO_ALL_VARIANTS_2_5(VLOAD, vector1, buffer);
  59   VLOAD(vector1, buffer, , float, f, 32, 2);
  60   VLOAD(vector1, buffer, q, float, f, 32, 4);
  61
  62   /* Choose arbitrary initialization values.  */
  63   VDUP(vector2, , int, s, 8, 8, 0x11);
  64   VDUP(vector2, , int, s, 16, 4, 0x22);
  65   VDUP(vector2, , int, s, 32, 2, 0x33);
  66   VDUP(vector2, , uint, u, 8, 8, 0x55);
  67   VDUP(vector2, , uint, u, 16, 4, 0x66);
  68   VDUP(vector2, , uint, u, 32, 2, 0x77);
  69   VDUP(vector2, , poly, p, 8, 8, 0x55);
  70   VDUP(vector2, , poly, p, 16, 4, 0x66);
  71   VDUP(vector2, , float, f, 32, 2, 33.6f);
  72
  73   VDUP(vector2, q, int, s, 8, 16, 0x11);
  74   VDUP(vector2, q, int, s, 16, 8, 0x22);
  75   VDUP(vector2, q, int, s, 32, 4, 0x33);
  76   VDUP(vector2, q, uint, u, 8, 16, 0x55);
  77   VDUP(vector2, q, uint, u, 16, 8, 0x66);
  78   VDUP(vector2, q, uint, u, 32, 4, 0x77);
  79   VDUP(vector2, q, poly, p, 8, 16, 0x55);
  80   VDUP(vector2, q, poly, p, 16, 8, 0x66);
  81   VDUP(vector2, q, float, f, 32, 4, 33.8f);
  82
  83 #define TEST_ALL_VSHUFFLE(INSN)                         \
  84   TEST_VSHUFFLE(INSN, , int, s, 8, 8);                  \
  85   TEST_VSHUFFLE(INSN, , int, s, 16, 4);                 \
  86   TEST_VSHUFFLE(INSN, , int, s, 32, 2);                 \
  87   TEST_VSHUFFLE(INSN, , uint, u, 8, 8);                 \
  88   TEST_VSHUFFLE(INSN, , uint, u, 16, 4);                \
  89   TEST_VSHUFFLE(INSN, , uint, u, 32, 2);                \
  90   TEST_VSHUFFLE(INSN, , poly, p, 8, 8);                 \
  91   TEST_VSHUFFLE(INSN, , poly, p, 16, 4);                \
  92   TEST_VSHUFFLE(INSN, , float, f, 32, 2);               \
  93   TEST_VSHUFFLE(INSN, q, int, s, 8, 16);                \
  94   TEST_VSHUFFLE(INSN, q, int, s, 16, 8);                \
  95   TEST_VSHUFFLE(INSN, q, int, s, 32, 4);                \
  96   TEST_VSHUFFLE(INSN, q, uint, u, 8, 16);               \
  97   TEST_VSHUFFLE(INSN, q, uint, u, 16, 8);               \
  98   TEST_VSHUFFLE(INSN, q, uint, u, 32, 4);               \
  99   TEST_VSHUFFLE(INSN, q, poly, p, 8, 16);               \
 100   TEST_VSHUFFLE(INSN, q, poly, p, 16, 8);               \
 101   TEST_VSHUFFLE(INSN, q, float, f, 32, 4)
 102
 103 #define TEST_ALL_EXTRA_CHUNKS()                 \
 104   TEST_EXTRA_CHUNK(int, 8, 8, 1);               \
 105   TEST_EXTRA_CHUNK(int, 16, 4, 1);              \
 106   TEST_EXTRA_CHUNK(int, 32, 2, 1);              \
 107   TEST_EXTRA_CHUNK(uint, 8, 8, 1);              \
 108   TEST_EXTRA_CHUNK(uint, 16, 4, 1);             \
 109   TEST_EXTRA_CHUNK(uint, 32, 2, 1);             \
 110   TEST_EXTRA_CHUNK(poly, 8, 8, 1);              \
 111   TEST_EXTRA_CHUNK(poly, 16, 4, 1);             \
 112   TEST_EXTRA_CHUNK(float, 32, 2, 1);            \
 113   TEST_EXTRA_CHUNK(int, 8, 16, 1);              \
 114   TEST_EXTRA_CHUNK(int, 16, 8, 1);              \
 115   TEST_EXTRA_CHUNK(int, 32, 4, 1);              \
 116   TEST_EXTRA_CHUNK(uint, 8, 16, 1);             \
 117   TEST_EXTRA_CHUNK(uint, 16, 8, 1);             \
 118   TEST_EXTRA_CHUNK(uint, 32, 4, 1);             \
 119   TEST_EXTRA_CHUNK(poly, 8, 16, 1);             \
 120   TEST_EXTRA_CHUNK(poly, 16, 8, 1);             \
 121   TEST_EXTRA_CHUNK(float, 32, 4, 1)
 122
 123   /* vshuffle support all vector types except [u]int64x1 and
 124      [u]int64x2.  */
 125 #define CHECK_RESULTS_VSHUFFLE(test_name,EXPECTED,comment)              \
 126   {                                                                     \
 127     CHECK(test_name, int, 8, 8, PRIx8, EXPECTED, comment);              \
 128     CHECK(test_name, int, 16, 4, PRIx16, EXPECTED, comment);            \
 129     CHECK(test_name, int, 32, 2, PRIx32, EXPECTED, comment);            \
 130     CHECK(test_name, uint, 8, 8, PRIx8, EXPECTED, comment);             \
 131     CHECK(test_name, uint, 16, 4, PRIx16, EXPECTED, comment);           \
 132     CHECK(test_name, uint, 32, 2, PRIx32, EXPECTED, comment);           \
 133     CHECK(test_name, poly, 8, 8, PRIx8, EXPECTED, comment);             \
 134     CHECK(test_name, poly, 16, 4, PRIx16, EXPECTED, comment);           \
 135     CHECK_FP(test_name, float, 32, 2, PRIx32, EXPECTED, comment);       \
 136                                                                         \
 137     CHECK(test_name, int, 8, 16, PRIx8, EXPECTED, comment);             \
 138     CHECK(test_name, int, 16, 8, PRIx16, EXPECTED, comment);            \
 139     CHECK(test_name, int, 32, 4, PRIx32, EXPECTED, comment);            \
 140     CHECK(test_name, uint, 8, 16, PRIx8, EXPECTED, comment);            \
 141     CHECK(test_name, uint, 16, 8, PRIx16, EXPECTED, comment);           \
 142     CHECK(test_name, uint, 32, 4, PRIx32, EXPECTED, comment);           \
 143     CHECK(test_name, poly, 8, 16, PRIx8, EXPECTED, comment);            \
 144     CHECK(test_name, poly, 16, 8, PRIx16, EXPECTED, comment);           \
 145     CHECK_FP(test_name, float, 32, 4, PRIx32, EXPECTED, comment);       \
 146   }                                                                     \
 147
 148   clean_results ();
 149
 150   /* Execute the tests.  */
 151   TEST_ALL_VSHUFFLE(INSN_NAME);
 152
 153   CHECK_RESULTS_VSHUFFLE (TEST_MSG, expected0, "(chunk 0)");
 154
 155   TEST_ALL_EXTRA_CHUNKS();
 156   CHECK_RESULTS_VSHUFFLE (TEST_MSG, expected1, "(chunk 1)");
 157 }
 158
 159 int main (void)
 160 {
 161   FNNAME (INSN_NAME) ();
 162
 163   return 0;
 164 }