Debian Codegraph @

gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vdup-vmov.c

raw
1 #include <arm_neon.h>
2 #include "arm-neon-ref.h"
3 #include "compute-ref-data.h"
4
5 /* We test vdup and vmov in the same place since they are aliases. */
6
7 /* Expected results. */
8 /* Chunk 0. */
9 VECT_VAR_DECL(expected0,int,8,8) [] = { 0xf0, 0xf0, 0xf0, 0xf0,
10 0xf0, 0xf0, 0xf0, 0xf0 };
11 VECT_VAR_DECL(expected0,int,16,4) [] = { 0xfff0, 0xfff0, 0xfff0, 0xfff0 };
12 VECT_VAR_DECL(expected0,int,32,2) [] = { 0xfffffff0, 0xfffffff0 };
13 VECT_VAR_DECL(expected0,int,64,1) [] = { 0xfffffffffffffff0 };
14 VECT_VAR_DECL(expected0,uint,8,8) [] = { 0xf0, 0xf0, 0xf0, 0xf0,
15 0xf0, 0xf0, 0xf0, 0xf0 };
16 VECT_VAR_DECL(expected0,uint,16,4) [] = { 0xfff0, 0xfff0, 0xfff0, 0xfff0 };
17 VECT_VAR_DECL(expected0,uint,32,2) [] = { 0xfffffff0, 0xfffffff0 };
18 VECT_VAR_DECL(expected0,uint,64,1) [] = { 0xfffffffffffffff0 };
19 VECT_VAR_DECL(expected0,poly,8,8) [] = { 0xf0, 0xf0, 0xf0, 0xf0,
20 0xf0, 0xf0, 0xf0, 0xf0 };
21 VECT_VAR_DECL(expected0,poly,16,4) [] = { 0xfff0, 0xfff0, 0xfff0, 0xfff0 };
22 #if MFLOAT8_SUPPORTED
23 VECT_VAR_DECL(expected0,hmfloat,8,8) [] = { 0xf0, 0xf0, 0xf0, 0xf0,
24 0xf0, 0xf0, 0xf0, 0xf0 };
25 #endif
26 #if defined (FP16_SUPPORTED)
27 VECT_VAR_DECL (expected0, hfloat, 16, 4) [] = { 0xcc00, 0xcc00,
28 0xcc00, 0xcc00 };
29 #endif
30 VECT_VAR_DECL(expected0,hfloat,32,2) [] = { 0xc1800000, 0xc1800000 };
31 VECT_VAR_DECL(expected0,int,8,16) [] = { 0xf0, 0xf0, 0xf0, 0xf0,
32 0xf0, 0xf0, 0xf0, 0xf0,
33 0xf0, 0xf0, 0xf0, 0xf0,
34 0xf0, 0xf0, 0xf0, 0xf0 };
35 VECT_VAR_DECL(expected0,int,16,8) [] = { 0xfff0, 0xfff0, 0xfff0, 0xfff0,
36 0xfff0, 0xfff0, 0xfff0, 0xfff0 };
37 VECT_VAR_DECL(expected0,int,32,4) [] = { 0xfffffff0, 0xfffffff0,
38 0xfffffff0, 0xfffffff0 };
39 VECT_VAR_DECL(expected0,int,64,2) [] = { 0xfffffffffffffff0,
40 0xfffffffffffffff0 };
41 VECT_VAR_DECL(expected0,uint,8,16) [] = { 0xf0, 0xf0, 0xf0, 0xf0,
42 0xf0, 0xf0, 0xf0, 0xf0,
43 0xf0, 0xf0, 0xf0, 0xf0,
44 0xf0, 0xf0, 0xf0, 0xf0 };
45 VECT_VAR_DECL(expected0,uint,16,8) [] = { 0xfff0, 0xfff0, 0xfff0, 0xfff0,
46 0xfff0, 0xfff0, 0xfff0, 0xfff0 };
47 VECT_VAR_DECL(expected0,uint,32,4) [] = { 0xfffffff0, 0xfffffff0,
48 0xfffffff0, 0xfffffff0 };
49 VECT_VAR_DECL(expected0,uint,64,2) [] = { 0xfffffffffffffff0,
50 0xfffffffffffffff0 };
51 VECT_VAR_DECL(expected0,poly,8,16) [] = { 0xf0, 0xf0, 0xf0, 0xf0,
52 0xf0, 0xf0, 0xf0, 0xf0,
53 0xf0, 0xf0, 0xf0, 0xf0,
54 0xf0, 0xf0, 0xf0, 0xf0 };
55 VECT_VAR_DECL(expected0,poly,16,8) [] = { 0xfff0, 0xfff0, 0xfff0, 0xfff0,
56 0xfff0, 0xfff0, 0xfff0, 0xfff0 };
57 #if MFLOAT8_SUPPORTED
58 VECT_VAR_DECL(expected0,hmfloat,8,16) [] = { 0xf0, 0xf0, 0xf0, 0xf0,
59 0xf0, 0xf0, 0xf0, 0xf0,
60 0xf0, 0xf0, 0xf0, 0xf0,
61 0xf0, 0xf0, 0xf0, 0xf0 };
62 #endif
63 #if defined (FP16_SUPPORTED)
64 VECT_VAR_DECL (expected0, hfloat, 16, 8) [] = { 0xcc00, 0xcc00,
65 0xcc00, 0xcc00,
66 0xcc00, 0xcc00,
67 0xcc00, 0xcc00 };
68 #endif
69 VECT_VAR_DECL(expected0,hfloat,32,4) [] = { 0xc1800000, 0xc1800000,
70 0xc1800000, 0xc1800000 };
71
72 /* Chunk 1. */
73 VECT_VAR_DECL(expected1,int,8,8) [] = { 0xf1, 0xf1, 0xf1, 0xf1,
74 0xf1, 0xf1, 0xf1, 0xf1 };
75 VECT_VAR_DECL(expected1,int,16,4) [] = { 0xfff1, 0xfff1, 0xfff1, 0xfff1 };
76 VECT_VAR_DECL(expected1,int,32,2) [] = { 0xfffffff1, 0xfffffff1 };
77 VECT_VAR_DECL(expected1,int,64,1) [] = { 0xfffffffffffffff1 };
78 VECT_VAR_DECL(expected1,uint,8,8) [] = { 0xf1, 0xf1, 0xf1, 0xf1,
79 0xf1, 0xf1, 0xf1, 0xf1 };
80 VECT_VAR_DECL(expected1,uint,16,4) [] = { 0xfff1, 0xfff1, 0xfff1, 0xfff1 };
81 VECT_VAR_DECL(expected1,uint,32,2) [] = { 0xfffffff1, 0xfffffff1 };
82 VECT_VAR_DECL(expected1,uint,64,1) [] = { 0xfffffffffffffff1 };
83 VECT_VAR_DECL(expected1,poly,8,8) [] = { 0xf1, 0xf1, 0xf1, 0xf1,
84 0xf1, 0xf1, 0xf1, 0xf1 };
85 VECT_VAR_DECL(expected1,poly,16,4) [] = { 0xfff1, 0xfff1, 0xfff1, 0xfff1 };
86 #if MFLOAT8_SUPPORTED
87 VECT_VAR_DECL(expected1,hmfloat,8,8) [] = { 0xf1, 0xf1, 0xf1, 0xf1,
88 0xf1, 0xf1, 0xf1, 0xf1 };
89 #endif
90 #if defined (FP16_SUPPORTED)
91 VECT_VAR_DECL (expected1, hfloat, 16, 4) [] = { 0xcb80, 0xcb80,
92 0xcb80, 0xcb80 };
93 #endif
94 VECT_VAR_DECL(expected1,hfloat,32,2) [] = { 0xc1700000, 0xc1700000 };
95 VECT_VAR_DECL(expected1,int,8,16) [] = { 0xf1, 0xf1, 0xf1, 0xf1,
96 0xf1, 0xf1, 0xf1, 0xf1,
97 0xf1, 0xf1, 0xf1, 0xf1,
98 0xf1, 0xf1, 0xf1, 0xf1 };
99 VECT_VAR_DECL(expected1,int,16,8) [] = { 0xfff1, 0xfff1, 0xfff1, 0xfff1,
100 0xfff1, 0xfff1, 0xfff1, 0xfff1 };
101 VECT_VAR_DECL(expected1,int,32,4) [] = { 0xfffffff1, 0xfffffff1,
102 0xfffffff1, 0xfffffff1 };
103 VECT_VAR_DECL(expected1,int,64,2) [] = { 0xfffffffffffffff1,
104 0xfffffffffffffff1 };
105 VECT_VAR_DECL(expected1,uint,8,16) [] = { 0xf1, 0xf1, 0xf1, 0xf1,
106 0xf1, 0xf1, 0xf1, 0xf1,
107 0xf1, 0xf1, 0xf1, 0xf1,
108 0xf1, 0xf1, 0xf1, 0xf1 };
109 VECT_VAR_DECL(expected1,uint,16,8) [] = { 0xfff1, 0xfff1, 0xfff1, 0xfff1,
110 0xfff1, 0xfff1, 0xfff1, 0xfff1 };
111 VECT_VAR_DECL(expected1,uint,32,4) [] = { 0xfffffff1, 0xfffffff1,
112 0xfffffff1, 0xfffffff1 };
113 VECT_VAR_DECL(expected1,uint,64,2) [] = { 0xfffffffffffffff1,
114 0xfffffffffffffff1 };
115 VECT_VAR_DECL(expected1,poly,8,16) [] = { 0xf1, 0xf1, 0xf1, 0xf1,
116 0xf1, 0xf1, 0xf1, 0xf1,
117 0xf1, 0xf1, 0xf1, 0xf1,
118 0xf1, 0xf1, 0xf1, 0xf1 };
119 VECT_VAR_DECL(expected1,poly,16,8) [] = { 0xfff1, 0xfff1, 0xfff1, 0xfff1,
120 0xfff1, 0xfff1, 0xfff1, 0xfff1 };
121 #if MFLOAT8_SUPPORTED
122 VECT_VAR_DECL(expected1,hmfloat,8,16) [] = { 0xf1, 0xf1, 0xf1, 0xf1,
123 0xf1, 0xf1, 0xf1, 0xf1,
124 0xf1, 0xf1, 0xf1, 0xf1,
125 0xf1, 0xf1, 0xf1, 0xf1 };
126 #endif
127 #if defined (FP16_SUPPORTED)
128 VECT_VAR_DECL (expected1, hfloat, 16, 8) [] = { 0xcb80, 0xcb80,
129 0xcb80, 0xcb80,
130 0xcb80, 0xcb80,
131 0xcb80, 0xcb80 };
132 #endif
133 VECT_VAR_DECL(expected1,hfloat,32,4) [] = { 0xc1700000, 0xc1700000,
134 0xc1700000, 0xc1700000 };
135
136 /* Chunk 2. */
137 VECT_VAR_DECL(expected2,int,8,8) [] = { 0xf2, 0xf2, 0xf2, 0xf2,
138 0xf2, 0xf2, 0xf2, 0xf2 };
139 VECT_VAR_DECL(expected2,int,16,4) [] = { 0xfff2, 0xfff2, 0xfff2, 0xfff2 };
140 VECT_VAR_DECL(expected2,int,32,2) [] = { 0xfffffff2, 0xfffffff2 };
141 VECT_VAR_DECL(expected2,int,64,1) [] = { 0xfffffffffffffff2 };
142 VECT_VAR_DECL(expected2,uint,8,8) [] = { 0xf2, 0xf2, 0xf2, 0xf2,
143 0xf2, 0xf2, 0xf2, 0xf2 };
144 VECT_VAR_DECL(expected2,uint,16,4) [] = { 0xfff2, 0xfff2, 0xfff2, 0xfff2 };
145 VECT_VAR_DECL(expected2,uint,32,2) [] = { 0xfffffff2, 0xfffffff2 };
146 VECT_VAR_DECL(expected2,uint,64,1) [] = { 0xfffffffffffffff2 };
147 VECT_VAR_DECL(expected2,poly,8,8) [] = { 0xf2, 0xf2, 0xf2, 0xf2,
148 0xf2, 0xf2, 0xf2, 0xf2 };
149 VECT_VAR_DECL(expected2,poly,16,4) [] = { 0xfff2, 0xfff2, 0xfff2, 0xfff2 };
150 #if MFLOAT8_SUPPORTED
151 VECT_VAR_DECL(expected2,hmfloat,8,8) [] = { 0xf2, 0xf2, 0xf2, 0xf2,
152 0xf2, 0xf2, 0xf2, 0xf2 };
153 #endif
154 #if defined (FP16_SUPPORTED)
155 VECT_VAR_DECL (expected2, hfloat, 16, 4) [] = { 0xcb00, 0xcb00,
156 0xcb00, 0xcb00 };
157 #endif
158 VECT_VAR_DECL(expected2,hfloat,32,2) [] = { 0xc1600000, 0xc1600000 };
159 VECT_VAR_DECL(expected2,int,8,16) [] = { 0xf2, 0xf2, 0xf2, 0xf2,
160 0xf2, 0xf2, 0xf2, 0xf2,
161 0xf2, 0xf2, 0xf2, 0xf2,
162 0xf2, 0xf2, 0xf2, 0xf2 };
163 VECT_VAR_DECL(expected2,int,16,8) [] = { 0xfff2, 0xfff2, 0xfff2, 0xfff2,
164 0xfff2, 0xfff2, 0xfff2, 0xfff2 };
165 VECT_VAR_DECL(expected2,int,32,4) [] = { 0xfffffff2, 0xfffffff2,
166 0xfffffff2, 0xfffffff2 };
167 VECT_VAR_DECL(expected2,int,64,2) [] = { 0xfffffffffffffff2,
168 0xfffffffffffffff2 };
169 VECT_VAR_DECL(expected2,uint,8,16) [] = { 0xf2, 0xf2, 0xf2, 0xf2,
170 0xf2, 0xf2, 0xf2, 0xf2,
171 0xf2, 0xf2, 0xf2, 0xf2,
172 0xf2, 0xf2, 0xf2, 0xf2 };
173 VECT_VAR_DECL(expected2,uint,16,8) [] = { 0xfff2, 0xfff2, 0xfff2, 0xfff2,
174 0xfff2, 0xfff2, 0xfff2, 0xfff2 };
175 VECT_VAR_DECL(expected2,uint,32,4) [] = { 0xfffffff2, 0xfffffff2,
176 0xfffffff2, 0xfffffff2 };
177 VECT_VAR_DECL(expected2,uint,64,2) [] = { 0xfffffffffffffff2,
178 0xfffffffffffffff2 };
179 VECT_VAR_DECL(expected2,poly,8,16) [] = { 0xf2, 0xf2, 0xf2, 0xf2,
180 0xf2, 0xf2, 0xf2, 0xf2,
181 0xf2, 0xf2, 0xf2, 0xf2,
182 0xf2, 0xf2, 0xf2, 0xf2 };
183 VECT_VAR_DECL(expected2,poly,16,8) [] = { 0xfff2, 0xfff2, 0xfff2, 0xfff2,
184 0xfff2, 0xfff2, 0xfff2, 0xfff2 };
185 #if MFLOAT8_SUPPORTED
186 VECT_VAR_DECL(expected2,hmfloat,8,16) [] = { 0xf2, 0xf2, 0xf2, 0xf2,
187 0xf2, 0xf2, 0xf2, 0xf2,
188 0xf2, 0xf2, 0xf2, 0xf2,
189 0xf2, 0xf2, 0xf2, 0xf2 };
190 #endif
191 #if defined (FP16_SUPPORTED)
192 VECT_VAR_DECL (expected2, hfloat, 16, 8) [] = { 0xcb00, 0xcb00,
193 0xcb00, 0xcb00,
194 0xcb00, 0xcb00,
195 0xcb00, 0xcb00 };
196 #endif
197 VECT_VAR_DECL(expected2,hfloat,32,4) [] = { 0xc1600000, 0xc1600000,
198 0xc1600000, 0xc1600000 };
199
200 #define TEST_MSG "VDUP/VDUPQ"
201 void exec_vdup_vmov (void)
202 {
203 int i;
204
205 /* Basic test: vec=vdup(x), then store the result. */
206 #undef TEST_VDUP
207 #define TEST_VDUP(Q, T1, T2, W, N) \
208 VECT_VAR(vector, T1, W, N) = \
209 vdup##Q##_n_##T2##W(VECT_VAR(buffer_dup, T1, W, N)[i]); \
210 vst1##Q##_##T2##W(VECT_VAR(result, T1, W, N), VECT_VAR(vector, T1, W, N))
211
212 /* Basic test: vec=vmov(x), then store the result. */
213 #define TEST_VMOV(Q, T1, T2, W, N) \
214 VECT_VAR(vector, T1, W, N) = \
215 vmov##Q##_n_##T2##W(VECT_VAR(buffer_dup, T1, W, N)[i]); \
216 vst1##Q##_##T2##W(VECT_VAR(result, T1, W, N), VECT_VAR(vector, T1, W, N))
217
218 DECL_VARIABLE_ALL_VARIANTS(vector);
219
220 /* Try to read different places from the input buffer. */
221 for (i=0; i< 3; i++) {
222 clean_results ();
223
224 TEST_VDUP(, int, s, 8, 8);
225 TEST_VDUP(, int, s, 16, 4);
226 TEST_VDUP(, int, s, 32, 2);
227 TEST_VDUP(, int, s, 64, 1);
228 TEST_VDUP(, uint, u, 8, 8);
229 TEST_VDUP(, uint, u, 16, 4);
230 TEST_VDUP(, uint, u, 32, 2);
231 TEST_VDUP(, uint, u, 64, 1);
232 TEST_VDUP(, poly, p, 8, 8);
233 TEST_VDUP(, poly, p, 16, 4);
234 MFLOAT8_ONLY(TEST_VDUP(, mfloat, mf, 8, 8));
235 #if defined (FP16_SUPPORTED)
236 TEST_VDUP(, float, f, 16, 4);
237 #endif
238 TEST_VDUP(, float, f, 32, 2);
239
240 TEST_VDUP(q, int, s, 8, 16);
241 TEST_VDUP(q, int, s, 16, 8);
242 TEST_VDUP(q, int, s, 32, 4);
243 TEST_VDUP(q, int, s, 64, 2);
244 TEST_VDUP(q, uint, u, 8, 16);
245 TEST_VDUP(q, uint, u, 16, 8);
246 TEST_VDUP(q, uint, u, 32, 4);
247 TEST_VDUP(q, uint, u, 64, 2);
248 TEST_VDUP(q, poly, p, 8, 16);
249 TEST_VDUP(q, poly, p, 16, 8);
250 MFLOAT8_ONLY(TEST_VDUP(q, mfloat, mf, 8, 16));
251 #if defined (FP16_SUPPORTED)
252 TEST_VDUP(q, float, f, 16, 8);
253 #endif
254 TEST_VDUP(q, float, f, 32, 4);
255
256 #if defined (FP16_SUPPORTED)
257 switch (i) {
258 case 0:
259 CHECK_RESULTS_NAMED (TEST_MSG, expected0, "");
260 break;
261 case 1:
262 CHECK_RESULTS_NAMED (TEST_MSG, expected1, "");
263 break;
264 case 2:
265 CHECK_RESULTS_NAMED (TEST_MSG, expected2, "");
266 break;
267 default:
268 abort();
269 }
270 #else
271 switch (i) {
272 case 0:
273 CHECK_RESULTS_NAMED_NO_FP16 (TEST_MSG, expected0, "");
274 break;
275 case 1:
276 CHECK_RESULTS_NAMED_NO_FP16 (TEST_MSG, expected1, "");
277 break;
278 case 2:
279 CHECK_RESULTS_NAMED_NO_FP16 (TEST_MSG, expected2, "");
280 break;
281 default:
282 abort();
283 }
284 #endif
285 }
286
287 /* Do the same tests with vmov. Use the same expected results. */
288 #undef TEST_MSG
289 #define TEST_MSG "VMOV/VMOVQ"
290 for (i=0; i< 3; i++) {
291 clean_results ();
292
293 TEST_VMOV(, int, s, 8, 8);
294 TEST_VMOV(, int, s, 16, 4);
295 TEST_VMOV(, int, s, 32, 2);
296 TEST_VMOV(, int, s, 64, 1);
297 TEST_VMOV(, uint, u, 8, 8);
298 TEST_VMOV(, uint, u, 16, 4);
299 TEST_VMOV(, uint, u, 32, 2);
300 TEST_VMOV(, uint, u, 64, 1);
301 TEST_VMOV(, poly, p, 8, 8);
302 TEST_VMOV(, poly, p, 16, 4);
303 MFLOAT8_ONLY(TEST_VMOV(, mfloat, mf, 8, 8));
304 #if defined (FP16_SUPPORTED)
305 TEST_VMOV(, float, f, 16, 4);
306 #endif
307 TEST_VMOV(, float, f, 32, 2);
308
309 TEST_VMOV(q, int, s, 8, 16);
310 TEST_VMOV(q, int, s, 16, 8);
311 TEST_VMOV(q, int, s, 32, 4);
312 TEST_VMOV(q, int, s, 64, 2);
313 TEST_VMOV(q, uint, u, 8, 16);
314 TEST_VMOV(q, uint, u, 16, 8);
315 TEST_VMOV(q, uint, u, 32, 4);
316 TEST_VMOV(q, uint, u, 64, 2);
317 TEST_VMOV(q, poly, p, 8, 16);
318 TEST_VMOV(q, poly, p, 16, 8);
319 MFLOAT8_ONLY(TEST_VMOV(q, mfloat, mf, 8, 16));
320 #if defined (FP16_SUPPORTED)
321 TEST_VMOV(q, float, f, 16, 8);
322 #endif
323 TEST_VMOV(q, float, f, 32, 4);
324
325 #if defined (FP16_SUPPORTED)
326 switch (i) {
327 case 0:
328 CHECK_RESULTS_NAMED (TEST_MSG, expected0, "");
329 break;
330 case 1:
331 CHECK_RESULTS_NAMED (TEST_MSG, expected1, "");
332 break;
333 case 2:
334 CHECK_RESULTS_NAMED (TEST_MSG, expected2, "");
335 break;
336 default:
337 abort();
338 }
339 #else
340 switch (i) {
341 case 0:
342 CHECK_RESULTS_NAMED_NO_FP16 (TEST_MSG, expected0, "");
343 break;
344 case 1:
345 CHECK_RESULTS_NAMED_NO_FP16 (TEST_MSG, expected1, "");
346 break;
347 case 2:
348 CHECK_RESULTS_NAMED_NO_FP16 (TEST_MSG, expected2, "");
349 break;
350 default:
351 abort();
352 }
353 #endif
354
355 }
356 }
357
358 int main (void)
359 {
360 exec_vdup_vmov ();
361 return 0;
362 }