Debian Codegraph @

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

raw
1 #include <arm_neon.h>
2 #include "arm-neon-ref.h"
3 #include "compute-ref-data.h"
4
5 /* Expected results. */
6
7 /* vld2_dup/chunk 0. */
8 VECT_VAR_DECL(expected_vld2_0,int,8,8) [] = { 0xf0, 0xf1, 0xf0, 0xf1,
9 0xf0, 0xf1, 0xf0, 0xf1 };
10 VECT_VAR_DECL(expected_vld2_0,int,16,4) [] = { 0xfff0, 0xfff1, 0xfff0, 0xfff1 };
11 VECT_VAR_DECL(expected_vld2_0,int,32,2) [] = { 0xfffffff0, 0xfffffff1 };
12 VECT_VAR_DECL(expected_vld2_0,int,64,1) [] = { 0xfffffffffffffff0 };
13 VECT_VAR_DECL(expected_vld2_0,uint,8,8) [] = { 0xf0, 0xf1, 0xf0, 0xf1,
14 0xf0, 0xf1, 0xf0, 0xf1 };
15 VECT_VAR_DECL(expected_vld2_0,uint,16,4) [] = { 0xfff0, 0xfff1, 0xfff0, 0xfff1 };
16 VECT_VAR_DECL(expected_vld2_0,uint,32,2) [] = { 0xfffffff0, 0xfffffff1 };
17 VECT_VAR_DECL(expected_vld2_0,uint,64,1) [] = { 0xfffffffffffffff0 };
18 VECT_VAR_DECL(expected_vld2_0,poly,8,8) [] = { 0xf0, 0xf1, 0xf0, 0xf1,
19 0xf0, 0xf1, 0xf0, 0xf1 };
20 VECT_VAR_DECL(expected_vld2_0,poly,16,4) [] = { 0xfff0, 0xfff1, 0xfff0, 0xfff1 };
21 #if MFLOAT8_SUPPORTED
22 VECT_VAR_DECL(expected_vld2_0,hmfloat,8,8) [] = { 0xf0, 0xf1, 0xf0, 0xf1,
23 0xf0, 0xf1, 0xf0, 0xf1 };
24 #endif
25 VECT_VAR_DECL(expected_vld2_0,hfloat,16,4) [] = {0xcc00, 0xcb80, 0xcc00, 0xcb80 };
26 VECT_VAR_DECL(expected_vld2_0,hfloat,32,2) [] = { 0xc1800000, 0xc1700000 };
27
28 /* vld2_dup/chunk 1. */
29 VECT_VAR_DECL(expected_vld2_1,int,8,8) [] = { 0xf0, 0xf1, 0xf0, 0xf1,
30 0xf0, 0xf1, 0xf0, 0xf1 };
31 VECT_VAR_DECL(expected_vld2_1,int,16,4) [] = { 0xfff0, 0xfff1, 0xfff0, 0xfff1 };
32 VECT_VAR_DECL(expected_vld2_1,int,32,2) [] = { 0xfffffff0, 0xfffffff1 };
33 VECT_VAR_DECL(expected_vld2_1,int,64,1) [] = { 0xfffffffffffffff1 };
34 VECT_VAR_DECL(expected_vld2_1,uint,8,8) [] = { 0xf0, 0xf1, 0xf0, 0xf1,
35 0xf0, 0xf1, 0xf0, 0xf1 };
36 VECT_VAR_DECL(expected_vld2_1,uint,16,4) [] = { 0xfff0, 0xfff1, 0xfff0, 0xfff1 };
37 VECT_VAR_DECL(expected_vld2_1,uint,32,2) [] = { 0xfffffff0, 0xfffffff1 };
38 VECT_VAR_DECL(expected_vld2_1,uint,64,1) [] = { 0xfffffffffffffff1 };
39 VECT_VAR_DECL(expected_vld2_1,poly,8,8) [] = { 0xf0, 0xf1, 0xf0, 0xf1,
40 0xf0, 0xf1, 0xf0, 0xf1 };
41 VECT_VAR_DECL(expected_vld2_1,poly,16,4) [] = { 0xfff0, 0xfff1,
42 0xfff0, 0xfff1 };
43 #if MFLOAT8_SUPPORTED
44 VECT_VAR_DECL(expected_vld2_1,hmfloat,8,8) [] = { 0xf0, 0xf1, 0xf0, 0xf1,
45 0xf0, 0xf1, 0xf0, 0xf1 };
46 #endif
47 VECT_VAR_DECL(expected_vld2_1,hfloat,16,4) [] = { 0xcc00, 0xcb80, 0xcc00, 0xcb80 };
48 VECT_VAR_DECL(expected_vld2_1,hfloat,32,2) [] = { 0xc1800000, 0xc1700000 };
49
50 /* vld3_dup/chunk 0. */
51 VECT_VAR_DECL(expected_vld3_0,int,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf0,
52 0xf1, 0xf2, 0xf0, 0xf1 };
53 VECT_VAR_DECL(expected_vld3_0,int,16,4) [] = { 0xfff0, 0xfff1,
54 0xfff2, 0xfff0 };
55 VECT_VAR_DECL(expected_vld3_0,int,32,2) [] = { 0xfffffff0, 0xfffffff1 };
56 VECT_VAR_DECL(expected_vld3_0,int,64,1) [] = { 0xfffffffffffffff0 };
57 VECT_VAR_DECL(expected_vld3_0,uint,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf0,
58 0xf1, 0xf2, 0xf0, 0xf1 };
59 VECT_VAR_DECL(expected_vld3_0,uint,16,4) [] = { 0xfff0, 0xfff1,
60 0xfff2, 0xfff0 };
61 VECT_VAR_DECL(expected_vld3_0,uint,32,2) [] = { 0xfffffff0, 0xfffffff1 };
62 VECT_VAR_DECL(expected_vld3_0,uint,64,1) [] = { 0xfffffffffffffff0 };
63 VECT_VAR_DECL(expected_vld3_0,poly,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf0,
64 0xf1, 0xf2, 0xf0, 0xf1 };
65 VECT_VAR_DECL(expected_vld3_0,poly,16,4) [] = { 0xfff0, 0xfff1,
66 0xfff2, 0xfff0 };
67 #if MFLOAT8_SUPPORTED
68 VECT_VAR_DECL(expected_vld3_0,hmfloat,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf0,
69 0xf1, 0xf2, 0xf0, 0xf1 };
70 #endif
71 VECT_VAR_DECL(expected_vld3_0,hfloat,16,4) [] = { 0xcc00, 0xcb80, 0xcb00, 0xcc00 };
72 VECT_VAR_DECL(expected_vld3_0,hfloat,32,2) [] = { 0xc1800000, 0xc1700000 };
73
74 /* vld3_dup/chunk 1. */
75 VECT_VAR_DECL(expected_vld3_1,int,8,8) [] = { 0xf2, 0xf0, 0xf1, 0xf2,
76 0xf0, 0xf1, 0xf2, 0xf0 };
77 VECT_VAR_DECL(expected_vld3_1,int,16,4) [] = { 0xfff1, 0xfff2,
78 0xfff0, 0xfff1 };
79 VECT_VAR_DECL(expected_vld3_1,int,32,2) [] = { 0xfffffff2, 0xfffffff0 };
80 VECT_VAR_DECL(expected_vld3_1,int,64,1) [] = { 0xfffffffffffffff1 };
81 VECT_VAR_DECL(expected_vld3_1,uint,8,8) [] = { 0xf2, 0xf0, 0xf1, 0xf2,
82 0xf0, 0xf1, 0xf2, 0xf0 };
83 VECT_VAR_DECL(expected_vld3_1,uint,16,4) [] = { 0xfff1, 0xfff2,
84 0xfff0, 0xfff1 };
85 VECT_VAR_DECL(expected_vld3_1,uint,32,2) [] = { 0xfffffff2, 0xfffffff0 };
86 VECT_VAR_DECL(expected_vld3_1,uint,64,1) [] = { 0xfffffffffffffff1 };
87 VECT_VAR_DECL(expected_vld3_1,poly,8,8) [] = { 0xf2, 0xf0, 0xf1, 0xf2,
88 0xf0, 0xf1, 0xf2, 0xf0 };
89 VECT_VAR_DECL(expected_vld3_1,poly,16,4) [] = { 0xfff1, 0xfff2,
90 0xfff0, 0xfff1 };
91 #if MFLOAT8_SUPPORTED
92 VECT_VAR_DECL(expected_vld3_1,hmfloat,8,8) [] = { 0xf2, 0xf0, 0xf1, 0xf2,
93 0xf0, 0xf1, 0xf2, 0xf0 };
94 #endif
95 VECT_VAR_DECL(expected_vld3_1,hfloat,16,4) [] = { 0xcb80, 0xcb00, 0xcc00, 0xcb80 };
96 VECT_VAR_DECL(expected_vld3_1,hfloat,32,2) [] = { 0xc1600000, 0xc1800000 };
97
98 /* vld3_dup/chunk 2. */
99 VECT_VAR_DECL(expected_vld3_2,int,8,8) [] = { 0xf1, 0xf2, 0xf0, 0xf1,
100 0xf2, 0xf0, 0xf1, 0xf2 };
101 VECT_VAR_DECL(expected_vld3_2,int,16,4) [] = { 0xfff2, 0xfff0,
102 0xfff1, 0xfff2 };
103 VECT_VAR_DECL(expected_vld3_2,int,32,2) [] = { 0xfffffff1, 0xfffffff2 };
104 VECT_VAR_DECL(expected_vld3_2,int,64,1) [] = { 0xfffffffffffffff2 };
105 VECT_VAR_DECL(expected_vld3_2,uint,8,8) [] = { 0xf1, 0xf2, 0xf0, 0xf1,
106 0xf2, 0xf0, 0xf1, 0xf2 };
107 VECT_VAR_DECL(expected_vld3_2,uint,16,4) [] = { 0xfff2, 0xfff0,
108 0xfff1, 0xfff2 };
109 VECT_VAR_DECL(expected_vld3_2,uint,32,2) [] = { 0xfffffff1, 0xfffffff2 };
110 VECT_VAR_DECL(expected_vld3_2,uint,64,1) [] = { 0xfffffffffffffff2 };
111 VECT_VAR_DECL(expected_vld3_2,poly,8,8) [] = { 0xf1, 0xf2, 0xf0, 0xf1,
112 0xf2, 0xf0, 0xf1, 0xf2 };
113 VECT_VAR_DECL(expected_vld3_2,poly,16,4) [] = { 0xfff2, 0xfff0,
114 0xfff1, 0xfff2 };
115 #if MFLOAT8_SUPPORTED
116 VECT_VAR_DECL(expected_vld3_2,hmfloat,8,8) [] = { 0xf1, 0xf2, 0xf0, 0xf1,
117 0xf2, 0xf0, 0xf1, 0xf2 };
118 #endif
119 VECT_VAR_DECL(expected_vld3_2,hfloat,16,4) [] = { 0xcb00, 0xcc00, 0xcb80, 0xcb00 };
120 VECT_VAR_DECL(expected_vld3_2,hfloat,32,2) [] = { 0xc1700000, 0xc1600000 };
121
122 /* vld4_dup/chunk 0. */
123 VECT_VAR_DECL(expected_vld4_0,int,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
124 0xf0, 0xf1, 0xf2, 0xf3 };
125 VECT_VAR_DECL(expected_vld4_0,int,16,4) [] = { 0xfff0, 0xfff1,
126 0xfff2, 0xfff3 };
127 VECT_VAR_DECL(expected_vld4_0,int,32,2) [] = { 0xfffffff0, 0xfffffff1 };
128 VECT_VAR_DECL(expected_vld4_0,int,64,1) [] = { 0xfffffffffffffff0 };
129 VECT_VAR_DECL(expected_vld4_0,uint,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
130 0xf0, 0xf1, 0xf2, 0xf3 };
131 VECT_VAR_DECL(expected_vld4_0,uint,16,4) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3 };
132 VECT_VAR_DECL(expected_vld4_0,uint,32,2) [] = { 0xfffffff0, 0xfffffff1 };
133 VECT_VAR_DECL(expected_vld4_0,uint,64,1) [] = { 0xfffffffffffffff0 };
134 VECT_VAR_DECL(expected_vld4_0,poly,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
135 0xf0, 0xf1, 0xf2, 0xf3 };
136 VECT_VAR_DECL(expected_vld4_0,poly,16,4) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3 };
137 #if MFLOAT8_SUPPORTED
138 VECT_VAR_DECL(expected_vld4_0,hmfloat,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
139 0xf0, 0xf1, 0xf2, 0xf3 };
140 #endif
141 VECT_VAR_DECL(expected_vld4_0,hfloat,16,4) [] = { 0xcc00, 0xcb80, 0xcb00, 0xca80 };
142 VECT_VAR_DECL(expected_vld4_0,hfloat,32,2) [] = { 0xc1800000, 0xc1700000 };
143
144 /* vld4_dup/chunk 1. */
145 VECT_VAR_DECL(expected_vld4_1,int,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
146 0xf0, 0xf1, 0xf2, 0xf3 };
147 VECT_VAR_DECL(expected_vld4_1,int,16,4) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3 };
148 VECT_VAR_DECL(expected_vld4_1,int,32,2) [] = { 0xfffffff2, 0xfffffff3 };
149 VECT_VAR_DECL(expected_vld4_1,int,64,1) [] = { 0xfffffffffffffff1 };
150 VECT_VAR_DECL(expected_vld4_1,uint,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
151 0xf0, 0xf1, 0xf2, 0xf3 };
152 VECT_VAR_DECL(expected_vld4_1,uint,16,4) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3 };
153 VECT_VAR_DECL(expected_vld4_1,uint,32,2) [] = { 0xfffffff2, 0xfffffff3 };
154 VECT_VAR_DECL(expected_vld4_1,uint,64,1) [] = { 0xfffffffffffffff1 };
155 VECT_VAR_DECL(expected_vld4_1,poly,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
156 0xf0, 0xf1, 0xf2, 0xf3 };
157 VECT_VAR_DECL(expected_vld4_1,poly,16,4) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3 };
158 #if MFLOAT8_SUPPORTED
159 VECT_VAR_DECL(expected_vld4_1,hmfloat,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
160 0xf0, 0xf1, 0xf2, 0xf3 };
161 #endif
162 VECT_VAR_DECL(expected_vld4_1,hfloat,16,4) [] = { 0xcc00, 0xcb80, 0xcb00, 0xca80 };
163 VECT_VAR_DECL(expected_vld4_1,hfloat,32,2) [] = { 0xc1600000, 0xc1500000 };
164
165 /* vld4_dup/chunk 2. */
166 VECT_VAR_DECL(expected_vld4_2,int,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
167 0xf0, 0xf1, 0xf2, 0xf3 };
168 VECT_VAR_DECL(expected_vld4_2,int,16,4) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3 };
169 VECT_VAR_DECL(expected_vld4_2,int,32,2) [] = { 0xfffffff0, 0xfffffff1 };
170 VECT_VAR_DECL(expected_vld4_2,int,64,1) [] = { 0xfffffffffffffff2 };
171 VECT_VAR_DECL(expected_vld4_2,uint,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
172 0xf0, 0xf1, 0xf2, 0xf3 };
173 VECT_VAR_DECL(expected_vld4_2,uint,16,4) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3 };
174 VECT_VAR_DECL(expected_vld4_2,uint,32,2) [] = { 0xfffffff0, 0xfffffff1 };
175 VECT_VAR_DECL(expected_vld4_2,uint,64,1) [] = { 0xfffffffffffffff2 };
176 VECT_VAR_DECL(expected_vld4_2,poly,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
177 0xf0, 0xf1, 0xf2, 0xf3 };
178 VECT_VAR_DECL(expected_vld4_2,poly,16,4) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3 };
179 #if MFLOAT8_SUPPORTED
180 VECT_VAR_DECL(expected_vld4_2,hmfloat,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
181 0xf0, 0xf1, 0xf2, 0xf3 };
182 #endif
183 VECT_VAR_DECL(expected_vld4_2,hfloat,16,4) [] = { 0xcc00, 0xcb80, 0xcb00, 0xca80 };
184 VECT_VAR_DECL(expected_vld4_2,hfloat,32,2) [] = { 0xc1800000, 0xc1700000 };
185
186 /* vld4_dup/chunk3. */
187 VECT_VAR_DECL(expected_vld4_3,int,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
188 0xf0, 0xf1, 0xf2, 0xf3 };
189 VECT_VAR_DECL(expected_vld4_3,int,16,4) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3 };
190 VECT_VAR_DECL(expected_vld4_3,int,32,2) [] = { 0xfffffff2, 0xfffffff3 };
191 VECT_VAR_DECL(expected_vld4_3,int,64,1) [] = { 0xfffffffffffffff3 };
192 VECT_VAR_DECL(expected_vld4_3,uint,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
193 0xf0, 0xf1, 0xf2, 0xf3 };
194 VECT_VAR_DECL(expected_vld4_3,uint,16,4) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3 };
195 VECT_VAR_DECL(expected_vld4_3,uint,32,2) [] = { 0xfffffff2, 0xfffffff3 };
196 VECT_VAR_DECL(expected_vld4_3,uint,64,1) [] = { 0xfffffffffffffff3 };
197 VECT_VAR_DECL(expected_vld4_3,poly,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
198 0xf0, 0xf1, 0xf2, 0xf3 };
199 VECT_VAR_DECL(expected_vld4_3,poly,16,4) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3 };
200 #if MFLOAT8_SUPPORTED
201 VECT_VAR_DECL(expected_vld4_3,hmfloat,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
202 0xf0, 0xf1, 0xf2, 0xf3 };
203 #endif
204 VECT_VAR_DECL(expected_vld4_3,hfloat,16,4) [] = { 0xcc00, 0xcb80, 0xcb00, 0xca80 };
205 VECT_VAR_DECL(expected_vld4_3,hfloat,32,2) [] = { 0xc1600000, 0xc1500000 };
206
207 void exec_vldX_dup (void)
208 {
209 /* In this case, input variables are arrays of vectors. */
210 #define DECL_VLDX_DUP(T1, W, N, X) \
211 VECT_ARRAY_TYPE(T1, W, N, X) VECT_ARRAY_VAR(vector, T1, W, N, X); \
212 VECT_VAR_DECL(result_bis_##X, T1, W, N)[X * N]
213
214 /* We need to use a temporary result buffer (result_bis), because
215 the one used for other tests is not large enough. A subset of the
216 result data is moved from result_bis to result, and it is this
217 subset which is used to check the actual behavior. The next
218 macro enables to move another chunk of data from result_bis to
219 result. */
220 #define TEST_VLDX_DUP(Q, T1, T2, W, N, X) \
221 VECT_ARRAY_VAR(vector, T1, W, N, X) = \
222 vld##X##Q##_dup_##T2##W(&VECT_VAR(buffer_dup, T1, W, N)[0]); \
223 \
224 vst##X##Q##_##T2##W(VECT_VAR(result_bis_##X, T1, W, N), \
225 VECT_ARRAY_VAR(vector, T1, W, N, X)); \
226 memcpy(VECT_VAR(result, T1, W, N), VECT_VAR(result_bis_##X, T1, W, N), \
227 sizeof(VECT_VAR(result, T1, W, N)));
228
229
230 /* Overwrite "result" with the contents of "result_bis"[Y]. */
231 #define TEST_EXTRA_CHUNK(T1, W, N, X,Y) \
232 memcpy(VECT_VAR(result, T1, W, N), \
233 &(VECT_VAR(result_bis_##X, T1, W, N)[Y*N]), \
234 sizeof(VECT_VAR(result, T1, W, N)));
235
236 #define DECL_ALL_VLDX_DUP_NO_FP16(X) \
237 DECL_VLDX_DUP(int, 8, 8, X); \
238 DECL_VLDX_DUP(int, 16, 4, X); \
239 DECL_VLDX_DUP(int, 32, 2, X); \
240 DECL_VLDX_DUP(int, 64, 1, X); \
241 DECL_VLDX_DUP(uint, 8, 8, X); \
242 DECL_VLDX_DUP(uint, 16, 4, X); \
243 DECL_VLDX_DUP(uint, 32, 2, X); \
244 DECL_VLDX_DUP(uint, 64, 1, X); \
245 DECL_VLDX_DUP(poly, 8, 8, X); \
246 DECL_VLDX_DUP(poly, 16, 4, X); \
247 MFLOAT8_ONLY(DECL_VLDX_DUP(mfloat, 8, 8, X)); \
248 DECL_VLDX_DUP(float, 32, 2, X)
249
250 #if defined (__ARM_FP16_FORMAT_IEEE) || defined (__ARM_FP16_FORMAT_ALTERNATIVE)
251 #define DECL_ALL_VLDX_DUP(X) \
252 DECL_ALL_VLDX_DUP_NO_FP16(X); \
253 DECL_VLDX_DUP(float, 16, 4, X)
254 #else
255 #define DECL_ALL_VLDX_DUP(X) DECL_ALL_VLDX_DUP_NO_FP16(X)
256 #endif
257
258 #define TEST_ALL_VLDX_DUP_NO_FP16(X) \
259 TEST_VLDX_DUP(, int, s, 8, 8, X); \
260 TEST_VLDX_DUP(, int, s, 16, 4, X); \
261 TEST_VLDX_DUP(, int, s, 32, 2, X); \
262 TEST_VLDX_DUP(, int, s, 64, 1, X); \
263 TEST_VLDX_DUP(, uint, u, 8, 8, X); \
264 TEST_VLDX_DUP(, uint, u, 16, 4, X); \
265 TEST_VLDX_DUP(, uint, u, 32, 2, X); \
266 TEST_VLDX_DUP(, uint, u, 64, 1, X); \
267 TEST_VLDX_DUP(, poly, p, 8, 8, X); \
268 TEST_VLDX_DUP(, poly, p, 16, 4, X); \
269 MFLOAT8_ONLY(TEST_VLDX_DUP(, mfloat, mf, 8, 8, X)); \
270 TEST_VLDX_DUP(, float, f, 32, 2, X)
271
272 #if defined (__ARM_FP16_FORMAT_IEEE) || defined (__ARM_FP16_FORMAT_ALTERNATIVE)
273 #define TEST_ALL_VLDX_DUP(X) \
274 TEST_ALL_VLDX_DUP_NO_FP16(X); \
275 TEST_VLDX_DUP(, float, f, 16, 4, X)
276 #else
277 #define TEST_ALL_VLDX_DUP(X) TEST_ALL_VLDX_DUP_NO_FP16(X)
278 #endif
279
280 #define TEST_ALL_EXTRA_CHUNKS_NO_FP16(X, Y) \
281 TEST_EXTRA_CHUNK(int, 8, 8, X, Y); \
282 TEST_EXTRA_CHUNK(int, 16, 4, X, Y); \
283 TEST_EXTRA_CHUNK(int, 32, 2, X, Y); \
284 TEST_EXTRA_CHUNK(int, 64, 1, X, Y); \
285 TEST_EXTRA_CHUNK(uint, 8, 8, X, Y); \
286 TEST_EXTRA_CHUNK(uint, 16, 4, X, Y); \
287 TEST_EXTRA_CHUNK(uint, 32, 2, X, Y); \
288 TEST_EXTRA_CHUNK(uint, 64, 1, X, Y); \
289 TEST_EXTRA_CHUNK(poly, 8, 8, X, Y); \
290 TEST_EXTRA_CHUNK(poly, 16, 4, X, Y); \
291 MFLOAT8_ONLY(TEST_EXTRA_CHUNK(mfloat, 8, 8, X, Y)); \
292 TEST_EXTRA_CHUNK(float, 32, 2, X, Y)
293
294 #if defined (__ARM_FP16_FORMAT_IEEE) || defined (__ARM_FP16_FORMAT_ALTERNATIVE)
295 #define TEST_ALL_EXTRA_CHUNKS(X, Y) \
296 TEST_ALL_EXTRA_CHUNKS_NO_FP16(X, Y); \
297 TEST_EXTRA_CHUNK(float, 16, 4, X, Y)
298 #else
299 #define TEST_ALL_EXTRA_CHUNKS(X, Y) TEST_ALL_EXTRA_CHUNKS_NO_FP16(X, Y)
300 #endif
301
302 /* vldX_dup supports only 64-bit inputs. */
303 #define CHECK_RESULTS_VLDX_DUP_NO_FP16(test_name,EXPECTED,comment) \
304 CHECK(test_name, int, 8, 8, PRIx8, EXPECTED, comment); \
305 CHECK(test_name, int, 16, 4, PRIx16, EXPECTED, comment); \
306 CHECK(test_name, int, 32, 2, PRIx32, EXPECTED, comment); \
307 CHECK(test_name, int, 64, 1, PRIx64, EXPECTED, comment); \
308 CHECK(test_name, uint, 8, 8, PRIx8, EXPECTED, comment); \
309 CHECK(test_name, uint, 16, 4, PRIx16, EXPECTED, comment); \
310 CHECK(test_name, uint, 32, 2, PRIx32, EXPECTED, comment); \
311 CHECK(test_name, uint, 64, 1, PRIx64, EXPECTED, comment); \
312 CHECK_POLY(test_name, poly, 8, 8, PRIx8, EXPECTED, comment); \
313 CHECK_POLY(test_name, poly, 16, 4, PRIx16, EXPECTED, comment); \
314 MFLOAT8_ONLY(CHECK_FP(test_name, mfloat, 8, 8, PRIx8, EXPECTED, comment)); \
315 CHECK_FP(test_name, float, 32, 2, PRIx32, EXPECTED, comment)
316
317 #if defined (__ARM_FP16_FORMAT_IEEE) || defined (__ARM_FP16_FORMAT_ALTERNATIVE)
318 #define CHECK_RESULTS_VLDX_DUP(test_name,EXPECTED,comment) \
319 { \
320 CHECK_RESULTS_VLDX_DUP_NO_FP16(test_name,EXPECTED,comment); \
321 CHECK_FP(test_name, float, 16, 4, PRIx16, EXPECTED, comment); \
322 }
323 #else
324 #define CHECK_RESULTS_VLDX_DUP(test_name,EXPECTED,comment) \
325 { \
326 CHECK_RESULTS_VLDX_DUP_NO_FP16(test_name,EXPECTED,comment); \
327 }
328 #endif
329
330 DECL_ALL_VLDX_DUP(2);
331 DECL_ALL_VLDX_DUP(3);
332 DECL_ALL_VLDX_DUP(4);
333
334 /* Special input buffers of suitable size are needed for vld2/vld3/vld4. */
335 /* Input buffers for vld2, 1 of each size */
336 VECT_ARRAY_INIT2(buffer_vld2, int, 8, 8);
337 PAD(buffer_vld2_pad, int, 8, 8);
338 VECT_ARRAY_INIT2(buffer_vld2, int, 16, 4);
339 PAD(buffer_vld2_pad, int, 16, 4);
340 VECT_ARRAY_INIT2(buffer_vld2, int, 32, 2);
341 PAD(buffer_vld2_pad, int, 32, 2);
342 VECT_ARRAY_INIT2(buffer_vld2, int, 64, 1);
343 PAD(buffer_vld2_pad, int, 64, 1);
344 VECT_ARRAY_INIT2(buffer_vld2, uint, 8, 8);
345 PAD(buffer_vld2_pad, uint, 8, 8);
346 VECT_ARRAY_INIT2(buffer_vld2, uint, 16, 4);
347 PAD(buffer_vld2_pad, uint, 16, 4);
348 VECT_ARRAY_INIT2(buffer_vld2, uint, 32, 2);
349 PAD(buffer_vld2_pad, uint, 32, 2);
350 VECT_ARRAY_INIT2(buffer_vld2, uint, 64, 1);
351 PAD(buffer_vld2_pad, uint, 64, 1);
352 VECT_ARRAY_INIT2(buffer_vld2, poly, 8, 8);
353 PAD(buffer_vld2_pad, poly, 8, 8);
354 VECT_ARRAY_INIT2(buffer_vld2, poly, 16, 4);
355 PAD(buffer_vld2_pad, poly, 16, 4);
356 #if MFLOAT8_SUPPORTED
357 VECT_ARRAY(buffer_vld2, mfloat, 8, 8, 2);
358 __builtin_memcpy (VECT_ARRAY_VAR(buffer_vld2, mfloat, 8, 8, 2),
359 VECT_ARRAY_VAR(buffer_vld2, int, 8, 8, 2), 8 * 2);
360 PAD(buffer_vld2_pad, mfloat, 8, 8);
361 #endif
362 #if defined (__ARM_FP16_FORMAT_IEEE) || defined (__ARM_FP16_FORMAT_ALTERNATIVE)
363 VECT_ARRAY_INIT2(buffer_vld2, float, 16, 4);
364 PAD(buffer_vld2_pad, float, 16, 4);
365 #endif
366 VECT_ARRAY_INIT2(buffer_vld2, float, 32, 2);
367 PAD(buffer_vld2_pad, float, 32, 2);
368
369 VECT_ARRAY_INIT2(buffer_vld2, int, 8, 16);
370 PAD(buffer_vld2_pad, int, 8, 16);
371 VECT_ARRAY_INIT2(buffer_vld2, int, 16, 8);
372 PAD(buffer_vld2_pad, int, 16, 8);
373 VECT_ARRAY_INIT2(buffer_vld2, int, 32, 4);
374 PAD(buffer_vld2_pad, int, 32, 4);
375 VECT_ARRAY_INIT2(buffer_vld2, int, 64, 2);
376 PAD(buffer_vld2_pad, int, 64, 2);
377 VECT_ARRAY_INIT2(buffer_vld2, uint, 8, 16);
378 PAD(buffer_vld2_pad, uint, 8, 16);
379 VECT_ARRAY_INIT2(buffer_vld2, uint, 16, 8);
380 PAD(buffer_vld2_pad, uint, 16, 8);
381 VECT_ARRAY_INIT2(buffer_vld2, uint, 32, 4);
382 PAD(buffer_vld2_pad, uint, 32, 4);
383 VECT_ARRAY_INIT2(buffer_vld2, uint, 64, 2);
384 PAD(buffer_vld2_pad, uint, 64, 2);
385 VECT_ARRAY_INIT2(buffer_vld2, poly, 8, 16);
386 PAD(buffer_vld2_pad, poly, 8, 16);
387 VECT_ARRAY_INIT2(buffer_vld2, poly, 16, 8);
388 PAD(buffer_vld2_pad, poly, 16, 8);
389 #if MFLOAT8_SUPPORTED
390 VECT_ARRAY(buffer_vld2, mfloat, 8, 16, 2);
391 PAD(buffer_vld2_pad, mfloat, 8, 16);
392 __builtin_memcpy (VECT_ARRAY_VAR(buffer_vld2, mfloat, 8, 16, 2),
393 VECT_ARRAY_VAR(buffer_vld2, int, 8, 16, 2), 16 * 2);
394 #endif
395 #if defined (__ARM_FP16_FORMAT_IEEE) || defined (__ARM_FP16_FORMAT_ALTERNATIVE)
396 VECT_ARRAY_INIT2(buffer_vld2, float, 16, 8);
397 PAD(buffer_vld2_pad, float, 16, 8);
398 #endif
399 VECT_ARRAY_INIT2(buffer_vld2, float, 32, 4);
400 PAD(buffer_vld2_pad, float, 32, 4);
401
402 /* Input buffers for vld3, 1 of each size */
403 VECT_ARRAY_INIT3(buffer_vld3, int, 8, 8);
404 PAD(buffer_vld3_pad, int, 8, 8);
405 VECT_ARRAY_INIT3(buffer_vld3, int, 16, 4);
406 PAD(buffer_vld3_pad, int, 16, 4);
407 VECT_ARRAY_INIT3(buffer_vld3, int, 32, 2);
408 PAD(buffer_vld3_pad, int, 32, 2);
409 VECT_ARRAY_INIT3(buffer_vld3, int, 64, 1);
410 PAD(buffer_vld3_pad, int, 64, 1);
411 VECT_ARRAY_INIT3(buffer_vld3, uint, 8, 8);
412 PAD(buffer_vld3_pad, uint, 8, 8);
413 VECT_ARRAY_INIT3(buffer_vld3, uint, 16, 4);
414 PAD(buffer_vld3_pad, uint, 16, 4);
415 VECT_ARRAY_INIT3(buffer_vld3, uint, 32, 2);
416 PAD(buffer_vld3_pad, uint, 32, 2);
417 VECT_ARRAY_INIT3(buffer_vld3, uint, 64, 1);
418 PAD(buffer_vld3_pad, uint, 64, 1);
419 VECT_ARRAY_INIT3(buffer_vld3, poly, 8, 8);
420 PAD(buffer_vld3_pad, poly, 8, 8);
421 VECT_ARRAY_INIT3(buffer_vld3, poly, 16, 4);
422 PAD(buffer_vld3_pad, poly, 16, 4);
423 #if MFLOAT8_SUPPORTED
424 VECT_ARRAY(buffer_vld3, mfloat, 8, 8, 3);
425 PAD(buffer_vld3_pad, mfloat, 8, 8);
426 __builtin_memcpy (VECT_ARRAY_VAR(buffer_vld3, mfloat, 8, 8, 3),
427 VECT_ARRAY_VAR(buffer_vld3, int, 8, 8, 3), 8 * 3);
428 #endif
429 #if defined (__ARM_FP16_FORMAT_IEEE) || defined (__ARM_FP16_FORMAT_ALTERNATIVE)
430 VECT_ARRAY_INIT3(buffer_vld3, float, 16, 4);
431 PAD(buffer_vld3_pad, float, 16, 4);
432 #endif
433 VECT_ARRAY_INIT3(buffer_vld3, float, 32, 2);
434 PAD(buffer_vld3_pad, float, 32, 2);
435
436 VECT_ARRAY_INIT3(buffer_vld3, int, 8, 16);
437 PAD(buffer_vld3_pad, int, 8, 16);
438 VECT_ARRAY_INIT3(buffer_vld3, int, 16, 8);
439 PAD(buffer_vld3_pad, int, 16, 8);
440 VECT_ARRAY_INIT3(buffer_vld3, int, 32, 4);
441 PAD(buffer_vld3_pad, int, 32, 4);
442 VECT_ARRAY_INIT3(buffer_vld3, int, 64, 2);
443 PAD(buffer_vld3_pad, int, 64, 2);
444 VECT_ARRAY_INIT3(buffer_vld3, uint, 8, 16);
445 PAD(buffer_vld3_pad, uint, 8, 16);
446 VECT_ARRAY_INIT3(buffer_vld3, uint, 16, 8);
447 PAD(buffer_vld3_pad, uint, 16, 8);
448 VECT_ARRAY_INIT3(buffer_vld3, uint, 32, 4);
449 PAD(buffer_vld3_pad, uint, 32, 4);
450 VECT_ARRAY_INIT3(buffer_vld3, uint, 64, 2);
451 PAD(buffer_vld3_pad, uint, 64, 2);
452 VECT_ARRAY_INIT3(buffer_vld3, poly, 8, 16);
453 PAD(buffer_vld3_pad, poly, 8, 16);
454 VECT_ARRAY_INIT3(buffer_vld3, poly, 16, 8);
455 PAD(buffer_vld3_pad, poly, 16, 8);
456 #if MFLOAT8_SUPPORTED
457 VECT_ARRAY(buffer_vld3, mfloat, 8, 16, 3);
458 PAD(buffer_vld3_pad, mfloat, 8, 16);
459 __builtin_memcpy (VECT_ARRAY_VAR(buffer_vld3, mfloat, 8, 16, 3),
460 VECT_ARRAY_VAR(buffer_vld3, int, 8, 16, 3), 16 * 3);
461 #endif
462 #if defined (__ARM_FP16_FORMAT_IEEE) || defined (__ARM_FP16_FORMAT_ALTERNATIVE)
463 VECT_ARRAY_INIT3(buffer_vld3, float, 16, 8);
464 PAD(buffer_vld3_pad, float, 16, 8);
465 #endif
466 VECT_ARRAY_INIT3(buffer_vld3, float, 32, 4);
467 PAD(buffer_vld3_pad, float, 32, 4);
468
469 /* Input buffers for vld4, 1 of each size */
470 VECT_ARRAY_INIT4(buffer_vld4, int, 8, 8);
471 PAD(buffer_vld4_pad, int, 8, 8);
472 VECT_ARRAY_INIT4(buffer_vld4, int, 16, 4);
473 PAD(buffer_vld4_pad, int, 16, 4);
474 VECT_ARRAY_INIT4(buffer_vld4, int, 32, 2);
475 PAD(buffer_vld4_pad, int, 32, 2);
476 VECT_ARRAY_INIT4(buffer_vld4, int, 64, 1);
477 PAD(buffer_vld4_pad, int, 64, 1);
478 VECT_ARRAY_INIT4(buffer_vld4, uint, 8, 8);
479 PAD(buffer_vld4_pad, uint, 8, 8);
480 VECT_ARRAY_INIT4(buffer_vld4, uint, 16, 4);
481 PAD(buffer_vld4_pad, uint, 16, 4);
482 VECT_ARRAY_INIT4(buffer_vld4, uint, 32, 2);
483 PAD(buffer_vld4_pad, uint, 32, 2);
484 VECT_ARRAY_INIT4(buffer_vld4, uint, 64, 1);
485 PAD(buffer_vld4_pad, uint, 64, 1);
486 VECT_ARRAY_INIT4(buffer_vld4, poly, 8, 8);
487 PAD(buffer_vld4_pad, poly, 8, 8);
488 VECT_ARRAY_INIT4(buffer_vld4, poly, 16, 4);
489 PAD(buffer_vld4_pad, poly, 16, 4);
490 #if MFLOAT8_SUPPORTED
491 VECT_ARRAY(buffer_vld4, mfloat, 8, 8, 4);
492 PAD(buffer_vld4_pad, mfloat, 8, 8);
493 __builtin_memcpy (VECT_ARRAY_VAR(buffer_vld4, mfloat, 8, 8, 4),
494 VECT_ARRAY_VAR(buffer_vld4, int, 8, 8, 4), 8 * 4);
495 #endif
496 #if defined (__ARM_FP16_FORMAT_IEEE) || defined (__ARM_FP16_FORMAT_ALTERNATIVE)
497 VECT_ARRAY_INIT4(buffer_vld4, float, 16, 4);
498 PAD(buffer_vld4_pad, float, 16, 4);
499 #endif
500 VECT_ARRAY_INIT4(buffer_vld4, float, 32, 2);
501 PAD(buffer_vld4_pad, float, 32, 2);
502
503 VECT_ARRAY_INIT4(buffer_vld4, int, 8, 16);
504 PAD(buffer_vld4_pad, int, 8, 16);
505 VECT_ARRAY_INIT4(buffer_vld4, int, 16, 8);
506 PAD(buffer_vld4_pad, int, 16, 8);
507 VECT_ARRAY_INIT4(buffer_vld4, int, 32, 4);
508 PAD(buffer_vld4_pad, int, 32, 4);
509 VECT_ARRAY_INIT4(buffer_vld4, int, 64, 2);
510 PAD(buffer_vld4_pad, int, 64, 2);
511 VECT_ARRAY_INIT4(buffer_vld4, uint, 8, 16);
512 PAD(buffer_vld4_pad, uint, 8, 16);
513 VECT_ARRAY_INIT4(buffer_vld4, uint, 16, 8);
514 PAD(buffer_vld4_pad, uint, 16, 8);
515 VECT_ARRAY_INIT4(buffer_vld4, uint, 32, 4);
516 PAD(buffer_vld4_pad, uint, 32, 4);
517 VECT_ARRAY_INIT4(buffer_vld4, uint, 64, 2);
518 PAD(buffer_vld4_pad, uint, 64, 2);
519 VECT_ARRAY_INIT4(buffer_vld4, poly, 8, 16);
520 PAD(buffer_vld4_pad, poly, 8, 16);
521 VECT_ARRAY_INIT4(buffer_vld4, poly, 16, 8);
522 PAD(buffer_vld4_pad, poly, 16, 8);
523 #if MFLOAT8_SUPPORTED
524 VECT_ARRAY(buffer_vld4, mfloat, 8, 16, 4);
525 PAD(buffer_vld4_pad, mfloat, 8, 16);
526 __builtin_memcpy (VECT_ARRAY_VAR(buffer_vld4, mfloat, 8, 16, 4),
527 VECT_ARRAY_VAR(buffer_vld4, int, 8, 16, 4), 16 * 4);
528 #endif
529 #if defined (__ARM_FP16_FORMAT_IEEE) || defined (__ARM_FP16_FORMAT_ALTERNATIVE)
530 VECT_ARRAY_INIT4(buffer_vld4, float, 16, 8);
531 PAD(buffer_vld4_pad, float, 16, 8);
532 #endif
533 VECT_ARRAY_INIT4(buffer_vld4, float, 32, 4);
534 PAD(buffer_vld4_pad, float, 32, 4);
535
536 /* Check vld2_dup/vld2q_dup. */
537 clean_results ();
538 #define TEST_MSG "VLD2_DUP/VLD2Q_DUP"
539 TEST_ALL_VLDX_DUP(2);
540 CHECK_RESULTS_VLDX_DUP (TEST_MSG, expected_vld2_0, "chunk 0");
541
542 TEST_ALL_EXTRA_CHUNKS(2, 1);
543 CHECK_RESULTS_VLDX_DUP (TEST_MSG, expected_vld2_1, "chunk 1");
544
545 /* Check vld3_dup/vld3q_dup. */
546 clean_results ();
547 #undef TEST_MSG
548 #define TEST_MSG "VLD3_DUP/VLD3Q_DUP"
549 TEST_ALL_VLDX_DUP(3);
550 CHECK_RESULTS_VLDX_DUP (TEST_MSG, expected_vld3_0, "chunk 0");
551
552 TEST_ALL_EXTRA_CHUNKS(3, 1);
553 CHECK_RESULTS_VLDX_DUP (TEST_MSG, expected_vld3_1, "chunk 1");
554
555 TEST_ALL_EXTRA_CHUNKS(3, 2);
556 CHECK_RESULTS_VLDX_DUP (TEST_MSG, expected_vld3_2, "chunk 2");
557
558 /* Check vld4_dup/vld4q_dup */
559 clean_results ();
560 #undef TEST_MSG
561 #define TEST_MSG "VLD4_DUP/VLD4Q_DUP"
562 TEST_ALL_VLDX_DUP(4);
563 CHECK_RESULTS_VLDX_DUP (TEST_MSG, expected_vld4_0, "chunk 0");
564
565 TEST_ALL_EXTRA_CHUNKS(4, 1);
566 CHECK_RESULTS_VLDX_DUP (TEST_MSG, expected_vld4_1, "chunk 1");
567
568 TEST_ALL_EXTRA_CHUNKS(4, 2);
569 CHECK_RESULTS_VLDX_DUP (TEST_MSG, expected_vld4_2, "chunk 2");
570
571 TEST_ALL_EXTRA_CHUNKS(4, 3);
572 CHECK_RESULTS_VLDX_DUP (TEST_MSG, expected_vld4_3, "chunk 3");
573 }
574
575 int main (void)
576 {
577 exec_vldX_dup ();
578 return 0;
579 }