Debian Codegraph @

gcc/testsuite/gcc.target/aarch64/sve2/acle/asm/ld4q_s8.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_s8_base:
12 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
13 ** ret
14 */
15 TEST_LOAD (ld4q_s8_base, svint8x4_t, int8_t,
16 z0 = svld4q_s8 (p0, x0),
17 z0 = svld4q (p0, x0))
18
19 /*
20 ** ld4q_s8_index:
21 ** add (x[0-9]), (?:x0, x1|x1, x0)
22 ** ld4q {z0\.q - z3\.q}, p0/z, \[\1\]
23 ** ret
24 */
25 TEST_LOAD (ld4q_s8_index, svint8x4_t, int8_t,
26 z0 = svld4q_s8 (p0, x0 + x1),
27 z0 = svld4q (p0, x0 + x1))
28
29 /*
30 ** ld4q_s8_index2:
31 ** add (x[0-9]), x0, x1, lsl #?1
32 ** ld4q {z0\.q - z3\.q}, p0/z, \[\1\]
33 ** ret
34 */
35 TEST_LOAD (ld4q_s8_index2, svint8x4_t, int8_t,
36 z0 = svld4q_s8 (p0, x0 + x1 * 2),
37 z0 = svld4q (p0, x0 + x1 * 2))
38
39 /*
40 ** ld4q_s8_index4:
41 ** add (x[0-9]), x0, x1, lsl #?2
42 ** ld4q {z0\.q - z3\.q}, p0/z, \[\1\]
43 ** ret
44 */
45 TEST_LOAD (ld4q_s8_index4, svint8x4_t, int8_t,
46 z0 = svld4q_s8 (p0, x0 + x1 * 4),
47 z0 = svld4q (p0, x0 + x1 * 4))
48
49 /*
50 ** ld4q_s8_index8:
51 ** add (x[0-9]), x0, x1, lsl #?3
52 ** ld4q {z0\.q - z3\.q}, p0/z, \[\1\]
53 ** ret
54 */
55 TEST_LOAD (ld4q_s8_index8, svint8x4_t, int8_t,
56 z0 = svld4q_s8 (p0, x0 + x1 * 8),
57 z0 = svld4q (p0, x0 + x1 * 8))
58
59 /*
60 ** ld4q_s8_index16:
61 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0, x1, lsl #?4\]
62 ** ret
63 */
64 TEST_LOAD (ld4q_s8_index16, svint8x4_t, int8_t,
65 z0 = svld4q_s8 (p0, x0 + x1 * 16),
66 z0 = svld4q (p0, x0 + x1 * 16))
67
68 /* Moving the constant into a register would also be OK. */
69 /*
70 ** ld4q_s8_1:
71 ** incb x0
72 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
73 ** ret
74 */
75 TEST_LOAD (ld4q_s8_1, svint8x4_t, int8_t,
76 z0 = svld4q_s8 (p0, x0 + svcntb ()),
77 z0 = svld4q (p0, x0 + svcntb ()))
78
79 /* Moving the constant into a register would also be OK. */
80 /*
81 ** ld4q_s8_2:
82 ** incb x0, all, mul #2
83 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
84 ** ret
85 */
86 TEST_LOAD (ld4q_s8_2, svint8x4_t, int8_t,
87 z0 = svld4q_s8 (p0, x0 + svcntb () * 2),
88 z0 = svld4q (p0, x0 + svcntb () * 2))
89
90 /* Moving the constant into a register would also be OK. */
91 /*
92 ** ld4q_s8_3:
93 ** incb x0, all, mul #3
94 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
95 ** ret
96 */
97 TEST_LOAD (ld4q_s8_3, svint8x4_t, int8_t,
98 z0 = svld4q_s8 (p0, x0 + svcntb () * 3),
99 z0 = svld4q (p0, x0 + svcntb () * 3))
100
101 /*
102 ** ld4q_s8_4:
103 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0, #4, mul vl\]
104 ** ret
105 */
106 TEST_LOAD (ld4q_s8_4, svint8x4_t, int8_t,
107 z0 = svld4q_s8 (p0, x0 + svcntb () * 4),
108 z0 = svld4q (p0, x0 + svcntb () * 4))
109
110 /*
111 ** ld4q_s8_28:
112 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0, #28, mul vl\]
113 ** ret
114 */
115 TEST_LOAD (ld4q_s8_28, svint8x4_t, int8_t,
116 z0 = svld4q_s8 (p0, x0 + svcntb () * 28),
117 z0 = svld4q (p0, x0 + svcntb () * 28))
118
119 /*
120 ** ld4q_s8_32:
121 ** [^{]*
122 ** ld4q {z0\.q - z3\.q}, p0/z, \[x[0-9]+\]
123 ** ret
124 */
125 TEST_LOAD (ld4q_s8_32, svint8x4_t, int8_t,
126 z0 = svld4q_s8 (p0, x0 + svcntb () * 32),
127 z0 = svld4q (p0, x0 + svcntb () * 32))
128
129 /* Moving the constant into a register would also be OK. */
130 /*
131 ** ld4q_s8_m1:
132 ** decb x0
133 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
134 ** ret
135 */
136 TEST_LOAD (ld4q_s8_m1, svint8x4_t, int8_t,
137 z0 = svld4q_s8 (p0, x0 - svcntb ()),
138 z0 = svld4q (p0, x0 - svcntb ()))
139
140 /* Moving the constant into a register would also be OK. */
141 /*
142 ** ld4q_s8_m2:
143 ** decb x0, all, mul #2
144 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
145 ** ret
146 */
147 TEST_LOAD (ld4q_s8_m2, svint8x4_t, int8_t,
148 z0 = svld4q_s8 (p0, x0 - svcntb () * 2),
149 z0 = svld4q (p0, x0 - svcntb () * 2))
150
151 /* Moving the constant into a register would also be OK. */
152 /*
153 ** ld4q_s8_m3:
154 ** decb x0, all, mul #3
155 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
156 ** ret
157 */
158 TEST_LOAD (ld4q_s8_m3, svint8x4_t, int8_t,
159 z0 = svld4q_s8 (p0, x0 - svcntb () * 3),
160 z0 = svld4q (p0, x0 - svcntb () * 3))
161
162 /*
163 ** ld4q_s8_m4:
164 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0, #-4, mul vl\]
165 ** ret
166 */
167 TEST_LOAD (ld4q_s8_m4, svint8x4_t, int8_t,
168 z0 = svld4q_s8 (p0, x0 - svcntb () * 4),
169 z0 = svld4q (p0, x0 - svcntb () * 4))
170
171 /*
172 ** ld4q_s8_m32:
173 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0, #-32, mul vl\]
174 ** ret
175 */
176 TEST_LOAD (ld4q_s8_m32, svint8x4_t, int8_t,
177 z0 = svld4q_s8 (p0, x0 - svcntb () * 32),
178 z0 = svld4q (p0, x0 - svcntb () * 32))
179
180 /*
181 ** ld4q_s8_m36:
182 ** [^{]*
183 ** ld4q {z0\.q - z3\.q}, p0/z, \[x[0-9]+\]
184 ** ret
185 */
186 TEST_LOAD (ld4q_s8_m36, svint8x4_t, int8_t,
187 z0 = svld4q_s8 (p0, x0 - svcntb () * 36),
188 z0 = svld4q (p0, x0 - svcntb () * 36))
189
190 /*
191 ** ld4q_vnum_s8_0:
192 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
193 ** ret
194 */
195 TEST_LOAD (ld4q_vnum_s8_0, svint8x4_t, int8_t,
196 z0 = svld4q_vnum_s8 (p0, x0, 0),
197 z0 = svld4q_vnum (p0, x0, 0))
198
199 /* Moving the constant into a register would also be OK. */
200 /*
201 ** ld4q_vnum_s8_1:
202 ** incb x0
203 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
204 ** ret
205 */
206 TEST_LOAD (ld4q_vnum_s8_1, svint8x4_t, int8_t,
207 z0 = svld4q_vnum_s8 (p0, x0, 1),
208 z0 = svld4q_vnum (p0, x0, 1))
209
210 /* Moving the constant into a register would also be OK. */
211 /*
212 ** ld4q_vnum_s8_2:
213 ** incb x0, all, mul #2
214 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
215 ** ret
216 */
217 TEST_LOAD (ld4q_vnum_s8_2, svint8x4_t, int8_t,
218 z0 = svld4q_vnum_s8 (p0, x0, 2),
219 z0 = svld4q_vnum (p0, x0, 2))
220
221 /* Moving the constant into a register would also be OK. */
222 /*
223 ** ld4q_vnum_s8_3:
224 ** incb x0, all, mul #3
225 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
226 ** ret
227 */
228 TEST_LOAD (ld4q_vnum_s8_3, svint8x4_t, int8_t,
229 z0 = svld4q_vnum_s8 (p0, x0, 3),
230 z0 = svld4q_vnum (p0, x0, 3))
231
232 /*
233 ** ld4q_vnum_s8_4:
234 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0, #4, mul vl\]
235 ** ret
236 */
237 TEST_LOAD (ld4q_vnum_s8_4, svint8x4_t, int8_t,
238 z0 = svld4q_vnum_s8 (p0, x0, 4),
239 z0 = svld4q_vnum (p0, x0, 4))
240
241 /*
242 ** ld4q_vnum_s8_28:
243 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0, #28, mul vl\]
244 ** ret
245 */
246 TEST_LOAD (ld4q_vnum_s8_28, svint8x4_t, int8_t,
247 z0 = svld4q_vnum_s8 (p0, x0, 28),
248 z0 = svld4q_vnum (p0, x0, 28))
249
250 /*
251 ** ld4q_vnum_s8_32:
252 ** [^{]*
253 ** ld4q {z0\.q - z3\.q}, p0/z, \[x[0-9]+\]
254 ** ret
255 */
256 TEST_LOAD (ld4q_vnum_s8_32, svint8x4_t, int8_t,
257 z0 = svld4q_vnum_s8 (p0, x0, 32),
258 z0 = svld4q_vnum (p0, x0, 32))
259
260 /* Moving the constant into a register would also be OK. */
261 /*
262 ** ld4q_vnum_s8_m1:
263 ** decb x0
264 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
265 ** ret
266 */
267 TEST_LOAD (ld4q_vnum_s8_m1, svint8x4_t, int8_t,
268 z0 = svld4q_vnum_s8 (p0, x0, -1),
269 z0 = svld4q_vnum (p0, x0, -1))
270
271 /* Moving the constant into a register would also be OK. */
272 /*
273 ** ld4q_vnum_s8_m2:
274 ** decb x0, all, mul #2
275 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
276 ** ret
277 */
278 TEST_LOAD (ld4q_vnum_s8_m2, svint8x4_t, int8_t,
279 z0 = svld4q_vnum_s8 (p0, x0, -2),
280 z0 = svld4q_vnum (p0, x0, -2))
281
282 /* Moving the constant into a register would also be OK. */
283 /*
284 ** ld4q_vnum_s8_m3:
285 ** decb x0, all, mul #3
286 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
287 ** ret
288 */
289 TEST_LOAD (ld4q_vnum_s8_m3, svint8x4_t, int8_t,
290 z0 = svld4q_vnum_s8 (p0, x0, -3),
291 z0 = svld4q_vnum (p0, x0, -3))
292
293 /*
294 ** ld4q_vnum_s8_m4:
295 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0, #-4, mul vl\]
296 ** ret
297 */
298 TEST_LOAD (ld4q_vnum_s8_m4, svint8x4_t, int8_t,
299 z0 = svld4q_vnum_s8 (p0, x0, -4),
300 z0 = svld4q_vnum (p0, x0, -4))
301
302 /*
303 ** ld4q_vnum_s8_m32:
304 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0, #-32, mul vl\]
305 ** ret
306 */
307 TEST_LOAD (ld4q_vnum_s8_m32, svint8x4_t, int8_t,
308 z0 = svld4q_vnum_s8 (p0, x0, -32),
309 z0 = svld4q_vnum (p0, x0, -32))
310
311 /*
312 ** ld4q_vnum_s8_m36:
313 ** [^{]*
314 ** ld4q {z0\.q - z3\.q}, p0/z, \[x[0-9]+\]
315 ** ret
316 */
317 TEST_LOAD (ld4q_vnum_s8_m36, svint8x4_t, int8_t,
318 z0 = svld4q_vnum_s8 (p0, x0, -36),
319 z0 = svld4q_vnum (p0, x0, -36))
320
321 /*
322 ** ld4q_vnum_s8_x1:
323 ** cntb (x[0-9]+)
324 ** (
325 ** madd (x[0-9]+), (?:x1, \1|\1, x1), x0
326 ** ld4q {z0\.q - z3\.q}, p0/z, \[\2\]
327 ** |
328 ** mul (x[0-9]+), (?:x1, \1|\1, x1)
329 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0, \3\]
330 ** )
331 ** ret
332 */
333 TEST_LOAD (ld4q_vnum_s8_x1, svint8x4_t, int8_t,
334 z0 = svld4q_vnum_s8 (p0, x0, x1),
335 z0 = svld4q_vnum (p0, x0, x1))