Debian Codegraph @

gcc/testsuite/gcc.target/aarch64/sve2/acle/asm/ld4q_s32.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_s32_base:
12 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
13 ** ret
14 */
15 TEST_LOAD (ld4q_s32_base, svint32x4_t, int32_t,
16 z0 = svld4q_s32 (p0, x0),
17 z0 = svld4q (p0, x0))
18
19 /*
20 ** ld4q_s32_index:
21 ** add (x[0-9]), x0, x1, lsl #?2
22 ** ld4q {z0\.q - z3\.q}, p0/z, \[\1\]
23 ** ret
24 */
25 TEST_LOAD (ld4q_s32_index, svint32x4_t, int32_t,
26 z0 = svld4q_s32 (p0, x0 + x1),
27 z0 = svld4q (p0, x0 + x1))
28
29 /*
30 ** ld4q_s32_index2:
31 ** add (x[0-9]), x0, x1, lsl #?3
32 ** ld4q {z0\.q - z3\.q}, p0/z, \[\1\]
33 ** ret
34 */
35 TEST_LOAD (ld4q_s32_index2, svint32x4_t, int32_t,
36 z0 = svld4q_s32 (p0, x0 + x1 * 2),
37 z0 = svld4q (p0, x0 + x1 * 2))
38
39 /*
40 ** ld4q_s32_index4:
41 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0, x1, lsl #?4\]
42 ** ret
43 */
44 TEST_LOAD (ld4q_s32_index4, svint32x4_t, int32_t,
45 z0 = svld4q_s32 (p0, x0 + x1 * 4),
46 z0 = svld4q (p0, x0 + x1 * 4))
47
48 /* Moving the constant into a register would also be OK. */
49 /*
50 ** ld4q_s32_1:
51 ** incb x0
52 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
53 ** ret
54 */
55 TEST_LOAD (ld4q_s32_1, svint32x4_t, int32_t,
56 z0 = svld4q_s32 (p0, x0 + svcntw ()),
57 z0 = svld4q (p0, x0 + svcntw ()))
58
59 /* Moving the constant into a register would also be OK. */
60 /*
61 ** ld4q_s32_2:
62 ** incb x0, all, mul #2
63 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
64 ** ret
65 */
66 TEST_LOAD (ld4q_s32_2, svint32x4_t, int32_t,
67 z0 = svld4q_s32 (p0, x0 + svcntw () * 2),
68 z0 = svld4q (p0, x0 + svcntw () * 2))
69
70 /* Moving the constant into a register would also be OK. */
71 /*
72 ** ld4q_s32_3:
73 ** incb x0, all, mul #3
74 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
75 ** ret
76 */
77 TEST_LOAD (ld4q_s32_3, svint32x4_t, int32_t,
78 z0 = svld4q_s32 (p0, x0 + svcntw () * 3),
79 z0 = svld4q (p0, x0 + svcntw () * 3))
80
81 /*
82 ** ld4q_s32_4:
83 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0, #4, mul vl\]
84 ** ret
85 */
86 TEST_LOAD (ld4q_s32_4, svint32x4_t, int32_t,
87 z0 = svld4q_s32 (p0, x0 + svcntw () * 4),
88 z0 = svld4q (p0, x0 + svcntw () * 4))
89
90 /*
91 ** ld4q_s32_28:
92 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0, #28, mul vl\]
93 ** ret
94 */
95 TEST_LOAD (ld4q_s32_28, svint32x4_t, int32_t,
96 z0 = svld4q_s32 (p0, x0 + svcntw () * 28),
97 z0 = svld4q (p0, x0 + svcntw () * 28))
98
99 /*
100 ** ld4q_s32_32:
101 ** [^{]*
102 ** ld4q {z0\.q - z3\.q}, p0/z, \[x[0-9]+\]
103 ** ret
104 */
105 TEST_LOAD (ld4q_s32_32, svint32x4_t, int32_t,
106 z0 = svld4q_s32 (p0, x0 + svcntw () * 32),
107 z0 = svld4q (p0, x0 + svcntw () * 32))
108
109 /* Moving the constant into a register would also be OK. */
110 /*
111 ** ld4q_s32_m1:
112 ** decb x0
113 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
114 ** ret
115 */
116 TEST_LOAD (ld4q_s32_m1, svint32x4_t, int32_t,
117 z0 = svld4q_s32 (p0, x0 - svcntw ()),
118 z0 = svld4q (p0, x0 - svcntw ()))
119
120 /* Moving the constant into a register would also be OK. */
121 /*
122 ** ld4q_s32_m2:
123 ** decb x0, all, mul #2
124 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
125 ** ret
126 */
127 TEST_LOAD (ld4q_s32_m2, svint32x4_t, int32_t,
128 z0 = svld4q_s32 (p0, x0 - svcntw () * 2),
129 z0 = svld4q (p0, x0 - svcntw () * 2))
130
131 /* Moving the constant into a register would also be OK. */
132 /*
133 ** ld4q_s32_m3:
134 ** decb x0, all, mul #3
135 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
136 ** ret
137 */
138 TEST_LOAD (ld4q_s32_m3, svint32x4_t, int32_t,
139 z0 = svld4q_s32 (p0, x0 - svcntw () * 3),
140 z0 = svld4q (p0, x0 - svcntw () * 3))
141
142 /*
143 ** ld4q_s32_m4:
144 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0, #-4, mul vl\]
145 ** ret
146 */
147 TEST_LOAD (ld4q_s32_m4, svint32x4_t, int32_t,
148 z0 = svld4q_s32 (p0, x0 - svcntw () * 4),
149 z0 = svld4q (p0, x0 - svcntw () * 4))
150
151 /*
152 ** ld4q_s32_m32:
153 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0, #-32, mul vl\]
154 ** ret
155 */
156 TEST_LOAD (ld4q_s32_m32, svint32x4_t, int32_t,
157 z0 = svld4q_s32 (p0, x0 - svcntw () * 32),
158 z0 = svld4q (p0, x0 - svcntw () * 32))
159
160 /*
161 ** ld4q_s32_m36:
162 ** [^{]*
163 ** ld4q {z0\.q - z3\.q}, p0/z, \[x[0-9]+\]
164 ** ret
165 */
166 TEST_LOAD (ld4q_s32_m36, svint32x4_t, int32_t,
167 z0 = svld4q_s32 (p0, x0 - svcntw () * 36),
168 z0 = svld4q (p0, x0 - svcntw () * 36))
169
170 /*
171 ** ld4q_vnum_s32_0:
172 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
173 ** ret
174 */
175 TEST_LOAD (ld4q_vnum_s32_0, svint32x4_t, int32_t,
176 z0 = svld4q_vnum_s32 (p0, x0, 0),
177 z0 = svld4q_vnum (p0, x0, 0))
178
179 /* Moving the constant into a register would also be OK. */
180 /*
181 ** ld4q_vnum_s32_1:
182 ** incb x0
183 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
184 ** ret
185 */
186 TEST_LOAD (ld4q_vnum_s32_1, svint32x4_t, int32_t,
187 z0 = svld4q_vnum_s32 (p0, x0, 1),
188 z0 = svld4q_vnum (p0, x0, 1))
189
190 /* Moving the constant into a register would also be OK. */
191 /*
192 ** ld4q_vnum_s32_2:
193 ** incb x0, all, mul #2
194 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
195 ** ret
196 */
197 TEST_LOAD (ld4q_vnum_s32_2, svint32x4_t, int32_t,
198 z0 = svld4q_vnum_s32 (p0, x0, 2),
199 z0 = svld4q_vnum (p0, x0, 2))
200
201 /* Moving the constant into a register would also be OK. */
202 /*
203 ** ld4q_vnum_s32_3:
204 ** incb x0, all, mul #3
205 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
206 ** ret
207 */
208 TEST_LOAD (ld4q_vnum_s32_3, svint32x4_t, int32_t,
209 z0 = svld4q_vnum_s32 (p0, x0, 3),
210 z0 = svld4q_vnum (p0, x0, 3))
211
212 /*
213 ** ld4q_vnum_s32_4:
214 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0, #4, mul vl\]
215 ** ret
216 */
217 TEST_LOAD (ld4q_vnum_s32_4, svint32x4_t, int32_t,
218 z0 = svld4q_vnum_s32 (p0, x0, 4),
219 z0 = svld4q_vnum (p0, x0, 4))
220
221 /*
222 ** ld4q_vnum_s32_28:
223 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0, #28, mul vl\]
224 ** ret
225 */
226 TEST_LOAD (ld4q_vnum_s32_28, svint32x4_t, int32_t,
227 z0 = svld4q_vnum_s32 (p0, x0, 28),
228 z0 = svld4q_vnum (p0, x0, 28))
229
230 /*
231 ** ld4q_vnum_s32_32:
232 ** [^{]*
233 ** ld4q {z0\.q - z3\.q}, p0/z, \[x[0-9]+\]
234 ** ret
235 */
236 TEST_LOAD (ld4q_vnum_s32_32, svint32x4_t, int32_t,
237 z0 = svld4q_vnum_s32 (p0, x0, 32),
238 z0 = svld4q_vnum (p0, x0, 32))
239
240 /* Moving the constant into a register would also be OK. */
241 /*
242 ** ld4q_vnum_s32_m1:
243 ** decb x0
244 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
245 ** ret
246 */
247 TEST_LOAD (ld4q_vnum_s32_m1, svint32x4_t, int32_t,
248 z0 = svld4q_vnum_s32 (p0, x0, -1),
249 z0 = svld4q_vnum (p0, x0, -1))
250
251 /* Moving the constant into a register would also be OK. */
252 /*
253 ** ld4q_vnum_s32_m2:
254 ** decb x0, all, mul #2
255 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
256 ** ret
257 */
258 TEST_LOAD (ld4q_vnum_s32_m2, svint32x4_t, int32_t,
259 z0 = svld4q_vnum_s32 (p0, x0, -2),
260 z0 = svld4q_vnum (p0, x0, -2))
261
262 /* Moving the constant into a register would also be OK. */
263 /*
264 ** ld4q_vnum_s32_m3:
265 ** decb x0, all, mul #3
266 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0\]
267 ** ret
268 */
269 TEST_LOAD (ld4q_vnum_s32_m3, svint32x4_t, int32_t,
270 z0 = svld4q_vnum_s32 (p0, x0, -3),
271 z0 = svld4q_vnum (p0, x0, -3))
272
273 /*
274 ** ld4q_vnum_s32_m4:
275 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0, #-4, mul vl\]
276 ** ret
277 */
278 TEST_LOAD (ld4q_vnum_s32_m4, svint32x4_t, int32_t,
279 z0 = svld4q_vnum_s32 (p0, x0, -4),
280 z0 = svld4q_vnum (p0, x0, -4))
281
282 /*
283 ** ld4q_vnum_s32_m32:
284 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0, #-32, mul vl\]
285 ** ret
286 */
287 TEST_LOAD (ld4q_vnum_s32_m32, svint32x4_t, int32_t,
288 z0 = svld4q_vnum_s32 (p0, x0, -32),
289 z0 = svld4q_vnum (p0, x0, -32))
290
291 /*
292 ** ld4q_vnum_s32_m36:
293 ** [^{]*
294 ** ld4q {z0\.q - z3\.q}, p0/z, \[x[0-9]+\]
295 ** ret
296 */
297 TEST_LOAD (ld4q_vnum_s32_m36, svint32x4_t, int32_t,
298 z0 = svld4q_vnum_s32 (p0, x0, -36),
299 z0 = svld4q_vnum (p0, x0, -36))
300
301 /*
302 ** ld4q_vnum_s32_x1:
303 ** cntb (x[0-9]+)
304 ** (
305 ** madd (x[0-9]+), (?:x1, \1|\1, x1), x0
306 ** ld4q {z0\.q - z3\.q}, p0/z, \[\2\]
307 ** |
308 ** mul (x[0-9]+), (?:x1, \1|\1, x1)
309 ** ld4q {z0\.q - z3\.q}, p0/z, \[x0, \3\]
310 ** )
311 ** ret
312 */
313 TEST_LOAD (ld4q_vnum_s32_x1, svint32x4_t, int32_t,
314 z0 = svld4q_vnum_s32 (p0, x0, x1),
315 z0 = svld4q_vnum (p0, x0, x1))