1 /* { dg-final { check-function-bodies "**" "" "-DCHECK_ASM" { target { ! ilp32 } } } } */
2
3 #include "test_sve_acle.h"
4
5 /*
6 ** ld2_f16_base:
7 ** ld2h {z0\.h(?: - |, )z1\.h}, p0/z, \[x0\]
8 ** ret
9 */
10 TEST_LOAD (ld2_f16_base, svfloat16x2_t, float16_t,
11 z0 = svld2_f16 (p0, x0),
12 z0 = svld2 (p0, x0))
13
14 /*
15 ** ld2_f16_index:
16 ** ld2h {z0\.h(?: - |, )z1\.h}, p0/z, \[x0, x1, lsl 1\]
17 ** ret
18 */
19 TEST_LOAD (ld2_f16_index, svfloat16x2_t, float16_t,
20 z0 = svld2_f16 (p0, x0 + x1),
21 z0 = svld2 (p0, x0 + x1))
22
23 /* Moving the constant into a register would also be OK. */
24 /*
25 ** ld2_f16_1:
26 ** incb x0
27 ** ld2h {z0\.h(?: - |, )z1\.h}, p0/z, \[x0\]
28 ** ret
29 */
30 TEST_LOAD (ld2_f16_1, svfloat16x2_t, float16_t,
31 z0 = svld2_f16 (p0, x0 + svcnth ()),
32 z0 = svld2 (p0, x0 + svcnth ()))
33
34 /*
35 ** ld2_f16_2:
36 ** ld2h {z0\.h(?: - |, )z1\.h}, p0/z, \[x0, #2, mul vl\]
37 ** ret
38 */
39 TEST_LOAD (ld2_f16_2, svfloat16x2_t, float16_t,
40 z0 = svld2_f16 (p0, x0 + svcnth () * 2),
41 z0 = svld2 (p0, x0 + svcnth () * 2))
42
43 /*
44 ** ld2_f16_14:
45 ** ld2h {z0\.h(?: - |, )z1\.h}, p0/z, \[x0, #14, mul vl\]
46 ** ret
47 */
48 TEST_LOAD (ld2_f16_14, svfloat16x2_t, float16_t,
49 z0 = svld2_f16 (p0, x0 + svcnth () * 14),
50 z0 = svld2 (p0, x0 + svcnth () * 14))
51
52 /* Moving the constant into a register would also be OK. */
53 /*
54 ** ld2_f16_16:
55 ** incb x0, all, mul #16
56 ** ld2h {z0\.h(?: - |, )z1\.h}, p0/z, \[x0\]
57 ** ret
58 */
59 TEST_LOAD (ld2_f16_16, svfloat16x2_t, float16_t,
60 z0 = svld2_f16 (p0, x0 + svcnth () * 16),
61 z0 = svld2 (p0, x0 + svcnth () * 16))
62
63 /* Moving the constant into a register would also be OK. */
64 /*
65 ** ld2_f16_m1:
66 ** decb x0
67 ** ld2h {z0\.h(?: - |, )z1\.h}, p0/z, \[x0\]
68 ** ret
69 */
70 TEST_LOAD (ld2_f16_m1, svfloat16x2_t, float16_t,
71 z0 = svld2_f16 (p0, x0 - svcnth ()),
72 z0 = svld2 (p0, x0 - svcnth ()))
73
74 /*
75 ** ld2_f16_m2:
76 ** ld2h {z0\.h(?: - |, )z1\.h}, p0/z, \[x0, #-2, mul vl\]
77 ** ret
78 */
79 TEST_LOAD (ld2_f16_m2, svfloat16x2_t, float16_t,
80 z0 = svld2_f16 (p0, x0 - svcnth () * 2),
81 z0 = svld2 (p0, x0 - svcnth () * 2))
82
83 /*
84 ** ld2_f16_m16:
85 ** ld2h {z0\.h(?: - |, )z1\.h}, p0/z, \[x0, #-16, mul vl\]
86 ** ret
87 */
88 TEST_LOAD (ld2_f16_m16, svfloat16x2_t, float16_t,
89 z0 = svld2_f16 (p0, x0 - svcnth () * 16),
90 z0 = svld2 (p0, x0 - svcnth () * 16))
91
92 /*
93 ** ld2_f16_m18:
94 ** addvl (x[0-9]+), x0, #-18
95 ** ld2h {z0\.h(?: - |, )z1\.h}, p0/z, \[\1\]
96 ** ret
97 */
98 TEST_LOAD (ld2_f16_m18, svfloat16x2_t, float16_t,
99 z0 = svld2_f16 (p0, x0 - svcnth () * 18),
100 z0 = svld2 (p0, x0 - svcnth () * 18))
101
102 /*
103 ** ld2_vnum_f16_0:
104 ** ld2h {z0\.h(?: - |, )z1\.h}, p0/z, \[x0\]
105 ** ret
106 */
107 TEST_LOAD (ld2_vnum_f16_0, svfloat16x2_t, float16_t,
108 z0 = svld2_vnum_f16 (p0, x0, 0),
109 z0 = svld2_vnum (p0, x0, 0))
110
111 /* Moving the constant into a register would also be OK. */
112 /*
113 ** ld2_vnum_f16_1:
114 ** incb x0
115 ** ld2h {z0\.h(?: - |, )z1\.h}, p0/z, \[x0\]
116 ** ret
117 */
118 TEST_LOAD (ld2_vnum_f16_1, svfloat16x2_t, float16_t,
119 z0 = svld2_vnum_f16 (p0, x0, 1),
120 z0 = svld2_vnum (p0, x0, 1))
121
122 /*
123 ** ld2_vnum_f16_2:
124 ** ld2h {z0\.h(?: - |, )z1\.h}, p0/z, \[x0, #2, mul vl\]
125 ** ret
126 */
127 TEST_LOAD (ld2_vnum_f16_2, svfloat16x2_t, float16_t,
128 z0 = svld2_vnum_f16 (p0, x0, 2),
129 z0 = svld2_vnum (p0, x0, 2))
130
131 /*
132 ** ld2_vnum_f16_14:
133 ** ld2h {z0\.h(?: - |, )z1\.h}, p0/z, \[x0, #14, mul vl\]
134 ** ret
135 */
136 TEST_LOAD (ld2_vnum_f16_14, svfloat16x2_t, float16_t,
137 z0 = svld2_vnum_f16 (p0, x0, 14),
138 z0 = svld2_vnum (p0, x0, 14))
139
140 /* Moving the constant into a register would also be OK. */
141 /*
142 ** ld2_vnum_f16_16:
143 ** incb x0, all, mul #16
144 ** ld2h {z0\.h(?: - |, )z1\.h}, p0/z, \[x0\]
145 ** ret
146 */
147 TEST_LOAD (ld2_vnum_f16_16, svfloat16x2_t, float16_t,
148 z0 = svld2_vnum_f16 (p0, x0, 16),
149 z0 = svld2_vnum (p0, x0, 16))
150
151 /* Moving the constant into a register would also be OK. */
152 /*
153 ** ld2_vnum_f16_m1:
154 ** decb x0
155 ** ld2h {z0\.h(?: - |, )z1\.h}, p0/z, \[x0\]
156 ** ret
157 */
158 TEST_LOAD (ld2_vnum_f16_m1, svfloat16x2_t, float16_t,
159 z0 = svld2_vnum_f16 (p0, x0, -1),
160 z0 = svld2_vnum (p0, x0, -1))
161
162 /*
163 ** ld2_vnum_f16_m2:
164 ** ld2h {z0\.h(?: - |, )z1\.h}, p0/z, \[x0, #-2, mul vl\]
165 ** ret
166 */
167 TEST_LOAD (ld2_vnum_f16_m2, svfloat16x2_t, float16_t,
168 z0 = svld2_vnum_f16 (p0, x0, -2),
169 z0 = svld2_vnum (p0, x0, -2))
170
171 /*
172 ** ld2_vnum_f16_m16:
173 ** ld2h {z0\.h(?: - |, )z1\.h}, p0/z, \[x0, #-16, mul vl\]
174 ** ret
175 */
176 TEST_LOAD (ld2_vnum_f16_m16, svfloat16x2_t, float16_t,
177 z0 = svld2_vnum_f16 (p0, x0, -16),
178 z0 = svld2_vnum (p0, x0, -16))
179
180 /*
181 ** ld2_vnum_f16_m18:
182 ** addvl (x[0-9]+), x0, #-18
183 ** ld2h {z0\.h(?: - |, )z1\.h}, p0/z, \[\1\]
184 ** ret
185 */
186 TEST_LOAD (ld2_vnum_f16_m18, svfloat16x2_t, float16_t,
187 z0 = svld2_vnum_f16 (p0, x0, -18),
188 z0 = svld2_vnum (p0, x0, -18))
189
190 /* Using MUL to calculate an index would also be OK. */
191 /*
192 ** ld2_vnum_f16_x1:
193 ** cntb (x[0-9]+)
194 ** madd (x[0-9]+), (x1, \1|\1, x1), x0
195 ** ld2h {z0\.h(?: - |, )z1\.h}, p0/z, \[\2\]
196 ** ret
197 */
198 TEST_LOAD (ld2_vnum_f16_x1, svfloat16x2_t, float16_t,
199 z0 = svld2_vnum_f16 (p0, x0, x1),
200 z0 = svld2_vnum (p0, x0, x1))