1#define FNNAME1(NAME) exec_ ## NAME 2#define FNNAME(NAME) FNNAME1(NAME) 3 4void 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 behavior. 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#if defined (FP16_SUPPORTED) 57 DECL_VSHUFFLE (float, 16, 4); 58 DECL_VSHUFFLE (float, 16, 8); 59#endif 60 61 /* Initialize input "vector" from "buffer". */ 62 TEST_MACRO_ALL_VARIANTS_2_5(VLOAD, vector1, buffer); 63#if defined (FP16_SUPPORTED) 64 VLOAD (vector1, buffer, , float, f, 16, 4); 65 VLOAD (vector1, buffer, q, float, f, 16, 8); 66#endif 67 VLOAD(vector1, buffer, , float, f, 32, 2); 68 VLOAD(vector1, buffer, q, float, f, 32, 4); 69 70 /* Choose arbitrary initialization values. */ 71 VDUP(vector2, , int, s, 8, 8, 0x11); 72 VDUP(vector2, , int, s, 16, 4, 0x22); 73 VDUP(vector2, , int, s, 32, 2, 0x33); 74 VDUP(vector2, , uint, u, 8, 8, 0x55); 75 VDUP(vector2, , uint, u, 16, 4, 0x66); 76 VDUP(vector2, , uint, u, 32, 2, 0x77); 77 VDUP(vector2, , poly, p, 8, 8, 0x55); 78 VDUP(vector2, , poly, p, 16, 4, 0x66); 79#if defined (FP16_SUPPORTED) 80 VDUP (vector2, , float, f, 16, 4, 14.6f); /* 14.6f is 0x4b4d. */ 81#endif 82 VDUP(vector2, , float, f, 32, 2, 33.6f); 83 84 VDUP(vector2, q, int, s, 8, 16, 0x11); 85 VDUP(vector2, q, int, s, 16, 8, 0x22); 86 VDUP(vector2, q, int, s, 32, 4, 0x33); 87 VDUP(vector2, q, uint, u, 8, 16, 0x55); 88 VDUP(vector2, q, uint, u, 16, 8, 0x66); 89 VDUP(vector2, q, uint, u, 32, 4, 0x77); 90 VDUP(vector2, q, poly, p, 8, 16, 0x55); 91 VDUP(vector2, q, poly, p, 16, 8, 0x66); 92#if defined (FP16_SUPPORTED) 93 VDUP (vector2, q, float, f, 16, 8, 14.6f); 94#endif 95 VDUP(vector2, q, float, f, 32, 4, 33.8f); 96 97#define TEST_ALL_VSHUFFLE(INSN) \ 98 TEST_VSHUFFLE(INSN, , int, s, 8, 8); \ 99 TEST_VSHUFFLE(INSN, , int, s, 16, 4); \ 100 TEST_VSHUFFLE(INSN, , int, s, 32, 2); \ 101 TEST_VSHUFFLE(INSN, , uint, u, 8, 8); \ 102 TEST_VSHUFFLE(INSN, , uint, u, 16, 4); \ 103 TEST_VSHUFFLE(INSN, , uint, u, 32, 2); \ 104 TEST_VSHUFFLE(INSN, , poly, p, 8, 8); \ 105 TEST_VSHUFFLE(INSN, , poly, p, 16, 4); \ 106 TEST_VSHUFFLE(INSN, , float, f, 32, 2); \ 107 TEST_VSHUFFLE(INSN, q, int, s, 8, 16); \ 108 TEST_VSHUFFLE(INSN, q, int, s, 16, 8); \ 109 TEST_VSHUFFLE(INSN, q, int, s, 32, 4); \ 110 TEST_VSHUFFLE(INSN, q, uint, u, 8, 16); \ 111 TEST_VSHUFFLE(INSN, q, uint, u, 16, 8); \ 112 TEST_VSHUFFLE(INSN, q, uint, u, 32, 4); \ 113 TEST_VSHUFFLE(INSN, q, poly, p, 8, 16); \ 114 TEST_VSHUFFLE(INSN, q, poly, p, 16, 8); \ 115 TEST_VSHUFFLE(INSN, q, float, f, 32, 4) 116 117#define TEST_VSHUFFLE_FP16(INSN) \ 118 TEST_VSHUFFLE(INSN, , float, f, 16, 4); \ 119 TEST_VSHUFFLE(INSN, q, float, f, 16, 8); 120 121#define TEST_ALL_EXTRA_CHUNKS() \ 122 TEST_EXTRA_CHUNK(int, 8, 8, 1); \ 123 TEST_EXTRA_CHUNK(int, 16, 4, 1); \ 124 TEST_EXTRA_CHUNK(int, 32, 2, 1); \ 125 TEST_EXTRA_CHUNK(uint, 8, 8, 1); \ 126 TEST_EXTRA_CHUNK(uint, 16, 4, 1); \ 127 TEST_EXTRA_CHUNK(uint, 32, 2, 1); \ 128 TEST_EXTRA_CHUNK(poly, 8, 8, 1); \ 129 TEST_EXTRA_CHUNK(poly, 16, 4, 1); \ 130 TEST_EXTRA_CHUNK(float, 32, 2, 1); \ 131 TEST_EXTRA_CHUNK(int, 8, 16, 1); \ 132 TEST_EXTRA_CHUNK(int, 16, 8, 1); \ 133 TEST_EXTRA_CHUNK(int, 32, 4, 1); \ 134 TEST_EXTRA_CHUNK(uint, 8, 16, 1); \ 135 TEST_EXTRA_CHUNK(uint, 16, 8, 1); \ 136 TEST_EXTRA_CHUNK(uint, 32, 4, 1); \ 137 TEST_EXTRA_CHUNK(poly, 8, 16, 1); \ 138 TEST_EXTRA_CHUNK(poly, 16, 8, 1); \ 139 TEST_EXTRA_CHUNK(float, 32, 4, 1) 140 141 /* vshuffle support all vector types except [u]int64x1 and 142 [u]int64x2. */ 143#define CHECK_RESULTS_VSHUFFLE(test_name,EXPECTED,comment) \ 144 { \ 145 CHECK(test_name, int, 8, 8, PRIx8, EXPECTED, comment); \ 146 CHECK(test_name, int, 16, 4, PRIx16, EXPECTED, comment); \ 147 CHECK(test_name, int, 32, 2, PRIx32, EXPECTED, comment); \ 148 CHECK(test_name, uint, 8, 8, PRIx8, EXPECTED, comment); \ 149 CHECK(test_name, uint, 16, 4, PRIx16, EXPECTED, comment); \ 150 CHECK(test_name, uint, 32, 2, PRIx32, EXPECTED, comment); \ 151 CHECK_POLY(test_name, poly, 8, 8, PRIx8, EXPECTED, comment); \ 152 CHECK_POLY(test_name, poly, 16, 4, PRIx16, EXPECTED, comment); \ 153 CHECK_FP(test_name, float, 32, 2, PRIx32, EXPECTED, comment); \ 154 \ 155 CHECK(test_name, int, 8, 16, PRIx8, EXPECTED, comment); \ 156 CHECK(test_name, int, 16, 8, PRIx16, EXPECTED, comment); \ 157 CHECK(test_name, int, 32, 4, PRIx32, EXPECTED, comment); \ 158 CHECK(test_name, uint, 8, 16, PRIx8, EXPECTED, comment); \ 159 CHECK(test_name, uint, 16, 8, PRIx16, EXPECTED, comment); \ 160 CHECK(test_name, uint, 32, 4, PRIx32, EXPECTED, comment); \ 161 CHECK_POLY(test_name, poly, 8, 16, PRIx8, EXPECTED, comment); \ 162 CHECK_POLY(test_name, poly, 16, 8, PRIx16, EXPECTED, comment); \ 163 CHECK_FP(test_name, float, 32, 4, PRIx32, EXPECTED, comment); \ 164 } 165 166#define CHECK_RESULTS_VSHUFFLE_FP16(test_name,EXPECTED,comment) \ 167 { \ 168 CHECK_FP (test_name, float, 16, 4, PRIx16, EXPECTED, comment); \ 169 CHECK_FP (test_name, float, 16, 8, PRIx16, EXPECTED, comment); \ 170 } 171 172 clean_results (); 173 174 /* Execute the tests. */ 175 TEST_ALL_VSHUFFLE(INSN_NAME); 176#if defined (FP16_SUPPORTED) 177 TEST_VSHUFFLE_FP16 (INSN_NAME); 178#endif 179 180 CHECK_RESULTS_VSHUFFLE (TEST_MSG, expected0, "(chunk 0)"); 181#if defined (FP16_SUPPORTED) 182 CHECK_RESULTS_VSHUFFLE_FP16 (TEST_MSG, expected0, "(chunk 0)"); 183#endif 184 185 TEST_ALL_EXTRA_CHUNKS(); 186#if defined (FP16_SUPPORTED) 187 TEST_EXTRA_CHUNK (float, 16, 4, 1); 188 TEST_EXTRA_CHUNK (float, 16, 8, 1); 189#endif 190 191 CHECK_RESULTS_VSHUFFLE (TEST_MSG, expected1, "(chunk 1)"); 192#if defined (FP16_SUPPORTED) 193 CHECK_RESULTS_VSHUFFLE_FP16 (TEST_MSG, expected1, "(chunk 1)"); 194#endif 195} 196 197int main (void) 198{ 199 FNNAME (INSN_NAME) (); 200 201 return 0; 202} 203