Debian Codegraph @

gcc/testsuite/gcc.target/aarch64/sve2/acle/asm/ld3q_u32.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 ** ld3q_u32_base:
12 ** ld3q {z0\.q - z2\.q}, p0/z, \[x0\]
13 ** ret
14 */
15 TEST_LOAD (ld3q_u32_base, svuint32x3_t, uint32_t,
16 z0 = svld3q_u32 (p0, x0),
17 z0 = svld3q (p0, x0))
18
19 /*
20 ** ld3q_u32_index:
21 ** add (x[0-9]), x0, x1, lsl #?2
22 ** ld3q {z0\.q - z2\.q}, p0/z, \[\1\]
23 ** ret
24 */
25 TEST_LOAD (ld3q_u32_index, svuint32x3_t, uint32_t,
26 z0 = svld3q_u32 (p0, x0 + x1),
27 z0 = svld3q (p0, x0 + x1))
28
29 /*
30 ** ld3q_u32_index2:
31 ** add (x[0-9]), x0, x1, lsl #?3
32 ** ld3q {z0\.q - z2\.q}, p0/z, \[\1\]
33 ** ret
34 */
35 TEST_LOAD (ld3q_u32_index2, svuint32x3_t, uint32_t,
36 z0 = svld3q_u32 (p0, x0 + x1 * 2),
37 z0 = svld3q (p0, x0 + x1 * 2))
38
39 /*
40 ** ld3q_u32_index4:
41 ** ld3q {z0\.q - z2\.q}, p0/z, \[x0, x1, lsl #?4\]
42 ** ret
43 */
44 TEST_LOAD (ld3q_u32_index4, svuint32x3_t, uint32_t,
45 z0 = svld3q_u32 (p0, x0 + x1 * 4),
46 z0 = svld3q (p0, x0 + x1 * 4))
47
48 /* Moving the constant into a register would also be OK. */
49 /*
50 ** ld3q_u32_1:
51 ** incb x0
52 ** ld3q {z0\.q - z2\.q}, p0/z, \[x0\]
53 ** ret
54 */
55 TEST_LOAD (ld3q_u32_1, svuint32x3_t, uint32_t,
56 z0 = svld3q_u32 (p0, x0 + svcntw ()),
57 z0 = svld3q (p0, x0 + svcntw ()))
58
59 /* Moving the constant into a register would also be OK. */
60 /*
61 ** ld3q_u32_2:
62 ** incb x0, all, mul #2
63 ** ld3q {z0\.q - z2\.q}, p0/z, \[x0\]
64 ** ret
65 */
66 TEST_LOAD (ld3q_u32_2, svuint32x3_t, uint32_t,
67 z0 = svld3q_u32 (p0, x0 + svcntw () * 2),
68 z0 = svld3q (p0, x0 + svcntw () * 2))
69
70 /*
71 ** ld3q_u32_3:
72 ** ld3q {z0\.q - z2\.q}, p0/z, \[x0, #3, mul vl\]
73 ** ret
74 */
75 TEST_LOAD (ld3q_u32_3, svuint32x3_t, uint32_t,
76 z0 = svld3q_u32 (p0, x0 + svcntw () * 3),
77 z0 = svld3q (p0, x0 + svcntw () * 3))
78
79 /*
80 ** ld3q_u32_21:
81 ** ld3q {z0\.q - z2\.q}, p0/z, \[x0, #21, mul vl\]
82 ** ret
83 */
84 TEST_LOAD (ld3q_u32_21, svuint32x3_t, uint32_t,
85 z0 = svld3q_u32 (p0, x0 + svcntw () * 21),
86 z0 = svld3q (p0, x0 + svcntw () * 21))
87
88 /*
89 ** ld3q_u32_24:
90 ** addvl (x[0-9]+), x0, #24
91 ** ld3q {z0\.q - z2\.q}, p0/z, \[\1\]
92 ** ret
93 */
94 TEST_LOAD (ld3q_u32_24, svuint32x3_t, uint32_t,
95 z0 = svld3q_u32 (p0, x0 + svcntw () * 24),
96 z0 = svld3q (p0, x0 + svcntw () * 24))
97
98 /* Moving the constant into a register would also be OK. */
99 /*
100 ** ld3q_u32_m1:
101 ** decb x0
102 ** ld3q {z0\.q - z2\.q}, p0/z, \[x0\]
103 ** ret
104 */
105 TEST_LOAD (ld3q_u32_m1, svuint32x3_t, uint32_t,
106 z0 = svld3q_u32 (p0, x0 - svcntw ()),
107 z0 = svld3q (p0, x0 - svcntw ()))
108
109 /* Moving the constant into a register would also be OK. */
110 /*
111 ** ld3q_u32_m2:
112 ** decb x0, all, mul #2
113 ** ld3q {z0\.q - z2\.q}, p0/z, \[x0\]
114 ** ret
115 */
116 TEST_LOAD (ld3q_u32_m2, svuint32x3_t, uint32_t,
117 z0 = svld3q_u32 (p0, x0 - svcntw () * 2),
118 z0 = svld3q (p0, x0 - svcntw () * 2))
119
120 /*
121 ** ld3q_u32_m3:
122 ** ld3q {z0\.q - z2\.q}, p0/z, \[x0, #-3, mul vl\]
123 ** ret
124 */
125 TEST_LOAD (ld3q_u32_m3, svuint32x3_t, uint32_t,
126 z0 = svld3q_u32 (p0, x0 - svcntw () * 3),
127 z0 = svld3q (p0, x0 - svcntw () * 3))
128
129 /*
130 ** ld3q_u32_m24:
131 ** ld3q {z0\.q - z2\.q}, p0/z, \[x0, #-24, mul vl\]
132 ** ret
133 */
134 TEST_LOAD (ld3q_u32_m24, svuint32x3_t, uint32_t,
135 z0 = svld3q_u32 (p0, x0 - svcntw () * 24),
136 z0 = svld3q (p0, x0 - svcntw () * 24))
137
138 /*
139 ** ld3q_u32_m27:
140 ** addvl (x[0-9]+), x0, #-27
141 ** ld3q {z0\.q - z2\.q}, p0/z, \[\1\]
142 ** ret
143 */
144 TEST_LOAD (ld3q_u32_m27, svuint32x3_t, uint32_t,
145 z0 = svld3q_u32 (p0, x0 - svcntw () * 27),
146 z0 = svld3q (p0, x0 - svcntw () * 27))
147
148 /*
149 ** ld3q_vnum_u32_0:
150 ** ld3q {z0\.q - z2\.q}, p0/z, \[x0\]
151 ** ret
152 */
153 TEST_LOAD (ld3q_vnum_u32_0, svuint32x3_t, uint32_t,
154 z0 = svld3q_vnum_u32 (p0, x0, 0),
155 z0 = svld3q_vnum (p0, x0, 0))
156
157 /* Moving the constant into a register would also be OK. */
158 /*
159 ** ld3q_vnum_u32_1:
160 ** incb x0
161 ** ld3q {z0\.q - z2\.q}, p0/z, \[x0\]
162 ** ret
163 */
164 TEST_LOAD (ld3q_vnum_u32_1, svuint32x3_t, uint32_t,
165 z0 = svld3q_vnum_u32 (p0, x0, 1),
166 z0 = svld3q_vnum (p0, x0, 1))
167
168 /* Moving the constant into a register would also be OK. */
169 /*
170 ** ld3q_vnum_u32_2:
171 ** incb x0, all, mul #2
172 ** ld3q {z0\.q - z2\.q}, p0/z, \[x0\]
173 ** ret
174 */
175 TEST_LOAD (ld3q_vnum_u32_2, svuint32x3_t, uint32_t,
176 z0 = svld3q_vnum_u32 (p0, x0, 2),
177 z0 = svld3q_vnum (p0, x0, 2))
178
179 /*
180 ** ld3q_vnum_u32_3:
181 ** ld3q {z0\.q - z2\.q}, p0/z, \[x0, #3, mul vl\]
182 ** ret
183 */
184 TEST_LOAD (ld3q_vnum_u32_3, svuint32x3_t, uint32_t,
185 z0 = svld3q_vnum_u32 (p0, x0, 3),
186 z0 = svld3q_vnum (p0, x0, 3))
187
188 /*
189 ** ld3q_vnum_u32_21:
190 ** ld3q {z0\.q - z2\.q}, p0/z, \[x0, #21, mul vl\]
191 ** ret
192 */
193 TEST_LOAD (ld3q_vnum_u32_21, svuint32x3_t, uint32_t,
194 z0 = svld3q_vnum_u32 (p0, x0, 21),
195 z0 = svld3q_vnum (p0, x0, 21))
196
197 /*
198 ** ld3q_vnum_u32_24:
199 ** addvl (x[0-9]+), x0, #24
200 ** ld3q {z0\.q - z2\.q}, p0/z, \[\1\]
201 ** ret
202 */
203 TEST_LOAD (ld3q_vnum_u32_24, svuint32x3_t, uint32_t,
204 z0 = svld3q_vnum_u32 (p0, x0, 24),
205 z0 = svld3q_vnum (p0, x0, 24))
206
207 /* Moving the constant into a register would also be OK. */
208 /*
209 ** ld3q_vnum_u32_m1:
210 ** decb x0
211 ** ld3q {z0\.q - z2\.q}, p0/z, \[x0\]
212 ** ret
213 */
214 TEST_LOAD (ld3q_vnum_u32_m1, svuint32x3_t, uint32_t,
215 z0 = svld3q_vnum_u32 (p0, x0, -1),
216 z0 = svld3q_vnum (p0, x0, -1))
217
218 /* Moving the constant into a register would also be OK. */
219 /*
220 ** ld3q_vnum_u32_m2:
221 ** decb x0, all, mul #2
222 ** ld3q {z0\.q - z2\.q}, p0/z, \[x0\]
223 ** ret
224 */
225 TEST_LOAD (ld3q_vnum_u32_m2, svuint32x3_t, uint32_t,
226 z0 = svld3q_vnum_u32 (p0, x0, -2),
227 z0 = svld3q_vnum (p0, x0, -2))
228
229 /*
230 ** ld3q_vnum_u32_m3:
231 ** ld3q {z0\.q - z2\.q}, p0/z, \[x0, #-3, mul vl\]
232 ** ret
233 */
234 TEST_LOAD (ld3q_vnum_u32_m3, svuint32x3_t, uint32_t,
235 z0 = svld3q_vnum_u32 (p0, x0, -3),
236 z0 = svld3q_vnum (p0, x0, -3))
237
238 /*
239 ** ld3q_vnum_u32_m24:
240 ** ld3q {z0\.q - z2\.q}, p0/z, \[x0, #-24, mul vl\]
241 ** ret
242 */
243 TEST_LOAD (ld3q_vnum_u32_m24, svuint32x3_t, uint32_t,
244 z0 = svld3q_vnum_u32 (p0, x0, -24),
245 z0 = svld3q_vnum (p0, x0, -24))
246
247 /*
248 ** ld3q_vnum_u32_m27:
249 ** addvl (x[0-9]+), x0, #-27
250 ** ld3q {z0\.q - z2\.q}, p0/z, \[\1\]
251 ** ret
252 */
253 TEST_LOAD (ld3q_vnum_u32_m27, svuint32x3_t, uint32_t,
254 z0 = svld3q_vnum_u32 (p0, x0, -27),
255 z0 = svld3q_vnum (p0, x0, -27))
256
257 /*
258 ** ld3q_vnum_u32_x1:
259 ** cntb (x[0-9]+)
260 ** (
261 ** madd (x[0-9]+), (?:x1, \1|\1, x1), x0
262 ** ld3q {z0\.q - z2\.q}, p0/z, \[\2\]
263 ** |
264 ** mul (x[0-9]+), (?:x1, \1|\1, x1)
265 ** ld3q {z0\.q - z2\.q}, p0/z, \[x0, \3\]
266 ** )
267 ** ret
268 */
269 TEST_LOAD (ld3q_vnum_u32_x1, svuint32x3_t, uint32_t,
270 z0 = svld3q_vnum_u32 (p0, x0, x1),
271 z0 = svld3q_vnum (p0, x0, x1))