Debian Codegraph @

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

raw
1 /* { dg-skip-if "" { arm*-*-* } } */
2
3 #include <arm_neon.h>
4 #include "arm-neon-ref.h"
5 #include "compute-ref-data.h"
6
7 /* Expected results. */
8 VECT_VAR_DECL(expected,int,8,8) [] = { 0xf0, 0xf2, 0xf4, 0xf6,
9 0x11, 0x11, 0x11, 0x11 };
10 VECT_VAR_DECL(expected,int,16,4) [] = { 0xfff0, 0xfff2, 0x22, 0x22 };
11 VECT_VAR_DECL(expected,int,32,2) [] = { 0xfffffff0, 0x33 };
12 VECT_VAR_DECL(expected,int,64,1) [] = { 0xfffffffffffffff0 };
13 VECT_VAR_DECL(expected,uint,8,8) [] = { 0xf0, 0xf2, 0xf4, 0xf6,
14 0x55, 0x55, 0x55, 0x55 };
15 VECT_VAR_DECL(expected,uint,16,4) [] = { 0xfff0, 0xfff2, 0x66, 0x66 };
16 VECT_VAR_DECL(expected,uint,32,2) [] = { 0xfffffff0, 0x77 };
17 VECT_VAR_DECL(expected,uint,64,1) [] = { 0xfffffffffffffff0 };
18 VECT_VAR_DECL(expected,poly,8,8) [] = { 0xf0, 0xf2, 0xf4, 0xf6,
19 0x55, 0x55, 0x55, 0x55 };
20 VECT_VAR_DECL(expected,poly,16,4) [] = { 0xfff0, 0xfff2, 0x66, 0x66 };
21 #if MFLOAT8_SUPPORTED
22 VECT_VAR_DECL(expected,hmfloat,8,8) [] = { 0xf0, 0xf2, 0xf4, 0xf6,
23 0x7b, 0x7b, 0x7b, 0x7b };
24 #endif
25 VECT_VAR_DECL(expected,hfloat,32,2) [] = { 0xc1800000, 0x42066666 };
26 #if defined (FP16_SUPPORTED)
27 VECT_VAR_DECL (expected, hfloat, 16, 4) [] = { 0xcc00, 0xcb00,
28 0x4b4d, 0x4b4d };
29 #endif
30 VECT_VAR_DECL(expected,int,8,16) [] = { 0xf0, 0xf2, 0xf4, 0xf6,
31 0xf8, 0xfa, 0xfc, 0xfe,
32 0x11, 0x11, 0x11, 0x11,
33 0x11, 0x11, 0x11, 0x11 };
34 VECT_VAR_DECL(expected,int,16,8) [] = { 0xfff0, 0xfff2, 0xfff4, 0xfff6,
35 0x22, 0x22, 0x22, 0x22 };
36 VECT_VAR_DECL(expected,int,32,4) [] = { 0xfffffff0, 0xfffffff2,
37 0x33, 0x33 };
38 VECT_VAR_DECL(expected,int,64,2) [] = { 0xfffffffffffffff0,
39 0x44 };
40 VECT_VAR_DECL(expected,uint,8,16) [] = { 0xf0, 0xf2, 0xf4, 0xf6,
41 0xf8, 0xfa, 0xfc, 0xfe,
42 0x55, 0x55, 0x55, 0x55,
43 0x55, 0x55, 0x55, 0x55 };
44 VECT_VAR_DECL(expected,uint,16,8) [] = { 0xfff0, 0xfff2, 0xfff4, 0xfff6,
45 0x66, 0x66, 0x66, 0x66 };
46 VECT_VAR_DECL(expected,uint,32,4) [] = { 0xfffffff0, 0xfffffff2, 0x77, 0x77 };
47 VECT_VAR_DECL(expected,uint,64,2) [] = { 0xfffffffffffffff0,
48 0x88 };
49 VECT_VAR_DECL(expected,poly,8,16) [] = { 0xf0, 0xf2, 0xf4, 0xf6,
50 0xf8, 0xfa, 0xfc, 0xfe,
51 0x55, 0x55, 0x55, 0x55,
52 0x55, 0x55, 0x55, 0x55 };
53 VECT_VAR_DECL(expected,poly,16,8) [] = { 0xfff0, 0xfff2, 0xfff4, 0xfff6,
54 0x66, 0x66, 0x66, 0x66 };
55 #if MFLOAT8_SUPPORTED
56 VECT_VAR_DECL(expected,hmfloat,8,16) [] = { 0xf0, 0xf2, 0xf4, 0xf6,
57 0xf8, 0xfa, 0xfc, 0xfe,
58 0x92, 0x92, 0x92, 0x92,
59 0x92, 0x92, 0x92, 0x92 };
60 #endif
61 #if defined (FP16_SUPPORTED)
62 VECT_VAR_DECL (expected, hfloat, 16, 8) [] = { 0xcc00, 0xcb00, 0xca00, 0xc900,
63 0x4b4d, 0x4b4d, 0x4b4d, 0x4b4d };
64 #endif
65 VECT_VAR_DECL(expected,hfloat,32,4) [] = { 0xc1800000, 0xc1600000,
66 0x42073333, 0x42073333 };
67
68 #define TEST_MSG "VUZP1"
69 void exec_vuzp_half (void)
70 {
71 #define TEST_VUZP(PART, Q, T1, T2, W, N) \
72 VECT_VAR(vector_res, T1, W, N) = \
73 vuzp##PART##Q##_##T2##W(VECT_VAR(vector, T1, W, N), \
74 VECT_VAR(vector2, T1, W, N)); \
75 vst1##Q##_##T2##W(VECT_VAR(result, T1, W, N), VECT_VAR(vector_res, T1, W, N))
76
77 #define TEST_VUZP1(Q, T1, T2, W, N) TEST_VUZP(1, Q, T1, T2, W, N)
78
79 /* Input vector can only have 64 bits. */
80 DECL_VARIABLE_ALL_VARIANTS(vector);
81 DECL_VARIABLE_ALL_VARIANTS(vector2);
82
83 DECL_VARIABLE_ALL_VARIANTS(vector_res);
84
85 clean_results ();
86 /* We don't have vuzp1_T64x1, so set expected to the clean value. */
87 CLEAN(expected, int, 64, 1);
88 CLEAN(expected, uint, 64, 1);
89
90 TEST_MACRO_ALL_VARIANTS_2_5(VLOAD, vector, buffer);
91 #if MFLOAT8_SUPPORTED
92 VLOAD(vector, buffer, , mfloat, mf, 8, 8);
93 VLOAD(vector, buffer, q, mfloat, mf, 8, 16);
94 #endif
95 #if defined (FP16_SUPPORTED)
96 VLOAD(vector, buffer, , float, f, 16, 4);
97 VLOAD(vector, buffer, q, float, f, 16, 8);
98 #endif
99 VLOAD(vector, buffer, , float, f, 32, 2);
100 VLOAD(vector, buffer, q, float, f, 32, 4);
101 VLOAD(vector, buffer, q, float, f, 64, 2);
102
103 /* Choose arbitrary initialization values. */
104 VDUP(vector2, , int, s, 8, 8, 0x11);
105 VDUP(vector2, , int, s, 16, 4, 0x22);
106 VDUP(vector2, , int, s, 32, 2, 0x33);
107 VDUP(vector2, , uint, u, 8, 8, 0x55);
108 VDUP(vector2, , uint, u, 16, 4, 0x66);
109 VDUP(vector2, , uint, u, 32, 2, 0x77);
110 VDUP(vector2, , poly, p, 8, 8, 0x55);
111 VDUP(vector2, , poly, p, 16, 4, 0x66);
112 MFLOAT8_ONLY(VDUP(vector2, , mfloat, mf, 8, 8, MFLOAT8(0x7b)));
113 #if defined (FP16_SUPPORTED)
114 VDUP (vector2, , float, f, 16, 4, 14.6f); /* 14.6f is 0x4b4d. */
115 #endif
116 VDUP(vector2, , float, f, 32, 2, 33.6f);
117
118 VDUP(vector2, q, int, s, 8, 16, 0x11);
119 VDUP(vector2, q, int, s, 16, 8, 0x22);
120 VDUP(vector2, q, int, s, 32, 4, 0x33);
121 VDUP(vector2, q, int, s, 64, 2, 0x44);
122 VDUP(vector2, q, uint, u, 8, 16, 0x55);
123 VDUP(vector2, q, uint, u, 16, 8, 0x66);
124 VDUP(vector2, q, uint, u, 32, 4, 0x77);
125 VDUP(vector2, q, uint, u, 64, 2, 0x88);
126 VDUP(vector2, q, poly, p, 8, 16, 0x55);
127 VDUP(vector2, q, poly, p, 16, 8, 0x66);
128 MFLOAT8_ONLY(VDUP(vector2, q, mfloat, mf, 8, 16, MFLOAT8(0x92)));
129 #if defined (FP16_SUPPORTED)
130 VDUP (vector2, q, float, f, 16, 8, 14.6f);
131 #endif
132 VDUP(vector2, q, float, f, 32, 4, 33.8f);
133 VDUP(vector2, q, float, f, 64, 2, 33.8f);
134
135 TEST_VUZP1(, int, s, 8, 8);
136 TEST_VUZP1(, int, s, 16, 4);
137 TEST_VUZP1(, int, s, 32, 2);
138 TEST_VUZP1(, uint, u, 8, 8);
139 TEST_VUZP1(, uint, u, 16, 4);
140 TEST_VUZP1(, uint, u, 32, 2);
141 TEST_VUZP1(, poly, p, 8, 8);
142 TEST_VUZP1(, poly, p, 16, 4);
143 MFLOAT8_ONLY(TEST_VUZP1(, mfloat, mf, 8, 8));
144 #if defined (FP16_SUPPORTED)
145 TEST_VUZP1(, float, f, 16, 4);
146 #endif
147 TEST_VUZP1(, float, f, 32, 2);
148
149 TEST_VUZP1(q, int, s, 8, 16);
150 TEST_VUZP1(q, int, s, 16, 8);
151 TEST_VUZP1(q, int, s, 32, 4);
152 TEST_VUZP1(q, int, s, 64, 2);
153 TEST_VUZP1(q, uint, u, 8, 16);
154 TEST_VUZP1(q, uint, u, 16, 8);
155 TEST_VUZP1(q, uint, u, 32, 4);
156 TEST_VUZP1(q, uint, u, 64, 2);
157 TEST_VUZP1(q, poly, p, 8, 16);
158 TEST_VUZP1(q, poly, p, 16, 8);
159 MFLOAT8_ONLY(TEST_VUZP1(q, mfloat, mf, 8, 16));
160 #if defined (FP16_SUPPORTED)
161 TEST_VUZP1(q, float, f, 16, 8);
162 #endif
163 TEST_VUZP1(q, float, f, 32, 4);
164 TEST_VUZP1(q, float, f, 64, 2);
165
166 #if defined (FP16_SUPPORTED)
167 CHECK_RESULTS (TEST_MSG, "");
168 #else
169 CHECK_RESULTS_NO_FP16 (TEST_MSG, "");
170 #endif
171
172 #undef TEST_MSG
173 #define TEST_MSG "VUZP2"
174
175 #define TEST_VUZP2(Q, T1, T2, W, N) TEST_VUZP(2, Q, T1, T2, W, N)
176
177 /* Expected results. */
178 VECT_VAR_DECL(expected2,int,8,8) [] = { 0xf1, 0xf3, 0xf5, 0xf7,
179 0x11, 0x11, 0x11, 0x11 };
180 VECT_VAR_DECL(expected2,int,16,4) [] = { 0xfff1, 0xfff3, 0x22, 0x22 };
181 VECT_VAR_DECL(expected2,int,32,2) [] = { 0xfffffff1, 0x33 };
182 VECT_VAR_DECL(expected2,int,64,1) [] = { 0xfffffffffffffff1 };
183 VECT_VAR_DECL(expected2,uint,8,8) [] = { 0xf1, 0xf3, 0xf5, 0xf7,
184 0x55, 0x55, 0x55, 0x55 };
185 VECT_VAR_DECL(expected2,uint,16,4) [] = { 0xfff1, 0xfff3, 0x66, 0x66 };
186 VECT_VAR_DECL(expected2,uint,32,2) [] = { 0xfffffff1, 0x77 };
187 VECT_VAR_DECL(expected2,uint,64,1) [] = { 0xfffffffffffffff1 };
188 VECT_VAR_DECL(expected2,poly,8,8) [] = { 0xf1, 0xf3, 0xf5, 0xf7,
189 0x55, 0x55, 0x55, 0x55 };
190 VECT_VAR_DECL(expected2,poly,16,4) [] = { 0xfff1, 0xfff3, 0x66, 0x66 };
191 #if MFLOAT8_SUPPORTED
192 VECT_VAR_DECL(expected2,hmfloat,8,8) [] = { 0xf1, 0xf3, 0xf5, 0xf7,
193 0x7b, 0x7b, 0x7b, 0x7b };
194 #endif
195 VECT_VAR_DECL(expected2,hfloat,32,2) [] = { 0xc1700000, 0x42066666 };
196 #if defined (FP16_SUPPORTED)
197 VECT_VAR_DECL (expected2, hfloat, 16, 4) [] = { 0xcb80, 0xca80,
198 0x4b4d, 0x4b4d };
199 #endif
200 VECT_VAR_DECL(expected2,int,8,16) [] = { 0xf1, 0xf3, 0xf5, 0xf7,
201 0xf9, 0xfb, 0xfd, 0xff,
202 0x11, 0x11, 0x11, 0x11,
203 0x11, 0x11, 0x11, 0x11 };
204 VECT_VAR_DECL(expected2,int,16,8) [] = { 0xfff1, 0xfff3, 0xfff5, 0xfff7,
205 0x22, 0x22, 0x22, 0x22 };
206 VECT_VAR_DECL(expected2,int,32,4) [] = { 0xfffffff1, 0xfffffff3,
207 0x33, 0x33 };
208 VECT_VAR_DECL(expected2,int,64,2) [] = { 0xfffffffffffffff1,
209 0x44 };
210 VECT_VAR_DECL(expected2,uint,8,16) [] = { 0xf1, 0xf3, 0xf5, 0xf7,
211 0xf9, 0xfb, 0xfd, 0xff,
212 0x55, 0x55, 0x55, 0x55,
213 0x55, 0x55, 0x55, 0x55 };
214 VECT_VAR_DECL(expected2,uint,16,8) [] = { 0xfff1, 0xfff3, 0xfff5, 0xfff7,
215 0x66, 0x66, 0x66, 0x66 };
216 VECT_VAR_DECL(expected2,uint,32,4) [] = { 0xfffffff1, 0xfffffff3, 0x77, 0x77 };
217 VECT_VAR_DECL(expected2,uint,64,2) [] = { 0xfffffffffffffff1,
218 0x88 };
219 VECT_VAR_DECL(expected2,poly,8,16) [] = { 0xf1, 0xf3, 0xf5, 0xf7,
220 0xf9, 0xfb, 0xfd, 0xff,
221 0x55, 0x55, 0x55, 0x55,
222 0x55, 0x55, 0x55, 0x55 };
223 VECT_VAR_DECL(expected2,poly,16,8) [] = { 0xfff1, 0xfff3, 0xfff5, 0xfff7,
224 0x66, 0x66, 0x66, 0x66 };
225 #if MFLOAT8_SUPPORTED
226 VECT_VAR_DECL(expected2,hmfloat,8,16) [] = { 0xf1, 0xf3, 0xf5, 0xf7,
227 0xf9, 0xfb, 0xfd, 0xff,
228 0x92, 0x92, 0x92, 0x92,
229 0x92, 0x92, 0x92, 0x92 };
230 #endif
231 #if defined (FP16_SUPPORTED)
232 VECT_VAR_DECL (expected2, hfloat, 16, 8) [] = { 0xcb80, 0xca80, 0xc980, 0xc880,
233 0x4b4d, 0x4b4d, 0x4b4d, 0x4b4d
234 };
235 #endif
236 VECT_VAR_DECL(expected2,hfloat,32,4) [] = { 0xc1700000, 0xc1500000,
237 0x42073333, 0x42073333 };
238
239 clean_results ();
240 CLEAN(expected2, int, 64, 1);
241 CLEAN(expected2, uint, 64, 1);
242
243 TEST_VUZP2(, int, s, 8, 8);
244 TEST_VUZP2(, int, s, 16, 4);
245 TEST_VUZP2(, int, s, 32, 2);
246 TEST_VUZP2(, uint, u, 8, 8);
247 TEST_VUZP2(, uint, u, 16, 4);
248 TEST_VUZP2(, uint, u, 32, 2);
249 TEST_VUZP2(, poly, p, 8, 8);
250 TEST_VUZP2(, poly, p, 16, 4);
251 MFLOAT8_ONLY(TEST_VUZP2(, mfloat, mf, 8, 8));
252 #if defined (FP16_SUPPORTED)
253 TEST_VUZP2(, float, f, 16, 4);
254 #endif
255 TEST_VUZP2(, float, f, 32, 2);
256
257 TEST_VUZP2(q, int, s, 8, 16);
258 TEST_VUZP2(q, int, s, 16, 8);
259 TEST_VUZP2(q, int, s, 32, 4);
260 TEST_VUZP2(q, int, s, 64, 2);
261 TEST_VUZP2(q, uint, u, 8, 16);
262 TEST_VUZP2(q, uint, u, 16, 8);
263 TEST_VUZP2(q, uint, u, 32, 4);
264 TEST_VUZP2(q, uint, u, 64, 2);
265 TEST_VUZP2(q, poly, p, 8, 16);
266 TEST_VUZP2(q, poly, p, 16, 8);
267 MFLOAT8_ONLY(TEST_VUZP2(q, mfloat, mf, 8, 16));
268 #if defined (FP16_SUPPORTED)
269 TEST_VUZP2(q, float, f, 16, 8);
270 #endif
271 TEST_VUZP2(q, float, f, 32, 4);
272 TEST_VUZP2(q, float, f, 64, 2);
273
274 CHECK_RESULTS_NAMED (TEST_MSG, expected2, "");
275 #if defined (FP16_SUPPORTED)
276 CHECK_FP(TEST_MSG, float, 16, 4, PRIx16, expected2, "");
277 CHECK_FP(TEST_MSG, float, 16, 8, PRIx16, expected2, "");
278 #endif
279 }
280
281 int main (void)
282 {
283 exec_vuzp_half ();
284 return 0;
285 }