Debian Codegraph @

gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vldX.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/chunk 0. */
8 VECT_VAR_DECL(expected_vld2_0,int,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
9 0xf4, 0xf5, 0xf6, 0xf7 };
10 VECT_VAR_DECL(expected_vld2_0,int,16,4) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3 };
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, 0xf2, 0xf3,
14 0xf4, 0xf5, 0xf6, 0xf7 };
15 VECT_VAR_DECL(expected_vld2_0,uint,16,4) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3 };
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, 0xf2, 0xf3,
19 0xf4, 0xf5, 0xf6, 0xf7 };
20 VECT_VAR_DECL(expected_vld2_0,poly,16,4) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3 };
21 #if MFLOAT8_SUPPORTED
22 VECT_VAR_DECL(expected_vld2_0,hmfloat,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
23 0xf4, 0xf5, 0xf6, 0xf7 };
24 #endif
25 VECT_VAR_DECL(expected_vld2_0,hfloat,16,4) [] = { 0xcc00, 0xcb80, 0xcb00, 0xca80 };
26 VECT_VAR_DECL(expected_vld2_0,hfloat,32,2) [] = { 0xc1800000, 0xc1700000 };
27 VECT_VAR_DECL(expected_vld2_0,int,8,16) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
28 0xf4, 0xf5, 0xf6, 0xf7,
29 0xf8, 0xf9, 0xfa, 0xfb,
30 0xfc, 0xfd, 0xfe, 0xff };
31 VECT_VAR_DECL(expected_vld2_0,int,16,8) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3,
32 0xfff4, 0xfff5, 0xfff6, 0xfff7 };
33 VECT_VAR_DECL(expected_vld2_0,int,32,4) [] = { 0xfffffff0, 0xfffffff1,
34 0xfffffff2, 0xfffffff3 };
35 VECT_VAR_DECL(expected_vld2_0,uint,8,16) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
36 0xf4, 0xf5, 0xf6, 0xf7,
37 0xf8, 0xf9, 0xfa, 0xfb,
38 0xfc, 0xfd, 0xfe, 0xff };
39 VECT_VAR_DECL(expected_vld2_0,uint,16,8) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3,
40 0xfff4, 0xfff5, 0xfff6, 0xfff7 };
41 VECT_VAR_DECL(expected_vld2_0,uint,32,4) [] = { 0xfffffff0, 0xfffffff1,
42 0xfffffff2, 0xfffffff3 };
43 VECT_VAR_DECL(expected_vld2_0,poly,8,16) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
44 0xf4, 0xf5, 0xf6, 0xf7,
45 0xf8, 0xf9, 0xfa, 0xfb,
46 0xfc, 0xfd, 0xfe, 0xff };
47 VECT_VAR_DECL(expected_vld2_0,poly,16,8) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3,
48 0xfff4, 0xfff5, 0xfff6, 0xfff7 };
49 #if MFLOAT8_SUPPORTED
50 VECT_VAR_DECL(expected_vld2_0,hmfloat,8,16) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
51 0xf4, 0xf5, 0xf6, 0xf7,
52 0xf8, 0xf9, 0xfa, 0xfb,
53 0xfc, 0xfd, 0xfe, 0xff };
54 #endif
55 VECT_VAR_DECL(expected_vld2_0,hfloat,16,8) [] = { 0xcc00, 0xcb80, 0xcb00, 0xca80,
56 0xca00, 0xc980, 0xc900, 0xc880 };
57 VECT_VAR_DECL(expected_vld2_0,hfloat,32,4) [] = { 0xc1800000, 0xc1700000,
58 0xc1600000, 0xc1500000 };
59
60 /* vld2/chunk 1. */
61 VECT_VAR_DECL(expected_vld2_1,int,8,8) [] = { 0xf8, 0xf9, 0xfa, 0xfb,
62 0xfc, 0xfd, 0xfe, 0xff };
63 VECT_VAR_DECL(expected_vld2_1,int,16,4) [] = { 0xfff4, 0xfff5, 0xfff6, 0xfff7 };
64 VECT_VAR_DECL(expected_vld2_1,int,32,2) [] = { 0xfffffff2, 0xfffffff3 };
65 VECT_VAR_DECL(expected_vld2_1,int,64,1) [] = { 0xfffffffffffffff1 };
66 VECT_VAR_DECL(expected_vld2_1,uint,8,8) [] = { 0xf8, 0xf9, 0xfa, 0xfb,
67 0xfc, 0xfd, 0xfe, 0xff };
68 VECT_VAR_DECL(expected_vld2_1,uint,16,4) [] = { 0xfff4, 0xfff5, 0xfff6, 0xfff7 };
69 VECT_VAR_DECL(expected_vld2_1,uint,32,2) [] = { 0xfffffff2, 0xfffffff3 };
70 VECT_VAR_DECL(expected_vld2_1,uint,64,1) [] = { 0xfffffffffffffff1 };
71 VECT_VAR_DECL(expected_vld2_1,poly,8,8) [] = { 0xf8, 0xf9, 0xfa, 0xfb,
72 0xfc, 0xfd, 0xfe, 0xff };
73 VECT_VAR_DECL(expected_vld2_1,poly,16,4) [] = { 0xfff4, 0xfff5, 0xfff6, 0xfff7 };
74 #if MFLOAT8_SUPPORTED
75 VECT_VAR_DECL(expected_vld2_1,hmfloat,8,8) [] = { 0xf8, 0xf9, 0xfa, 0xfb,
76 0xfc, 0xfd, 0xfe, 0xff };
77 #endif
78 VECT_VAR_DECL(expected_vld2_1,hfloat,16,4) [] = { 0xca00, 0xc980, 0xc900, 0xc880 };
79 VECT_VAR_DECL(expected_vld2_1,hfloat,32,2) [] = { 0xc1600000, 0xc1500000 };
80 VECT_VAR_DECL(expected_vld2_1,int,8,16) [] = { 0x0, 0x1, 0x2, 0x3,
81 0x4, 0x5, 0x6, 0x7,
82 0x8, 0x9, 0xa, 0xb,
83 0xc, 0xd, 0xe, 0xf };
84 VECT_VAR_DECL(expected_vld2_1,int,16,8) [] = { 0xfff8, 0xfff9, 0xfffa, 0xfffb,
85 0xfffc, 0xfffd, 0xfffe, 0xffff };
86 VECT_VAR_DECL(expected_vld2_1,int,32,4) [] = { 0xfffffff4, 0xfffffff5,
87 0xfffffff6, 0xfffffff7 };
88 VECT_VAR_DECL(expected_vld2_1,uint,8,16) [] = { 0x0, 0x1, 0x2, 0x3,
89 0x4, 0x5, 0x6, 0x7,
90 0x8, 0x9, 0xa, 0xb,
91 0xc, 0xd, 0xe, 0xf };
92 VECT_VAR_DECL(expected_vld2_1,uint,16,8) [] = { 0xfff8, 0xfff9, 0xfffa, 0xfffb,
93 0xfffc, 0xfffd, 0xfffe, 0xffff };
94 VECT_VAR_DECL(expected_vld2_1,uint,32,4) [] = { 0xfffffff4, 0xfffffff5,
95 0xfffffff6, 0xfffffff7 };
96 VECT_VAR_DECL(expected_vld2_1,poly,8,16) [] = { 0x0, 0x1, 0x2, 0x3,
97 0x4, 0x5, 0x6, 0x7,
98 0x8, 0x9, 0xa, 0xb,
99 0xc, 0xd, 0xe, 0xf };
100 VECT_VAR_DECL(expected_vld2_1,poly,16,8) [] = { 0xfff8, 0xfff9, 0xfffa, 0xfffb,
101 0xfffc, 0xfffd, 0xfffe, 0xffff };
102 #if MFLOAT8_SUPPORTED
103 VECT_VAR_DECL(expected_vld2_1,hmfloat,8,16) [] = { 0x0, 0x1, 0x2, 0x3,
104 0x4, 0x5, 0x6, 0x7,
105 0x8, 0x9, 0xa, 0xb,
106 0xc, 0xd, 0xe, 0xf };
107 #endif
108 VECT_VAR_DECL(expected_vld2_1,hfloat,16,8) [] = { 0xc800, 0xc700, 0xc600, 0xc500,
109 0xc400, 0xc200, 0xc000, 0xbc00 };
110 VECT_VAR_DECL(expected_vld2_1,hfloat,32,4) [] = { 0xc1400000, 0xc1300000,
111 0xc1200000, 0xc1100000 };
112
113 /* vld3/chunk 0. */
114 VECT_VAR_DECL(expected_vld3_0,int,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
115 0xf4, 0xf5, 0xf6, 0xf7 };
116 VECT_VAR_DECL(expected_vld3_0,int,16,4) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3 };
117 VECT_VAR_DECL(expected_vld3_0,int,32,2) [] = { 0xfffffff0, 0xfffffff1 };
118 VECT_VAR_DECL(expected_vld3_0,int,64,1) [] = { 0xfffffffffffffff0 };
119 VECT_VAR_DECL(expected_vld3_0,uint,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
120 0xf4, 0xf5, 0xf6, 0xf7 };
121 VECT_VAR_DECL(expected_vld3_0,uint,16,4) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3 };
122 VECT_VAR_DECL(expected_vld3_0,uint,32,2) [] = { 0xfffffff0, 0xfffffff1 };
123 VECT_VAR_DECL(expected_vld3_0,uint,64,1) [] = { 0xfffffffffffffff0 };
124 VECT_VAR_DECL(expected_vld3_0,poly,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
125 0xf4, 0xf5, 0xf6, 0xf7 };
126 VECT_VAR_DECL(expected_vld3_0,poly,16,4) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3 };
127 #if MFLOAT8_SUPPORTED
128 VECT_VAR_DECL(expected_vld3_0,hmfloat,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
129 0xf4, 0xf5, 0xf6, 0xf7 };
130 #endif
131 VECT_VAR_DECL(expected_vld3_0,hfloat,16,4) [] = { 0xcc00, 0xcb80, 0xcb00, 0xca80 };
132 VECT_VAR_DECL(expected_vld3_0,hfloat,32,2) [] = { 0xc1800000, 0xc1700000 };
133 VECT_VAR_DECL(expected_vld3_0,int,8,16) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
134 0xf4, 0xf5, 0xf6, 0xf7,
135 0xf8, 0xf9, 0xfa, 0xfb,
136 0xfc, 0xfd, 0xfe, 0xff };
137 VECT_VAR_DECL(expected_vld3_0,int,16,8) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3,
138 0xfff4, 0xfff5, 0xfff6, 0xfff7 };
139 VECT_VAR_DECL(expected_vld3_0,int,32,4) [] = { 0xfffffff0, 0xfffffff1,
140 0xfffffff2, 0xfffffff3 };
141 VECT_VAR_DECL(expected_vld3_0,uint,8,16) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
142 0xf4, 0xf5, 0xf6, 0xf7,
143 0xf8, 0xf9, 0xfa, 0xfb,
144 0xfc, 0xfd, 0xfe, 0xff };
145 VECT_VAR_DECL(expected_vld3_0,uint,16,8) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3,
146 0xfff4, 0xfff5, 0xfff6, 0xfff7 };
147 VECT_VAR_DECL(expected_vld3_0,uint,32,4) [] = { 0xfffffff0, 0xfffffff1,
148 0xfffffff2, 0xfffffff3 };
149 VECT_VAR_DECL(expected_vld3_0,poly,8,16) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
150 0xf4, 0xf5, 0xf6, 0xf7,
151 0xf8, 0xf9, 0xfa, 0xfb,
152 0xfc, 0xfd, 0xfe, 0xff };
153 VECT_VAR_DECL(expected_vld3_0,poly,16,8) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3,
154 0xfff4, 0xfff5, 0xfff6, 0xfff7 };
155 #if MFLOAT8_SUPPORTED
156 VECT_VAR_DECL(expected_vld3_0,hmfloat,8,16) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
157 0xf4, 0xf5, 0xf6, 0xf7,
158 0xf8, 0xf9, 0xfa, 0xfb,
159 0xfc, 0xfd, 0xfe, 0xff };
160 #endif
161 VECT_VAR_DECL(expected_vld3_0,hfloat,16,8) [] = { 0xcc00, 0xcb80, 0xcb00, 0xca80,
162 0xca00, 0xc980, 0xc900, 0xc880 };
163 VECT_VAR_DECL(expected_vld3_0,hfloat,32,4) [] = { 0xc1800000, 0xc1700000,
164 0xc1600000, 0xc1500000 };
165
166 /* vld3/chunk 1. */
167 VECT_VAR_DECL(expected_vld3_1,int,8,8) [] = { 0xf8, 0xf9, 0xfa, 0xfb,
168 0xfc, 0xfd, 0xfe, 0xff };
169 VECT_VAR_DECL(expected_vld3_1,int,16,4) [] = { 0xfff4, 0xfff5, 0xfff6, 0xfff7 };
170 VECT_VAR_DECL(expected_vld3_1,int,32,2) [] = { 0xfffffff2, 0xfffffff3 };
171 VECT_VAR_DECL(expected_vld3_1,int,64,1) [] = { 0xfffffffffffffff1 };
172 VECT_VAR_DECL(expected_vld3_1,uint,8,8) [] = { 0xf8, 0xf9, 0xfa, 0xfb,
173 0xfc, 0xfd, 0xfe, 0xff };
174 VECT_VAR_DECL(expected_vld3_1,uint,16,4) [] = { 0xfff4, 0xfff5, 0xfff6, 0xfff7 };
175 VECT_VAR_DECL(expected_vld3_1,uint,32,2) [] = { 0xfffffff2, 0xfffffff3 };
176 VECT_VAR_DECL(expected_vld3_1,uint,64,1) [] = { 0xfffffffffffffff1 };
177 VECT_VAR_DECL(expected_vld3_1,poly,8,8) [] = { 0xf8, 0xf9, 0xfa, 0xfb,
178 0xfc, 0xfd, 0xfe, 0xff };
179 VECT_VAR_DECL(expected_vld3_1,poly,16,4) [] = { 0xfff4, 0xfff5, 0xfff6, 0xfff7 };
180 #if MFLOAT8_SUPPORTED
181 VECT_VAR_DECL(expected_vld3_1,hmfloat,8,8) [] = { 0xf8, 0xf9, 0xfa, 0xfb,
182 0xfc, 0xfd, 0xfe, 0xff };
183 #endif
184 VECT_VAR_DECL(expected_vld3_1,hfloat,16,4) [] = { 0xca00, 0xc980, 0xc900, 0xc880 };
185 VECT_VAR_DECL(expected_vld3_1,hfloat,32,2) [] = { 0xc1600000, 0xc1500000 };
186 VECT_VAR_DECL(expected_vld3_1,int,8,16) [] = { 0x0, 0x1, 0x2, 0x3,
187 0x4, 0x5, 0x6, 0x7,
188 0x8, 0x9, 0xa, 0xb,
189 0xc, 0xd, 0xe, 0xf };
190 VECT_VAR_DECL(expected_vld3_1,int,16,8) [] = { 0xfff8, 0xfff9, 0xfffa, 0xfffb,
191 0xfffc, 0xfffd, 0xfffe, 0xffff };
192 VECT_VAR_DECL(expected_vld3_1,int,32,4) [] = { 0xfffffff4, 0xfffffff5,
193 0xfffffff6, 0xfffffff7 };
194 VECT_VAR_DECL(expected_vld3_1,uint,8,16) [] = { 0x0, 0x1, 0x2, 0x3,
195 0x4, 0x5, 0x6, 0x7,
196 0x8, 0x9, 0xa, 0xb,
197 0xc, 0xd, 0xe, 0xf };
198 VECT_VAR_DECL(expected_vld3_1,uint,16,8) [] = { 0xfff8, 0xfff9, 0xfffa, 0xfffb,
199 0xfffc, 0xfffd, 0xfffe, 0xffff };
200 VECT_VAR_DECL(expected_vld3_1,uint,32,4) [] = { 0xfffffff4, 0xfffffff5,
201 0xfffffff6, 0xfffffff7 };
202 VECT_VAR_DECL(expected_vld3_1,poly,8,16) [] = { 0x0, 0x1, 0x2, 0x3,
203 0x4, 0x5, 0x6, 0x7,
204 0x8, 0x9, 0xa, 0xb,
205 0xc, 0xd, 0xe, 0xf };
206 VECT_VAR_DECL(expected_vld3_1,poly,16,8) [] = { 0xfff8, 0xfff9, 0xfffa, 0xfffb,
207 0xfffc, 0xfffd, 0xfffe, 0xffff };
208 #if MFLOAT8_SUPPORTED
209 VECT_VAR_DECL(expected_vld3_1,hmfloat,8,16) [] = { 0x0, 0x1, 0x2, 0x3,
210 0x4, 0x5, 0x6, 0x7,
211 0x8, 0x9, 0xa, 0xb,
212 0xc, 0xd, 0xe, 0xf };
213 #endif
214 VECT_VAR_DECL(expected_vld3_1,hfloat,16,8) [] = { 0xc800, 0xc700, 0xc600, 0xc500,
215 0xc400, 0xc200, 0xc000, 0xbc00 };
216 VECT_VAR_DECL(expected_vld3_1,hfloat,32,4) [] = { 0xc1400000, 0xc1300000,
217 0xc1200000, 0xc1100000 };
218
219 /* vld3/chunk 2. */
220 VECT_VAR_DECL(expected_vld3_2,int,8,8) [] = { 0x0, 0x1, 0x2, 0x3,
221 0x4, 0x5, 0x6, 0x7 };
222 VECT_VAR_DECL(expected_vld3_2,int,16,4) [] = { 0xfff8, 0xfff9,
223 0xfffa, 0xfffb };
224 VECT_VAR_DECL(expected_vld3_2,int,32,2) [] = { 0xfffffff4, 0xfffffff5 };
225 VECT_VAR_DECL(expected_vld3_2,int,64,1) [] = { 0xfffffffffffffff2 };
226 VECT_VAR_DECL(expected_vld3_2,uint,8,8) [] = { 0x0, 0x1, 0x2, 0x3,
227 0x4, 0x5, 0x6, 0x7 };
228 VECT_VAR_DECL(expected_vld3_2,uint,16,4) [] = { 0xfff8, 0xfff9,
229 0xfffa, 0xfffb };
230 VECT_VAR_DECL(expected_vld3_2,uint,32,2) [] = { 0xfffffff4, 0xfffffff5 };
231 VECT_VAR_DECL(expected_vld3_2,uint,64,1) [] = { 0xfffffffffffffff2 };
232 VECT_VAR_DECL(expected_vld3_2,poly,8,8) [] = { 0x0, 0x1, 0x2, 0x3,
233 0x4, 0x5, 0x6, 0x7 };
234 VECT_VAR_DECL(expected_vld3_2,poly,16,4) [] = { 0xfff8, 0xfff9,
235 0xfffa, 0xfffb };
236 #if MFLOAT8_SUPPORTED
237 VECT_VAR_DECL(expected_vld3_2,hmfloat,8,8) [] = { 0x0, 0x1, 0x2, 0x3,
238 0x4, 0x5, 0x6, 0x7 };
239 #endif
240 VECT_VAR_DECL(expected_vld3_2,hfloat,16,4) [] = { 0xc800, 0xc700, 0xc600, 0xc500 };
241 VECT_VAR_DECL(expected_vld3_2,hfloat,32,2) [] = { 0xc1400000, 0xc1300000 };
242 VECT_VAR_DECL(expected_vld3_2,int,8,16) [] = { 0x10, 0x11, 0x12, 0x13,
243 0x14, 0x15, 0x16, 0x17,
244 0x18, 0x19, 0x1a, 0x1b,
245 0x1c, 0x1d, 0x1e, 0x1f };
246 VECT_VAR_DECL(expected_vld3_2,int,16,8) [] = { 0x0, 0x1, 0x2, 0x3,
247 0x4, 0x5, 0x6, 0x7 };
248 VECT_VAR_DECL(expected_vld3_2,int,32,4) [] = { 0xfffffff8, 0xfffffff9,
249 0xfffffffa, 0xfffffffb };
250 VECT_VAR_DECL(expected_vld3_2,uint,8,16) [] = { 0x10, 0x11, 0x12, 0x13,
251 0x14, 0x15, 0x16, 0x17,
252 0x18, 0x19, 0x1a, 0x1b,
253 0x1c, 0x1d, 0x1e, 0x1f };
254 VECT_VAR_DECL(expected_vld3_2,uint,16,8) [] = { 0x0, 0x1, 0x2, 0x3,
255 0x4, 0x5, 0x6, 0x7 };
256 VECT_VAR_DECL(expected_vld3_2,uint,32,4) [] = { 0xfffffff8, 0xfffffff9,
257 0xfffffffa, 0xfffffffb };
258 VECT_VAR_DECL(expected_vld3_2,poly,8,16) [] = { 0x10, 0x11, 0x12, 0x13,
259 0x14, 0x15, 0x16, 0x17,
260 0x18, 0x19, 0x1a, 0x1b,
261 0x1c, 0x1d, 0x1e, 0x1f };
262 VECT_VAR_DECL(expected_vld3_2,poly,16,8) [] = { 0x0, 0x1, 0x2, 0x3,
263 0x4, 0x5, 0x6, 0x7 };
264 #if MFLOAT8_SUPPORTED
265 VECT_VAR_DECL(expected_vld3_2,hmfloat,8,16) [] = { 0x10, 0x11, 0x12, 0x13,
266 0x14, 0x15, 0x16, 0x17,
267 0x18, 0x19, 0x1a, 0x1b,
268 0x1c, 0x1d, 0x1e, 0x1f };
269 #endif
270 VECT_VAR_DECL(expected_vld3_2,hfloat,16,8) [] = { 0x0000, 0x3c00, 0x4000, 0x4200,
271 0x4400, 0x4500, 0x4600, 0x4700 };
272 VECT_VAR_DECL(expected_vld3_2,hfloat,32,4) [] = { 0xc1000000, 0xc0e00000,
273 0xc0c00000, 0xc0a00000 };
274
275 /* vld4/chunk 0. */
276 VECT_VAR_DECL(expected_vld4_0,int,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
277 0xf4, 0xf5, 0xf6, 0xf7 };
278 VECT_VAR_DECL(expected_vld4_0,int,16,4) [] = { 0xfff0, 0xfff1,
279 0xfff2, 0xfff3 };
280 VECT_VAR_DECL(expected_vld4_0,int,32,2) [] = { 0xfffffff0, 0xfffffff1 };
281 VECT_VAR_DECL(expected_vld4_0,int,64,1) [] = { 0xfffffffffffffff0 };
282 VECT_VAR_DECL(expected_vld4_0,uint,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
283 0xf4, 0xf5, 0xf6, 0xf7 };
284 VECT_VAR_DECL(expected_vld4_0,uint,16,4) [] = { 0xfff0, 0xfff1,
285 0xfff2, 0xfff3 };
286 VECT_VAR_DECL(expected_vld4_0,uint,32,2) [] = { 0xfffffff0, 0xfffffff1 };
287 VECT_VAR_DECL(expected_vld4_0,uint,64,1) [] = { 0xfffffffffffffff0 };
288 VECT_VAR_DECL(expected_vld4_0,poly,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
289 0xf4, 0xf5, 0xf6, 0xf7 };
290 #if MFLOAT8_SUPPORTED
291 VECT_VAR_DECL(expected_vld4_0,hmfloat,8,8) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
292 0xf4, 0xf5, 0xf6, 0xf7 };
293 #endif
294 VECT_VAR_DECL(expected_vld4_0,poly,16,4) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3 };
295 VECT_VAR_DECL(expected_vld4_0,hfloat,16,4) [] = { 0xcc00, 0xcb80, 0xcb00, 0xca80 };
296 VECT_VAR_DECL(expected_vld4_0,hfloat,32,2) [] = { 0xc1800000, 0xc1700000 };
297 VECT_VAR_DECL(expected_vld4_0,int,8,16) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
298 0xf4, 0xf5, 0xf6, 0xf7,
299 0xf8, 0xf9, 0xfa, 0xfb,
300 0xfc, 0xfd, 0xfe, 0xff };
301 VECT_VAR_DECL(expected_vld4_0,int,16,8) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3,
302 0xfff4, 0xfff5, 0xfff6, 0xfff7 };
303 VECT_VAR_DECL(expected_vld4_0,int,32,4) [] = { 0xfffffff0, 0xfffffff1,
304 0xfffffff2, 0xfffffff3 };
305 VECT_VAR_DECL(expected_vld4_0,uint,8,16) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
306 0xf4, 0xf5, 0xf6, 0xf7,
307 0xf8, 0xf9, 0xfa, 0xfb,
308 0xfc, 0xfd, 0xfe, 0xff };
309 VECT_VAR_DECL(expected_vld4_0,uint,16,8) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3,
310 0xfff4, 0xfff5, 0xfff6, 0xfff7 };
311 VECT_VAR_DECL(expected_vld4_0,uint,32,4) [] = { 0xfffffff0, 0xfffffff1,
312 0xfffffff2, 0xfffffff3 };
313 VECT_VAR_DECL(expected_vld4_0,poly,8,16) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
314 0xf4, 0xf5, 0xf6, 0xf7,
315 0xf8, 0xf9, 0xfa, 0xfb,
316 0xfc, 0xfd, 0xfe, 0xff };
317 VECT_VAR_DECL(expected_vld4_0,poly,16,8) [] = { 0xfff0, 0xfff1, 0xfff2, 0xfff3,
318 0xfff4, 0xfff5, 0xfff6, 0xfff7 };
319 #if MFLOAT8_SUPPORTED
320 VECT_VAR_DECL(expected_vld4_0,hmfloat,8,16) [] = { 0xf0, 0xf1, 0xf2, 0xf3,
321 0xf4, 0xf5, 0xf6, 0xf7,
322 0xf8, 0xf9, 0xfa, 0xfb,
323 0xfc, 0xfd, 0xfe, 0xff };
324 #endif
325 VECT_VAR_DECL(expected_vld4_0,hfloat,16,8) [] = { 0xcc00, 0xcb80, 0xcb00, 0xca80,
326 0xca00, 0xc980, 0xc900, 0xc880 };
327 VECT_VAR_DECL(expected_vld4_0,hfloat,32,4) [] = { 0xc1800000, 0xc1700000,
328 0xc1600000, 0xc1500000 };
329
330 /* vld4/chunk 1. */
331 VECT_VAR_DECL(expected_vld4_1,int,8,8) [] = { 0xf8, 0xf9, 0xfa, 0xfb,
332 0xfc, 0xfd, 0xfe, 0xff };
333 VECT_VAR_DECL(expected_vld4_1,int,16,4) [] = { 0xfff4, 0xfff5, 0xfff6, 0xfff7 };
334 VECT_VAR_DECL(expected_vld4_1,int,32,2) [] = { 0xfffffff2, 0xfffffff3 };
335 VECT_VAR_DECL(expected_vld4_1,int,64,1) [] = { 0xfffffffffffffff1 };
336 VECT_VAR_DECL(expected_vld4_1,uint,8,8) [] = { 0xf8, 0xf9, 0xfa, 0xfb,
337 0xfc, 0xfd, 0xfe, 0xff };
338 VECT_VAR_DECL(expected_vld4_1,uint,16,4) [] = { 0xfff4, 0xfff5, 0xfff6, 0xfff7 };
339 VECT_VAR_DECL(expected_vld4_1,uint,32,2) [] = { 0xfffffff2, 0xfffffff3 };
340 VECT_VAR_DECL(expected_vld4_1,uint,64,1) [] = { 0xfffffffffffffff1 };
341 VECT_VAR_DECL(expected_vld4_1,poly,8,8) [] = { 0xf8, 0xf9, 0xfa, 0xfb,
342 0xfc, 0xfd, 0xfe, 0xff };
343 VECT_VAR_DECL(expected_vld4_1,poly,16,4) [] = { 0xfff4, 0xfff5, 0xfff6, 0xfff7 };
344 #if MFLOAT8_SUPPORTED
345 VECT_VAR_DECL(expected_vld4_1,hmfloat,8,8) [] = { 0xf8, 0xf9, 0xfa, 0xfb,
346 0xfc, 0xfd, 0xfe, 0xff };
347 #endif
348 VECT_VAR_DECL(expected_vld4_1,hfloat,16,4) [] = { 0xca00, 0xc980, 0xc900, 0xc880 };
349 VECT_VAR_DECL(expected_vld4_1,hfloat,32,2) [] = { 0xc1600000, 0xc1500000 };
350 VECT_VAR_DECL(expected_vld4_1,int,8,16) [] = { 0x0, 0x1, 0x2, 0x3,
351 0x4, 0x5, 0x6, 0x7,
352 0x8, 0x9, 0xa, 0xb,
353 0xc, 0xd, 0xe, 0xf };
354 VECT_VAR_DECL(expected_vld4_1,int,16,8) [] = { 0xfff8, 0xfff9, 0xfffa, 0xfffb,
355 0xfffc, 0xfffd, 0xfffe, 0xffff };
356 VECT_VAR_DECL(expected_vld4_1,int,32,4) [] = { 0xfffffff4, 0xfffffff5,
357 0xfffffff6, 0xfffffff7 };
358 VECT_VAR_DECL(expected_vld4_1,uint,8,16) [] = { 0x0, 0x1, 0x2, 0x3,
359 0x4, 0x5, 0x6, 0x7,
360 0x8, 0x9, 0xa, 0xb,
361 0xc, 0xd, 0xe, 0xf };
362 VECT_VAR_DECL(expected_vld4_1,uint,16,8) [] = { 0xfff8, 0xfff9, 0xfffa, 0xfffb,
363 0xfffc, 0xfffd, 0xfffe, 0xffff };
364 VECT_VAR_DECL(expected_vld4_1,uint,32,4) [] = { 0xfffffff4, 0xfffffff5,
365 0xfffffff6, 0xfffffff7 };
366 VECT_VAR_DECL(expected_vld4_1,poly,8,16) [] = { 0x0, 0x1, 0x2, 0x3,
367 0x4, 0x5, 0x6, 0x7,
368 0x8, 0x9, 0xa, 0xb,
369 0xc, 0xd, 0xe, 0xf };
370 VECT_VAR_DECL(expected_vld4_1,poly,16,8) [] = { 0xfff8, 0xfff9, 0xfffa, 0xfffb,
371 0xfffc, 0xfffd, 0xfffe, 0xffff };
372 #if MFLOAT8_SUPPORTED
373 VECT_VAR_DECL(expected_vld4_1,hmfloat,8,16) [] = { 0x0, 0x1, 0x2, 0x3,
374 0x4, 0x5, 0x6, 0x7,
375 0x8, 0x9, 0xa, 0xb,
376 0xc, 0xd, 0xe, 0xf };
377 #endif
378 VECT_VAR_DECL(expected_vld4_1,hfloat,16,8) [] = { 0xc800, 0xc700, 0xc600, 0xc500,
379 0xc400, 0xc200, 0xc000, 0xbc00 };
380 VECT_VAR_DECL(expected_vld4_1,hfloat,32,4) [] = { 0xc1400000, 0xc1300000,
381 0xc1200000, 0xc1100000 };
382
383 /* vld4/chunk 2. */
384 VECT_VAR_DECL(expected_vld4_2,int,8,8) [] = { 0x0, 0x1, 0x2, 0x3,
385 0x4, 0x5, 0x6, 0x7 };
386 VECT_VAR_DECL(expected_vld4_2,int,16,4) [] = { 0xfff8, 0xfff9, 0xfffa, 0xfffb };
387 VECT_VAR_DECL(expected_vld4_2,int,32,2) [] = { 0xfffffff4, 0xfffffff5 };
388 VECT_VAR_DECL(expected_vld4_2,int,64,1) [] = { 0xfffffffffffffff2 };
389 VECT_VAR_DECL(expected_vld4_2,uint,8,8) [] = { 0x0, 0x1, 0x2, 0x3,
390 0x4, 0x5, 0x6, 0x7 };
391 VECT_VAR_DECL(expected_vld4_2,uint,16,4) [] = { 0xfff8, 0xfff9, 0xfffa, 0xfffb };
392 VECT_VAR_DECL(expected_vld4_2,uint,32,2) [] = { 0xfffffff4, 0xfffffff5 };
393 VECT_VAR_DECL(expected_vld4_2,uint,64,1) [] = { 0xfffffffffffffff2 };
394 VECT_VAR_DECL(expected_vld4_2,poly,8,8) [] = { 0x0, 0x1, 0x2, 0x3,
395 0x4, 0x5, 0x6, 0x7 };
396 VECT_VAR_DECL(expected_vld4_2,poly,16,4) [] = { 0xfff8, 0xfff9, 0xfffa, 0xfffb };
397 #if MFLOAT8_SUPPORTED
398 VECT_VAR_DECL(expected_vld4_2,hmfloat,8,8) [] = { 0x0, 0x1, 0x2, 0x3,
399 0x4, 0x5, 0x6, 0x7 };
400 #endif
401 VECT_VAR_DECL(expected_vld4_2,hfloat,16,4) [] = { 0xc800, 0xc700, 0xc600, 0xc500 };
402 VECT_VAR_DECL(expected_vld4_2,hfloat,32,2) [] = { 0xc1400000, 0xc1300000 };
403 VECT_VAR_DECL(expected_vld4_2,int,8,16) [] = { 0x10, 0x11, 0x12, 0x13,
404 0x14, 0x15, 0x16, 0x17,
405 0x18, 0x19, 0x1a, 0x1b,
406 0x1c, 0x1d, 0x1e, 0x1f };
407 VECT_VAR_DECL(expected_vld4_2,int,16,8) [] = { 0x0, 0x1, 0x2, 0x3,
408 0x4, 0x5, 0x6, 0x7 };
409 VECT_VAR_DECL(expected_vld4_2,int,32,4) [] = { 0xfffffff8, 0xfffffff9,
410 0xfffffffa, 0xfffffffb };
411 VECT_VAR_DECL(expected_vld4_2,uint,8,16) [] = { 0x10, 0x11, 0x12, 0x13,
412 0x14, 0x15, 0x16, 0x17,
413 0x18, 0x19, 0x1a, 0x1b,
414 0x1c, 0x1d, 0x1e, 0x1f };
415 VECT_VAR_DECL(expected_vld4_2,uint,16,8) [] = { 0x0, 0x1, 0x2, 0x3,
416 0x4, 0x5, 0x6, 0x7 };
417 VECT_VAR_DECL(expected_vld4_2,uint,32,4) [] = { 0xfffffff8, 0xfffffff9,
418 0xfffffffa, 0xfffffffb };
419 VECT_VAR_DECL(expected_vld4_2,poly,8,16) [] = { 0x10, 0x11, 0x12, 0x13,
420 0x14, 0x15, 0x16, 0x17,
421 0x18, 0x19, 0x1a, 0x1b,
422 0x1c, 0x1d, 0x1e, 0x1f };
423 VECT_VAR_DECL(expected_vld4_2,poly,16,8) [] = { 0x0, 0x1, 0x2, 0x3,
424 0x4, 0x5, 0x6, 0x7 };
425 #if MFLOAT8_SUPPORTED
426 VECT_VAR_DECL(expected_vld4_2,hmfloat,8,16) [] = { 0x10, 0x11, 0x12, 0x13,
427 0x14, 0x15, 0x16, 0x17,
428 0x18, 0x19, 0x1a, 0x1b,
429 0x1c, 0x1d, 0x1e, 0x1f };
430 #endif
431 VECT_VAR_DECL(expected_vld4_2,hfloat,16,8) [] = { 0x0000, 0x3c00, 0x4000, 0x4200,
432 0x4400, 0x4500, 0x4600, 0x4700 };
433 VECT_VAR_DECL(expected_vld4_2,hfloat,32,4) [] = { 0xc1000000, 0xc0e00000,
434 0xc0c00000, 0xc0a00000 };
435
436 /* vld4/chunk 3. */
437 VECT_VAR_DECL(expected_vld4_3,int,8,8) [] = { 0x8, 0x9, 0xa, 0xb,
438 0xc, 0xd, 0xe, 0xf };
439 VECT_VAR_DECL(expected_vld4_3,int,16,4) [] = { 0xfffc, 0xfffd, 0xfffe, 0xffff };
440 VECT_VAR_DECL(expected_vld4_3,int,32,2) [] = { 0xfffffff6, 0xfffffff7 };
441 VECT_VAR_DECL(expected_vld4_3,int,64,1) [] = { 0xfffffffffffffff3 };
442 VECT_VAR_DECL(expected_vld4_3,uint,8,8) [] = { 0x8, 0x9, 0xa, 0xb,
443 0xc, 0xd, 0xe, 0xf };
444 VECT_VAR_DECL(expected_vld4_3,uint,16,4) [] = { 0xfffc, 0xfffd, 0xfffe, 0xffff };
445 VECT_VAR_DECL(expected_vld4_3,uint,32,2) [] = { 0xfffffff6, 0xfffffff7 };
446 VECT_VAR_DECL(expected_vld4_3,uint,64,1) [] = { 0xfffffffffffffff3 };
447 VECT_VAR_DECL(expected_vld4_3,poly,8,8) [] = { 0x8, 0x9, 0xa, 0xb,
448 0xc, 0xd, 0xe, 0xf };
449 VECT_VAR_DECL(expected_vld4_3,poly,16,4) [] = { 0xfffc, 0xfffd, 0xfffe, 0xffff };
450 #if MFLOAT8_SUPPORTED
451 VECT_VAR_DECL(expected_vld4_3,hmfloat,8,8) [] = { 0x8, 0x9, 0xa, 0xb,
452 0xc, 0xd, 0xe, 0xf };
453 #endif
454 VECT_VAR_DECL(expected_vld4_3,hfloat,16,4) [] = { 0xc400, 0xc200, 0xc000, 0xbc00 };
455 VECT_VAR_DECL(expected_vld4_3,hfloat,32,2) [] = { 0xc1200000, 0xc1100000 };
456 VECT_VAR_DECL(expected_vld4_3,int,8,16) [] = { 0x20, 0x21, 0x22, 0x23,
457 0x24, 0x25, 0x26, 0x27,
458 0x28, 0x29, 0x2a, 0x2b,
459 0x2c, 0x2d, 0x2e, 0x2f };
460 VECT_VAR_DECL(expected_vld4_3,int,16,8) [] = { 0x8, 0x9, 0xa, 0xb,
461 0xc, 0xd, 0xe, 0xf };
462 VECT_VAR_DECL(expected_vld4_3,int,32,4) [] = { 0xfffffffc, 0xfffffffd,
463 0xfffffffe, 0xffffffff };
464 VECT_VAR_DECL(expected_vld4_3,uint,8,16) [] = { 0x20, 0x21, 0x22, 0x23,
465 0x24, 0x25, 0x26, 0x27,
466 0x28, 0x29, 0x2a, 0x2b,
467 0x2c, 0x2d, 0x2e, 0x2f };
468 VECT_VAR_DECL(expected_vld4_3,uint,16,8) [] = { 0x8, 0x9, 0xa, 0xb,
469 0xc, 0xd, 0xe, 0xf };
470 VECT_VAR_DECL(expected_vld4_3,uint,32,4) [] = { 0xfffffffc, 0xfffffffd,
471 0xfffffffe, 0xffffffff };
472 VECT_VAR_DECL(expected_vld4_3,poly,8,16) [] = { 0x20, 0x21, 0x22, 0x23,
473 0x24, 0x25, 0x26, 0x27,
474 0x28, 0x29, 0x2a, 0x2b,
475 0x2c, 0x2d, 0x2e, 0x2f };
476 VECT_VAR_DECL(expected_vld4_3,poly,16,8) [] = { 0x8, 0x9, 0xa, 0xb,
477 0xc, 0xd, 0xe, 0xf };
478 #if MFLOAT8_SUPPORTED
479 VECT_VAR_DECL(expected_vld4_3,hmfloat,8,16) [] = { 0x20, 0x21, 0x22, 0x23,
480 0x24, 0x25, 0x26, 0x27,
481 0x28, 0x29, 0x2a, 0x2b,
482 0x2c, 0x2d, 0x2e, 0x2f };
483 #endif
484 VECT_VAR_DECL(expected_vld4_3,hfloat,16,8) [] = { 0x4800, 0x4880, 0x4900, 0x4980,
485 0x4a00, 0x4a80, 0x4b00, 0x4b80 };
486 VECT_VAR_DECL(expected_vld4_3,hfloat,32,4) [] = { 0xc0800000, 0xc0400000,
487 0xc0000000, 0xbf800000 };
488
489 void exec_vldX (void)
490 {
491 /* In this case, input variables are arrays of vectors. */
492 #define DECL_VLDX(T1, W, N, X) \
493 VECT_ARRAY_TYPE(T1, W, N, X) VECT_ARRAY_VAR(vector, T1, W, N, X); \
494 VECT_VAR_DECL(result_bis_##X, T1, W, N)[X * N]
495
496 /* We need to use a temporary result buffer (result_bis), because
497 the one used for other tests is not large enough. A subset of the
498 result data is moved from result_bis to result, and it is this
499 subset which is used to check the actual behavior. The next
500 macro enables to move another chunk of data from result_bis to
501 result. */
502 #define TEST_VLDX(Q, T1, T2, W, N, X) \
503 VECT_ARRAY_VAR(vector, T1, W, N, X) = \
504 /* Use dedicated init buffer, of size X */ \
505 vld##X##Q##_##T2##W(VECT_ARRAY_VAR(buffer_vld##X, T1, W, N, X)); \
506 vst##X##Q##_##T2##W(VECT_VAR(result_bis_##X, T1, W, N), \
507 VECT_ARRAY_VAR(vector, T1, W, N, X)); \
508 memcpy(VECT_VAR(result, T1, W, N), VECT_VAR(result_bis_##X, T1, W, N), \
509 sizeof(VECT_VAR(result, T1, W, N)));
510
511 /* Overwrite "result" with the contents of "result_bis"[Y]. */
512 #define TEST_EXTRA_CHUNK(T1, W, N, X,Y) \
513 memcpy(VECT_VAR(result, T1, W, N), \
514 &(VECT_VAR(result_bis_##X, T1, W, N)[Y*N]), \
515 sizeof(VECT_VAR(result, T1, W, N)));
516
517 /* We need all variants in 64 bits, but there is no 64x2 variant. */
518 #define DECL_ALL_VLDX_NO_FP16(X) \
519 DECL_VLDX(int, 8, 8, X); \
520 DECL_VLDX(int, 16, 4, X); \
521 DECL_VLDX(int, 32, 2, X); \
522 DECL_VLDX(int, 64, 1, X); \
523 DECL_VLDX(uint, 8, 8, X); \
524 DECL_VLDX(uint, 16, 4, X); \
525 DECL_VLDX(uint, 32, 2, X); \
526 DECL_VLDX(uint, 64, 1, X); \
527 DECL_VLDX(poly, 8, 8, X); \
528 DECL_VLDX(poly, 16, 4, X); \
529 MFLOAT8_ONLY(DECL_VLDX(mfloat, 8, 8, X)); \
530 DECL_VLDX(float, 32, 2, X); \
531 DECL_VLDX(int, 8, 16, X); \
532 DECL_VLDX(int, 16, 8, X); \
533 DECL_VLDX(int, 32, 4, X); \
534 DECL_VLDX(uint, 8, 16, X); \
535 DECL_VLDX(uint, 16, 8, X); \
536 DECL_VLDX(uint, 32, 4, X); \
537 DECL_VLDX(poly, 8, 16, X); \
538 DECL_VLDX(poly, 16, 8, X); \
539 MFLOAT8_ONLY(DECL_VLDX(mfloat, 8, 16, X)); \
540 DECL_VLDX(float, 32, 4, X)
541
542 #if defined (__ARM_FP16_FORMAT_IEEE) || defined (__ARM_FP16_FORMAT_ALTERNATIVE)
543 #define DECL_ALL_VLDX(X) \
544 DECL_ALL_VLDX_NO_FP16(X); \
545 DECL_VLDX(float, 16, 4, X); \
546 DECL_VLDX(float, 16, 8, X)
547 #else
548 #define DECL_ALL_VLDX(X) DECL_ALL_VLDX_NO_FP16(X)
549 #endif
550
551 #define TEST_ALL_VLDX_NO_FP16(X) \
552 TEST_VLDX(, int, s, 8, 8, X); \
553 TEST_VLDX(, int, s, 16, 4, X); \
554 TEST_VLDX(, int, s, 32, 2, X); \
555 TEST_VLDX(, int, s, 64, 1, X); \
556 TEST_VLDX(, uint, u, 8, 8, X); \
557 TEST_VLDX(, uint, u, 16, 4, X); \
558 TEST_VLDX(, uint, u, 32, 2, X); \
559 TEST_VLDX(, uint, u, 64, 1, X); \
560 TEST_VLDX(, poly, p, 8, 8, X); \
561 TEST_VLDX(, poly, p, 16, 4, X); \
562 MFLOAT8_ONLY(TEST_VLDX(, mfloat, mf, 8, 8, X)); \
563 TEST_VLDX(, float, f, 32, 2, X); \
564 TEST_VLDX(q, int, s, 8, 16, X); \
565 TEST_VLDX(q, int, s, 16, 8, X); \
566 TEST_VLDX(q, int, s, 32, 4, X); \
567 TEST_VLDX(q, uint, u, 8, 16, X); \
568 TEST_VLDX(q, uint, u, 16, 8, X); \
569 TEST_VLDX(q, uint, u, 32, 4, X); \
570 TEST_VLDX(q, poly, p, 8, 16, X); \
571 TEST_VLDX(q, poly, p, 16, 8, X); \
572 MFLOAT8_ONLY(TEST_VLDX(q, mfloat, mf, 8, 16, X)); \
573 TEST_VLDX(q, float, f, 32, 4, X)
574
575 #if defined (__ARM_FP16_FORMAT_IEEE) || defined (__ARM_FP16_FORMAT_ALTERNATIVE)
576 #define TEST_ALL_VLDX(X) \
577 TEST_ALL_VLDX_NO_FP16(X); \
578 TEST_VLDX(, float, f, 16, 4, X); \
579 TEST_VLDX(q, float, f, 16, 8, X)
580 #else
581 #define TEST_ALL_VLDX(X) TEST_ALL_VLDX_NO_FP16(X)
582 #endif
583
584 #define TEST_ALL_EXTRA_CHUNKS_NO_FP16(X, Y) \
585 TEST_EXTRA_CHUNK(int, 8, 8, X, Y); \
586 TEST_EXTRA_CHUNK(int, 16, 4, X, Y); \
587 TEST_EXTRA_CHUNK(int, 32, 2, X, Y); \
588 TEST_EXTRA_CHUNK(int, 64, 1, X, Y); \
589 TEST_EXTRA_CHUNK(uint, 8, 8, X, Y); \
590 TEST_EXTRA_CHUNK(uint, 16, 4, X, Y); \
591 TEST_EXTRA_CHUNK(uint, 32, 2, X, Y); \
592 TEST_EXTRA_CHUNK(uint, 64, 1, X, Y); \
593 TEST_EXTRA_CHUNK(poly, 8, 8, X, Y); \
594 TEST_EXTRA_CHUNK(poly, 16, 4, X, Y); \
595 MFLOAT8_ONLY(TEST_EXTRA_CHUNK(mfloat, 8, 8, X, Y)); \
596 TEST_EXTRA_CHUNK(float, 32, 2, X, Y); \
597 TEST_EXTRA_CHUNK(int, 8, 16, X, Y); \
598 TEST_EXTRA_CHUNK(int, 16, 8, X, Y); \
599 TEST_EXTRA_CHUNK(int, 32, 4, X, Y); \
600 TEST_EXTRA_CHUNK(uint, 8, 16, X, Y); \
601 TEST_EXTRA_CHUNK(uint, 16, 8, X, Y); \
602 TEST_EXTRA_CHUNK(uint, 32, 4, X, Y); \
603 TEST_EXTRA_CHUNK(poly, 8, 16, X, Y); \
604 TEST_EXTRA_CHUNK(poly, 16, 8, X, Y); \
605 MFLOAT8_ONLY(TEST_EXTRA_CHUNK(mfloat, 8, 16, X, Y)); \
606 TEST_EXTRA_CHUNK(float, 32, 4, X, Y)
607
608 #if defined (__ARM_FP16_FORMAT_IEEE) || defined (__ARM_FP16_FORMAT_ALTERNATIVE)
609 #define TEST_ALL_EXTRA_CHUNKS(X, Y) \
610 TEST_ALL_EXTRA_CHUNKS_NO_FP16(X, Y) \
611 TEST_EXTRA_CHUNK(float, 16, 4, X, Y); \
612 TEST_EXTRA_CHUNK(float, 16, 8, X, Y);
613 #else
614 #define TEST_ALL_EXTRA_CHUNKS(X, Y) TEST_ALL_EXTRA_CHUNKS_NO_FP16(X, Y)
615 #endif
616
617 /* vldX supports all vector types except [u]int64x2. */
618 #define CHECK_RESULTS_VLDX_NO_FP16(test_name,EXPECTED,comment) \
619 CHECK(test_name, int, 8, 8, PRIx8, EXPECTED, comment); \
620 CHECK(test_name, int, 16, 4, PRIx16, EXPECTED, comment); \
621 CHECK(test_name, int, 32, 2, PRIx32, EXPECTED, comment); \
622 CHECK(test_name, int, 64, 1, PRIx64, EXPECTED, comment); \
623 CHECK(test_name, uint, 8, 8, PRIx8, EXPECTED, comment); \
624 CHECK(test_name, uint, 16, 4, PRIx16, EXPECTED, comment); \
625 CHECK(test_name, uint, 32, 2, PRIx32, EXPECTED, comment); \
626 CHECK(test_name, uint, 64, 1, PRIx64, EXPECTED, comment); \
627 CHECK_POLY(test_name, poly, 8, 8, PRIx8, EXPECTED, comment); \
628 CHECK_POLY(test_name, poly, 16, 4, PRIx16, EXPECTED, comment); \
629 MFLOAT8_ONLY(CHECK_FP(test_name, mfloat, 8, 8, PRIx8, EXPECTED, comment)); \
630 CHECK_FP(test_name, float, 32, 2, PRIx32, EXPECTED, comment); \
631 \
632 CHECK(test_name, int, 8, 16, PRIx8, EXPECTED, comment); \
633 CHECK(test_name, int, 16, 8, PRIx16, EXPECTED, comment); \
634 CHECK(test_name, int, 32, 4, PRIx32, EXPECTED, comment); \
635 CHECK(test_name, uint, 8, 16, PRIx8, EXPECTED, comment); \
636 CHECK(test_name, uint, 16, 8, PRIx16, EXPECTED, comment); \
637 CHECK(test_name, uint, 32, 4, PRIx32, EXPECTED, comment); \
638 CHECK_POLY(test_name, poly, 8, 16, PRIx8, EXPECTED, comment); \
639 CHECK_POLY(test_name, poly, 16, 8, PRIx16, EXPECTED, comment); \
640 MFLOAT8_ONLY(CHECK_FP(test_name, mfloat, 8, 16, PRIx8, EXPECTED, comment)); \
641 CHECK_FP(test_name, float, 32, 4, PRIx32, EXPECTED, comment)
642
643 #if defined (__ARM_FP16_FORMAT_IEEE) || defined (__ARM_FP16_FORMAT_ALTERNATIVE)
644 #define CHECK_RESULTS_VLDX(test_name,EXPECTED,comment) \
645 { \
646 CHECK_RESULTS_VLDX_NO_FP16(test_name, EXPECTED, comment); \
647 CHECK_FP(test_name, float, 16, 4, PRIx16, EXPECTED, comment); \
648 CHECK_FP(test_name, float, 16, 8, PRIx16, EXPECTED, comment); \
649 }
650 #else
651 #define CHECK_RESULTS_VLDX(test_name, EXPECTED, comment) \
652 { CHECK_RESULTS_VLDX_NO_FP16(test_name, EXPECTED, comment); }
653 #endif
654
655 DECL_ALL_VLDX(2);
656 DECL_ALL_VLDX(3);
657 DECL_ALL_VLDX(4);
658
659 /* Special input buffers of suitable size are needed for vld2/vld3/vld4. */
660 /* Input buffers for vld2, 1 of each size */
661 VECT_ARRAY_INIT2(buffer_vld2, int, 8, 8);
662 PAD(buffer_vld2_pad, int, 8, 8);
663 VECT_ARRAY_INIT2(buffer_vld2, int, 16, 4);
664 PAD(buffer_vld2_pad, int, 16, 4);
665 VECT_ARRAY_INIT2(buffer_vld2, int, 32, 2);
666 PAD(buffer_vld2_pad, int, 32, 2);
667 VECT_ARRAY_INIT2(buffer_vld2, int, 64, 1);
668 PAD(buffer_vld2_pad, int, 64, 1);
669 VECT_ARRAY_INIT2(buffer_vld2, uint, 8, 8);
670 PAD(buffer_vld2_pad, uint, 8, 8);
671 VECT_ARRAY_INIT2(buffer_vld2, uint, 16, 4);
672 PAD(buffer_vld2_pad, uint, 16, 4);
673 VECT_ARRAY_INIT2(buffer_vld2, uint, 32, 2);
674 PAD(buffer_vld2_pad, uint, 32, 2);
675 VECT_ARRAY_INIT2(buffer_vld2, uint, 64, 1);
676 PAD(buffer_vld2_pad, uint, 64, 1);
677 VECT_ARRAY_INIT2(buffer_vld2, poly, 8, 8);
678 PAD(buffer_vld2_pad, poly, 8, 8);
679 VECT_ARRAY_INIT2(buffer_vld2, poly, 16, 4);
680 PAD(buffer_vld2_pad, poly, 16, 4);
681 #if MFLOAT8_SUPPORTED
682 VECT_ARRAY(buffer_vld2, mfloat, 8, 8, 2);
683 __builtin_memcpy (VECT_ARRAY_VAR(buffer_vld2, mfloat, 8, 8, 2),
684 VECT_ARRAY_VAR(buffer_vld2, int, 8, 8, 2), 8 * 2);
685 PAD(buffer_vld2_pad, mfloat, 8, 8);
686 #endif
687 #if defined (__ARM_FP16_FORMAT_IEEE) || defined (__ARM_FP16_FORMAT_ALTERNATIVE)
688 VECT_ARRAY_INIT2(buffer_vld2, float, 16, 4);
689 PAD(buffer_vld2_pad, float, 16, 4);
690 #endif
691 VECT_ARRAY_INIT2(buffer_vld2, float, 32, 2);
692 PAD(buffer_vld2_pad, float, 32, 2);
693
694 VECT_ARRAY_INIT2(buffer_vld2, int, 8, 16);
695 PAD(buffer_vld2_pad, int, 8, 16);
696 VECT_ARRAY_INIT2(buffer_vld2, int, 16, 8);
697 PAD(buffer_vld2_pad, int, 16, 8);
698 VECT_ARRAY_INIT2(buffer_vld2, int, 32, 4);
699 PAD(buffer_vld2_pad, int, 32, 4);
700 VECT_ARRAY_INIT2(buffer_vld2, int, 64, 2);
701 PAD(buffer_vld2_pad, int, 64, 2);
702 VECT_ARRAY_INIT2(buffer_vld2, uint, 8, 16);
703 PAD(buffer_vld2_pad, uint, 8, 16);
704 VECT_ARRAY_INIT2(buffer_vld2, uint, 16, 8);
705 PAD(buffer_vld2_pad, uint, 16, 8);
706 VECT_ARRAY_INIT2(buffer_vld2, uint, 32, 4);
707 PAD(buffer_vld2_pad, uint, 32, 4);
708 VECT_ARRAY_INIT2(buffer_vld2, uint, 64, 2);
709 PAD(buffer_vld2_pad, uint, 64, 2);
710 VECT_ARRAY_INIT2(buffer_vld2, poly, 8, 16);
711 PAD(buffer_vld2_pad, poly, 8, 16);
712 VECT_ARRAY_INIT2(buffer_vld2, poly, 16, 8);
713 PAD(buffer_vld2_pad, poly, 16, 8);
714 #if MFLOAT8_SUPPORTED
715 VECT_ARRAY(buffer_vld2, mfloat, 8, 16, 2);
716 PAD(buffer_vld2_pad, mfloat, 8, 16);
717 __builtin_memcpy (VECT_ARRAY_VAR(buffer_vld2, mfloat, 8, 16, 2),
718 VECT_ARRAY_VAR(buffer_vld2, int, 8, 16, 2), 16 * 2);
719 #endif
720 #if defined (__ARM_FP16_FORMAT_IEEE) || defined (__ARM_FP16_FORMAT_ALTERNATIVE)
721 VECT_ARRAY_INIT2(buffer_vld2, float, 16, 8);
722 PAD(buffer_vld2_pad, float, 16, 8);
723 #endif
724 VECT_ARRAY_INIT2(buffer_vld2, float, 32, 4);
725 PAD(buffer_vld2_pad, float, 32, 4);
726
727 /* Input buffers for vld3, 1 of each size */
728 VECT_ARRAY_INIT3(buffer_vld3, int, 8, 8);
729 PAD(buffer_vld3_pad, int, 8, 8);
730 VECT_ARRAY_INIT3(buffer_vld3, int, 16, 4);
731 PAD(buffer_vld3_pad, int, 16, 4);
732 VECT_ARRAY_INIT3(buffer_vld3, int, 32, 2);
733 PAD(buffer_vld3_pad, int, 32, 2);
734 VECT_ARRAY_INIT3(buffer_vld3, int, 64, 1);
735 PAD(buffer_vld3_pad, int, 64, 1);
736 VECT_ARRAY_INIT3(buffer_vld3, uint, 8, 8);
737 PAD(buffer_vld3_pad, uint, 8, 8);
738 VECT_ARRAY_INIT3(buffer_vld3, uint, 16, 4);
739 PAD(buffer_vld3_pad, uint, 16, 4);
740 VECT_ARRAY_INIT3(buffer_vld3, uint, 32, 2);
741 PAD(buffer_vld3_pad, uint, 32, 2);
742 VECT_ARRAY_INIT3(buffer_vld3, uint, 64, 1);
743 PAD(buffer_vld3_pad, uint, 64, 1);
744 VECT_ARRAY_INIT3(buffer_vld3, poly, 8, 8);
745 PAD(buffer_vld3_pad, poly, 8, 8);
746 VECT_ARRAY_INIT3(buffer_vld3, poly, 16, 4);
747 PAD(buffer_vld3_pad, poly, 16, 4);
748 #if MFLOAT8_SUPPORTED
749 VECT_ARRAY(buffer_vld3, mfloat, 8, 8, 3);
750 PAD(buffer_vld3_pad, mfloat, 8, 8);
751 __builtin_memcpy (VECT_ARRAY_VAR(buffer_vld3, mfloat, 8, 8, 3),
752 VECT_ARRAY_VAR(buffer_vld3, int, 8, 8, 3), 8 * 3);
753 #endif
754 #if defined (__ARM_FP16_FORMAT_IEEE) || defined (__ARM_FP16_FORMAT_ALTERNATIVE)
755 VECT_ARRAY_INIT3(buffer_vld3, float, 16, 4);
756 PAD(buffer_vld3_pad, float, 16, 4);
757 #endif
758 VECT_ARRAY_INIT3(buffer_vld3, float, 32, 2);
759 PAD(buffer_vld3_pad, float, 32, 2);
760
761 VECT_ARRAY_INIT3(buffer_vld3, int, 8, 16);
762 PAD(buffer_vld3_pad, int, 8, 16);
763 VECT_ARRAY_INIT3(buffer_vld3, int, 16, 8);
764 PAD(buffer_vld3_pad, int, 16, 8);
765 VECT_ARRAY_INIT3(buffer_vld3, int, 32, 4);
766 PAD(buffer_vld3_pad, int, 32, 4);
767 VECT_ARRAY_INIT3(buffer_vld3, int, 64, 2);
768 PAD(buffer_vld3_pad, int, 64, 2);
769 VECT_ARRAY_INIT3(buffer_vld3, uint, 8, 16);
770 PAD(buffer_vld3_pad, uint, 8, 16);
771 VECT_ARRAY_INIT3(buffer_vld3, uint, 16, 8);
772 PAD(buffer_vld3_pad, uint, 16, 8);
773 VECT_ARRAY_INIT3(buffer_vld3, uint, 32, 4);
774 PAD(buffer_vld3_pad, uint, 32, 4);
775 VECT_ARRAY_INIT3(buffer_vld3, uint, 64, 2);
776 PAD(buffer_vld3_pad, uint, 64, 2);
777 VECT_ARRAY_INIT3(buffer_vld3, poly, 8, 16);
778 PAD(buffer_vld3_pad, poly, 8, 16);
779 VECT_ARRAY_INIT3(buffer_vld3, poly, 16, 8);
780 PAD(buffer_vld3_pad, poly, 16, 8);
781 #if MFLOAT8_SUPPORTED
782 VECT_ARRAY(buffer_vld3, mfloat, 8, 16, 3);
783 PAD(buffer_vld3_pad, mfloat, 8, 16);
784 __builtin_memcpy (VECT_ARRAY_VAR(buffer_vld3, mfloat, 8, 16, 3),
785 VECT_ARRAY_VAR(buffer_vld3, int, 8, 16, 3), 16 * 3);
786 #endif
787 #if defined (__ARM_FP16_FORMAT_IEEE) || defined (__ARM_FP16_FORMAT_ALTERNATIVE)
788 VECT_ARRAY_INIT3(buffer_vld3, float, 16, 8);
789 PAD(buffer_vld3_pad, float, 16, 8);
790 #endif
791 VECT_ARRAY_INIT3(buffer_vld3, float, 32, 4);
792 PAD(buffer_vld3_pad, float, 32, 4);
793
794 /* Input buffers for vld4, 1 of each size */
795 VECT_ARRAY_INIT4(buffer_vld4, int, 8, 8);
796 PAD(buffer_vld4_pad, int, 8, 8);
797 VECT_ARRAY_INIT4(buffer_vld4, int, 16, 4);
798 PAD(buffer_vld4_pad, int, 16, 4);
799 VECT_ARRAY_INIT4(buffer_vld4, int, 32, 2);
800 PAD(buffer_vld4_pad, int, 32, 2);
801 VECT_ARRAY_INIT4(buffer_vld4, int, 64, 1);
802 PAD(buffer_vld4_pad, int, 64, 1);
803 VECT_ARRAY_INIT4(buffer_vld4, uint, 8, 8);
804 PAD(buffer_vld4_pad, uint, 8, 8);
805 VECT_ARRAY_INIT4(buffer_vld4, uint, 16, 4);
806 PAD(buffer_vld4_pad, uint, 16, 4);
807 VECT_ARRAY_INIT4(buffer_vld4, uint, 32, 2);
808 PAD(buffer_vld4_pad, uint, 32, 2);
809 VECT_ARRAY_INIT4(buffer_vld4, uint, 64, 1);
810 PAD(buffer_vld4_pad, uint, 64, 1);
811 VECT_ARRAY_INIT4(buffer_vld4, poly, 8, 8);
812 PAD(buffer_vld4_pad, poly, 8, 8);
813 VECT_ARRAY_INIT4(buffer_vld4, poly, 16, 4);
814 PAD(buffer_vld4_pad, poly, 16, 4);
815 #if MFLOAT8_SUPPORTED
816 VECT_ARRAY(buffer_vld4, mfloat, 8, 8, 4);
817 PAD(buffer_vld4_pad, mfloat, 8, 8);
818 __builtin_memcpy (VECT_ARRAY_VAR(buffer_vld4, mfloat, 8, 8, 4),
819 VECT_ARRAY_VAR(buffer_vld4, int, 8, 8, 4), 8 * 4);
820 #endif
821 #if defined (__ARM_FP16_FORMAT_IEEE) || defined (__ARM_FP16_FORMAT_ALTERNATIVE)
822 VECT_ARRAY_INIT4(buffer_vld4, float, 16, 4);
823 PAD(buffer_vld4_pad, float, 16, 4);
824 #endif
825 VECT_ARRAY_INIT4(buffer_vld4, float, 32, 2);
826 PAD(buffer_vld4_pad, float, 32, 2);
827
828 VECT_ARRAY_INIT4(buffer_vld4, int, 8, 16);
829 PAD(buffer_vld4_pad, int, 8, 16);
830 VECT_ARRAY_INIT4(buffer_vld4, int, 16, 8);
831 PAD(buffer_vld4_pad, int, 16, 8);
832 VECT_ARRAY_INIT4(buffer_vld4, int, 32, 4);
833 PAD(buffer_vld4_pad, int, 32, 4);
834 VECT_ARRAY_INIT4(buffer_vld4, int, 64, 2);
835 PAD(buffer_vld4_pad, int, 64, 2);
836 VECT_ARRAY_INIT4(buffer_vld4, uint, 8, 16);
837 PAD(buffer_vld4_pad, uint, 8, 16);
838 VECT_ARRAY_INIT4(buffer_vld4, uint, 16, 8);
839 PAD(buffer_vld4_pad, uint, 16, 8);
840 VECT_ARRAY_INIT4(buffer_vld4, uint, 32, 4);
841 PAD(buffer_vld4_pad, uint, 32, 4);
842 VECT_ARRAY_INIT4(buffer_vld4, uint, 64, 2);
843 PAD(buffer_vld4_pad, uint, 64, 2);
844 VECT_ARRAY_INIT4(buffer_vld4, poly, 8, 16);
845 PAD(buffer_vld4_pad, poly, 8, 16);
846 VECT_ARRAY_INIT4(buffer_vld4, poly, 16, 8);
847 PAD(buffer_vld4_pad, poly, 16, 8);
848 #if MFLOAT8_SUPPORTED
849 VECT_ARRAY(buffer_vld4, mfloat, 8, 16, 4);
850 PAD(buffer_vld4_pad, mfloat, 8, 16);
851 __builtin_memcpy (VECT_ARRAY_VAR(buffer_vld4, mfloat, 8, 16, 4),
852 VECT_ARRAY_VAR(buffer_vld4, int, 8, 16, 4), 16 * 4);
853 #endif
854 #if defined (__ARM_FP16_FORMAT_IEEE) || defined (__ARM_FP16_FORMAT_ALTERNATIVE)
855 VECT_ARRAY_INIT4(buffer_vld4, float, 16, 8);
856 PAD(buffer_vld4_pad, float, 16, 8);
857 #endif
858 VECT_ARRAY_INIT4(buffer_vld4, float, 32, 4);
859 PAD(buffer_vld4_pad, float, 32, 4);
860
861 /* Check vld2/vld2q. */
862 clean_results ();
863 #define TEST_MSG "VLD2/VLD2Q"
864 TEST_ALL_VLDX(2);
865 CHECK_RESULTS_VLDX (TEST_MSG, expected_vld2_0, "chunk 0");
866
867 TEST_ALL_EXTRA_CHUNKS(2, 1);
868 CHECK_RESULTS_VLDX (TEST_MSG, expected_vld2_1, "chunk 1");
869
870 /* Check vld3/vld3q. */
871 clean_results ();
872 #undef TEST_MSG
873 #define TEST_MSG "VLD3/VLD3Q"
874 TEST_ALL_VLDX(3);
875 CHECK_RESULTS_VLDX (TEST_MSG, expected_vld3_0, "chunk 0");
876
877 TEST_ALL_EXTRA_CHUNKS(3, 1);
878 CHECK_RESULTS_VLDX (TEST_MSG, expected_vld3_1, "chunk 1");
879
880 TEST_ALL_EXTRA_CHUNKS(3, 2);
881 CHECK_RESULTS_VLDX (TEST_MSG, expected_vld3_2, "chunk 2");
882
883 /* Check vld4/vld4q. */
884 clean_results ();
885 #undef TEST_MSG
886 #define TEST_MSG "VLD4/VLD4Q"
887 TEST_ALL_VLDX(4);
888 CHECK_RESULTS_VLDX (TEST_MSG, expected_vld4_0, "chunk 0");
889
890 TEST_ALL_EXTRA_CHUNKS(4, 1);
891 CHECK_RESULTS_VLDX (TEST_MSG, expected_vld4_1, "chunk 1");
892
893 TEST_ALL_EXTRA_CHUNKS(4, 2);
894 CHECK_RESULTS_VLDX (TEST_MSG, expected_vld4_2, "chunk 2");
895
896 TEST_ALL_EXTRA_CHUNKS(4, 3);
897 CHECK_RESULTS_VLDX (TEST_MSG, expected_vld4_3, "chunk 3");
898 }
899
900 int main (void)
901 {
902 exec_vldX ();
903 return 0;
904 }