Debian Codegraph @

gcc/testsuite/gcc.target/aarch64/sme2/acle-asm/ld1_u32_x4.c

raw
1 /* { dg-final { check-function-bodies "**" "" "-DCHECK_ASM" { target { ! ilp32 } } } } */
2
3 #include "test_sme2_acle.h"
4
5 /*
6 ** ld1_u32_base:
7 ** ld1w {z0\.s - z3\.s}, pn8/z, \[x0\]
8 ** ret
9 */
10 TEST_LOAD_COUNT (ld1_u32_base, svuint32x4_t, uint32_t,
11 z0 = svld1_u32_x4 (pn8, x0),
12 z0 = svld1_x4 (pn8, x0))
13
14 /*
15 ** ld1_u32_index:
16 ** ld1w {z0\.s - z3\.s}, pn8/z, \[x0, x1, lsl #?2\]
17 ** ret
18 */
19 TEST_LOAD_COUNT (ld1_u32_index, svuint32x4_t, uint32_t,
20 z0 = svld1_u32_x4 (pn8, x0 + x1),
21 z0 = svld1_x4 (pn8, x0 + x1))
22
23 /* Moving the constant into a register would also be OK. */
24 /*
25 ** ld1_u32_1:
26 ** incb x0
27 ** ld1w {z0\.s - z3\.s}, pn8/z, \[x0\]
28 ** ret
29 */
30 TEST_LOAD_COUNT (ld1_u32_1, svuint32x4_t, uint32_t,
31 z0 = svld1_u32_x4 (pn8, x0 + svcntw ()),
32 z0 = svld1_x4 (pn8, x0 + svcntw ()))
33
34 /* Moving the constant into a register would also be OK. */
35 /*
36 ** ld1_u32_2:
37 ** incb x0, all, mul #2
38 ** ld1w {z0\.s - z3\.s}, pn8/z, \[x0\]
39 ** ret
40 */
41 TEST_LOAD_COUNT (ld1_u32_2, svuint32x4_t, uint32_t,
42 z0 = svld1_u32_x4 (pn8, x0 + svcntw () * 2),
43 z0 = svld1_x4 (pn8, x0 + svcntw () * 2))
44
45 /* Moving the constant into a register would also be OK. */
46 /*
47 ** ld1_u32_3:
48 ** incb x0, all, mul #3
49 ** ld1w {z0\.s - z3\.s}, pn8/z, \[x0\]
50 ** ret
51 */
52 TEST_LOAD_COUNT (ld1_u32_3, svuint32x4_t, uint32_t,
53 z0 = svld1_u32_x4 (pn8, x0 + svcntw () * 3),
54 z0 = svld1_x4 (pn8, x0 + svcntw () * 3))
55
56 /*
57 ** ld1_u32_4:
58 ** ld1w {z0\.s - z3\.s}, pn8/z, \[x0, #4, mul vl\]
59 ** ret
60 */
61 TEST_LOAD_COUNT (ld1_u32_4, svuint32x4_t, uint32_t,
62 z0 = svld1_u32_x4 (pn8, x0 + svcntw () * 4),
63 z0 = svld1_x4 (pn8, x0 + svcntw () * 4))
64
65 /*
66 ** ld1_u32_28:
67 ** ld1w {z0\.s - z3\.s}, pn8/z, \[x0, #28, mul vl\]
68 ** ret
69 */
70 TEST_LOAD_COUNT (ld1_u32_28, svuint32x4_t, uint32_t,
71 z0 = svld1_u32_x4 (pn8, x0 + svcntw () * 28),
72 z0 = svld1_x4 (pn8, x0 + svcntw () * 28))
73
74 /*
75 ** ld1_u32_32:
76 ** [^{]*
77 ** ld1w {z0\.s - z3\.s}, pn8/z, \[x[0-9]+\]
78 ** ret
79 */
80 TEST_LOAD_COUNT (ld1_u32_32, svuint32x4_t, uint32_t,
81 z0 = svld1_u32_x4 (pn8, x0 + svcntw () * 32),
82 z0 = svld1_x4 (pn8, x0 + svcntw () * 32))
83
84 /* Moving the constant into a register would also be OK. */
85 /*
86 ** ld1_u32_m1:
87 ** decb x0
88 ** ld1w {z0\.s - z3\.s}, pn8/z, \[x0\]
89 ** ret
90 */
91 TEST_LOAD_COUNT (ld1_u32_m1, svuint32x4_t, uint32_t,
92 z0 = svld1_u32_x4 (pn8, x0 - svcntw ()),
93 z0 = svld1_x4 (pn8, x0 - svcntw ()))
94
95 /* Moving the constant into a register would also be OK. */
96 /*
97 ** ld1_u32_m2:
98 ** decb x0, all, mul #2
99 ** ld1w {z0\.s - z3\.s}, pn8/z, \[x0\]
100 ** ret
101 */
102 TEST_LOAD_COUNT (ld1_u32_m2, svuint32x4_t, uint32_t,
103 z0 = svld1_u32_x4 (pn8, x0 - svcntw () * 2),
104 z0 = svld1_x4 (pn8, x0 - svcntw () * 2))
105
106 /* Moving the constant into a register would also be OK. */
107 /*
108 ** ld1_u32_m3:
109 ** decb x0, all, mul #3
110 ** ld1w {z0\.s - z3\.s}, pn8/z, \[x0\]
111 ** ret
112 */
113 TEST_LOAD_COUNT (ld1_u32_m3, svuint32x4_t, uint32_t,
114 z0 = svld1_u32_x4 (pn8, x0 - svcntw () * 3),
115 z0 = svld1_x4 (pn8, x0 - svcntw () * 3))
116
117 /*
118 ** ld1_u32_m4:
119 ** ld1w {z0\.s - z3\.s}, pn8/z, \[x0, #-4, mul vl\]
120 ** ret
121 */
122 TEST_LOAD_COUNT (ld1_u32_m4, svuint32x4_t, uint32_t,
123 z0 = svld1_u32_x4 (pn8, x0 - svcntw () * 4),
124 z0 = svld1_x4 (pn8, x0 - svcntw () * 4))
125
126 /*
127 ** ld1_u32_m32:
128 ** ld1w {z0\.s - z3\.s}, pn8/z, \[x0, #-32, mul vl\]
129 ** ret
130 */
131 TEST_LOAD_COUNT (ld1_u32_m32, svuint32x4_t, uint32_t,
132 z0 = svld1_u32_x4 (pn8, x0 - svcntw () * 32),
133 z0 = svld1_x4 (pn8, x0 - svcntw () * 32))
134
135 /*
136 ** ld1_u32_m36:
137 ** [^{]*
138 ** ld1w {z0\.s - z3\.s}, pn8/z, \[x[0-9]+\]
139 ** ret
140 */
141 TEST_LOAD_COUNT (ld1_u32_m36, svuint32x4_t, uint32_t,
142 z0 = svld1_u32_x4 (pn8, x0 - svcntw () * 36),
143 z0 = svld1_x4 (pn8, x0 - svcntw () * 36))
144
145 /*
146 ** ld1_u32_z17:
147 ** ld1w {z[^\n]+}, pn8/z, \[x0\]
148 ** mov [^\n]+
149 ** mov [^\n]+
150 ** mov [^\n]+
151 ** mov [^\n]+
152 ** ret
153 */
154 TEST_LOAD_COUNT (ld1_u32_z17, svuint32x4_t, uint32_t,
155 z17 = svld1_u32_x4 (pn8, x0),
156 z17 = svld1_x4 (pn8, x0))
157
158 /*
159 ** ld1_u32_z22:
160 ** ld1w {z[^\n]+}, pn8/z, \[x0\]
161 ** mov [^\n]+
162 ** mov [^\n]+
163 ** mov [^\n]+
164 ** mov [^\n]+
165 ** ret
166 */
167 TEST_LOAD_COUNT (ld1_u32_z22, svuint32x4_t, uint32_t,
168 z22 = svld1_u32_x4 (pn8, x0),
169 z22 = svld1_x4 (pn8, x0))
170
171 /*
172 ** ld1_u32_z28:
173 ** ld1w {z28\.s(?: - |, )z31\.s}, pn8/z, \[x0\]
174 ** ret
175 */
176 TEST_LOAD_COUNT (ld1_u32_z28, svuint32x4_t, uint32_t,
177 z28 = svld1_u32_x4 (pn8, x0),
178 z28 = svld1_x4 (pn8, x0))
179
180 /*
181 ** ld1_u32_pn0:
182 ** mov p([89]|1[0-5])\.b, p0\.b
183 ** ld1w {z0\.s(?: - |, )z3\.s}, pn\1/z, \[x0\]
184 ** ret
185 */
186 TEST_LOAD_COUNT (ld1_u32_pn0, svuint32x4_t, uint32_t,
187 z0 = svld1_u32_x4 (pn0, x0),
188 z0 = svld1_x4 (pn0, x0))
189
190 /*
191 ** ld1_u32_pn7:
192 ** mov p([89]|1[0-5])\.b, p7\.b
193 ** ld1w {z0\.s(?: - |, )z3\.s}, pn\1/z, \[x0\]
194 ** ret
195 */
196 TEST_LOAD_COUNT (ld1_u32_pn7, svuint32x4_t, uint32_t,
197 z0 = svld1_u32_x4 (pn7, x0),
198 z0 = svld1_x4 (pn7, x0))
199
200 /*
201 ** ld1_u32_pn15:
202 ** ld1w {z0\.s(?: - |, )z3\.s}, pn15/z, \[x0\]
203 ** ret
204 */
205 TEST_LOAD_COUNT (ld1_u32_pn15, svuint32x4_t, uint32_t,
206 z0 = svld1_u32_x4 (pn15, x0),
207 z0 = svld1_x4 (pn15, x0))
208
209 /*
210 ** ld1_vnum_u32_0:
211 ** ld1w {z0\.s - z3\.s}, pn8/z, \[x0\]
212 ** ret
213 */
214 TEST_LOAD_COUNT (ld1_vnum_u32_0, svuint32x4_t, uint32_t,
215 z0 = svld1_vnum_u32_x4 (pn8, x0, 0),
216 z0 = svld1_vnum_x4 (pn8, x0, 0))
217
218 /* Moving the constant into a register would also be OK. */
219 /*
220 ** ld1_vnum_u32_1:
221 ** incb x0
222 ** ld1w {z0\.s - z3\.s}, pn8/z, \[x0\]
223 ** ret
224 */
225 TEST_LOAD_COUNT (ld1_vnum_u32_1, svuint32x4_t, uint32_t,
226 z0 = svld1_vnum_u32_x4 (pn8, x0, 1),
227 z0 = svld1_vnum_x4 (pn8, x0, 1))
228
229 /* Moving the constant into a register would also be OK. */
230 /*
231 ** ld1_vnum_u32_2:
232 ** incb x0, all, mul #2
233 ** ld1w {z0\.s - z3\.s}, pn8/z, \[x0\]
234 ** ret
235 */
236 TEST_LOAD_COUNT (ld1_vnum_u32_2, svuint32x4_t, uint32_t,
237 z0 = svld1_vnum_u32_x4 (pn8, x0, 2),
238 z0 = svld1_vnum_x4 (pn8, x0, 2))
239
240 /* Moving the constant into a register would also be OK. */
241 /*
242 ** ld1_vnum_u32_3:
243 ** incb x0, all, mul #3
244 ** ld1w {z0\.s - z3\.s}, pn8/z, \[x0\]
245 ** ret
246 */
247 TEST_LOAD_COUNT (ld1_vnum_u32_3, svuint32x4_t, uint32_t,
248 z0 = svld1_vnum_u32_x4 (pn8, x0, 3),
249 z0 = svld1_vnum_x4 (pn8, x0, 3))
250
251 /*
252 ** ld1_vnum_u32_4:
253 ** ld1w {z0\.s - z3\.s}, pn8/z, \[x0, #4, mul vl\]
254 ** ret
255 */
256 TEST_LOAD_COUNT (ld1_vnum_u32_4, svuint32x4_t, uint32_t,
257 z0 = svld1_vnum_u32_x4 (pn8, x0, 4),
258 z0 = svld1_vnum_x4 (pn8, x0, 4))
259
260 /*
261 ** ld1_vnum_u32_28:
262 ** ld1w {z0\.s - z3\.s}, pn8/z, \[x0, #28, mul vl\]
263 ** ret
264 */
265 TEST_LOAD_COUNT (ld1_vnum_u32_28, svuint32x4_t, uint32_t,
266 z0 = svld1_vnum_u32_x4 (pn8, x0, 28),
267 z0 = svld1_vnum_x4 (pn8, x0, 28))
268
269 /*
270 ** ld1_vnum_u32_32:
271 ** [^{]*
272 ** ld1w {z0\.s - z3\.s}, pn8/z, \[x[0-9]+\]
273 ** ret
274 */
275 TEST_LOAD_COUNT (ld1_vnum_u32_32, svuint32x4_t, uint32_t,
276 z0 = svld1_vnum_u32_x4 (pn8, x0, 32),
277 z0 = svld1_vnum_x4 (pn8, x0, 32))
278
279 /* Moving the constant into a register would also be OK. */
280 /*
281 ** ld1_vnum_u32_m1:
282 ** decb x0
283 ** ld1w {z0\.s - z3\.s}, pn8/z, \[x0\]
284 ** ret
285 */
286 TEST_LOAD_COUNT (ld1_vnum_u32_m1, svuint32x4_t, uint32_t,
287 z0 = svld1_vnum_u32_x4 (pn8, x0, -1),
288 z0 = svld1_vnum_x4 (pn8, x0, -1))
289
290 /* Moving the constant into a register would also be OK. */
291 /*
292 ** ld1_vnum_u32_m2:
293 ** decb x0, all, mul #2
294 ** ld1w {z0\.s - z3\.s}, pn8/z, \[x0\]
295 ** ret
296 */
297 TEST_LOAD_COUNT (ld1_vnum_u32_m2, svuint32x4_t, uint32_t,
298 z0 = svld1_vnum_u32_x4 (pn8, x0, -2),
299 z0 = svld1_vnum_x4 (pn8, x0, -2))
300
301 /* Moving the constant into a register would also be OK. */
302 /*
303 ** ld1_vnum_u32_m3:
304 ** decb x0, all, mul #3
305 ** ld1w {z0\.s - z3\.s}, pn8/z, \[x0\]
306 ** ret
307 */
308 TEST_LOAD_COUNT (ld1_vnum_u32_m3, svuint32x4_t, uint32_t,
309 z0 = svld1_vnum_u32_x4 (pn8, x0, -3),
310 z0 = svld1_vnum_x4 (pn8, x0, -3))
311
312 /*
313 ** ld1_vnum_u32_m4:
314 ** ld1w {z0\.s - z3\.s}, pn8/z, \[x0, #-4, mul vl\]
315 ** ret
316 */
317 TEST_LOAD_COUNT (ld1_vnum_u32_m4, svuint32x4_t, uint32_t,
318 z0 = svld1_vnum_u32_x4 (pn8, x0, -4),
319 z0 = svld1_vnum_x4 (pn8, x0, -4))
320
321 /*
322 ** ld1_vnum_u32_m32:
323 ** ld1w {z0\.s - z3\.s}, pn8/z, \[x0, #-32, mul vl\]
324 ** ret
325 */
326 TEST_LOAD_COUNT (ld1_vnum_u32_m32, svuint32x4_t, uint32_t,
327 z0 = svld1_vnum_u32_x4 (pn8, x0, -32),
328 z0 = svld1_vnum_x4 (pn8, x0, -32))
329
330 /*
331 ** ld1_vnum_u32_m36:
332 ** [^{]*
333 ** ld1w {z0\.s - z3\.s}, pn8/z, \[x[0-9]+\]
334 ** ret
335 */
336 TEST_LOAD_COUNT (ld1_vnum_u32_m36, svuint32x4_t, uint32_t,
337 z0 = svld1_vnum_u32_x4 (pn8, x0, -36),
338 z0 = svld1_vnum_x4 (pn8, x0, -36))
339
340 /*
341 ** ld1_vnum_u32_x1:
342 ** cntb (x[0-9]+)
343 ** (
344 ** madd (x[0-9]+), (?:x1, \1|\1, x1), x0
345 ** ld1w {z0\.s - z3\.s}, pn8/z, \[\2\]
346 ** |
347 ** mul (x[0-9]+), (?:x1, \1|\1, x1)
348 ** ld1w {z0\.s - z3\.s}, pn8/z, \[x0, \3\]
349 ** )
350 ** ret
351 */
352 TEST_LOAD_COUNT (ld1_vnum_u32_x1, svuint32x4_t, uint32_t,
353 z0 = svld1_vnum_u32_x4 (pn8, x0, x1),
354 z0 = svld1_vnum_x4 (pn8, x0, x1))