Debian Codegraph @

gcc/testsuite/gcc.target/aarch64/sve2/acle/asm/st4q_s64.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 ** st4q_s64_base:
12 ** st4q {z0\.q - z3\.q}, p0, \[x0\]
13 ** ret
14 */
15 TEST_STORE (st4q_s64_base, svint64x4_t, int64_t,
16 svst4q_s64 (p0, x0, z0),
17 svst4q (p0, x0, z0))
18
19 /*
20 ** st4q_s64_index:
21 ** add (x[0-9]), x0, x1, lsl #?3
22 ** st4q {z0\.q - z3\.q}, p0, \[\1\]
23 ** ret
24 */
25 TEST_STORE (st4q_s64_index, svint64x4_t, int64_t,
26 svst4q_s64 (p0, x0 + x1, z0),
27 svst4q (p0, x0 + x1, z0))
28
29 /*
30 ** st4q_s64_index2:
31 ** st4q {z0\.q - z3\.q}, p0, \[x0, x1, lsl #?4\]
32 ** ret
33 */
34 TEST_STORE (st4q_s64_index2, svint64x4_t, int64_t,
35 svst4q_s64 (p0, x0 + x1 * 2, z0),
36 svst4q (p0, x0 + x1 * 2, z0))
37
38 /* Moving the constant into a register would also be OK. */
39 /*
40 ** st4q_s64_1:
41 ** incb x0
42 ** st4q {z0\.q - z3\.q}, p0, \[x0\]
43 ** ret
44 */
45 TEST_STORE (st4q_s64_1, svint64x4_t, int64_t,
46 svst4q_s64 (p0, x0 + svcntd (), z0),
47 svst4q (p0, x0 + svcntd (), z0))
48
49 /* Moving the constant into a register would also be OK. */
50 /*
51 ** st4q_s64_2:
52 ** incb x0, all, mul #2
53 ** st4q {z0\.q - z3\.q}, p0, \[x0\]
54 ** ret
55 */
56 TEST_STORE (st4q_s64_2, svint64x4_t, int64_t,
57 svst4q_s64 (p0, x0 + svcntd () * 2, z0),
58 svst4q (p0, x0 + svcntd () * 2, z0))
59
60 /* Moving the constant into a register would also be OK. */
61 /*
62 ** st4q_s64_3:
63 ** incb x0, all, mul #3
64 ** st4q {z0\.q - z3\.q}, p0, \[x0\]
65 ** ret
66 */
67 TEST_STORE (st4q_s64_3, svint64x4_t, int64_t,
68 svst4q_s64 (p0, x0 + svcntd () * 3, z0),
69 svst4q (p0, x0 + svcntd () * 3, z0))
70
71 /*
72 ** st4q_s64_4:
73 ** st4q {z0\.q - z3\.q}, p0, \[x0, #4, mul vl\]
74 ** ret
75 */
76 TEST_STORE (st4q_s64_4, svint64x4_t, int64_t,
77 svst4q_s64 (p0, x0 + svcntd () * 4, z0),
78 svst4q (p0, x0 + svcntd () * 4, z0))
79
80 /*
81 ** st4q_s64_28:
82 ** st4q {z0\.q - z3\.q}, p0, \[x0, #28, mul vl\]
83 ** ret
84 */
85 TEST_STORE (st4q_s64_28, svint64x4_t, int64_t,
86 svst4q_s64 (p0, x0 + svcntd () * 28, z0),
87 svst4q (p0, x0 + svcntd () * 28, z0))
88
89 /*
90 ** st4q_s64_32:
91 ** [^{]*
92 ** st4q {z0\.q - z3\.q}, p0, \[x[0-9]+\]
93 ** ret
94 */
95 TEST_STORE (st4q_s64_32, svint64x4_t, int64_t,
96 svst4q_s64 (p0, x0 + svcntd () * 32, z0),
97 svst4q (p0, x0 + svcntd () * 32, z0))
98
99 /* Moving the constant into a register would also be OK. */
100 /*
101 ** st4q_s64_m1:
102 ** decb x0
103 ** st4q {z0\.q - z3\.q}, p0, \[x0\]
104 ** ret
105 */
106 TEST_STORE (st4q_s64_m1, svint64x4_t, int64_t,
107 svst4q_s64 (p0, x0 - svcntd (), z0),
108 svst4q (p0, x0 - svcntd (), z0))
109
110 /* Moving the constant into a register would also be OK. */
111 /*
112 ** st4q_s64_m2:
113 ** decb x0, all, mul #2
114 ** st4q {z0\.q - z3\.q}, p0, \[x0\]
115 ** ret
116 */
117 TEST_STORE (st4q_s64_m2, svint64x4_t, int64_t,
118 svst4q_s64 (p0, x0 - svcntd () * 2, z0),
119 svst4q (p0, x0 - svcntd () * 2, z0))
120
121 /* Moving the constant into a register would also be OK. */
122 /*
123 ** st4q_s64_m3:
124 ** decb x0, all, mul #3
125 ** st4q {z0\.q - z3\.q}, p0, \[x0\]
126 ** ret
127 */
128 TEST_STORE (st4q_s64_m3, svint64x4_t, int64_t,
129 svst4q_s64 (p0, x0 - svcntd () * 3, z0),
130 svst4q (p0, x0 - svcntd () * 3, z0))
131
132 /*
133 ** st4q_s64_m4:
134 ** st4q {z0\.q - z3\.q}, p0, \[x0, #-4, mul vl\]
135 ** ret
136 */
137 TEST_STORE (st4q_s64_m4, svint64x4_t, int64_t,
138 svst4q_s64 (p0, x0 - svcntd () * 4, z0),
139 svst4q (p0, x0 - svcntd () * 4, z0))
140
141 /*
142 ** st4q_s64_m32:
143 ** st4q {z0\.q - z3\.q}, p0, \[x0, #-32, mul vl\]
144 ** ret
145 */
146 TEST_STORE (st4q_s64_m32, svint64x4_t, int64_t,
147 svst4q_s64 (p0, x0 - svcntd () * 32, z0),
148 svst4q (p0, x0 - svcntd () * 32, z0))
149
150 /*
151 ** st4q_s64_m36:
152 ** [^{]*
153 ** st4q {z0\.q - z3\.q}, p0, \[x[0-9]+\]
154 ** ret
155 */
156 TEST_STORE (st4q_s64_m36, svint64x4_t, int64_t,
157 svst4q_s64 (p0, x0 - svcntd () * 36, z0),
158 svst4q (p0, x0 - svcntd () * 36, z0))
159
160 /*
161 ** st4q_vnum_s64_0:
162 ** st4q {z0\.q - z3\.q}, p0, \[x0\]
163 ** ret
164 */
165 TEST_STORE (st4q_vnum_s64_0, svint64x4_t, int64_t,
166 svst4q_vnum_s64 (p0, x0, 0, z0),
167 svst4q_vnum (p0, x0, 0, z0))
168
169 /* Moving the constant into a register would also be OK. */
170 /*
171 ** st4q_vnum_s64_1:
172 ** incb x0
173 ** st4q {z0\.q - z3\.q}, p0, \[x0\]
174 ** ret
175 */
176 TEST_STORE (st4q_vnum_s64_1, svint64x4_t, int64_t,
177 svst4q_vnum_s64 (p0, x0, 1, z0),
178 svst4q_vnum (p0, x0, 1, z0))
179
180 /* Moving the constant into a register would also be OK. */
181 /*
182 ** st4q_vnum_s64_2:
183 ** incb x0, all, mul #2
184 ** st4q {z0\.q - z3\.q}, p0, \[x0\]
185 ** ret
186 */
187 TEST_STORE (st4q_vnum_s64_2, svint64x4_t, int64_t,
188 svst4q_vnum_s64 (p0, x0, 2, z0),
189 svst4q_vnum (p0, x0, 2, z0))
190
191 /* Moving the constant into a register would also be OK. */
192 /*
193 ** st4q_vnum_s64_3:
194 ** incb x0, all, mul #3
195 ** st4q {z0\.q - z3\.q}, p0, \[x0\]
196 ** ret
197 */
198 TEST_STORE (st4q_vnum_s64_3, svint64x4_t, int64_t,
199 svst4q_vnum_s64 (p0, x0, 3, z0),
200 svst4q_vnum (p0, x0, 3, z0))
201
202 /*
203 ** st4q_vnum_s64_4:
204 ** st4q {z0\.q - z3\.q}, p0, \[x0, #4, mul vl\]
205 ** ret
206 */
207 TEST_STORE (st4q_vnum_s64_4, svint64x4_t, int64_t,
208 svst4q_vnum_s64 (p0, x0, 4, z0),
209 svst4q_vnum (p0, x0, 4, z0))
210
211 /*
212 ** st4q_vnum_s64_28:
213 ** st4q {z0\.q - z3\.q}, p0, \[x0, #28, mul vl\]
214 ** ret
215 */
216 TEST_STORE (st4q_vnum_s64_28, svint64x4_t, int64_t,
217 svst4q_vnum_s64 (p0, x0, 28, z0),
218 svst4q_vnum (p0, x0, 28, z0))
219
220 /*
221 ** st4q_vnum_s64_32:
222 ** [^{]*
223 ** st4q {z0\.q - z3\.q}, p0, \[x[0-9]+\]
224 ** ret
225 */
226 TEST_STORE (st4q_vnum_s64_32, svint64x4_t, int64_t,
227 svst4q_vnum_s64 (p0, x0, 32, z0),
228 svst4q_vnum (p0, x0, 32, z0))
229
230 /* Moving the constant into a register would also be OK. */
231 /*
232 ** st4q_vnum_s64_m1:
233 ** decb x0
234 ** st4q {z0\.q - z3\.q}, p0, \[x0\]
235 ** ret
236 */
237 TEST_STORE (st4q_vnum_s64_m1, svint64x4_t, int64_t,
238 svst4q_vnum_s64 (p0, x0, -1, z0),
239 svst4q_vnum (p0, x0, -1, z0))
240
241 /* Moving the constant into a register would also be OK. */
242 /*
243 ** st4q_vnum_s64_m2:
244 ** decb x0, all, mul #2
245 ** st4q {z0\.q - z3\.q}, p0, \[x0\]
246 ** ret
247 */
248 TEST_STORE (st4q_vnum_s64_m2, svint64x4_t, int64_t,
249 svst4q_vnum_s64 (p0, x0, -2, z0),
250 svst4q_vnum (p0, x0, -2, z0))
251
252 /* Moving the constant into a register would also be OK. */
253 /*
254 ** st4q_vnum_s64_m3:
255 ** decb x0, all, mul #3
256 ** st4q {z0\.q - z3\.q}, p0, \[x0\]
257 ** ret
258 */
259 TEST_STORE (st4q_vnum_s64_m3, svint64x4_t, int64_t,
260 svst4q_vnum_s64 (p0, x0, -3, z0),
261 svst4q_vnum (p0, x0, -3, z0))
262
263 /*
264 ** st4q_vnum_s64_m4:
265 ** st4q {z0\.q - z3\.q}, p0, \[x0, #-4, mul vl\]
266 ** ret
267 */
268 TEST_STORE (st4q_vnum_s64_m4, svint64x4_t, int64_t,
269 svst4q_vnum_s64 (p0, x0, -4, z0),
270 svst4q_vnum (p0, x0, -4, z0))
271
272 /*
273 ** st4q_vnum_s64_m32:
274 ** st4q {z0\.q - z3\.q}, p0, \[x0, #-32, mul vl\]
275 ** ret
276 */
277 TEST_STORE (st4q_vnum_s64_m32, svint64x4_t, int64_t,
278 svst4q_vnum_s64 (p0, x0, -32, z0),
279 svst4q_vnum (p0, x0, -32, z0))
280
281 /*
282 ** st4q_vnum_s64_m36:
283 ** [^{]*
284 ** st4q {z0\.q - z3\.q}, p0, \[x[0-9]+\]
285 ** ret
286 */
287 TEST_STORE (st4q_vnum_s64_m36, svint64x4_t, int64_t,
288 svst4q_vnum_s64 (p0, x0, -36, z0),
289 svst4q_vnum (p0, x0, -36, z0))
290
291 /*
292 ** st4q_vnum_s64_x1:
293 ** cntb (x[0-9]+)
294 ** (
295 ** madd (x[0-9]+), (?:x1, \1|\1, x1), x0
296 ** st4q {z0\.q - z3\.q}, p0, \[\2\]
297 ** |
298 ** mul (x[0-9]+), (?:x1, \1|\1, x1)
299 ** st4q {z0\.q - z3\.q}, p0, \[x0, \3\]
300 ** )
301 ** ret
302 */
303 TEST_STORE (st4q_vnum_s64_x1, svint64x4_t, int64_t,
304 svst4q_vnum_s64 (p0, x0, x1, z0),
305 svst4q_vnum (p0, x0, x1, z0))