2 /* { dg-skip-if "" { arm*-*-* } } */
5 #include "arm-neon-ref.h"
6 #include "compute-ref-data.h"
8 /* Expected results. */
9 VECT_VAR_DECL(expected
,int,8,8) [] = { 0xf0, 0x11, 0xf1, 0x11,
10 0xf2, 0x11, 0xf3, 0x11 };
11 VECT_VAR_DECL(expected
,int,16,4) [] = { 0xfff0, 0x22, 0xfff1, 0x22 };
12 VECT_VAR_DECL(expected
,int,32,2) [] = { 0xfffffff0, 0x33 };
13 VECT_VAR_DECL(expected
,int,64,1) [] = { 0xfffffffffffffff0 };
14 VECT_VAR_DECL(expected
,uint
,8,8) [] = { 0xf0, 0x55, 0xf1, 0x55,
15 0xf2, 0x55, 0xf3, 0x55 };
16 VECT_VAR_DECL(expected
,uint
,16,4) [] = { 0xfff0, 0x66, 0xfff1, 0x66 };
17 VECT_VAR_DECL(expected
,uint
,32,2) [] = { 0xfffffff0, 0x77 };
18 VECT_VAR_DECL(expected
,uint
,64,1) [] = { 0xfffffffffffffff0 };
19 VECT_VAR_DECL(expected
,poly
,8,8) [] = { 0xf0, 0x55, 0xf1, 0x55,
20 0xf2, 0x55, 0xf3, 0x55 };
21 VECT_VAR_DECL(expected
,poly
,16,4) [] = { 0xfff0, 0x66, 0xfff1, 0x66 };
22 VECT_VAR_DECL(expected
,hfloat
,32,2) [] = { 0xc1800000, 0x42066666 };
23 #if defined (FP16_SUPPORTED)
24 VECT_VAR_DECL (expected
, hfloat
, 16, 4) [] = { 0xcc00, 0x4b4d,
27 VECT_VAR_DECL(expected
,int,8,16) [] = { 0xf0, 0x11, 0xf1, 0x11,
28 0xf2, 0x11, 0xf3, 0x11,
29 0xf4, 0x11, 0xf5, 0x11,
30 0xf6, 0x11, 0xf7, 0x11 };
31 VECT_VAR_DECL(expected
,int,16,8) [] = { 0xfff0, 0x22, 0xfff1, 0x22,
32 0xfff2, 0x22, 0xfff3, 0x22 };
33 VECT_VAR_DECL(expected
,int,32,4) [] = { 0xfffffff0, 0x33,
35 VECT_VAR_DECL(expected
,int,64,2) [] = { 0xfffffffffffffff0,
37 VECT_VAR_DECL(expected
,uint
,8,16) [] = { 0xf0, 0x55, 0xf1, 0x55,
38 0xf2, 0x55, 0xf3, 0x55,
39 0xf4, 0x55, 0xf5, 0x55,
40 0xf6, 0x55, 0xf7, 0x55 };
41 VECT_VAR_DECL(expected
,uint
,16,8) [] = { 0xfff0, 0x66, 0xfff1, 0x66,
42 0xfff2, 0x66, 0xfff3, 0x66 };
43 VECT_VAR_DECL(expected
,uint
,32,4) [] = { 0xfffffff0, 0x77,
45 VECT_VAR_DECL(expected
,uint
,64,2) [] = { 0xfffffffffffffff0,
47 VECT_VAR_DECL(expected
,poly
,8,16) [] = { 0xf0, 0x55, 0xf1, 0x55,
48 0xf2, 0x55, 0xf3, 0x55,
49 0xf4, 0x55, 0xf5, 0x55,
50 0xf6, 0x55, 0xf7, 0x55 };
51 VECT_VAR_DECL(expected
,poly
,16,8) [] = { 0xfff0, 0x66, 0xfff1, 0x66,
52 0xfff2, 0x66, 0xfff3, 0x66 };
53 #if defined (FP16_SUPPORTED)
54 VECT_VAR_DECL (expected
, hfloat
, 16, 8) [] = { 0xcc00, 0x4b4d,
59 VECT_VAR_DECL(expected
,hfloat
,32,4) [] = { 0xc1800000, 0x42073333,
60 0xc1700000, 0x42073333 };
62 #define TEST_MSG "VZIP1"
63 void exec_vzip_half (void)
65 #define TEST_VZIP(PART, Q, T1, T2, W, N) \
66 VECT_VAR(vector_res, T1, W, N) = \
67 vzip##PART##Q##_##T2##W(VECT_VAR(vector, T1, W, N), \
68 VECT_VAR(vector2, T1, W, N)); \
69 vst1##Q##_##T2##W(VECT_VAR(result, T1, W, N), VECT_VAR(vector_res, T1, W, N))
71 #define TEST_VZIP1(Q, T1, T2, W, N) TEST_VZIP(1, Q, T1, T2, W, N)
73 /* Input vector can only have 64 bits. */
74 DECL_VARIABLE_ALL_VARIANTS(vector
);
75 DECL_VARIABLE_ALL_VARIANTS(vector2
);
77 DECL_VARIABLE_ALL_VARIANTS(vector_res
);
80 /* We don't have vzip1_T64x1, so set expected to the clean value. */
81 CLEAN(expected
, int, 64, 1);
82 CLEAN(expected
, uint
, 64, 1);
84 TEST_MACRO_ALL_VARIANTS_2_5(VLOAD
, vector
, buffer
);
85 #if defined (FP16_SUPPORTED)
86 VLOAD(vector
, buffer
, , float, f
, 16, 4);
87 VLOAD(vector
, buffer
, q
, float, f
, 16, 8);
89 VLOAD(vector
, buffer
, , float, f
, 32, 2);
90 VLOAD(vector
, buffer
, q
, float, f
, 32, 4);
91 VLOAD(vector
, buffer
, q
, float, f
, 64, 2);
93 /* Choose arbitrary initialization values. */
94 VDUP(vector2
, , int, s
, 8, 8, 0x11);
95 VDUP(vector2
, , int, s
, 16, 4, 0x22);
96 VDUP(vector2
, , int, s
, 32, 2, 0x33);
97 VDUP(vector2
, , uint
, u
, 8, 8, 0x55);
98 VDUP(vector2
, , uint
, u
, 16, 4, 0x66);
99 VDUP(vector2
, , uint
, u
, 32, 2, 0x77);
100 VDUP(vector2
, , poly
, p
, 8, 8, 0x55);
101 VDUP(vector2
, , poly
, p
, 16, 4, 0x66);
102 #if defined (FP16_SUPPORTED)
103 VDUP (vector2
, , float, f
, 16, 4, 14.6f
); /* 14.6f is 0x4b4d. */
105 VDUP(vector2
, , float, f
, 32, 2, 33.6f
);
107 VDUP(vector2
, q
, int, s
, 8, 16, 0x11);
108 VDUP(vector2
, q
, int, s
, 16, 8, 0x22);
109 VDUP(vector2
, q
, int, s
, 32, 4, 0x33);
110 VDUP(vector2
, q
, int, s
, 64, 2, 0x44);
111 VDUP(vector2
, q
, uint
, u
, 8, 16, 0x55);
112 VDUP(vector2
, q
, uint
, u
, 16, 8, 0x66);
113 VDUP(vector2
, q
, uint
, u
, 32, 4, 0x77);
114 VDUP(vector2
, q
, uint
, u
, 64, 2, 0x88);
115 VDUP(vector2
, q
, poly
, p
, 8, 16, 0x55);
116 VDUP(vector2
, q
, poly
, p
, 16, 8, 0x66);
117 #if defined (FP16_SUPPORTED)
118 VDUP (vector2
, q
, float, f
, 16, 8, 14.6f
);
120 VDUP(vector2
, q
, float, f
, 32, 4, 33.8f
);
121 VDUP(vector2
, q
, float, f
, 64, 2, 33.8f
);
123 TEST_VZIP1(, int, s
, 8, 8);
124 TEST_VZIP1(, int, s
, 16, 4);
125 TEST_VZIP1(, int, s
, 32, 2);
126 TEST_VZIP1(, uint
, u
, 8, 8);
127 TEST_VZIP1(, uint
, u
, 16, 4);
128 TEST_VZIP1(, uint
, u
, 32, 2);
129 TEST_VZIP1(, poly
, p
, 8, 8);
130 TEST_VZIP1(, poly
, p
, 16, 4);
131 #if defined (FP16_SUPPORTED)
132 TEST_VZIP1(, float, f
, 16, 4);
134 TEST_VZIP1(, float, f
, 32, 2);
136 TEST_VZIP1(q
, int, s
, 8, 16);
137 TEST_VZIP1(q
, int, s
, 16, 8);
138 TEST_VZIP1(q
, int, s
, 32, 4);
139 TEST_VZIP1(q
, int, s
, 64, 2);
140 TEST_VZIP1(q
, uint
, u
, 8, 16);
141 TEST_VZIP1(q
, uint
, u
, 16, 8);
142 TEST_VZIP1(q
, uint
, u
, 32, 4);
143 TEST_VZIP1(q
, uint
, u
, 64, 2);
144 TEST_VZIP1(q
, poly
, p
, 8, 16);
145 TEST_VZIP1(q
, poly
, p
, 16, 8);
146 #if defined (FP16_SUPPORTED)
147 TEST_VZIP1(q
, float, f
, 16, 8);
149 TEST_VZIP1(q
, float, f
, 32, 4);
150 TEST_VZIP1(q
, float, f
, 64, 2);
152 #if defined (FP16_SUPPORTED)
153 CHECK_RESULTS (TEST_MSG
, "");
155 CHECK_RESULTS_NO_FP16 (TEST_MSG
, "");
159 #define TEST_MSG "VZIP2"
161 #define TEST_VZIP2(Q, T1, T2, W, N) TEST_VZIP(2, Q, T1, T2, W, N)
163 /* Expected results. */
164 VECT_VAR_DECL(expected2
,int,8,8) [] = { 0xf4, 0x11, 0xf5, 0x11,
165 0xf6, 0x11, 0xf7, 0x11 };
166 VECT_VAR_DECL(expected2
,int,16,4) [] = { 0xfff2, 0x22, 0xfff3, 0x22 };
167 VECT_VAR_DECL(expected2
,int,32,2) [] = { 0xfffffff1, 0x33 };
168 VECT_VAR_DECL(expected2
,int,64,1) [] = { 0xfffffffffffffff1 };
169 VECT_VAR_DECL(expected2
,uint
,8,8) [] = { 0xf4, 0x55, 0xf5, 0x55,
170 0xf6, 0x55, 0xf7, 0x55 };
171 VECT_VAR_DECL(expected2
,uint
,16,4) [] = { 0xfff2, 0x66, 0xfff3, 0x66 };
172 VECT_VAR_DECL(expected2
,uint
,32,2) [] = { 0xfffffff1, 0x77 };
173 VECT_VAR_DECL(expected2
,uint
,64,1) [] = { 0xfffffffffffffff1 };
174 VECT_VAR_DECL(expected2
,poly
,8,8) [] = { 0xf4, 0x55, 0xf5, 0x55,
175 0xf6, 0x55, 0xf7, 0x55 };
176 VECT_VAR_DECL(expected2
,poly
,16,4) [] = { 0xfff2, 0x66, 0xfff3, 0x66 };
177 VECT_VAR_DECL(expected2
,hfloat
,32,2) [] = { 0xc1700000, 0x42066666 };
178 #if defined (FP16_SUPPORTED)
179 VECT_VAR_DECL (expected2
, hfloat
, 16, 4) [] = { 0xcb00, 0x4b4d,
182 VECT_VAR_DECL(expected2
,int,8,16) [] = { 0xf8, 0x11, 0xf9, 0x11,
183 0xfa, 0x11, 0xfb, 0x11,
184 0xfc, 0x11, 0xfd, 0x11,
185 0xfe, 0x11, 0xff, 0x11 };
186 VECT_VAR_DECL(expected2
,int,16,8) [] = { 0xfff4, 0x22, 0xfff5, 0x22,
187 0xfff6, 0x22, 0xfff7, 0x22 };
188 VECT_VAR_DECL(expected2
,int,32,4) [] = { 0xfffffff2, 0x33,
190 VECT_VAR_DECL(expected2
,int,64,2) [] = { 0xfffffffffffffff1,
192 VECT_VAR_DECL(expected2
,uint
,8,16) [] = { 0xf8, 0x55, 0xf9, 0x55,
193 0xfa, 0x55, 0xfb, 0x55,
194 0xfc, 0x55, 0xfd, 0x55,
195 0xfe, 0x55, 0xff, 0x55 };
196 VECT_VAR_DECL(expected2
,uint
,16,8) [] = { 0xfff4, 0x66, 0xfff5, 0x66,
197 0xfff6, 0x66, 0xfff7, 0x66 };
198 VECT_VAR_DECL(expected2
,uint
,32,4) [] = { 0xfffffff2, 0x77,
200 VECT_VAR_DECL(expected2
,uint
,64,2) [] = { 0xfffffffffffffff1,
202 VECT_VAR_DECL(expected2
,poly
,8,16) [] = { 0xf8, 0x55, 0xf9, 0x55,
203 0xfa, 0x55, 0xfb, 0x55,
204 0xfc, 0x55, 0xfd, 0x55,
205 0xfe, 0x55, 0xff, 0x55 };
206 VECT_VAR_DECL(expected2
,poly
,16,8) [] = { 0xfff4, 0x66, 0xfff5, 0x66,
207 0xfff6, 0x66, 0xfff7, 0x66 };
208 #if defined (FP16_SUPPORTED)
209 VECT_VAR_DECL (expected2
, hfloat
, 16, 8) [] = { 0xca00, 0x4b4d,
214 VECT_VAR_DECL(expected2
,hfloat
,32,4) [] = { 0xc1600000, 0x42073333,
215 0xc1500000, 0x42073333 };
217 CLEAN(expected2
, int, 64, 1);
218 CLEAN(expected2
, uint
, 64, 1);
220 TEST_VZIP2(, int, s
, 8, 8);
221 TEST_VZIP2(, int, s
, 16, 4);
222 TEST_VZIP2(, int, s
, 32, 2);
223 TEST_VZIP2(, uint
, u
, 8, 8);
224 TEST_VZIP2(, uint
, u
, 16, 4);
225 TEST_VZIP2(, uint
, u
, 32, 2);
226 TEST_VZIP2(, poly
, p
, 8, 8);
227 TEST_VZIP2(, poly
, p
, 16, 4);
228 #if defined (FP16_SUPPORTED)
229 TEST_VZIP2(, float, f
, 16, 4);
231 TEST_VZIP2(, float, f
, 32, 2);
233 TEST_VZIP2(q
, int, s
, 8, 16);
234 TEST_VZIP2(q
, int, s
, 16, 8);
235 TEST_VZIP2(q
, int, s
, 32, 4);
236 TEST_VZIP2(q
, int, s
, 64, 2);
237 TEST_VZIP2(q
, uint
, u
, 8, 16);
238 TEST_VZIP2(q
, uint
, u
, 16, 8);
239 TEST_VZIP2(q
, uint
, u
, 32, 4);
240 TEST_VZIP2(q
, uint
, u
, 64, 2);
241 TEST_VZIP2(q
, poly
, p
, 8, 16);
242 TEST_VZIP2(q
, poly
, p
, 16, 8);
243 #if defined (FP16_SUPPORTED)
244 TEST_VZIP2(q
, float, f
, 16, 8);
246 TEST_VZIP2(q
, float, f
, 32, 4);
247 TEST_VZIP2(q
, float, f
, 64, 2);
249 CHECK_RESULTS_NAMED (TEST_MSG
, expected2
, "");
250 #if defined (FP16_SUPPORTED)
251 CHECK_FP(TEST_MSG
, float, 16, 4, PRIx16
, expected2
, "");
252 CHECK_FP(TEST_MSG
, float, 16, 8, PRIx16
, expected2
, "");