Debian Codegraph @

gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vqrshl.c

raw
1 #include <arm_neon.h>
2 #include "arm-neon-ref.h"
3 #include "compute-ref-data.h"
4
5 /* Expected results with input=0. */
6 VECT_VAR_DECL(expected_0,int,8,8) [] = { 0x0, 0x0, 0x0, 0x0,
7 0x0, 0x0, 0x0, 0x0 };
8 VECT_VAR_DECL(expected_0,int,16,4) [] = { 0x0, 0x0, 0x0, 0x0 };
9 VECT_VAR_DECL(expected_0,int,32,2) [] = { 0x0, 0x0 };
10 VECT_VAR_DECL(expected_0,int,64,1) [] = { 0x0 };
11 VECT_VAR_DECL(expected_0,uint,8,8) [] = { 0x0, 0x0, 0x0, 0x0,
12 0x0, 0x0, 0x0, 0x0 };
13 VECT_VAR_DECL(expected_0,uint,16,4) [] = { 0x0, 0x0, 0x0, 0x0 };
14 VECT_VAR_DECL(expected_0,uint,32,2) [] = { 0x0, 0x0 };
15 VECT_VAR_DECL(expected_0,uint,64,1) [] = { 0x0 };
16 VECT_VAR_DECL(expected_0,int,8,16) [] = { 0x0, 0x0, 0x0, 0x0,
17 0x0, 0x0, 0x0, 0x0,
18 0x0, 0x0, 0x0, 0x0,
19 0x0, 0x0, 0x0, 0x0 };
20 VECT_VAR_DECL(expected_0,int,16,8) [] = { 0x0, 0x0, 0x0, 0x0,
21 0x0, 0x0, 0x0, 0x0 };
22 VECT_VAR_DECL(expected_0,int,32,4) [] = { 0x0, 0x0, 0x0, 0x0 };
23 VECT_VAR_DECL(expected_0,int,64,2) [] = { 0x0, 0x0 };
24 VECT_VAR_DECL(expected_0,uint,8,16) [] = { 0x0, 0x0, 0x0, 0x0,
25 0x0, 0x0, 0x0, 0x0,
26 0x0, 0x0, 0x0, 0x0,
27 0x0, 0x0, 0x0, 0x0 };
28 VECT_VAR_DECL(expected_0,uint,16,8) [] = { 0x0, 0x0, 0x0, 0x0,
29 0x0, 0x0, 0x0, 0x0 };
30 VECT_VAR_DECL(expected_0,uint,32,4) [] = { 0x0, 0x0, 0x0, 0x0 };
31 VECT_VAR_DECL(expected_0,uint,64,2) [] = { 0x0, 0x0 };
32
33 /* Expected results with input=0 and negative shift amount. */
34 VECT_VAR_DECL(expected_0_neg,int,8,8) [] = { 0x0, 0x0, 0x0, 0x0,
35 0x0, 0x0, 0x0, 0x0 };
36 VECT_VAR_DECL(expected_0_neg,int,16,4) [] = { 0x0, 0x0, 0x0, 0x0 };
37 VECT_VAR_DECL(expected_0_neg,int,32,2) [] = { 0x0, 0x0 };
38 VECT_VAR_DECL(expected_0_neg,int,64,1) [] = { 0x0 };
39 VECT_VAR_DECL(expected_0_neg,uint,8,8) [] = { 0x0, 0x0, 0x0, 0x0,
40 0x0, 0x0, 0x0, 0x0 };
41 VECT_VAR_DECL(expected_0_neg,uint,16,4) [] = { 0x0, 0x0, 0x0, 0x0 };
42 VECT_VAR_DECL(expected_0_neg,uint,32,2) [] = { 0x0, 0x0 };
43 VECT_VAR_DECL(expected_0_neg,uint,64,1) [] = { 0x0 };
44 VECT_VAR_DECL(expected_0_neg,int,8,16) [] = { 0x0, 0x0, 0x0, 0x0,
45 0x0, 0x0, 0x0, 0x0,
46 0x0, 0x0, 0x0, 0x0,
47 0x0, 0x0, 0x0, 0x0 };
48 VECT_VAR_DECL(expected_0_neg,int,16,8) [] = { 0x0, 0x0, 0x0, 0x0,
49 0x0, 0x0, 0x0, 0x0 };
50 VECT_VAR_DECL(expected_0_neg,int,32,4) [] = { 0x0, 0x0, 0x0, 0x0 };
51 VECT_VAR_DECL(expected_0_neg,int,64,2) [] = { 0x0, 0x0 };
52 VECT_VAR_DECL(expected_0_neg,uint,8,16) [] = { 0x0, 0x0, 0x0, 0x0,
53 0x0, 0x0, 0x0, 0x0,
54 0x0, 0x0, 0x0, 0x0,
55 0x0, 0x0, 0x0, 0x0 };
56 VECT_VAR_DECL(expected_0_neg,uint,16,8) [] = { 0x0, 0x0, 0x0, 0x0,
57 0x0, 0x0, 0x0, 0x0 };
58 VECT_VAR_DECL(expected_0_neg,uint,32,4) [] = { 0x0, 0x0, 0x0, 0x0 };
59 VECT_VAR_DECL(expected_0_neg,uint,64,2) [] = { 0x0, 0x0 };
60
61 /* Expected results. */
62 VECT_VAR_DECL(expected,int,8,8) [] = { 0xe0, 0xe2, 0xe4, 0xe6,
63 0xe8, 0xea, 0xec, 0xee };
64 VECT_VAR_DECL(expected,int,16,4) [] = { 0xff80, 0xff88, 0xff90, 0xff98 };
65 VECT_VAR_DECL(expected,int,32,2) [] = { 0xfffff000, 0xfffff100 };
66 VECT_VAR_DECL(expected,int,64,1) [] = { 0xffffffffffffff80 };
67 VECT_VAR_DECL(expected,uint,8,8) [] = { 0xff, 0xff, 0xff, 0xff,
68 0xff, 0xff, 0xff, 0xff };
69 VECT_VAR_DECL(expected,uint,16,4) [] = { 0xffff, 0xffff, 0xffff, 0xffff };
70 VECT_VAR_DECL(expected,uint,32,2) [] = { 0xffffffff, 0xffffffff };
71 VECT_VAR_DECL(expected,uint,64,1) [] = { 0xffffffffffffffff };
72 VECT_VAR_DECL(expected,int,8,16) [] = { 0x80, 0x80, 0x80, 0x80,
73 0x80, 0x80, 0x80, 0x80,
74 0x80, 0x80, 0x80, 0x80,
75 0x80, 0x80, 0x80, 0x80 };
76 VECT_VAR_DECL(expected,int,16,8) [] = { 0x8000, 0x8000, 0x8000, 0x8000,
77 0x8000, 0x8000, 0x8000, 0x8000 };
78 VECT_VAR_DECL(expected,int,32,4) [] = { 0x80000000, 0x80000000,
79 0x80000000, 0x80000000 };
80 VECT_VAR_DECL(expected,int,64,2) [] = { 0x8000000000000000, 0x8000000000000000 };
81 VECT_VAR_DECL(expected,uint,8,16) [] = { 0xff, 0xff, 0xff, 0xff,
82 0xff, 0xff, 0xff, 0xff,
83 0xff, 0xff, 0xff, 0xff,
84 0xff, 0xff, 0xff, 0xff };
85 VECT_VAR_DECL(expected,uint,16,8) [] = { 0xffff, 0xffff, 0xffff, 0xffff,
86 0xffff, 0xffff, 0xffff, 0xffff };
87 VECT_VAR_DECL(expected,uint,32,4) [] = { 0xffffffff, 0xffffffff,
88 0xffffffff, 0xffffffff };
89 VECT_VAR_DECL(expected,uint,64,2) [] = { 0xffffffffffffffff,
90 0xffffffffffffffff };
91
92 /* Expected results with negative shift amount. */
93 VECT_VAR_DECL(expected_neg,int,8,8) [] = { 0xfc, 0xfc, 0xfd, 0xfd,
94 0xfd, 0xfd, 0xfe, 0xfe };
95 VECT_VAR_DECL(expected_neg,int,16,4) [] = { 0xfffc, 0xfffc, 0xfffd, 0xfffd };
96 VECT_VAR_DECL(expected_neg,int,32,2) [] = { 0xfffffffe, 0xfffffffe };
97 VECT_VAR_DECL(expected_neg,int,64,1) [] = { 0xffffffffffffffff };
98 VECT_VAR_DECL(expected_neg,uint,8,8) [] = { 0x3c, 0x3c, 0x3d, 0x3d,
99 0x3d, 0x3d, 0x3e, 0x3e };
100 VECT_VAR_DECL(expected_neg,uint,16,4) [] = { 0x3ffc, 0x3ffc, 0x3ffd, 0x3ffd };
101 VECT_VAR_DECL(expected_neg,uint,32,2) [] = { 0x1ffffffe, 0x1ffffffe };
102 VECT_VAR_DECL(expected_neg,uint,64,1) [] = { 0xfffffffffffffff };
103 VECT_VAR_DECL(expected_neg,int,8,16) [] = { 0x0, 0x0, 0x0, 0x0,
104 0x0, 0x0, 0x0, 0x0,
105 0x0, 0x0, 0x0, 0x0,
106 0x0, 0x0, 0x0, 0x0 };
107 VECT_VAR_DECL(expected_neg,int,16,8) [] = { 0x0, 0x0, 0x0, 0x0,
108 0x0, 0x0, 0x0, 0x0 };
109 VECT_VAR_DECL(expected_neg,int,32,4) [] = { 0x0, 0x0, 0x0, 0x0 };
110 VECT_VAR_DECL(expected_neg,int,64,2) [] = { 0x0, 0x0 };
111 VECT_VAR_DECL(expected_neg,uint,8,16) [] = { 0x2, 0x2, 0x2, 0x2,
112 0x2, 0x2, 0x2, 0x2,
113 0x2, 0x2, 0x2, 0x2,
114 0x2, 0x2, 0x2, 0x2 };
115 VECT_VAR_DECL(expected_neg,uint,16,8) [] = { 0x20, 0x20, 0x20, 0x20,
116 0x20, 0x20, 0x20, 0x20 };
117 VECT_VAR_DECL(expected_neg,uint,32,4) [] = { 0x80000, 0x80000,
118 0x80000, 0x80000 };
119 VECT_VAR_DECL(expected_neg,uint,64,2) [] = { 0x100000000000, 0x100000000000 };
120
121 /* Expected results with input=max and shift by -1. */
122 VECT_VAR_DECL(expected_minus1,int,8,8) [] = { 0x40, 0x40, 0x40, 0x40,
123 0x40, 0x40, 0x40, 0x40 };
124 VECT_VAR_DECL(expected_minus1,int,16,4) [] = { 0x4000, 0x4000, 0x4000, 0x4000 };
125 VECT_VAR_DECL(expected_minus1,int,32,2) [] = { 0x40000000, 0x40000000 };
126 VECT_VAR_DECL(expected_minus1,int,64,1) [] = { 0x4000000000000000 };
127 VECT_VAR_DECL(expected_minus1,uint,8,8) [] = { 0x80, 0x80, 0x80, 0x80,
128 0x80, 0x80, 0x80, 0x80 };
129 VECT_VAR_DECL(expected_minus1,uint,16,4) [] = { 0x8000, 0x8000, 0x8000, 0x8000 };
130 VECT_VAR_DECL(expected_minus1,uint,32,2) [] = { 0x80000000, 0x80000000 };
131 VECT_VAR_DECL(expected_minus1,uint,64,1) [] = { 0x8000000000000000 };
132 VECT_VAR_DECL(expected_minus1,int,8,16) [] = { 0x40, 0x40, 0x40, 0x40,
133 0x40, 0x40, 0x40, 0x40,
134 0x40, 0x40, 0x40, 0x40,
135 0x40, 0x40, 0x40, 0x40 };
136 VECT_VAR_DECL(expected_minus1,int,16,8) [] = { 0x4000, 0x4000, 0x4000, 0x4000,
137 0x4000, 0x4000, 0x4000, 0x4000 };
138 VECT_VAR_DECL(expected_minus1,int,32,4) [] = { 0x40000000, 0x40000000,
139 0x40000000, 0x40000000 };
140 VECT_VAR_DECL(expected_minus1,int,64,2) [] = { 0x4000000000000000,
141 0x4000000000000000 };
142 VECT_VAR_DECL(expected_minus1,uint,8,16) [] = { 0x80, 0x80, 0x80, 0x80,
143 0x80, 0x80, 0x80, 0x80,
144 0x80, 0x80, 0x80, 0x80,
145 0x80, 0x80, 0x80, 0x80 };
146 VECT_VAR_DECL(expected_minus1,uint,16,8) [] = { 0x8000, 0x8000, 0x8000, 0x8000,
147 0x8000, 0x8000, 0x8000, 0x8000 };
148 VECT_VAR_DECL(expected_minus1,uint,32,4) [] = { 0x80000000, 0x80000000,
149 0x80000000, 0x80000000 };
150 VECT_VAR_DECL(expected_minus1,uint,64,2) [] = { 0x8000000000000000,
151 0x8000000000000000 };
152
153 /* Expected results with input=max and shift by -3. */
154 VECT_VAR_DECL(expected_minus3,int,8,8) [] = { 0x10, 0x10, 0x10, 0x10,
155 0x10, 0x10, 0x10, 0x10 };
156 VECT_VAR_DECL(expected_minus3,int,16,4) [] = { 0x1000, 0x1000, 0x1000, 0x1000 };
157 VECT_VAR_DECL(expected_minus3,int,32,2) [] = { 0x10000000, 0x10000000 };
158 VECT_VAR_DECL(expected_minus3,int,64,1) [] = { 0x1000000000000000 };
159 VECT_VAR_DECL(expected_minus3,uint,8,8) [] = { 0x20, 0x20, 0x20, 0x20,
160 0x20, 0x20, 0x20, 0x20 };
161 VECT_VAR_DECL(expected_minus3,uint,16,4) [] = { 0x2000, 0x2000, 0x2000, 0x2000 };
162 VECT_VAR_DECL(expected_minus3,uint,32,2) [] = { 0x20000000, 0x20000000 };
163 VECT_VAR_DECL(expected_minus3,uint,64,1) [] = { 0x2000000000000000 };
164 VECT_VAR_DECL(expected_minus3,int,8,16) [] = { 0x10, 0x10, 0x10, 0x10,
165 0x10, 0x10, 0x10, 0x10,
166 0x10, 0x10, 0x10, 0x10,
167 0x10, 0x10, 0x10, 0x10 };
168 VECT_VAR_DECL(expected_minus3,int,16,8) [] = { 0x1000, 0x1000, 0x1000, 0x1000,
169 0x1000, 0x1000, 0x1000, 0x1000 };
170 VECT_VAR_DECL(expected_minus3,int,32,4) [] = { 0x10000000, 0x10000000,
171 0x10000000, 0x10000000 };
172 VECT_VAR_DECL(expected_minus3,int,64,2) [] = { 0x1000000000000000,
173 0x1000000000000000 };
174 VECT_VAR_DECL(expected_minus3,uint,8,16) [] = { 0x20, 0x20, 0x20, 0x20,
175 0x20, 0x20, 0x20, 0x20,
176 0x20, 0x20, 0x20, 0x20,
177 0x20, 0x20, 0x20, 0x20 };
178 VECT_VAR_DECL(expected_minus3,uint,16,8) [] = { 0x2000, 0x2000, 0x2000, 0x2000,
179 0x2000, 0x2000, 0x2000, 0x2000 };
180 VECT_VAR_DECL(expected_minus3,uint,32,4) [] = { 0x20000000, 0x20000000,
181 0x20000000, 0x20000000 };
182 VECT_VAR_DECL(expected_minus3,uint,64,2) [] = { 0x2000000000000000,
183 0x2000000000000000 };
184
185 /* Expected results with input=max and large shift amount. */
186 VECT_VAR_DECL(expected_large_sh,int,8,8) [] = { 0x7f, 0x7f, 0x7f, 0x7f,
187 0x7f, 0x7f, 0x7f, 0x7f };
188 VECT_VAR_DECL(expected_large_sh,int,16,4) [] = { 0x7fff, 0x7fff,
189 0x7fff, 0x7fff };
190 VECT_VAR_DECL(expected_large_sh,int,32,2) [] = { 0x7fffffff, 0x7fffffff };
191 VECT_VAR_DECL(expected_large_sh,int,64,1) [] = { 0x7fffffffffffffff };
192 VECT_VAR_DECL(expected_large_sh,uint,8,8) [] = { 0xff, 0xff, 0xff, 0xff,
193 0xff, 0xff, 0xff, 0xff };
194 VECT_VAR_DECL(expected_large_sh,uint,16,4) [] = { 0xffff, 0xffff,
195 0xffff, 0xffff };
196 VECT_VAR_DECL(expected_large_sh,uint,32,2) [] = { 0xffffffff, 0xffffffff };
197 VECT_VAR_DECL(expected_large_sh,uint,64,1) [] = { 0xffffffffffffffff };
198 VECT_VAR_DECL(expected_large_sh,int,8,16) [] = { 0x7f, 0x7f, 0x7f, 0x7f,
199 0x7f, 0x7f, 0x7f, 0x7f,
200 0x7f, 0x7f, 0x7f, 0x7f,
201 0x7f, 0x7f, 0x7f, 0x7f };
202 VECT_VAR_DECL(expected_large_sh,int,16,8) [] = { 0x7fff, 0x7fff,
203 0x7fff, 0x7fff,
204 0x7fff, 0x7fff,
205 0x7fff, 0x7fff };
206 VECT_VAR_DECL(expected_large_sh,int,32,4) [] = { 0x7fffffff, 0x7fffffff,
207 0x7fffffff, 0x7fffffff };
208 VECT_VAR_DECL(expected_large_sh,int,64,2) [] = { 0x7fffffffffffffff,
209 0x7fffffffffffffff };
210 VECT_VAR_DECL(expected_large_sh,uint,8,16) [] = { 0xff, 0xff, 0xff, 0xff,
211 0xff, 0xff, 0xff, 0xff,
212 0xff, 0xff, 0xff, 0xff,
213 0xff, 0xff, 0xff, 0xff };
214 VECT_VAR_DECL(expected_large_sh,uint,16,8) [] = { 0xffff, 0xffff,
215 0xffff, 0xffff,
216 0xffff, 0xffff,
217 0xffff, 0xffff };
218 VECT_VAR_DECL(expected_large_sh,uint,32,4) [] = { 0xffffffff, 0xffffffff,
219 0xffffffff, 0xffffffff };
220 VECT_VAR_DECL(expected_large_sh,uint,64,2) [] = { 0xffffffffffffffff,
221 0xffffffffffffffff };
222
223 /* Expected results with negative input and large shift amount. */
224 VECT_VAR_DECL(expected_neg_large_sh,int,8,8) [] = { 0x80, 0x80, 0x80, 0x80,
225 0x80, 0x80, 0x80, 0x80 };
226 VECT_VAR_DECL(expected_neg_large_sh,int,16,4) [] = { 0x8000, 0x8000,
227 0x8000, 0x8000 };
228 VECT_VAR_DECL(expected_neg_large_sh,int,32,2) [] = { 0x80000000, 0x80000000 };
229 VECT_VAR_DECL(expected_neg_large_sh,int,64,1) [] = { 0x8000000000000000 };
230 VECT_VAR_DECL(expected_neg_large_sh,uint,8,8) [] = { 0xff, 0xff, 0xff, 0xff,
231 0xff, 0xff, 0xff, 0xff };
232 VECT_VAR_DECL(expected_neg_large_sh,uint,16,4) [] = { 0xffff, 0xffff,
233 0xffff, 0xffff };
234 VECT_VAR_DECL(expected_neg_large_sh,uint,32,2) [] = { 0xffffffff,
235 0xffffffff };
236 VECT_VAR_DECL(expected_neg_large_sh,uint,64,1) [] = { 0xffffffffffffffff };
237 VECT_VAR_DECL(expected_neg_large_sh,int,8,16) [] = { 0x80, 0x80, 0x80, 0x80,
238 0x80, 0x80, 0x80, 0x80,
239 0x80, 0x80, 0x80, 0x80,
240 0x80, 0x80, 0x80, 0x80 };
241 VECT_VAR_DECL(expected_neg_large_sh,int,16,8) [] = { 0x8000, 0x8000,
242 0x8000, 0x8000,
243 0x8000, 0x8000,
244 0x8000, 0x8000 };
245 VECT_VAR_DECL(expected_neg_large_sh,int,32,4) [] = { 0x80000000, 0x80000000,
246 0x80000000, 0x80000000 };
247 VECT_VAR_DECL(expected_neg_large_sh,int,64,2) [] = { 0x8000000000000000,
248 0x8000000000000000 };
249 VECT_VAR_DECL(expected_neg_large_sh,uint,8,16) [] = { 0xff, 0xff, 0xff, 0xff,
250 0xff, 0xff, 0xff, 0xff,
251 0xff, 0xff, 0xff, 0xff,
252 0xff, 0xff, 0xff, 0xff };
253 VECT_VAR_DECL(expected_neg_large_sh,uint,16,8) [] = { 0xffff, 0xffff,
254 0xffff, 0xffff,
255 0xffff, 0xffff,
256 0xffff, 0xffff };
257 VECT_VAR_DECL(expected_neg_large_sh,uint,32,4) [] = { 0xffffffff,
258 0xffffffff,
259 0xffffffff,
260 0xffffffff };
261 VECT_VAR_DECL(expected_neg_large_sh,uint,64,2) [] = { 0xffffffffffffffff,
262 0xffffffffffffffff };
263
264 /* Expected results with max/min input and large negative shift amount. */
265 VECT_VAR_DECL(expected_large_neg_sh,int,8,8) [] = { 0x0, 0x0, 0x0, 0x0,
266 0x0, 0x0, 0x0, 0x0 };
267 VECT_VAR_DECL(expected_large_neg_sh,int,16,4) [] = { 0x0, 0x0, 0x0, 0x0 };
268 VECT_VAR_DECL(expected_large_neg_sh,int,32,2) [] = { 0x0, 0x0 };
269 VECT_VAR_DECL(expected_large_neg_sh,int,64,1) [] = { 0x0 };
270 VECT_VAR_DECL(expected_large_neg_sh,uint,8,8) [] = { 0x0, 0x0, 0x0, 0x0,
271 0x0, 0x0, 0x0, 0x0 };
272 VECT_VAR_DECL(expected_large_neg_sh,uint,16,4) [] = { 0x0, 0x0, 0x0, 0x0 };
273 VECT_VAR_DECL(expected_large_neg_sh,uint,32,2) [] = { 0x0, 0x0 };
274 VECT_VAR_DECL(expected_large_neg_sh,uint,64,1) [] = { 0x0 };
275 VECT_VAR_DECL(expected_large_neg_sh,int,8,16) [] = { 0x0, 0x0, 0x0, 0x0,
276 0x0, 0x0, 0x0, 0x0,
277 0x0, 0x0, 0x0, 0x0,
278 0x0, 0x0, 0x0, 0x0 };
279 VECT_VAR_DECL(expected_large_neg_sh,int,16,8) [] = { 0x0, 0x0, 0x0, 0x0,
280 0x0, 0x0, 0x0, 0x0 };
281 VECT_VAR_DECL(expected_large_neg_sh,int,32,4) [] = { 0x0, 0x0, 0x0, 0x0 };
282 VECT_VAR_DECL(expected_large_neg_sh,int,64,2) [] = { 0x0, 0x0 };
283 VECT_VAR_DECL(expected_large_neg_sh,uint,8,16) [] = { 0x0, 0x0, 0x0, 0x0,
284 0x0, 0x0, 0x0, 0x0,
285 0x0, 0x0, 0x0, 0x0,
286 0x0, 0x0, 0x0, 0x0 };
287 VECT_VAR_DECL(expected_large_neg_sh,uint,16,8) [] = { 0x0, 0x0, 0x0, 0x0,
288 0x0, 0x0, 0x0, 0x0 };
289 VECT_VAR_DECL(expected_large_neg_sh,uint,32,4) [] = { 0x0, 0x0, 0x0, 0x0 };
290 VECT_VAR_DECL(expected_large_neg_sh,uint,64,2) [] = { 0x0, 0x0 };
291
292 /* Expected results with input=0 and large negative shift amount. */
293 VECT_VAR_DECL(expected_0_large_neg_sh,int,8,8) [] = { 0x0, 0x0, 0x0, 0x0,
294 0x0, 0x0, 0x0, 0x0 };
295 VECT_VAR_DECL(expected_0_large_neg_sh,int,16,4) [] = { 0x0, 0x0, 0x0, 0x0 };
296 VECT_VAR_DECL(expected_0_large_neg_sh,int,32,2) [] = { 0x0, 0x0 };
297 VECT_VAR_DECL(expected_0_large_neg_sh,int,64,1) [] = { 0x0 };
298 VECT_VAR_DECL(expected_0_large_neg_sh,uint,8,8) [] = { 0x0, 0x0, 0x0, 0x0,
299 0x0, 0x0, 0x0, 0x0 };
300 VECT_VAR_DECL(expected_0_large_neg_sh,uint,16,4) [] = { 0x0, 0x0, 0x0, 0x0 };
301 VECT_VAR_DECL(expected_0_large_neg_sh,uint,32,2) [] = { 0x0, 0x0 };
302 VECT_VAR_DECL(expected_0_large_neg_sh,uint,64,1) [] = { 0x0 };
303 VECT_VAR_DECL(expected_0_large_neg_sh,int,8,16) [] = { 0x0, 0x0, 0x0, 0x0,
304 0x0, 0x0, 0x0, 0x0,
305 0x0, 0x0, 0x0, 0x0,
306 0x0, 0x0, 0x0, 0x0 };
307 VECT_VAR_DECL(expected_0_large_neg_sh,int,16,8) [] = { 0x0, 0x0, 0x0, 0x0,
308 0x0, 0x0, 0x0, 0x0 };
309 VECT_VAR_DECL(expected_0_large_neg_sh,int,32,4) [] = { 0x0, 0x0, 0x0, 0x0 };
310 VECT_VAR_DECL(expected_0_large_neg_sh,int,64,2) [] = { 0x0, 0x0 };
311 VECT_VAR_DECL(expected_0_large_neg_sh,uint,8,16) [] = { 0x0, 0x0, 0x0, 0x0,
312 0x0, 0x0, 0x0, 0x0,
313 0x0, 0x0, 0x0, 0x0,
314 0x0, 0x0, 0x0, 0x0 };
315 VECT_VAR_DECL(expected_0_large_neg_sh,uint,16,8) [] = { 0x0, 0x0, 0x0, 0x0,
316 0x0, 0x0, 0x0, 0x0 };
317 VECT_VAR_DECL(expected_0_large_neg_sh,uint,32,4) [] = { 0x0, 0x0, 0x0, 0x0 };
318 VECT_VAR_DECL(expected_0_large_neg_sh,uint,64,2) [] = { 0x0, 0x0 };
319
320 #define INSN vqrshl
321 #define TEST_MSG "VQRSHL/VQRSHLQ"
322
323 #define FNNAME1(NAME) void exec_ ## NAME (void)
324 #define FNNAME(NAME) FNNAME1(NAME)
325
326 FNNAME (INSN)
327 {
328 /* Basic test: v3=vqrshl(v1,v2), then store the result. */
329 #define TEST_VQRSHL2(INSN, T3, Q, T1, T2, W, N, CMT) \
330 Set_Neon_Cumulative_Sat(0, VECT_VAR(vector_res, T1, W, N)); \
331 VECT_VAR(vector_res, T1, W, N) = \
332 INSN##Q##_##T2##W(VECT_VAR(vector, T1, W, N), \
333 VECT_VAR(vector_shift, T3, W, N)); \
334 vst1##Q##_##T2##W(VECT_VAR(result, T1, W, N), \
335 VECT_VAR(vector_res, T1, W, N))
336
337 /* Two auxliary macros are necessary to expand INSN */
338 #define TEST_VQRSHL1(INSN, T3, Q, T1, T2, W, N, CMT) \
339 TEST_VQRSHL2(INSN, T3, Q, T1, T2, W, N, CMT)
340
341 #define TEST_VQRSHL(T3, Q, T1, T2, W, N, CMT) \
342 TEST_VQRSHL1(INSN, T3, Q, T1, T2, W, N, CMT)
343
344 DECL_VARIABLE_ALL_VARIANTS(vector);
345 DECL_VARIABLE_ALL_VARIANTS(vector_res);
346
347 DECL_VARIABLE_SIGNED_VARIANTS(vector_shift);
348
349 clean_results ();
350
351 /* Fill input vector with 0, to check saturation on limits. */
352 VDUP(vector, , int, s, 8, 8, 0);
353 VDUP(vector, , int, s, 16, 4, 0);
354 VDUP(vector, , int, s, 32, 2, 0);
355 VDUP(vector, , int, s, 64, 1, 0);
356 VDUP(vector, , uint, u, 8, 8, 0);
357 VDUP(vector, , uint, u, 16, 4, 0);
358 VDUP(vector, , uint, u, 32, 2, 0);
359 VDUP(vector, , uint, u, 64, 1, 0);
360 VDUP(vector, q, int, s, 8, 16, 0);
361 VDUP(vector, q, int, s, 16, 8, 0);
362 VDUP(vector, q, int, s, 32, 4, 0);
363 VDUP(vector, q, int, s, 64, 2, 0);
364 VDUP(vector, q, uint, u, 8, 16, 0);
365 VDUP(vector, q, uint, u, 16, 8, 0);
366 VDUP(vector, q, uint, u, 32, 4, 0);
367 VDUP(vector, q, uint, u, 64, 2, 0);
368
369 /* Choose init value arbitrarily, will be used as shift amount */
370 /* Use values equal to or one-less-than the type width to check
371 behavior on limits. */
372 VDUP(vector_shift, , int, s, 8, 8, 7);
373 VDUP(vector_shift, , int, s, 16, 4, 15);
374 VDUP(vector_shift, , int, s, 32, 2, 31);
375 VDUP(vector_shift, , int, s, 64, 1, 63);
376 VDUP(vector_shift, q, int, s, 8, 16, 8);
377 VDUP(vector_shift, q, int, s, 16, 8, 16);
378 VDUP(vector_shift, q, int, s, 32, 4, 32);
379 VDUP(vector_shift, q, int, s, 64, 2, 64);
380
381 #define CMT " (with input = 0)"
382 TEST_VQRSHL(int, , int, s, 8, 8, CMT);
383 TEST_VQRSHL(int, , int, s, 16, 4, CMT);
384 TEST_VQRSHL(int, , int, s, 32, 2, CMT);
385 TEST_VQRSHL(int, , int, s, 64, 1, CMT);
386 TEST_VQRSHL(int, , uint, u, 8, 8, CMT);
387 TEST_VQRSHL(int, , uint, u, 16, 4, CMT);
388 TEST_VQRSHL(int, , uint, u, 32, 2, CMT);
389 TEST_VQRSHL(int, , uint, u, 64, 1, CMT);
390 TEST_VQRSHL(int, q, int, s, 8, 16, CMT);
391 TEST_VQRSHL(int, q, int, s, 16, 8, CMT);
392 TEST_VQRSHL(int, q, int, s, 32, 4, CMT);
393 TEST_VQRSHL(int, q, int, s, 64, 2, CMT);
394 TEST_VQRSHL(int, q, uint, u, 8, 16, CMT);
395 TEST_VQRSHL(int, q, uint, u, 16, 8, CMT);
396 TEST_VQRSHL(int, q, uint, u, 32, 4, CMT);
397 TEST_VQRSHL(int, q, uint, u, 64, 2, CMT);
398
399 CHECK(TEST_MSG, int, 8, 8, PRIx8, expected_0, CMT);
400 CHECK(TEST_MSG, int, 16, 4, PRIx16, expected_0, CMT);
401 CHECK(TEST_MSG, int, 32, 2, PRIx32, expected_0, CMT);
402 CHECK(TEST_MSG, int, 64, 1, PRIx64, expected_0, CMT);
403 CHECK(TEST_MSG, uint, 8, 8, PRIx8, expected_0, CMT);
404 CHECK(TEST_MSG, uint, 16, 4, PRIx16, expected_0, CMT);
405 CHECK(TEST_MSG, uint, 32, 2, PRIx32, expected_0, CMT);
406 CHECK(TEST_MSG, uint, 64, 1, PRIx64, expected_0, CMT);
407 CHECK(TEST_MSG, int, 8, 16, PRIx8, expected_0, CMT);
408 CHECK(TEST_MSG, int, 16, 8, PRIx16, expected_0, CMT);
409 CHECK(TEST_MSG, int, 32, 4, PRIx32, expected_0, CMT);
410 CHECK(TEST_MSG, int, 64, 2, PRIx64, expected_0, CMT);
411 CHECK(TEST_MSG, uint, 8, 16, PRIx8, expected_0, CMT);
412 CHECK(TEST_MSG, uint, 16, 8, PRIx16, expected_0, CMT);
413 CHECK(TEST_MSG, uint, 32, 4, PRIx32, expected_0, CMT);
414 CHECK(TEST_MSG, uint, 64, 2, PRIx64, expected_0, CMT);
415
416
417 /* Use negative shift amounts. */
418 VDUP(vector_shift, , int, s, 8, 8, -1);
419 VDUP(vector_shift, , int, s, 16, 4, -2);
420 VDUP(vector_shift, , int, s, 32, 2, -3);
421 VDUP(vector_shift, , int, s, 64, 1, -4);
422 VDUP(vector_shift, q, int, s, 8, 16, -7);
423 VDUP(vector_shift, q, int, s, 16, 8, -11);
424 VDUP(vector_shift, q, int, s, 32, 4, -13);
425 VDUP(vector_shift, q, int, s, 64, 2, -20);
426
427 #undef CMT
428 #define CMT " (input 0 and negative shift amount)"
429 TEST_VQRSHL(int, , int, s, 8, 8, CMT);
430 TEST_VQRSHL(int, , int, s, 16, 4, CMT);
431 TEST_VQRSHL(int, , int, s, 32, 2, CMT);
432 TEST_VQRSHL(int, , int, s, 64, 1, CMT);
433 TEST_VQRSHL(int, , uint, u, 8, 8, CMT);
434 TEST_VQRSHL(int, , uint, u, 16, 4, CMT);
435 TEST_VQRSHL(int, , uint, u, 32, 2, CMT);
436 TEST_VQRSHL(int, , uint, u, 64, 1, CMT);
437 TEST_VQRSHL(int, q, int, s, 8, 16, CMT);
438 TEST_VQRSHL(int, q, int, s, 16, 8, CMT);
439 TEST_VQRSHL(int, q, int, s, 32, 4, CMT);
440 TEST_VQRSHL(int, q, int, s, 64, 2, CMT);
441 TEST_VQRSHL(int, q, uint, u, 8, 16, CMT);
442 TEST_VQRSHL(int, q, uint, u, 16, 8, CMT);
443 TEST_VQRSHL(int, q, uint, u, 32, 4, CMT);
444 TEST_VQRSHL(int, q, uint, u, 64, 2, CMT);
445
446 CHECK(TEST_MSG, int, 8, 8, PRIx8, expected_0_neg, CMT);
447 CHECK(TEST_MSG, int, 16, 4, PRIx16, expected_0_neg, CMT);
448 CHECK(TEST_MSG, int, 32, 2, PRIx32, expected_0_neg, CMT);
449 CHECK(TEST_MSG, int, 64, 1, PRIx64, expected_0_neg, CMT);
450 CHECK(TEST_MSG, uint, 8, 8, PRIx8, expected_0_neg, CMT);
451 CHECK(TEST_MSG, uint, 16, 4, PRIx16, expected_0_neg, CMT);
452 CHECK(TEST_MSG, uint, 32, 2, PRIx32, expected_0_neg, CMT);
453 CHECK(TEST_MSG, uint, 64, 1, PRIx64, expected_0_neg, CMT);
454 CHECK(TEST_MSG, int, 8, 16, PRIx8, expected_0_neg, CMT);
455 CHECK(TEST_MSG, int, 16, 8, PRIx16, expected_0_neg, CMT);
456 CHECK(TEST_MSG, int, 32, 4, PRIx32, expected_0_neg, CMT);
457 CHECK(TEST_MSG, int, 64, 2, PRIx64, expected_0_neg, CMT);
458 CHECK(TEST_MSG, uint, 8, 16, PRIx8, expected_0_neg, CMT);
459 CHECK(TEST_MSG, uint, 16, 8, PRIx16, expected_0_neg, CMT);
460 CHECK(TEST_MSG, uint, 32, 4, PRIx32, expected_0_neg, CMT);
461 CHECK(TEST_MSG, uint, 64, 2, PRIx64, expected_0_neg, CMT);
462
463
464 /* Test again, with predefined input values. */
465 TEST_MACRO_ALL_VARIANTS_2_5(VLOAD, vector, buffer);
466
467 /* Choose init value arbitrarily, will be used as shift amount. */
468 VDUP(vector_shift, , int, s, 8, 8, 1);
469 VDUP(vector_shift, , int, s, 16, 4, 3);
470 VDUP(vector_shift, , int, s, 32, 2, 8);
471 VDUP(vector_shift, , int, s, 64, 1, 3);
472 VDUP(vector_shift, q, int, s, 8, 16, 10);
473 VDUP(vector_shift, q, int, s, 16, 8, 12);
474 VDUP(vector_shift, q, int, s, 32, 4, 31);
475 VDUP(vector_shift, q, int, s, 64, 2, 63);
476
477 #undef CMT
478 #define CMT ""
479 TEST_VQRSHL(int, , int, s, 8, 8, CMT);
480 TEST_VQRSHL(int, , int, s, 16, 4, CMT);
481 TEST_VQRSHL(int, , int, s, 32, 2, CMT);
482 TEST_VQRSHL(int, , int, s, 64, 1, CMT);
483 TEST_VQRSHL(int, , uint, u, 8, 8, CMT);
484 TEST_VQRSHL(int, , uint, u, 16, 4, CMT);
485 TEST_VQRSHL(int, , uint, u, 32, 2, CMT);
486 TEST_VQRSHL(int, , uint, u, 64, 1, CMT);
487 TEST_VQRSHL(int, q, int, s, 8, 16, CMT);
488 TEST_VQRSHL(int, q, int, s, 16, 8, CMT);
489 TEST_VQRSHL(int, q, int, s, 32, 4, CMT);
490 TEST_VQRSHL(int, q, int, s, 64, 2, CMT);
491 TEST_VQRSHL(int, q, uint, u, 8, 16, CMT);
492 TEST_VQRSHL(int, q, uint, u, 16, 8, CMT);
493 TEST_VQRSHL(int, q, uint, u, 32, 4, CMT);
494 TEST_VQRSHL(int, q, uint, u, 64, 2, CMT);
495
496 CHECK(TEST_MSG, int, 8, 8, PRIx8, expected, CMT);
497 CHECK(TEST_MSG, int, 16, 4, PRIx16, expected, CMT);
498 CHECK(TEST_MSG, int, 32, 2, PRIx32, expected, CMT);
499 CHECK(TEST_MSG, int, 64, 1, PRIx64, expected, CMT);
500 CHECK(TEST_MSG, uint, 8, 8, PRIx8, expected, CMT);
501 CHECK(TEST_MSG, uint, 16, 4, PRIx16, expected, CMT);
502 CHECK(TEST_MSG, uint, 32, 2, PRIx32, expected, CMT);
503 CHECK(TEST_MSG, uint, 64, 1, PRIx64, expected, CMT);
504 CHECK(TEST_MSG, int, 8, 16, PRIx8, expected, CMT);
505 CHECK(TEST_MSG, int, 16, 8, PRIx16, expected, CMT);
506 CHECK(TEST_MSG, int, 32, 4, PRIx32, expected, CMT);
507 CHECK(TEST_MSG, int, 64, 2, PRIx64, expected, CMT);
508 CHECK(TEST_MSG, uint, 8, 16, PRIx8, expected, CMT);
509 CHECK(TEST_MSG, uint, 16, 8, PRIx16, expected, CMT);
510 CHECK(TEST_MSG, uint, 32, 4, PRIx32, expected, CMT);
511 CHECK(TEST_MSG, uint, 64, 2, PRIx64, expected, CMT);
512
513
514 /* Use negative shift amounts. */
515 VDUP(vector_shift, , int, s, 8, 8, -2);
516 VDUP(vector_shift, , int, s, 16, 4, -2);
517 VDUP(vector_shift, , int, s, 32, 2, -3);
518 VDUP(vector_shift, , int, s, 64, 1, -4);
519 VDUP(vector_shift, q, int, s, 8, 16, -7);
520 VDUP(vector_shift, q, int, s, 16, 8, -11);
521 VDUP(vector_shift, q, int, s, 32, 4, -13);
522 VDUP(vector_shift, q, int, s, 64, 2, -20);
523
524 #undef CMT
525 #define CMT " (negative shift amount)"
526 TEST_VQRSHL(int, , int, s, 8, 8, CMT);
527 TEST_VQRSHL(int, , int, s, 16, 4, CMT);
528 TEST_VQRSHL(int, , int, s, 32, 2, CMT);
529 TEST_VQRSHL(int, , int, s, 64, 1, CMT);
530 TEST_VQRSHL(int, , uint, u, 8, 8, CMT);
531 TEST_VQRSHL(int, , uint, u, 16, 4, CMT);
532 TEST_VQRSHL(int, , uint, u, 32, 2, CMT);
533 TEST_VQRSHL(int, , uint, u, 64, 1, CMT);
534 TEST_VQRSHL(int, q, int, s, 8, 16, CMT);
535 TEST_VQRSHL(int, q, int, s, 16, 8, CMT);
536 TEST_VQRSHL(int, q, int, s, 32, 4, CMT);
537 TEST_VQRSHL(int, q, int, s, 64, 2, CMT);
538 TEST_VQRSHL(int, q, uint, u, 8, 16, CMT);
539 TEST_VQRSHL(int, q, uint, u, 16, 8, CMT);
540 TEST_VQRSHL(int, q, uint, u, 32, 4, CMT);
541 TEST_VQRSHL(int, q, uint, u, 64, 2, CMT);
542
543 CHECK(TEST_MSG, int, 8, 8, PRIx8, expected_neg, CMT);
544 CHECK(TEST_MSG, int, 16, 4, PRIx16, expected_neg, CMT);
545 CHECK(TEST_MSG, int, 32, 2, PRIx32, expected_neg, CMT);
546 CHECK(TEST_MSG, int, 64, 1, PRIx64, expected_neg, CMT);
547 CHECK(TEST_MSG, uint, 8, 8, PRIx8, expected_neg, CMT);
548 CHECK(TEST_MSG, uint, 16, 4, PRIx16, expected_neg, CMT);
549 CHECK(TEST_MSG, uint, 32, 2, PRIx32, expected_neg, CMT);
550 CHECK(TEST_MSG, uint, 64, 1, PRIx64, expected_neg, CMT);
551 CHECK(TEST_MSG, int, 8, 16, PRIx8, expected_neg, CMT);
552 CHECK(TEST_MSG, int, 16, 8, PRIx16, expected_neg, CMT);
553 CHECK(TEST_MSG, int, 32, 4, PRIx32, expected_neg, CMT);
554 CHECK(TEST_MSG, int, 64, 2, PRIx64, expected_neg, CMT);
555 CHECK(TEST_MSG, uint, 8, 16, PRIx8, expected_neg, CMT);
556 CHECK(TEST_MSG, uint, 16, 8, PRIx16, expected_neg, CMT);
557 CHECK(TEST_MSG, uint, 32, 4, PRIx32, expected_neg, CMT);
558 CHECK(TEST_MSG, uint, 64, 2, PRIx64, expected_neg, CMT);
559
560
561 /* Fill input vector with max value, to check saturation on
562 limits. */
563 VDUP(vector, , int, s, 8, 8, 0x7F);
564 VDUP(vector, , int, s, 16, 4, 0x7FFF);
565 VDUP(vector, , int, s, 32, 2, 0x7FFFFFFF);
566 VDUP(vector, , int, s, 64, 1, 0x7FFFFFFFFFFFFFFFLL);
567 VDUP(vector, , uint, u, 8, 8, 0xFF);
568 VDUP(vector, , uint, u, 16, 4, 0xFFFF);
569 VDUP(vector, , uint, u, 32, 2, 0xFFFFFFFF);
570 VDUP(vector, , uint, u, 64, 1, 0xFFFFFFFFFFFFFFFFULL);
571 VDUP(vector, q, int, s, 8, 16, 0x7F);
572 VDUP(vector, q, int, s, 16, 8, 0x7FFF);
573 VDUP(vector, q, int, s, 32, 4, 0x7FFFFFFF);
574 VDUP(vector, q, int, s, 64, 2, 0x7FFFFFFFFFFFFFFFLL);
575 VDUP(vector, q, uint, u, 8, 16, 0xFF);
576 VDUP(vector, q, uint, u, 16, 8, 0xFFFF);
577 VDUP(vector, q, uint, u, 32, 4, 0xFFFFFFFF);
578 VDUP(vector, q, uint, u, 64, 2, 0xFFFFFFFFFFFFFFFFULL);
579
580 /* Use -1 shift amount to check cumulative saturation with
581 round_const. */
582 VDUP(vector_shift, , int, s, 8, 8, -1);
583 VDUP(vector_shift, , int, s, 16, 4, -1);
584 VDUP(vector_shift, , int, s, 32, 2, -1);
585 VDUP(vector_shift, , int, s, 64, 1, -1);
586 VDUP(vector_shift, q, int, s, 8, 16, -1);
587 VDUP(vector_shift, q, int, s, 16, 8, -1);
588 VDUP(vector_shift, q, int, s, 32, 4, -1);
589 VDUP(vector_shift, q, int, s, 64, 2, -1);
590
591 #undef CMT
592 #define CMT " (checking cumulative saturation: shift by -1)"
593 TEST_VQRSHL(int, , int, s, 8, 8, CMT);
594 TEST_VQRSHL(int, , int, s, 16, 4, CMT);
595 TEST_VQRSHL(int, , int, s, 32, 2, CMT);
596 TEST_VQRSHL(int, , int, s, 64, 1, CMT);
597 TEST_VQRSHL(int, , uint, u, 8, 8, CMT);
598 TEST_VQRSHL(int, , uint, u, 16, 4, CMT);
599 TEST_VQRSHL(int, , uint, u, 32, 2, CMT);
600 TEST_VQRSHL(int, , uint, u, 64, 1, CMT);
601 TEST_VQRSHL(int, q, int, s, 8, 16, CMT);
602 TEST_VQRSHL(int, q, int, s, 16, 8, CMT);
603 TEST_VQRSHL(int, q, int, s, 32, 4, CMT);
604 TEST_VQRSHL(int, q, int, s, 64, 2, CMT);
605 TEST_VQRSHL(int, q, uint, u, 8, 16, CMT);
606 TEST_VQRSHL(int, q, uint, u, 16, 8, CMT);
607 TEST_VQRSHL(int, q, uint, u, 32, 4, CMT);
608 TEST_VQRSHL(int, q, uint, u, 64, 2, CMT);
609
610 CHECK(TEST_MSG, int, 8, 8, PRIx8, expected_minus1, CMT);
611 CHECK(TEST_MSG, int, 16, 4, PRIx16, expected_minus1, CMT);
612 CHECK(TEST_MSG, int, 32, 2, PRIx32, expected_minus1, CMT);
613 CHECK(TEST_MSG, int, 64, 1, PRIx64, expected_minus1, CMT);
614 CHECK(TEST_MSG, uint, 8, 8, PRIx8, expected_minus1, CMT);
615 CHECK(TEST_MSG, uint, 16, 4, PRIx16, expected_minus1, CMT);
616 CHECK(TEST_MSG, uint, 32, 2, PRIx32, expected_minus1, CMT);
617 CHECK(TEST_MSG, uint, 64, 1, PRIx64, expected_minus1, CMT);
618 CHECK(TEST_MSG, int, 8, 16, PRIx8, expected_minus1, CMT);
619 CHECK(TEST_MSG, int, 16, 8, PRIx16, expected_minus1, CMT);
620 CHECK(TEST_MSG, int, 32, 4, PRIx32, expected_minus1, CMT);
621 CHECK(TEST_MSG, int, 64, 2, PRIx64, expected_minus1, CMT);
622 CHECK(TEST_MSG, uint, 8, 16, PRIx8, expected_minus1, CMT);
623 CHECK(TEST_MSG, uint, 16, 8, PRIx16, expected_minus1, CMT);
624 CHECK(TEST_MSG, uint, 32, 4, PRIx32, expected_minus1, CMT);
625 CHECK(TEST_MSG, uint, 64, 2, PRIx64, expected_minus1, CMT);
626
627
628 /* Use -3 shift amount to check cumulative saturation with
629 round_const. */
630 VDUP(vector_shift, , int, s, 8, 8, -3);
631 VDUP(vector_shift, , int, s, 16, 4, -3);
632 VDUP(vector_shift, , int, s, 32, 2, -3);
633 VDUP(vector_shift, , int, s, 64, 1, -3);
634 VDUP(vector_shift, q, int, s, 8, 16, -3);
635 VDUP(vector_shift, q, int, s, 16, 8, -3);
636 VDUP(vector_shift, q, int, s, 32, 4, -3);
637 VDUP(vector_shift, q, int, s, 64, 2, -3);
638
639 #undef CMT
640 #define CMT " (checking cumulative saturation: shift by -3)"
641 TEST_VQRSHL(int, , int, s, 8, 8, CMT);
642 TEST_VQRSHL(int, , int, s, 16, 4, CMT);
643 TEST_VQRSHL(int, , int, s, 32, 2, CMT);
644 TEST_VQRSHL(int, , int, s, 64, 1, CMT);
645 TEST_VQRSHL(int, , uint, u, 8, 8, CMT);
646 TEST_VQRSHL(int, , uint, u, 16, 4, CMT);
647 TEST_VQRSHL(int, , uint, u, 32, 2, CMT);
648 TEST_VQRSHL(int, , uint, u, 64, 1, CMT);
649 TEST_VQRSHL(int, q, int, s, 8, 16, CMT);
650 TEST_VQRSHL(int, q, int, s, 16, 8, CMT);
651 TEST_VQRSHL(int, q, int, s, 32, 4, CMT);
652 TEST_VQRSHL(int, q, int, s, 64, 2, CMT);
653 TEST_VQRSHL(int, q, uint, u, 8, 16, CMT);
654 TEST_VQRSHL(int, q, uint, u, 16, 8, CMT);
655 TEST_VQRSHL(int, q, uint, u, 32, 4, CMT);
656 TEST_VQRSHL(int, q, uint, u, 64, 2, CMT);
657
658 CHECK(TEST_MSG, int, 8, 8, PRIx8, expected_minus3, CMT);
659 CHECK(TEST_MSG, int, 16, 4, PRIx16, expected_minus3, CMT);
660 CHECK(TEST_MSG, int, 32, 2, PRIx32, expected_minus3, CMT);
661 CHECK(TEST_MSG, int, 64, 1, PRIx64, expected_minus3, CMT);
662 CHECK(TEST_MSG, uint, 8, 8, PRIx8, expected_minus3, CMT);
663 CHECK(TEST_MSG, uint, 16, 4, PRIx16, expected_minus3, CMT);
664 CHECK(TEST_MSG, uint, 32, 2, PRIx32, expected_minus3, CMT);
665 CHECK(TEST_MSG, uint, 64, 1, PRIx64, expected_minus3, CMT);
666 CHECK(TEST_MSG, int, 8, 16, PRIx8, expected_minus3, CMT);
667 CHECK(TEST_MSG, int, 16, 8, PRIx16, expected_minus3, CMT);
668 CHECK(TEST_MSG, int, 32, 4, PRIx32, expected_minus3, CMT);
669 CHECK(TEST_MSG, int, 64, 2, PRIx64, expected_minus3, CMT);
670 CHECK(TEST_MSG, uint, 8, 16, PRIx8, expected_minus3, CMT);
671 CHECK(TEST_MSG, uint, 16, 8, PRIx16, expected_minus3, CMT);
672 CHECK(TEST_MSG, uint, 32, 4, PRIx32, expected_minus3, CMT);
673 CHECK(TEST_MSG, uint, 64, 2, PRIx64, expected_minus3, CMT);
674
675
676 /* Use large shift amount. */
677 VDUP(vector_shift, , int, s, 8, 8, 10);
678 VDUP(vector_shift, , int, s, 16, 4, 20);
679 VDUP(vector_shift, , int, s, 32, 2, 40);
680 VDUP(vector_shift, , int, s, 64, 1, 70);
681 VDUP(vector_shift, q, int, s, 8, 16, 10);
682 VDUP(vector_shift, q, int, s, 16, 8, 20);
683 VDUP(vector_shift, q, int, s, 32, 4, 40);
684 VDUP(vector_shift, q, int, s, 64, 2, 70);
685
686 #undef CMT
687 #define CMT " (checking cumulative saturation: large shift amount)"
688 TEST_VQRSHL(int, , int, s, 8, 8, CMT);
689 TEST_VQRSHL(int, , int, s, 16, 4, CMT);
690 TEST_VQRSHL(int, , int, s, 32, 2, CMT);
691 TEST_VQRSHL(int, , int, s, 64, 1, CMT);
692 TEST_VQRSHL(int, , uint, u, 8, 8, CMT);
693 TEST_VQRSHL(int, , uint, u, 16, 4, CMT);
694 TEST_VQRSHL(int, , uint, u, 32, 2, CMT);
695 TEST_VQRSHL(int, , uint, u, 64, 1, CMT);
696 TEST_VQRSHL(int, q, int, s, 8, 16, CMT);
697 TEST_VQRSHL(int, q, int, s, 16, 8, CMT);
698 TEST_VQRSHL(int, q, int, s, 32, 4, CMT);
699 TEST_VQRSHL(int, q, int, s, 64, 2, CMT);
700 TEST_VQRSHL(int, q, uint, u, 8, 16, CMT);
701 TEST_VQRSHL(int, q, uint, u, 16, 8, CMT);
702 TEST_VQRSHL(int, q, uint, u, 32, 4, CMT);
703 TEST_VQRSHL(int, q, uint, u, 64, 2, CMT);
704
705 CHECK(TEST_MSG, int, 8, 8, PRIx8, expected_large_sh, CMT);
706 CHECK(TEST_MSG, int, 16, 4, PRIx16, expected_large_sh, CMT);
707 CHECK(TEST_MSG, int, 32, 2, PRIx32, expected_large_sh, CMT);
708 CHECK(TEST_MSG, int, 64, 1, PRIx64, expected_large_sh, CMT);
709 CHECK(TEST_MSG, uint, 8, 8, PRIx8, expected_large_sh, CMT);
710 CHECK(TEST_MSG, uint, 16, 4, PRIx16, expected_large_sh, CMT);
711 CHECK(TEST_MSG, uint, 32, 2, PRIx32, expected_large_sh, CMT);
712 CHECK(TEST_MSG, uint, 64, 1, PRIx64, expected_large_sh, CMT);
713 CHECK(TEST_MSG, int, 8, 16, PRIx8, expected_large_sh, CMT);
714 CHECK(TEST_MSG, int, 16, 8, PRIx16, expected_large_sh, CMT);
715 CHECK(TEST_MSG, int, 32, 4, PRIx32, expected_large_sh, CMT);
716 CHECK(TEST_MSG, int, 64, 2, PRIx64, expected_large_sh, CMT);
717 CHECK(TEST_MSG, uint, 8, 16, PRIx8, expected_large_sh, CMT);
718 CHECK(TEST_MSG, uint, 16, 8, PRIx16, expected_large_sh, CMT);
719 CHECK(TEST_MSG, uint, 32, 4, PRIx32, expected_large_sh, CMT);
720 CHECK(TEST_MSG, uint, 64, 2, PRIx64, expected_large_sh, CMT);
721
722
723 /* Fill input vector with negative values, to check saturation on
724 limits. */
725 VDUP(vector, , int, s, 8, 8, 0x80);
726 VDUP(vector, , int, s, 16, 4, 0x8000);
727 VDUP(vector, , int, s, 32, 2, 0x80000000);
728 VDUP(vector, , int, s, 64, 1, 0x8000000000000000LL);
729 VDUP(vector, q, int, s, 8, 16, 0x80);
730 VDUP(vector, q, int, s, 16, 8, 0x8000);
731 VDUP(vector, q, int, s, 32, 4, 0x80000000);
732 VDUP(vector, q, int, s, 64, 2, 0x8000000000000000LL);
733
734 /* Use large shift amount. */
735 VDUP(vector_shift, , int, s, 8, 8, 10);
736 VDUP(vector_shift, , int, s, 16, 4, 20);
737 VDUP(vector_shift, , int, s, 32, 2, 40);
738 VDUP(vector_shift, , int, s, 64, 1, 70);
739 VDUP(vector_shift, q, int, s, 8, 16, 10);
740 VDUP(vector_shift, q, int, s, 16, 8, 20);
741 VDUP(vector_shift, q, int, s, 32, 4, 40);
742 VDUP(vector_shift, q, int, s, 64, 2, 70);
743
744 #undef CMT
745 #define CMT " (checking cumulative saturation: large shift amount with negative input)"
746 TEST_VQRSHL(int, , int, s, 8, 8, CMT);
747 TEST_VQRSHL(int, , int, s, 16, 4, CMT);
748 TEST_VQRSHL(int, , int, s, 32, 2, CMT);
749 TEST_VQRSHL(int, , int, s, 64, 1, CMT);
750 TEST_VQRSHL(int, , uint, u, 8, 8, CMT);
751 TEST_VQRSHL(int, , uint, u, 16, 4, CMT);
752 TEST_VQRSHL(int, , uint, u, 32, 2, CMT);
753 TEST_VQRSHL(int, , uint, u, 64, 1, CMT);
754 TEST_VQRSHL(int, q, int, s, 8, 16, CMT);
755 TEST_VQRSHL(int, q, int, s, 16, 8, CMT);
756 TEST_VQRSHL(int, q, int, s, 32, 4, CMT);
757 TEST_VQRSHL(int, q, int, s, 64, 2, CMT);
758 TEST_VQRSHL(int, q, uint, u, 8, 16, CMT);
759 TEST_VQRSHL(int, q, uint, u, 16, 8, CMT);
760 TEST_VQRSHL(int, q, uint, u, 32, 4, CMT);
761 TEST_VQRSHL(int, q, uint, u, 64, 2, CMT);
762
763 CHECK(TEST_MSG, int, 8, 8, PRIx8, expected_neg_large_sh, CMT);
764 CHECK(TEST_MSG, int, 16, 4, PRIx16, expected_neg_large_sh, CMT);
765 CHECK(TEST_MSG, int, 32, 2, PRIx32, expected_neg_large_sh, CMT);
766 CHECK(TEST_MSG, int, 64, 1, PRIx64, expected_neg_large_sh, CMT);
767 CHECK(TEST_MSG, uint, 8, 8, PRIx8, expected_neg_large_sh, CMT);
768 CHECK(TEST_MSG, uint, 16, 4, PRIx16, expected_neg_large_sh, CMT);
769 CHECK(TEST_MSG, uint, 32, 2, PRIx32, expected_neg_large_sh, CMT);
770 CHECK(TEST_MSG, uint, 64, 1, PRIx64, expected_neg_large_sh, CMT);
771 CHECK(TEST_MSG, int, 8, 16, PRIx8, expected_neg_large_sh, CMT);
772 CHECK(TEST_MSG, int, 16, 8, PRIx16, expected_neg_large_sh, CMT);
773 CHECK(TEST_MSG, int, 32, 4, PRIx32, expected_neg_large_sh, CMT);
774 CHECK(TEST_MSG, int, 64, 2, PRIx64, expected_neg_large_sh, CMT);
775 CHECK(TEST_MSG, uint, 8, 16, PRIx8, expected_neg_large_sh, CMT);
776 CHECK(TEST_MSG, uint, 16, 8, PRIx16, expected_neg_large_sh, CMT);
777 CHECK(TEST_MSG, uint, 32, 4, PRIx32, expected_neg_large_sh, CMT);
778 CHECK(TEST_MSG, uint, 64, 2, PRIx64, expected_neg_large_sh, CMT);
779
780
781 /* Fill input vector with negative and positive values, to check
782 * saturation on limits */
783 VDUP(vector, , int, s, 8, 8, 0x7F);
784 VDUP(vector, , int, s, 16, 4, 0x7FFF);
785 VDUP(vector, , int, s, 32, 2, 0x7FFFFFFF);
786 VDUP(vector, , int, s, 64, 1, 0x7FFFFFFFFFFFFFFFLL);
787 VDUP(vector, q, int, s, 8, 16, 0x80);
788 VDUP(vector, q, int, s, 16, 8, 0x8000);
789 VDUP(vector, q, int, s, 32, 4, 0x80000000);
790 VDUP(vector, q, int, s, 64, 2, 0x8000000000000000LL);
791
792 /* Use large negative shift amount */
793 VDUP(vector_shift, , int, s, 8, 8, -10);
794 VDUP(vector_shift, , int, s, 16, 4, -20);
795 VDUP(vector_shift, , int, s, 32, 2, -40);
796 VDUP(vector_shift, , int, s, 64, 1, -70);
797 VDUP(vector_shift, q, int, s, 8, 16, -10);
798 VDUP(vector_shift, q, int, s, 16, 8, -20);
799 VDUP(vector_shift, q, int, s, 32, 4, -40);
800 VDUP(vector_shift, q, int, s, 64, 2, -70);
801
802 #undef CMT
803 #define CMT " (checking cumulative saturation: large negative shift amount)"
804 TEST_VQRSHL(int, , int, s, 8, 8, CMT);
805 TEST_VQRSHL(int, , int, s, 16, 4, CMT);
806 TEST_VQRSHL(int, , int, s, 32, 2, CMT);
807 TEST_VQRSHL(int, , int, s, 64, 1, CMT);
808 TEST_VQRSHL(int, , uint, u, 8, 8, CMT);
809 TEST_VQRSHL(int, , uint, u, 16, 4, CMT);
810 TEST_VQRSHL(int, , uint, u, 32, 2, CMT);
811 TEST_VQRSHL(int, , uint, u, 64, 1, CMT);
812 TEST_VQRSHL(int, q, int, s, 8, 16, CMT);
813 TEST_VQRSHL(int, q, int, s, 16, 8, CMT);
814 TEST_VQRSHL(int, q, int, s, 32, 4, CMT);
815 TEST_VQRSHL(int, q, int, s, 64, 2, CMT);
816 TEST_VQRSHL(int, q, uint, u, 8, 16, CMT);
817 TEST_VQRSHL(int, q, uint, u, 16, 8, CMT);
818 TEST_VQRSHL(int, q, uint, u, 32, 4, CMT);
819 TEST_VQRSHL(int, q, uint, u, 64, 2, CMT);
820
821 CHECK(TEST_MSG, int, 8, 8, PRIx8, expected_large_neg_sh, CMT);
822 CHECK(TEST_MSG, int, 16, 4, PRIx16, expected_large_neg_sh, CMT);
823 CHECK(TEST_MSG, int, 32, 2, PRIx32, expected_large_neg_sh, CMT);
824 CHECK(TEST_MSG, int, 64, 1, PRIx64, expected_large_neg_sh, CMT);
825 CHECK(TEST_MSG, uint, 8, 8, PRIx8, expected_large_neg_sh, CMT);
826 CHECK(TEST_MSG, uint, 16, 4, PRIx16, expected_large_neg_sh, CMT);
827 CHECK(TEST_MSG, uint, 32, 2, PRIx32, expected_large_neg_sh, CMT);
828 CHECK(TEST_MSG, uint, 64, 1, PRIx64, expected_large_neg_sh, CMT);
829 CHECK(TEST_MSG, int, 8, 16, PRIx8, expected_large_neg_sh, CMT);
830 CHECK(TEST_MSG, int, 16, 8, PRIx16, expected_large_neg_sh, CMT);
831 CHECK(TEST_MSG, int, 32, 4, PRIx32, expected_large_neg_sh, CMT);
832 CHECK(TEST_MSG, int, 64, 2, PRIx64, expected_large_neg_sh, CMT);
833 CHECK(TEST_MSG, uint, 8, 16, PRIx8, expected_large_neg_sh, CMT);
834 CHECK(TEST_MSG, uint, 16, 8, PRIx16, expected_large_neg_sh, CMT);
835 CHECK(TEST_MSG, uint, 32, 4, PRIx32, expected_large_neg_sh, CMT);
836 CHECK(TEST_MSG, uint, 64, 2, PRIx64, expected_large_neg_sh, CMT);
837
838
839 /* Fill input vector with 0, to check saturation in case of large
840 * shift amount */
841 VDUP(vector, , int, s, 8, 8, 0);
842 VDUP(vector, , int, s, 16, 4, 0);
843 VDUP(vector, , int, s, 32, 2, 0);
844 VDUP(vector, , int, s, 64, 1, 0);
845 VDUP(vector, q, int, s, 8, 16, 0);
846 VDUP(vector, q, int, s, 16, 8, 0);
847 VDUP(vector, q, int, s, 32, 4, 0);
848 VDUP(vector, q, int, s, 64, 2, 0);
849
850 /* Use large shift amount */
851 VDUP(vector_shift, , int, s, 8, 8, -10);
852 VDUP(vector_shift, , int, s, 16, 4, -20);
853 VDUP(vector_shift, , int, s, 32, 2, -40);
854 VDUP(vector_shift, , int, s, 64, 1, -70);
855 VDUP(vector_shift, q, int, s, 8, 16, -10);
856 VDUP(vector_shift, q, int, s, 16, 8, -20);
857 VDUP(vector_shift, q, int, s, 32, 4, -40);
858 VDUP(vector_shift, q, int, s, 64, 2, -70);
859
860 #undef CMT
861 #define CMT " (checking cumulative saturation: large negative shift amount with 0 input)"
862 TEST_VQRSHL(int, , int, s, 8, 8, CMT);
863 TEST_VQRSHL(int, , int, s, 16, 4, CMT);
864 TEST_VQRSHL(int, , int, s, 32, 2, CMT);
865 TEST_VQRSHL(int, , int, s, 64, 1, CMT);
866 TEST_VQRSHL(int, , uint, u, 8, 8, CMT);
867 TEST_VQRSHL(int, , uint, u, 16, 4, CMT);
868 TEST_VQRSHL(int, , uint, u, 32, 2, CMT);
869 TEST_VQRSHL(int, , uint, u, 64, 1, CMT);
870 TEST_VQRSHL(int, q, int, s, 8, 16, CMT);
871 TEST_VQRSHL(int, q, int, s, 16, 8, CMT);
872 TEST_VQRSHL(int, q, int, s, 32, 4, CMT);
873 TEST_VQRSHL(int, q, int, s, 64, 2, CMT);
874 TEST_VQRSHL(int, q, uint, u, 8, 16, CMT);
875 TEST_VQRSHL(int, q, uint, u, 16, 8, CMT);
876 TEST_VQRSHL(int, q, uint, u, 32, 4, CMT);
877 TEST_VQRSHL(int, q, uint, u, 64, 2, CMT);
878
879 CHECK(TEST_MSG, int, 8, 8, PRIx8, expected_large_neg_sh, CMT);
880 CHECK(TEST_MSG, int, 16, 4, PRIx16, expected_large_neg_sh, CMT);
881 CHECK(TEST_MSG, int, 32, 2, PRIx32, expected_large_neg_sh, CMT);
882 CHECK(TEST_MSG, int, 64, 1, PRIx64, expected_large_neg_sh, CMT);
883 CHECK(TEST_MSG, uint, 8, 8, PRIx8, expected_large_neg_sh, CMT);
884 CHECK(TEST_MSG, uint, 16, 4, PRIx16, expected_large_neg_sh, CMT);
885 CHECK(TEST_MSG, uint, 32, 2, PRIx32, expected_large_neg_sh, CMT);
886 CHECK(TEST_MSG, uint, 64, 1, PRIx64, expected_large_neg_sh, CMT);
887 CHECK(TEST_MSG, int, 8, 16, PRIx8, expected_large_neg_sh, CMT);
888 CHECK(TEST_MSG, int, 16, 8, PRIx16, expected_large_neg_sh, CMT);
889 CHECK(TEST_MSG, int, 32, 4, PRIx32, expected_large_neg_sh, CMT);
890 CHECK(TEST_MSG, int, 64, 2, PRIx64, expected_large_neg_sh, CMT);
891 CHECK(TEST_MSG, uint, 8, 16, PRIx8, expected_large_neg_sh, CMT);
892 CHECK(TEST_MSG, uint, 16, 8, PRIx16, expected_large_neg_sh, CMT);
893 CHECK(TEST_MSG, uint, 32, 4, PRIx32, expected_large_neg_sh, CMT);
894 CHECK(TEST_MSG, uint, 64, 2, PRIx64, expected_large_neg_sh, CMT);
895 }
896
897 int main (void)
898 {
899 exec_vqrshl ();
900 return 0;
901 }