Debian Codegraph @

gcc/testsuite/gcc.target/aarch64/sve2/acle/asm/ld1_f64_x4.c

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