Debian Codegraph @

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