Debian Codegraph @

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

raw
1 /* { dg-do assemble { target aarch64_asm_sve2p1_ok } } */
2 /* { dg-do compile { target { ! aarch64_asm_sve2p1_ok } } } */
3 /* { dg-skip-if "" { *-*-* } { "-DSTREAMING_COMPATIBLE" } { "" } } */
4 /* { dg-final { check-function-bodies "**" "" "-DCHECK_ASM" } } */
5
6 #include "test_sve_acle.h"
7
8 #pragma GCC target "+sve2p1"
9
10 /*
11 ** ld4q_u64_base:
12 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
13 ** ret
14 */
15 TEST_LOAD (ld4q_u64_base, svuint64x4_t, uint64_t,
16 z0 = svld4q_u64 (p0, x0),
17 z0 = svld4q (p0, x0))
18
19 /*
20 ** ld4q_u64_index:
21 ** add (x[0-9]), x0, x1, lsl #?3
22 ** ld4q {z0\.q - z3\.q}, p0/z, \[\1\]
23 ** ret
24 */
25 TEST_LOAD (ld4q_u64_index, svuint64x4_t, uint64_t,
26 z0 = svld4q_u64 (p0, x0 + x1),
27 z0 = svld4q (p0, x0 + x1))
28
29 /*
30 ** ld4q_u64_index2:
31 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0, x1, lsl #?4\]
32 ** ret
33 */
34 TEST_LOAD (ld4q_u64_index2, svuint64x4_t, uint64_t,
35 z0 = svld4q_u64 (p0, x0 + x1 * 2),
36 z0 = svld4q (p0, x0 + x1 * 2))
37
38 /* Moving the constant into a register would also be OK. */
39 /*
40 ** ld4q_u64_1:
41 ** incb x0
42 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
43 ** ret
44 */
45 TEST_LOAD (ld4q_u64_1, svuint64x4_t, uint64_t,
46 z0 = svld4q_u64 (p0, x0 + svcntd ()),
47 z0 = svld4q (p0, x0 + svcntd ()))
48
49 /* Moving the constant into a register would also be OK. */
50 /*
51 ** ld4q_u64_2:
52 ** incb x0, all, mul #2
53 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
54 ** ret
55 */
56 TEST_LOAD (ld4q_u64_2, svuint64x4_t, uint64_t,
57 z0 = svld4q_u64 (p0, x0 + svcntd () * 2),
58 z0 = svld4q (p0, x0 + svcntd () * 2))
59
60 /* Moving the constant into a register would also be OK. */
61 /*
62 ** ld4q_u64_3:
63 ** incb x0, all, mul #3
64 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
65 ** ret
66 */
67 TEST_LOAD (ld4q_u64_3, svuint64x4_t, uint64_t,
68 z0 = svld4q_u64 (p0, x0 + svcntd () * 3),
69 z0 = svld4q (p0, x0 + svcntd () * 3))
70
71 /*
72 ** ld4q_u64_4:
73 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0, #4, mul vl\]
74 ** ret
75 */
76 TEST_LOAD (ld4q_u64_4, svuint64x4_t, uint64_t,
77 z0 = svld4q_u64 (p0, x0 + svcntd () * 4),
78 z0 = svld4q (p0, x0 + svcntd () * 4))
79
80 /*
81 ** ld4q_u64_28:
82 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0, #28, mul vl\]
83 ** ret
84 */
85 TEST_LOAD (ld4q_u64_28, svuint64x4_t, uint64_t,
86 z0 = svld4q_u64 (p0, x0 + svcntd () * 28),
87 z0 = svld4q (p0, x0 + svcntd () * 28))
88
89 /*
90 ** ld4q_u64_32:
91 ** [^{]*
92 ** ld4q {z0\.q - z3\.q}, p0/z, \[x[0-9]+\]
93 ** ret
94 */
95 TEST_LOAD (ld4q_u64_32, svuint64x4_t, uint64_t,
96 z0 = svld4q_u64 (p0, x0 + svcntd () * 32),
97 z0 = svld4q (p0, x0 + svcntd () * 32))
98
99 /* Moving the constant into a register would also be OK. */
100 /*
101 ** ld4q_u64_m1:
102 ** decb x0
103 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
104 ** ret
105 */
106 TEST_LOAD (ld4q_u64_m1, svuint64x4_t, uint64_t,
107 z0 = svld4q_u64 (p0, x0 - svcntd ()),
108 z0 = svld4q (p0, x0 - svcntd ()))
109
110 /* Moving the constant into a register would also be OK. */
111 /*
112 ** ld4q_u64_m2:
113 ** decb x0, all, mul #2
114 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
115 ** ret
116 */
117 TEST_LOAD (ld4q_u64_m2, svuint64x4_t, uint64_t,
118 z0 = svld4q_u64 (p0, x0 - svcntd () * 2),
119 z0 = svld4q (p0, x0 - svcntd () * 2))
120
121 /* Moving the constant into a register would also be OK. */
122 /*
123 ** ld4q_u64_m3:
124 ** decb x0, all, mul #3
125 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
126 ** ret
127 */
128 TEST_LOAD (ld4q_u64_m3, svuint64x4_t, uint64_t,
129 z0 = svld4q_u64 (p0, x0 - svcntd () * 3),
130 z0 = svld4q (p0, x0 - svcntd () * 3))
131
132 /*
133 ** ld4q_u64_m4:
134 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0, #-4, mul vl\]
135 ** ret
136 */
137 TEST_LOAD (ld4q_u64_m4, svuint64x4_t, uint64_t,
138 z0 = svld4q_u64 (p0, x0 - svcntd () * 4),
139 z0 = svld4q (p0, x0 - svcntd () * 4))
140
141 /*
142 ** ld4q_u64_m32:
143 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0, #-32, mul vl\]
144 ** ret
145 */
146 TEST_LOAD (ld4q_u64_m32, svuint64x4_t, uint64_t,
147 z0 = svld4q_u64 (p0, x0 - svcntd () * 32),
148 z0 = svld4q (p0, x0 - svcntd () * 32))
149
150 /*
151 ** ld4q_u64_m36:
152 ** [^{]*
153 ** ld4q {z0\.q - z3\.q}, p0/z, \[x[0-9]+\]
154 ** ret
155 */
156 TEST_LOAD (ld4q_u64_m36, svuint64x4_t, uint64_t,
157 z0 = svld4q_u64 (p0, x0 - svcntd () * 36),
158 z0 = svld4q (p0, x0 - svcntd () * 36))
159
160 /*
161 ** ld4q_vnum_u64_0:
162 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
163 ** ret
164 */
165 TEST_LOAD (ld4q_vnum_u64_0, svuint64x4_t, uint64_t,
166 z0 = svld4q_vnum_u64 (p0, x0, 0),
167 z0 = svld4q_vnum (p0, x0, 0))
168
169 /* Moving the constant into a register would also be OK. */
170 /*
171 ** ld4q_vnum_u64_1:
172 ** incb x0
173 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
174 ** ret
175 */
176 TEST_LOAD (ld4q_vnum_u64_1, svuint64x4_t, uint64_t,
177 z0 = svld4q_vnum_u64 (p0, x0, 1),
178 z0 = svld4q_vnum (p0, x0, 1))
179
180 /* Moving the constant into a register would also be OK. */
181 /*
182 ** ld4q_vnum_u64_2:
183 ** incb x0, all, mul #2
184 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
185 ** ret
186 */
187 TEST_LOAD (ld4q_vnum_u64_2, svuint64x4_t, uint64_t,
188 z0 = svld4q_vnum_u64 (p0, x0, 2),
189 z0 = svld4q_vnum (p0, x0, 2))
190
191 /* Moving the constant into a register would also be OK. */
192 /*
193 ** ld4q_vnum_u64_3:
194 ** incb x0, all, mul #3
195 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
196 ** ret
197 */
198 TEST_LOAD (ld4q_vnum_u64_3, svuint64x4_t, uint64_t,
199 z0 = svld4q_vnum_u64 (p0, x0, 3),
200 z0 = svld4q_vnum (p0, x0, 3))
201
202 /*
203 ** ld4q_vnum_u64_4:
204 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0, #4, mul vl\]
205 ** ret
206 */
207 TEST_LOAD (ld4q_vnum_u64_4, svuint64x4_t, uint64_t,
208 z0 = svld4q_vnum_u64 (p0, x0, 4),
209 z0 = svld4q_vnum (p0, x0, 4))
210
211 /*
212 ** ld4q_vnum_u64_28:
213 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0, #28, mul vl\]
214 ** ret
215 */
216 TEST_LOAD (ld4q_vnum_u64_28, svuint64x4_t, uint64_t,
217 z0 = svld4q_vnum_u64 (p0, x0, 28),
218 z0 = svld4q_vnum (p0, x0, 28))
219
220 /*
221 ** ld4q_vnum_u64_32:
222 ** [^{]*
223 ** ld4q {z0\.q - z3\.q}, p0/z, \[x[0-9]+\]
224 ** ret
225 */
226 TEST_LOAD (ld4q_vnum_u64_32, svuint64x4_t, uint64_t,
227 z0 = svld4q_vnum_u64 (p0, x0, 32),
228 z0 = svld4q_vnum (p0, x0, 32))
229
230 /* Moving the constant into a register would also be OK. */
231 /*
232 ** ld4q_vnum_u64_m1:
233 ** decb x0
234 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
235 ** ret
236 */
237 TEST_LOAD (ld4q_vnum_u64_m1, svuint64x4_t, uint64_t,
238 z0 = svld4q_vnum_u64 (p0, x0, -1),
239 z0 = svld4q_vnum (p0, x0, -1))
240
241 /* Moving the constant into a register would also be OK. */
242 /*
243 ** ld4q_vnum_u64_m2:
244 ** decb x0, all, mul #2
245 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
246 ** ret
247 */
248 TEST_LOAD (ld4q_vnum_u64_m2, svuint64x4_t, uint64_t,
249 z0 = svld4q_vnum_u64 (p0, x0, -2),
250 z0 = svld4q_vnum (p0, x0, -2))
251
252 /* Moving the constant into a register would also be OK. */
253 /*
254 ** ld4q_vnum_u64_m3:
255 ** decb x0, all, mul #3
256 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
257 ** ret
258 */
259 TEST_LOAD (ld4q_vnum_u64_m3, svuint64x4_t, uint64_t,
260 z0 = svld4q_vnum_u64 (p0, x0, -3),
261 z0 = svld4q_vnum (p0, x0, -3))
262
263 /*
264 ** ld4q_vnum_u64_m4:
265 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0, #-4, mul vl\]
266 ** ret
267 */
268 TEST_LOAD (ld4q_vnum_u64_m4, svuint64x4_t, uint64_t,
269 z0 = svld4q_vnum_u64 (p0, x0, -4),
270 z0 = svld4q_vnum (p0, x0, -4))
271
272 /*
273 ** ld4q_vnum_u64_m32:
274 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0, #-32, mul vl\]
275 ** ret
276 */
277 TEST_LOAD (ld4q_vnum_u64_m32, svuint64x4_t, uint64_t,
278 z0 = svld4q_vnum_u64 (p0, x0, -32),
279 z0 = svld4q_vnum (p0, x0, -32))
280
281 /*
282 ** ld4q_vnum_u64_m36:
283 ** [^{]*
284 ** ld4q {z0\.q - z3\.q}, p0/z, \[x[0-9]+\]
285 ** ret
286 */
287 TEST_LOAD (ld4q_vnum_u64_m36, svuint64x4_t, uint64_t,
288 z0 = svld4q_vnum_u64 (p0, x0, -36),
289 z0 = svld4q_vnum (p0, x0, -36))
290
291 /*
292 ** ld4q_vnum_u64_x1:
293 ** cntb (x[0-9]+)
294 ** (
295 ** madd (x[0-9]+), (?:x1, \1|\1, x1), x0
296 ** ld4q {z0\.q - z3\.q}, p0/z, \[\2\]
297 ** |
298 ** mul (x[0-9]+), (?:x1, \1|\1, x1)
299 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0, \3\]
300 ** )
301 ** ret
302 */
303 TEST_LOAD (ld4q_vnum_u64_x1, svuint64x4_t, uint64_t,
304 z0 = svld4q_vnum_u64 (p0, x0, x1),
305 z0 = svld4q_vnum (p0, x0, x1))