1 /* { dg-final { check-function-bodies "**" "" "-DCHECK_ASM" { target { ! ilp32 } } } } */
2
3 #include "test_sve_acle.h"
4
5 /*
6 ** ld4_u32_base:
7 ** ld4w {z0\.s - z3\.s}, p0/z, \[x0\]
8 ** ret
9 */
10 TEST_LOAD (ld4_u32_base, svuint32x4_t, uint32_t,
11 z0 = svld4_u32 (p0, x0),
12 z0 = svld4 (p0, x0))
13
14 /*
15 ** ld4_u32_index:
16 ** ld4w {z0\.s - z3\.s}, p0/z, \[x0, x1, lsl 2\]
17 ** ret
18 */
19 TEST_LOAD (ld4_u32_index, svuint32x4_t, uint32_t,
20 z0 = svld4_u32 (p0, x0 + x1),
21 z0 = svld4 (p0, x0 + x1))
22
23 /* Moving the constant into a register would also be OK. */
24 /*
25 ** ld4_u32_1:
26 ** incb x0
27 ** ld4w {z0\.s - z3\.s}, p0/z, \[x0\]
28 ** ret
29 */
30 TEST_LOAD (ld4_u32_1, svuint32x4_t, uint32_t,
31 z0 = svld4_u32 (p0, x0 + svcntw ()),
32 z0 = svld4 (p0, x0 + svcntw ()))
33
34 /* Moving the constant into a register would also be OK. */
35 /*
36 ** ld4_u32_2:
37 ** incb x0, all, mul #2
38 ** ld4w {z0\.s - z3\.s}, p0/z, \[x0\]
39 ** ret
40 */
41 TEST_LOAD (ld4_u32_2, svuint32x4_t, uint32_t,
42 z0 = svld4_u32 (p0, x0 + svcntw () * 2),
43 z0 = svld4 (p0, x0 + svcntw () * 2))
44
45 /* Moving the constant into a register would also be OK. */
46 /*
47 ** ld4_u32_3:
48 ** incb x0, all, mul #3
49 ** ld4w {z0\.s - z3\.s}, p0/z, \[x0\]
50 ** ret
51 */
52 TEST_LOAD (ld4_u32_3, svuint32x4_t, uint32_t,
53 z0 = svld4_u32 (p0, x0 + svcntw () * 3),
54 z0 = svld4 (p0, x0 + svcntw () * 3))
55
56 /*
57 ** ld4_u32_4:
58 ** ld4w {z0\.s - z3\.s}, p0/z, \[x0, #4, mul vl\]
59 ** ret
60 */
61 TEST_LOAD (ld4_u32_4, svuint32x4_t, uint32_t,
62 z0 = svld4_u32 (p0, x0 + svcntw () * 4),
63 z0 = svld4 (p0, x0 + svcntw () * 4))
64
65 /*
66 ** ld4_u32_28:
67 ** ld4w {z0\.s - z3\.s}, p0/z, \[x0, #28, mul vl\]
68 ** ret
69 */
70 TEST_LOAD (ld4_u32_28, svuint32x4_t, uint32_t,
71 z0 = svld4_u32 (p0, x0 + svcntw () * 28),
72 z0 = svld4 (p0, x0 + svcntw () * 28))
73
74 /*
75 ** ld4_u32_32:
76 ** [^{]*
77 ** ld4w {z0\.s - z3\.s}, p0/z, \[x[0-9]+\]
78 ** ret
79 */
80 TEST_LOAD (ld4_u32_32, svuint32x4_t, uint32_t,
81 z0 = svld4_u32 (p0, x0 + svcntw () * 32),
82 z0 = svld4 (p0, x0 + svcntw () * 32))
83
84 /* Moving the constant into a register would also be OK. */
85 /*
86 ** ld4_u32_m1:
87 ** decb x0
88 ** ld4w {z0\.s - z3\.s}, p0/z, \[x0\]
89 ** ret
90 */
91 TEST_LOAD (ld4_u32_m1, svuint32x4_t, uint32_t,
92 z0 = svld4_u32 (p0, x0 - svcntw ()),
93 z0 = svld4 (p0, x0 - svcntw ()))
94
95 /* Moving the constant into a register would also be OK. */
96 /*
97 ** ld4_u32_m2:
98 ** decb x0, all, mul #2
99 ** ld4w {z0\.s - z3\.s}, p0/z, \[x0\]
100 ** ret
101 */
102 TEST_LOAD (ld4_u32_m2, svuint32x4_t, uint32_t,
103 z0 = svld4_u32 (p0, x0 - svcntw () * 2),
104 z0 = svld4 (p0, x0 - svcntw () * 2))
105
106 /* Moving the constant into a register would also be OK. */
107 /*
108 ** ld4_u32_m3:
109 ** decb x0, all, mul #3
110 ** ld4w {z0\.s - z3\.s}, p0/z, \[x0\]
111 ** ret
112 */
113 TEST_LOAD (ld4_u32_m3, svuint32x4_t, uint32_t,
114 z0 = svld4_u32 (p0, x0 - svcntw () * 3),
115 z0 = svld4 (p0, x0 - svcntw () * 3))
116
117 /*
118 ** ld4_u32_m4:
119 ** ld4w {z0\.s - z3\.s}, p0/z, \[x0, #-4, mul vl\]
120 ** ret
121 */
122 TEST_LOAD (ld4_u32_m4, svuint32x4_t, uint32_t,
123 z0 = svld4_u32 (p0, x0 - svcntw () * 4),
124 z0 = svld4 (p0, x0 - svcntw () * 4))
125
126 /*
127 ** ld4_u32_m32:
128 ** ld4w {z0\.s - z3\.s}, p0/z, \[x0, #-32, mul vl\]
129 ** ret
130 */
131 TEST_LOAD (ld4_u32_m32, svuint32x4_t, uint32_t,
132 z0 = svld4_u32 (p0, x0 - svcntw () * 32),
133 z0 = svld4 (p0, x0 - svcntw () * 32))
134
135 /*
136 ** ld4_u32_m36:
137 ** [^{]*
138 ** ld4w {z0\.s - z3\.s}, p0/z, \[x[0-9]+\]
139 ** ret
140 */
141 TEST_LOAD (ld4_u32_m36, svuint32x4_t, uint32_t,
142 z0 = svld4_u32 (p0, x0 - svcntw () * 36),
143 z0 = svld4 (p0, x0 - svcntw () * 36))
144
145 /*
146 ** ld4_vnum_u32_0:
147 ** ld4w {z0\.s - z3\.s}, p0/z, \[x0\]
148 ** ret
149 */
150 TEST_LOAD (ld4_vnum_u32_0, svuint32x4_t, uint32_t,
151 z0 = svld4_vnum_u32 (p0, x0, 0),
152 z0 = svld4_vnum (p0, x0, 0))
153
154 /* Moving the constant into a register would also be OK. */
155 /*
156 ** ld4_vnum_u32_1:
157 ** incb x0
158 ** ld4w {z0\.s - z3\.s}, p0/z, \[x0\]
159 ** ret
160 */
161 TEST_LOAD (ld4_vnum_u32_1, svuint32x4_t, uint32_t,
162 z0 = svld4_vnum_u32 (p0, x0, 1),
163 z0 = svld4_vnum (p0, x0, 1))
164
165 /* Moving the constant into a register would also be OK. */
166 /*
167 ** ld4_vnum_u32_2:
168 ** incb x0, all, mul #2
169 ** ld4w {z0\.s - z3\.s}, p0/z, \[x0\]
170 ** ret
171 */
172 TEST_LOAD (ld4_vnum_u32_2, svuint32x4_t, uint32_t,
173 z0 = svld4_vnum_u32 (p0, x0, 2),
174 z0 = svld4_vnum (p0, x0, 2))
175
176 /* Moving the constant into a register would also be OK. */
177 /*
178 ** ld4_vnum_u32_3:
179 ** incb x0, all, mul #3
180 ** ld4w {z0\.s - z3\.s}, p0/z, \[x0\]
181 ** ret
182 */
183 TEST_LOAD (ld4_vnum_u32_3, svuint32x4_t, uint32_t,
184 z0 = svld4_vnum_u32 (p0, x0, 3),
185 z0 = svld4_vnum (p0, x0, 3))
186
187 /*
188 ** ld4_vnum_u32_4:
189 ** ld4w {z0\.s - z3\.s}, p0/z, \[x0, #4, mul vl\]
190 ** ret
191 */
192 TEST_LOAD (ld4_vnum_u32_4, svuint32x4_t, uint32_t,
193 z0 = svld4_vnum_u32 (p0, x0, 4),
194 z0 = svld4_vnum (p0, x0, 4))
195
196 /*
197 ** ld4_vnum_u32_28:
198 ** ld4w {z0\.s - z3\.s}, p0/z, \[x0, #28, mul vl\]
199 ** ret
200 */
201 TEST_LOAD (ld4_vnum_u32_28, svuint32x4_t, uint32_t,
202 z0 = svld4_vnum_u32 (p0, x0, 28),
203 z0 = svld4_vnum (p0, x0, 28))
204
205 /*
206 ** ld4_vnum_u32_32:
207 ** [^{]*
208 ** ld4w {z0\.s - z3\.s}, p0/z, \[x[0-9]+\]
209 ** ret
210 */
211 TEST_LOAD (ld4_vnum_u32_32, svuint32x4_t, uint32_t,
212 z0 = svld4_vnum_u32 (p0, x0, 32),
213 z0 = svld4_vnum (p0, x0, 32))
214
215 /* Moving the constant into a register would also be OK. */
216 /*
217 ** ld4_vnum_u32_m1:
218 ** decb x0
219 ** ld4w {z0\.s - z3\.s}, p0/z, \[x0\]
220 ** ret
221 */
222 TEST_LOAD (ld4_vnum_u32_m1, svuint32x4_t, uint32_t,
223 z0 = svld4_vnum_u32 (p0, x0, -1),
224 z0 = svld4_vnum (p0, x0, -1))
225
226 /* Moving the constant into a register would also be OK. */
227 /*
228 ** ld4_vnum_u32_m2:
229 ** decb x0, all, mul #2
230 ** ld4w {z0\.s - z3\.s}, p0/z, \[x0\]
231 ** ret
232 */
233 TEST_LOAD (ld4_vnum_u32_m2, svuint32x4_t, uint32_t,
234 z0 = svld4_vnum_u32 (p0, x0, -2),
235 z0 = svld4_vnum (p0, x0, -2))
236
237 /* Moving the constant into a register would also be OK. */
238 /*
239 ** ld4_vnum_u32_m3:
240 ** decb x0, all, mul #3
241 ** ld4w {z0\.s - z3\.s}, p0/z, \[x0\]
242 ** ret
243 */
244 TEST_LOAD (ld4_vnum_u32_m3, svuint32x4_t, uint32_t,
245 z0 = svld4_vnum_u32 (p0, x0, -3),
246 z0 = svld4_vnum (p0, x0, -3))
247
248 /*
249 ** ld4_vnum_u32_m4:
250 ** ld4w {z0\.s - z3\.s}, p0/z, \[x0, #-4, mul vl\]
251 ** ret
252 */
253 TEST_LOAD (ld4_vnum_u32_m4, svuint32x4_t, uint32_t,
254 z0 = svld4_vnum_u32 (p0, x0, -4),
255 z0 = svld4_vnum (p0, x0, -4))
256
257 /*
258 ** ld4_vnum_u32_m32:
259 ** ld4w {z0\.s - z3\.s}, p0/z, \[x0, #-32, mul vl\]
260 ** ret
261 */
262 TEST_LOAD (ld4_vnum_u32_m32, svuint32x4_t, uint32_t,
263 z0 = svld4_vnum_u32 (p0, x0, -32),
264 z0 = svld4_vnum (p0, x0, -32))
265
266 /*
267 ** ld4_vnum_u32_m36:
268 ** [^{]*
269 ** ld4w {z0\.s - z3\.s}, p0/z, \[x[0-9]+\]
270 ** ret
271 */
272 TEST_LOAD (ld4_vnum_u32_m36, svuint32x4_t, uint32_t,
273 z0 = svld4_vnum_u32 (p0, x0, -36),
274 z0 = svld4_vnum (p0, x0, -36))
275
276 /* Using MUL to calculate an index would also be OK. */
277 /*
278 ** ld4_vnum_u32_x1:
279 ** cntb (x[0-9]+)
280 ** madd (x[0-9]+), (x1, \1|\1, x1), x0
281 ** ld4w {z0\.s - z3\.s}, p0/z, \[\2\]
282 ** ret
283 */
284 TEST_LOAD (ld4_vnum_u32_x1, svuint32x4_t, uint32_t,
285 z0 = svld4_vnum_u32 (p0, x0, x1),
286 z0 = svld4_vnum (p0, x0, x1))