Debian Codegraph @

gcc/testsuite/gcc.target/aarch64/sve2/acle/asm/ld2q_f32.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 ** ld2q_f32_base:
12 ** ld2q {z0\.q(?: - |, )z1\.q}, p0/z, \[x0\]
13 ** ret
14 */
15 TEST_LOAD (ld2q_f32_base, svfloat32x2_t, float32_t,
16 z0 = svld2q_f32 (p0, x0),
17 z0 = svld2q (p0, x0))
18
19 /*
20 ** ld2q_f32_index:
21 ** add (x[0-9]), x0, x1, lsl #?2
22 ** ld2q {z0\.q(?: - |, )z1\.q}, p0/z, \[\1\]
23 ** ret
24 */
25 TEST_LOAD (ld2q_f32_index, svfloat32x2_t, float32_t,
26 z0 = svld2q_f32 (p0, x0 + x1),
27 z0 = svld2q (p0, x0 + x1))
28
29 /*
30 ** ld2q_f32_index2:
31 ** add (x[0-9]), x0, x1, lsl #?3
32 ** ld2q {z0\.q(?: - |, )z1\.q}, p0/z, \[\1\]
33 ** ret
34 */
35 TEST_LOAD (ld2q_f32_index2, svfloat32x2_t, float32_t,
36 z0 = svld2q_f32 (p0, x0 + x1 * 2),
37 z0 = svld2q (p0, x0 + x1 * 2))
38
39 /*
40 ** ld2q_f32_index4:
41 ** ld2q {z0\.q(?: - |, )z1\.q}, p0/z, \[x0, x1, lsl #?4\]
42 ** ret
43 */
44 TEST_LOAD (ld2q_f32_index4, svfloat32x2_t, float32_t,
45 z0 = svld2q_f32 (p0, x0 + x1 * 4),
46 z0 = svld2q (p0, x0 + x1 * 4))
47
48 /* Moving the constant into a register would also be OK. */
49 /*
50 ** ld2q_f32_1:
51 ** incb x0
52 ** ld2q {z0\.q(?: - |, )z1\.q}, p0/z, \[x0\]
53 ** ret
54 */
55 TEST_LOAD (ld2q_f32_1, svfloat32x2_t, float32_t,
56 z0 = svld2q_f32 (p0, x0 + svcntw ()),
57 z0 = svld2q (p0, x0 + svcntw ()))
58
59 /*
60 ** ld2q_f32_2:
61 ** ld2q {z0\.q(?: - |, )z1\.q}, p0/z, \[x0, #2, mul vl\]
62 ** ret
63 */
64 TEST_LOAD (ld2q_f32_2, svfloat32x2_t, float32_t,
65 z0 = svld2q_f32 (p0, x0 + svcntw () * 2),
66 z0 = svld2q (p0, x0 + svcntw () * 2))
67
68 /*
69 ** ld2q_f32_14:
70 ** ld2q {z0\.q(?: - |, )z1\.q}, p0/z, \[x0, #14, mul vl\]
71 ** ret
72 */
73 TEST_LOAD (ld2q_f32_14, svfloat32x2_t, float32_t,
74 z0 = svld2q_f32 (p0, x0 + svcntw () * 14),
75 z0 = svld2q (p0, x0 + svcntw () * 14))
76
77 /* Moving the constant into a register would also be OK. */
78 /*
79 ** ld2q_f32_16:
80 ** incb x0, all, mul #16
81 ** ld2q {z0\.q(?: - |, )z1\.q}, p0/z, \[x0\]
82 ** ret
83 */
84 TEST_LOAD (ld2q_f32_16, svfloat32x2_t, float32_t,
85 z0 = svld2q_f32 (p0, x0 + svcntw () * 16),
86 z0 = svld2q (p0, x0 + svcntw () * 16))
87
88 /* Moving the constant into a register would also be OK. */
89 /*
90 ** ld2q_f32_m1:
91 ** decb x0
92 ** ld2q {z0\.q(?: - |, )z1\.q}, p0/z, \[x0\]
93 ** ret
94 */
95 TEST_LOAD (ld2q_f32_m1, svfloat32x2_t, float32_t,
96 z0 = svld2q_f32 (p0, x0 - svcntw ()),
97 z0 = svld2q (p0, x0 - svcntw ()))
98
99 /*
100 ** ld2q_f32_m2:
101 ** ld2q {z0\.q(?: - |, )z1\.q}, p0/z, \[x0, #-2, mul vl\]
102 ** ret
103 */
104 TEST_LOAD (ld2q_f32_m2, svfloat32x2_t, float32_t,
105 z0 = svld2q_f32 (p0, x0 - svcntw () * 2),
106 z0 = svld2q (p0, x0 - svcntw () * 2))
107
108 /*
109 ** ld2q_f32_m16:
110 ** ld2q {z0\.q(?: - |, )z1\.q}, p0/z, \[x0, #-16, mul vl\]
111 ** ret
112 */
113 TEST_LOAD (ld2q_f32_m16, svfloat32x2_t, float32_t,
114 z0 = svld2q_f32 (p0, x0 - svcntw () * 16),
115 z0 = svld2q (p0, x0 - svcntw () * 16))
116
117 /*
118 ** ld2q_f32_m18:
119 ** addvl (x[0-9]+), x0, #-18
120 ** ld2q {z0\.q(?: - |, )z1\.q}, p0/z, \[\1\]
121 ** ret
122 */
123 TEST_LOAD (ld2q_f32_m18, svfloat32x2_t, float32_t,
124 z0 = svld2q_f32 (p0, x0 - svcntw () * 18),
125 z0 = svld2q (p0, x0 - svcntw () * 18))
126
127 /*
128 ** ld2q_vnum_f32_0:
129 ** ld2q {z0\.q(?: - |, )z1\.q}, p0/z, \[x0\]
130 ** ret
131 */
132 TEST_LOAD (ld2q_vnum_f32_0, svfloat32x2_t, float32_t,
133 z0 = svld2q_vnum_f32 (p0, x0, 0),
134 z0 = svld2q_vnum (p0, x0, 0))
135
136 /* Moving the constant into a register would also be OK. */
137 /*
138 ** ld2q_vnum_f32_1:
139 ** incb x0
140 ** ld2q {z0\.q(?: - |, )z1\.q}, p0/z, \[x0\]
141 ** ret
142 */
143 TEST_LOAD (ld2q_vnum_f32_1, svfloat32x2_t, float32_t,
144 z0 = svld2q_vnum_f32 (p0, x0, 1),
145 z0 = svld2q_vnum (p0, x0, 1))
146
147 /*
148 ** ld2q_vnum_f32_2:
149 ** ld2q {z0\.q(?: - |, )z1\.q}, p0/z, \[x0, #2, mul vl\]
150 ** ret
151 */
152 TEST_LOAD (ld2q_vnum_f32_2, svfloat32x2_t, float32_t,
153 z0 = svld2q_vnum_f32 (p0, x0, 2),
154 z0 = svld2q_vnum (p0, x0, 2))
155
156 /*
157 ** ld2q_vnum_f32_14:
158 ** ld2q {z0\.q(?: - |, )z1\.q}, p0/z, \[x0, #14, mul vl\]
159 ** ret
160 */
161 TEST_LOAD (ld2q_vnum_f32_14, svfloat32x2_t, float32_t,
162 z0 = svld2q_vnum_f32 (p0, x0, 14),
163 z0 = svld2q_vnum (p0, x0, 14))
164
165 /* Moving the constant into a register would also be OK. */
166 /*
167 ** ld2q_vnum_f32_16:
168 ** incb x0, all, mul #16
169 ** ld2q {z0\.q(?: - |, )z1\.q}, p0/z, \[x0\]
170 ** ret
171 */
172 TEST_LOAD (ld2q_vnum_f32_16, svfloat32x2_t, float32_t,
173 z0 = svld2q_vnum_f32 (p0, x0, 16),
174 z0 = svld2q_vnum (p0, x0, 16))
175
176 /* Moving the constant into a register would also be OK. */
177 /*
178 ** ld2q_vnum_f32_m1:
179 ** decb x0
180 ** ld2q {z0\.q(?: - |, )z1\.q}, p0/z, \[x0\]
181 ** ret
182 */
183 TEST_LOAD (ld2q_vnum_f32_m1, svfloat32x2_t, float32_t,
184 z0 = svld2q_vnum_f32 (p0, x0, -1),
185 z0 = svld2q_vnum (p0, x0, -1))
186
187 /*
188 ** ld2q_vnum_f32_m2:
189 ** ld2q {z0\.q(?: - |, )z1\.q}, p0/z, \[x0, #-2, mul vl\]
190 ** ret
191 */
192 TEST_LOAD (ld2q_vnum_f32_m2, svfloat32x2_t, float32_t,
193 z0 = svld2q_vnum_f32 (p0, x0, -2),
194 z0 = svld2q_vnum (p0, x0, -2))
195
196 /*
197 ** ld2q_vnum_f32_m16:
198 ** ld2q {z0\.q(?: - |, )z1\.q}, p0/z, \[x0, #-16, mul vl\]
199 ** ret
200 */
201 TEST_LOAD (ld2q_vnum_f32_m16, svfloat32x2_t, float32_t,
202 z0 = svld2q_vnum_f32 (p0, x0, -16),
203 z0 = svld2q_vnum (p0, x0, -16))
204
205 /*
206 ** ld2q_vnum_f32_m18:
207 ** addvl (x[0-9]+), x0, #-18
208 ** ld2q {z0\.q(?: - |, )z1\.q}, p0/z, \[\1\]
209 ** ret
210 */
211 TEST_LOAD (ld2q_vnum_f32_m18, svfloat32x2_t, float32_t,
212 z0 = svld2q_vnum_f32 (p0, x0, -18),
213 z0 = svld2q_vnum (p0, x0, -18))
214
215 /*
216 ** ld2q_vnum_f32_x1:
217 ** cntb (x[0-9]+)
218 ** madd (x[0-9]+), (?:x1, \1|\1, x1), x0
219 ** ld2q {z0\.q(?: - |, )z1\.q}, p0/z, \[\2\]
220 ** ret
221 */
222 TEST_LOAD (ld2q_vnum_f32_x1, svfloat32x2_t, float32_t,
223 z0 = svld2q_vnum_f32 (p0, x0, x1),
224 z0 = svld2q_vnum (p0, x0, x1))