Debian Codegraph @

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

raw
1 #include <arm_neon.h>
2 #include "arm-neon-ref.h"
3 #include "compute-ref-data.h"
4
5 /* Expected results. */
6 VECT_VAR_DECL(expected,int,8,8) [] = { 0xf1, 0xf1, 0xf1, 0xf1,
7 0xf1, 0xf1, 0xf1, 0xf1 };
8 VECT_VAR_DECL(expected,int,16,4) [] = { 0xfff2, 0xfff2, 0xfff2, 0xfff2 };
9 VECT_VAR_DECL(expected,int,32,2) [] = { 0xfffffff1, 0xfffffff1 };
10 VECT_VAR_DECL(expected,int,64,1) [] = { 0xfffffffffffffff0 };
11 VECT_VAR_DECL(expected,uint,8,8) [] = { 0xf7, 0xf7, 0xf7, 0xf7,
12 0xf7, 0xf7, 0xf7, 0xf7 };
13 VECT_VAR_DECL(expected,uint,16,4) [] = { 0xfff3, 0xfff3, 0xfff3, 0xfff3 };
14 VECT_VAR_DECL(expected,uint,32,2) [] = { 0xfffffff1, 0xfffffff1 };
15 VECT_VAR_DECL(expected,uint,64,1) [] = { 0xfffffffffffffff0 };
16 VECT_VAR_DECL(expected,poly,8,8) [] = { 0xf7, 0xf7, 0xf7, 0xf7,
17 0xf7, 0xf7, 0xf7, 0xf7 };
18 VECT_VAR_DECL(expected,poly,16,4) [] = { 0xfff3, 0xfff3, 0xfff3, 0xfff3 };
19 #if MFLOAT8_SUPPORTED
20 VECT_VAR_DECL(expected,hmfloat,8,8) [] = { 0xf6, 0xf6, 0xf6, 0xf6,
21 0xf6, 0xf6, 0xf6, 0xf6 };
22 #endif
23 VECT_VAR_DECL(expected,hfloat,32,2) [] = { 0xc1700000, 0xc1700000 };
24 #if defined (FP16_SUPPORTED)
25 VECT_VAR_DECL (expected, hfloat, 16, 4) [] = { 0xca80, 0xca80,
26 0xca80, 0xca80 };
27 #endif
28 VECT_VAR_DECL(expected,int,8,16) [] = { 0xf2, 0xf2, 0xf2, 0xf2,
29 0xf2, 0xf2, 0xf2, 0xf2,
30 0xf2, 0xf2, 0xf2, 0xf2,
31 0xf2, 0xf2, 0xf2, 0xf2 };
32 VECT_VAR_DECL(expected,int,16,8) [] = { 0xfff3, 0xfff3, 0xfff3, 0xfff3,
33 0xfff3, 0xfff3, 0xfff3, 0xfff3 };
34 VECT_VAR_DECL(expected,int,32,4) [] = { 0xfffffff1, 0xfffffff1,
35 0xfffffff1, 0xfffffff1 };
36 VECT_VAR_DECL(expected,int,64,2) [] = { 0xfffffffffffffff0,
37 0xfffffffffffffff0 };
38 VECT_VAR_DECL(expected,uint,8,16) [] = { 0xf5, 0xf5, 0xf5, 0xf5,
39 0xf5, 0xf5, 0xf5, 0xf5,
40 0xf5, 0xf5, 0xf5, 0xf5,
41 0xf5, 0xf5, 0xf5, 0xf5 };
42 VECT_VAR_DECL(expected,uint,16,8) [] = { 0xfff1, 0xfff1, 0xfff1, 0xfff1,
43 0xfff1, 0xfff1, 0xfff1, 0xfff1 };
44 VECT_VAR_DECL(expected,uint,32,4) [] = { 0xfffffff0, 0xfffffff0,
45 0xfffffff0, 0xfffffff0 };
46 VECT_VAR_DECL(expected,uint,64,2) [] = { 0xfffffffffffffff0,
47 0xfffffffffffffff0 };
48 VECT_VAR_DECL(expected,poly,8,16) [] = { 0xf5, 0xf5, 0xf5, 0xf5,
49 0xf5, 0xf5, 0xf5, 0xf5,
50 0xf5, 0xf5, 0xf5, 0xf5,
51 0xf5, 0xf5, 0xf5, 0xf5 };
52 VECT_VAR_DECL(expected,poly,16,8) [] = { 0xfff1, 0xfff1, 0xfff1, 0xfff1,
53 0xfff1, 0xfff1, 0xfff1, 0xfff1 };
54 #if MFLOAT8_SUPPORTED
55 VECT_VAR_DECL(expected,hmfloat,8,16) [] = { 0xf7, 0xf7, 0xf7, 0xf7,
56 0xf7, 0xf7, 0xf7, 0xf7,
57 0xf7, 0xf7, 0xf7, 0xf7,
58 0xf7, 0xf7, 0xf7, 0xf7 };
59 #endif
60 #if defined (FP16_SUPPORTED)
61 VECT_VAR_DECL (expected, hfloat, 16, 8) [] = { 0xca80, 0xca80,
62 0xca80, 0xca80,
63 0xca80, 0xca80,
64 0xca80, 0xca80 };
65 #endif
66 VECT_VAR_DECL(expected,hfloat,32,4) [] = { 0xc1700000, 0xc1700000,
67 0xc1700000, 0xc1700000 };
68
69 #define TEST_MSG "VDUP_LANE/VDUPQ_LANE"
70 void exec_vdup_lane (void)
71 {
72 /* Basic test: vec1=vdup_lane(vec2, lane), then store the result. */
73 #define TEST_VDUP_LANE(Q, T1, T2, W, N, N2, L) \
74 VECT_VAR(vector_res, T1, W, N) = \
75 vdup##Q##_lane_##T2##W(VECT_VAR(vector, T1, W, N2), L); \
76 vst1##Q##_##T2##W(VECT_VAR(result, T1, W, N), VECT_VAR(vector_res, T1, W, N))
77
78 /* Input vector can only have 64 bits. */
79 DECL_VARIABLE_64BITS_VARIANTS(vector);
80
81 DECL_VARIABLE_ALL_VARIANTS(vector_res);
82
83 clean_results ();
84
85 TEST_MACRO_64BITS_VARIANTS_2_5(VLOAD, vector, buffer);
86 MFLOAT8_ONLY(VLOAD(vector, buffer, , mfloat, mf, 8, 8);)
87 #if defined (FP16_SUPPORTED)
88 VLOAD(vector, buffer, , float, f, 16, 4);
89 #endif
90 VLOAD(vector, buffer, , float, f, 32, 2);
91
92 /* Choose lane arbitrarily. */
93 TEST_VDUP_LANE(, int, s, 8, 8, 8, 1);
94 TEST_VDUP_LANE(, int, s, 16, 4, 4, 2);
95 TEST_VDUP_LANE(, int, s, 32, 2, 2, 1);
96 TEST_VDUP_LANE(, int, s, 64, 1, 1, 0);
97 TEST_VDUP_LANE(, uint, u, 8, 8, 8, 7);
98 TEST_VDUP_LANE(, uint, u, 16, 4, 4, 3);
99 TEST_VDUP_LANE(, uint, u, 32, 2, 2, 1);
100 TEST_VDUP_LANE(, uint, u, 64, 1, 1, 0);
101 TEST_VDUP_LANE(, poly, p, 8, 8, 8, 7);
102 TEST_VDUP_LANE(, poly, p, 16, 4, 4, 3);
103 MFLOAT8_ONLY(TEST_VDUP_LANE(, mfloat, mf, 8, 8, 8, 6);)
104 #if defined (FP16_SUPPORTED)
105 TEST_VDUP_LANE(, float, f, 16, 4, 4, 3);
106 #endif
107 TEST_VDUP_LANE(, float, f, 32, 2, 2, 1);
108
109 TEST_VDUP_LANE(q, int, s, 8, 16, 8, 2);
110 TEST_VDUP_LANE(q, int, s, 16, 8, 4, 3);
111 TEST_VDUP_LANE(q, int, s, 32, 4, 2, 1);
112 TEST_VDUP_LANE(q, int, s, 64, 2, 1, 0);
113 TEST_VDUP_LANE(q, uint, u, 8, 16, 8, 5);
114 TEST_VDUP_LANE(q, uint, u, 16, 8, 4, 1);
115 TEST_VDUP_LANE(q, uint, u, 32, 4, 2, 0);
116 TEST_VDUP_LANE(q, uint, u, 64, 2, 1, 0);
117 TEST_VDUP_LANE(q, poly, p, 8, 16, 8, 5);
118 TEST_VDUP_LANE(q, poly, p, 16, 8, 4, 1);
119 MFLOAT8_ONLY(TEST_VDUP_LANE(q, mfloat, mf, 8, 16, 8, 7);)
120 #if defined (FP16_SUPPORTED)
121 TEST_VDUP_LANE(q, float, f, 16, 8, 4, 3);
122 #endif
123 TEST_VDUP_LANE(q, float, f, 32, 4, 2, 1);
124
125 #if defined (FP16_SUPPORTED)
126 CHECK_RESULTS (TEST_MSG, "");
127 #else
128 CHECK_RESULTS_NO_FP16 (TEST_MSG, "");
129 #endif
130
131 #if defined (__aarch64__)
132
133 #undef TEST_MSG
134 #define TEST_MSG "VDUP_LANEQ/VDUPQ_LANEQ"
135
136 /* Expected results for vdup*_laneq tests. */
137 VECT_VAR_DECL(expected2,int,8,8) [] = { 0xfd, 0xfd, 0xfd, 0xfd,
138 0xfd, 0xfd, 0xfd, 0xfd };
139 VECT_VAR_DECL(expected2,int,16,4) [] = { 0xfff2, 0xfff2, 0xfff2, 0xfff2 };
140 VECT_VAR_DECL(expected2,int,32,2) [] = { 0xfffffff1, 0xfffffff1 };
141 VECT_VAR_DECL(expected2,int,64,1) [] = { 0xfffffffffffffff0 };
142 VECT_VAR_DECL(expected2,uint,8,8) [] = { 0xff, 0xff, 0xff, 0xff,
143 0xff, 0xff, 0xff, 0xff };
144 VECT_VAR_DECL(expected2,uint,16,4) [] = { 0xfff3, 0xfff3, 0xfff3, 0xfff3 };
145 VECT_VAR_DECL(expected2,uint,32,2) [] = { 0xfffffff1, 0xfffffff1 };
146 VECT_VAR_DECL(expected2,uint,64,1) [] = { 0xfffffffffffffff0 };
147 VECT_VAR_DECL(expected2,poly,8,8) [] = { 0xf7, 0xf7, 0xf7, 0xf7,
148 0xf7, 0xf7, 0xf7, 0xf7 };
149 VECT_VAR_DECL(expected2,poly,16,4) [] = { 0xfff3, 0xfff3, 0xfff3, 0xfff3 };
150 #if MFLOAT8_SUPPORTED
151 VECT_VAR_DECL(expected2,hmfloat,8,8) [] = { 0xfb, 0xfb, 0xfb, 0xfb,
152 0xfb, 0xfb, 0xfb, 0xfb };
153 #endif
154 VECT_VAR_DECL(expected2,hfloat,32,2) [] = { 0xc1700000, 0xc1700000 };
155 #if defined (FP16_SUPPORTED)
156 VECT_VAR_DECL (expected2, hfloat, 16, 4) [] = { 0xca80, 0xca80,
157 0xca80, 0xca80 };
158 #endif
159 VECT_VAR_DECL(expected2,int,8,16) [] = { 0xfb, 0xfb, 0xfb, 0xfb,
160 0xfb, 0xfb, 0xfb, 0xfb,
161 0xfb, 0xfb, 0xfb, 0xfb,
162 0xfb, 0xfb, 0xfb, 0xfb };
163 VECT_VAR_DECL(expected2,int,16,8) [] = { 0xfff7, 0xfff7, 0xfff7, 0xfff7,
164 0xfff7, 0xfff7, 0xfff7, 0xfff7 };
165 VECT_VAR_DECL(expected2,int,32,4) [] = { 0xfffffff1, 0xfffffff1,
166 0xfffffff1, 0xfffffff1 };
167 VECT_VAR_DECL(expected2,int,64,2) [] = { 0xfffffffffffffff0,
168 0xfffffffffffffff0 };
169 VECT_VAR_DECL(expected2,uint,8,16) [] = { 0xf5, 0xf5, 0xf5, 0xf5,
170 0xf5, 0xf5, 0xf5, 0xf5,
171 0xf5, 0xf5, 0xf5, 0xf5,
172 0xf5, 0xf5, 0xf5, 0xf5 };
173 VECT_VAR_DECL(expected2,uint,16,8) [] = { 0xfff1, 0xfff1, 0xfff1, 0xfff1,
174 0xfff1, 0xfff1, 0xfff1, 0xfff1 };
175 VECT_VAR_DECL(expected2,uint,32,4) [] = { 0xfffffff0, 0xfffffff0,
176 0xfffffff0, 0xfffffff0 };
177 VECT_VAR_DECL(expected2,uint,64,2) [] = { 0xfffffffffffffff0,
178 0xfffffffffffffff0 };
179 VECT_VAR_DECL(expected2,poly,8,16) [] = { 0xf5, 0xf5, 0xf5, 0xf5,
180 0xf5, 0xf5, 0xf5, 0xf5,
181 0xf5, 0xf5, 0xf5, 0xf5,
182 0xf5, 0xf5, 0xf5, 0xf5 };
183 VECT_VAR_DECL(expected2,poly,16,8) [] = { 0xfff1, 0xfff1, 0xfff1, 0xfff1,
184 0xfff1, 0xfff1, 0xfff1, 0xfff1 };
185 #if MFLOAT8_SUPPORTED
186 VECT_VAR_DECL(expected2,hmfloat,8,16) [] = { 0xfc, 0xfc, 0xfc, 0xfc,
187 0xfc, 0xfc, 0xfc, 0xfc,
188 0xfc, 0xfc, 0xfc, 0xfc,
189 0xfc, 0xfc, 0xfc, 0xfc };
190 #endif
191 #if defined (FP16_SUPPORTED)
192 VECT_VAR_DECL (expected2, hfloat, 16, 8) [] = { 0xc880, 0xc880,
193 0xc880, 0xc880,
194 0xc880, 0xc880,
195 0xc880, 0xc880 };
196 #endif
197 VECT_VAR_DECL(expected2,hfloat,32,4) [] = { 0xc1700000, 0xc1700000,
198 0xc1700000, 0xc1700000 };
199
200 /* Clean all results for vdup*_laneq tests. */
201 clean_results ();
202 /* Basic test: vec1=vdup_lane(vec2, lane), then store the result. */
203 #define TEST_VDUP_LANEQ(Q, T1, T2, W, N, N2, L) \
204 VECT_VAR(vector_res, T1, W, N) = \
205 vdup##Q##_laneq_##T2##W(VECT_VAR(vector, T1, W, N2), L); \
206 vst1##Q##_##T2##W(VECT_VAR(result, T1, W, N), VECT_VAR(vector_res, T1, W, N))
207
208 /* Input vector can only have 64 bits. */
209 DECL_VARIABLE_128BITS_VARIANTS(vector);
210
211 clean_results ();
212
213 TEST_MACRO_128BITS_VARIANTS_2_5(VLOAD, vector, buffer);
214 MFLOAT8_ONLY(VLOAD(vector, buffer, q, mfloat, mf, 8, 16);)
215 #if defined (FP16_SUPPORTED)
216 VLOAD(vector, buffer, q, float, f, 16, 8);
217 #endif
218 VLOAD(vector, buffer, q, float, f, 32, 4);
219
220 /* Choose lane arbitrarily. */
221 TEST_VDUP_LANEQ(, int, s, 8, 8, 16, 13);
222 TEST_VDUP_LANEQ(, int, s, 16, 4, 8, 2);
223 TEST_VDUP_LANEQ(, int, s, 32, 2, 4, 1);
224 TEST_VDUP_LANEQ(, int, s, 64, 1, 2, 0);
225 TEST_VDUP_LANEQ(, uint, u, 8, 8, 16, 15);
226 TEST_VDUP_LANEQ(, uint, u, 16, 4, 8, 3);
227 TEST_VDUP_LANEQ(, uint, u, 32, 2, 4, 1);
228 TEST_VDUP_LANEQ(, uint, u, 64, 1, 2, 0);
229 TEST_VDUP_LANEQ(, poly, p, 8, 8, 16, 7);
230 TEST_VDUP_LANEQ(, poly, p, 16, 4, 8, 3);
231 MFLOAT8_ONLY(TEST_VDUP_LANEQ(, mfloat, mf, 8, 8, 16, 11);)
232 #if defined (FP16_SUPPORTED)
233 TEST_VDUP_LANEQ(, float, f, 16, 4, 8, 3);
234 #endif
235 TEST_VDUP_LANEQ(, float, f, 32, 2, 4, 1);
236
237 TEST_VDUP_LANEQ(q, int, s, 8, 16, 16, 11);
238 TEST_VDUP_LANEQ(q, int, s, 16, 8, 8, 7);
239 TEST_VDUP_LANEQ(q, int, s, 32, 4, 4, 1);
240 TEST_VDUP_LANEQ(q, int, s, 64, 2, 2, 0);
241 TEST_VDUP_LANEQ(q, uint, u, 8, 16, 16, 5);
242 TEST_VDUP_LANEQ(q, uint, u, 16, 8, 8, 1);
243 TEST_VDUP_LANEQ(q, uint, u, 32, 4, 4, 0);
244 TEST_VDUP_LANEQ(q, uint, u, 64, 2, 2, 0);
245 TEST_VDUP_LANEQ(q, poly, p, 8, 16, 16, 5);
246 TEST_VDUP_LANEQ(q, poly, p, 16, 8, 8, 1);
247 MFLOAT8_ONLY(TEST_VDUP_LANEQ(q, mfloat, mf, 8, 16, 16, 12);)
248 #if defined (FP16_SUPPORTED)
249 TEST_VDUP_LANEQ(q, float, f, 16, 8, 8, 7);
250 #endif
251 TEST_VDUP_LANEQ(q, float, f, 32, 4, 4, 1);
252
253 CHECK_RESULTS_NAMED (TEST_MSG, expected2, "");
254 #if defined (FP16_SUPPORTED)
255 CHECK_FP(TEST_MSG, float, 16, 4, PRIx16, expected2, "");
256 CHECK_FP(TEST_MSG, float, 16, 8, PRIx16, expected2, "");
257 #endif
258
259 #endif /* __aarch64__. */
260 }
261
262 int main (void)
263 {
264 exec_vdup_lane ();
265 return 0;
266 }