Debian Codegraph @

gcc/testsuite/gcc.target/aarch64/sve2/acle/asm/ld1udq_f64.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 ** ld1udq_f64_base:
12 ** ld1d {z0\.q}, p0/z, \[x0\]
13 ** ret
14 */
15 TEST_LOAD (ld1udq_f64_base, svfloat64_t, float64_t,
16 z0 = svld1udq_f64 (p0, x0),
17 z0 = svld1udq (p0, x0))
18
19 /*
20 ** ld1udq_f64_index:
21 ** ld1d {z0\.q}, p0/z, \[x0, x1, lsl 3\]
22 ** ret
23 */
24 TEST_LOAD (ld1udq_f64_index, svfloat64_t, float64_t,
25 z0 = svld1udq_f64 (p0, x0 + x1),
26 z0 = svld1udq (p0, x0 + x1))
27
28 /*
29 ** ld1udq_f64_1:
30 ** ld1d {z0\.q}, p0/z, \[x0, #2, mul vl\]
31 ** ret
32 */
33 TEST_LOAD (ld1udq_f64_1, svfloat64_t, float64_t,
34 z0 = svld1udq_f64 (p0, x0 + svcntd ()),
35 z0 = svld1udq (p0, x0 + svcntd ()))
36
37 /*
38 ** ld1udq_f64_7:
39 ** ld1d {z0\.q}, p0/z, \[x0, #6, mul vl\]
40 ** ret
41 */
42 TEST_LOAD (ld1udq_f64_7, svfloat64_t, float64_t,
43 z0 = svld1udq_f64 (p0, x0 + svcntd () * 3),
44 z0 = svld1udq (p0, x0 + svcntd () * 3))
45
46 /* Moving the constant into a register would also be OK. */
47 /*
48 ** ld1udq_f64_8:
49 ** incb x0, all, mul #4
50 ** ld1d {z0\.q}, p0/z, \[x0\]
51 ** ret
52 */
53 TEST_LOAD (ld1udq_f64_8, svfloat64_t, float64_t,
54 z0 = svld1udq_f64 (p0, x0 + svcntd () * 4),
55 z0 = svld1udq (p0, x0 + svcntd () * 4))
56
57 /*
58 ** ld1udq_f64_m2:
59 ** ld1d {z0\.q}, p0/z, \[x0, #-2, mul vl\]
60 ** ret
61 */
62 TEST_LOAD (ld1udq_f64_m2, svfloat64_t, float64_t,
63 z0 = svld1udq_f64 (p0, x0 - svcntd ()),
64 z0 = svld1udq (p0, x0 - svcntd ()))
65
66 /*
67 ** ld1udq_f64_m8:
68 ** ld1d {z0\.q}, p0/z, \[x0, #-8, mul vl\]
69 ** ret
70 */
71 TEST_LOAD (ld1udq_f64_m8, svfloat64_t, float64_t,
72 z0 = svld1udq_f64 (p0, x0 - svcntd () * 4),
73 z0 = svld1udq (p0, x0 - svcntd () * 4))
74
75 /* Moving the constant into a register would also be OK. */
76 /*
77 ** ld1udq_f64_m10:
78 ** decb x0, all, mul #5
79 ** ld1d {z0\.q}, p0/z, \[x0\]
80 ** ret
81 */
82 TEST_LOAD (ld1udq_f64_m10, svfloat64_t, float64_t,
83 z0 = svld1udq_f64 (p0, x0 - svcntd () * 5),
84 z0 = svld1udq (p0, x0 - svcntd () * 5))
85
86 /*
87 ** ld1udq_vnum_f64_0:
88 ** ld1d {z0\.q}, p0/z, \[x0\]
89 ** ret
90 */
91 TEST_LOAD (ld1udq_vnum_f64_0, svfloat64_t, float64_t,
92 z0 = svld1udq_vnum_f64 (p0, x0, 0),
93 z0 = svld1udq_vnum (p0, x0, 0))
94
95 /*
96 ** ld1udq_vnum_f64_1:
97 ** ld1d {z0\.q}, p0/z, \[x0, #1, mul vl\]
98 ** ret
99 */
100 TEST_LOAD (ld1udq_vnum_f64_1, svfloat64_t, float64_t,
101 z0 = svld1udq_vnum_f64 (p0, x0, 1),
102 z0 = svld1udq_vnum (p0, x0, 1))
103
104 /*
105 ** ld1udq_vnum_f64_7:
106 ** ld1d {z0\.q}, p0/z, \[x0, #7, mul vl\]
107 ** ret
108 */
109 TEST_LOAD (ld1udq_vnum_f64_7, svfloat64_t, float64_t,
110 z0 = svld1udq_vnum_f64 (p0, x0, 7),
111 z0 = svld1udq_vnum (p0, x0, 7))
112
113 /* Moving the constant into a register would also be OK. */
114 /*
115 ** ld1udq_vnum_f64_8:
116 ** incb x0, all, mul #4
117 ** ld1d {z0\.q}, p0/z, \[x0\]
118 ** ret
119 */
120 TEST_LOAD (ld1udq_vnum_f64_8, svfloat64_t, float64_t,
121 z0 = svld1udq_vnum_f64 (p0, x0, 8),
122 z0 = svld1udq_vnum (p0, x0, 8))
123
124 /*
125 ** ld1udq_vnum_f64_m1:
126 ** ld1d {z0\.q}, p0/z, \[x0, #-1, mul vl\]
127 ** ret
128 */
129 TEST_LOAD (ld1udq_vnum_f64_m1, svfloat64_t, float64_t,
130 z0 = svld1udq_vnum_f64 (p0, x0, -1),
131 z0 = svld1udq_vnum (p0, x0, -1))
132
133 /*
134 ** ld1udq_vnum_f64_m8:
135 ** ld1d {z0\.q}, p0/z, \[x0, #-8, mul vl\]
136 ** ret
137 */
138 TEST_LOAD (ld1udq_vnum_f64_m8, svfloat64_t, float64_t,
139 z0 = svld1udq_vnum_f64 (p0, x0, -8),
140 z0 = svld1udq_vnum (p0, x0, -8))
141
142 /* Moving the constant into a register would also be OK. */
143 /*
144 ** ld1udq_vnum_f64_m9:
145 ** dech x0, all, mul #9
146 ** ld1d {z0\.q}, p0/z, \[x0\]
147 ** ret
148 */
149 TEST_LOAD (ld1udq_vnum_f64_m9, svfloat64_t, float64_t,
150 z0 = svld1udq_vnum_f64 (p0, x0, -9),
151 z0 = svld1udq_vnum (p0, x0, -9))
152
153 /* Using MUL to calculate an index would also be OK. */
154 /*
155 ** ld1udq_vnum_f64_x1:
156 ** cnth (x[0-9]+)
157 ** madd (x[0-9]+), (x1, \1|\1, x1), x0
158 ** ld1d {z0\.q}, p0/z, \[\2\]
159 ** ret
160 */
161 TEST_LOAD (ld1udq_vnum_f64_x1, svfloat64_t, float64_t,
162 z0 = svld1udq_vnum_f64 (p0, x0, x1),
163 z0 = svld1udq_vnum (p0, x0, x1))