Debian Codegraph @

gcc/testsuite/gcc.target/powerpc/vec-shift-double-runnable-int128.c

raw
1 /* { dg-do run { target power10_hw } } */
2 /* { dg-do compile { target { ! power10_hw } } } */
3 /* { dg-require-effective-target int128 } */
4
5 /* Need -save-temps for dg-final scan-assembler-times at end of test. */
6 /* { dg-options "-mdejagnu-cpu=power10 -save-temps" } */
7
8 #include <altivec.h>
9
10 #define DEBUG 0
11
12 #if DEBUG
13 #include <stdio.h>
14
15 void print_i128 (unsigned __int128 val)
16 {
17 printf(" 0x%016llx%016llx",
18 (unsigned long long)(val >> 64),
19 (unsigned long long)(val & 0xFFFFFFFFFFFFFFFF));
20 }
21 #endif
22
23 extern void abort (void);
24
25 #if DEBUG
26 #define ACTION_2ARG_UNSIGNED(NAME, TYPE_NAME) \
27 printf ("vec_%s (vector TYPE __int128, vector TYPE __int128) \n", #NAME); \
28 printf(" src_va_s128[0] = "); \
29 print_i128 ((unsigned __int128) src_va_##TYPE_NAME[0]); \
30 printf("\n"); \
31 printf(" src_vb_uc = 0x"); \
32 for (i = 0; i < 16; i++) \
33 printf("%02x", src_vb_uc[i]); \
34 printf("\n"); \
35 printf(" vresult[0] = "); \
36 print_i128 ((unsigned __int128) vresult[0]); \
37 printf("\n"); \
38 printf(" expected_vresult[0] = "); \
39 print_i128 ((unsigned __int128) expected_vresult[0]); \
40 printf("\n");
41
42 #define ACTION_2ARG_SIGNED(NAME, TYPE_NAME) \
43 printf ("vec_%s (vector TYPE __int128, vector TYPE __int128) \n", #NAME); \
44 printf(" src_va_s128[0] = "); \
45 print_i128 ((unsigned __int128) src_va_##TYPE_NAME[0]); \
46 printf("\n"); \
47 printf(" src_vb_sc = 0x"); \
48 for (i = 0; i < 16; i++) \
49 printf("%02x", src_vb_sc[i]); \
50 printf("\n"); \
51 printf(" vresult[0] = "); \
52 print_i128 ((unsigned __int128) vresult[0]); \
53 printf("\n"); \
54 printf(" expected_vresult[0] = "); \
55 print_i128 ((unsigned __int128) expected_vresult[0]); \
56 printf("\n");
57
58 #define ACTION_3ARG(NAME, TYPE_NAME, CONST) \
59 printf ("vec_%s (vector TYPE __int128, vector TYPE __int128, %s) \n", \
60 #NAME, #CONST); \
61 printf(" src_va_s128[0] = "); \
62 print_i128 ((unsigned __int128) src_va_##TYPE_NAME[0]); \
63 printf("\n"); \
64 printf(" src_vb_s128[0] = "); \
65 print_i128 ((unsigned __int128) src_vb_##TYPE_NAME[0]); \
66 printf("\n"); \
67 printf(" vresult[0] = "); \
68 print_i128 ((unsigned __int128) vresult[0]); \
69 printf("\n"); \
70 printf(" expected_vresult[0] = "); \
71 print_i128 ((unsigned __int128) expected_vresult[0]); \
72 printf("\n");
73
74 #else
75 #define ACTION_2ARG_UNSIGNED(NAME, TYPE_NAME) \
76 abort();
77
78 #define ACTION_2ARG_SIGNED(NAME, TYPE_NAME) \
79 abort();
80
81 #define ACTION_2ARG(NAME, TYPE_NAME) \
82 abort();
83
84 #define ACTION_3ARG(NAME, TYPE_NAME, CONST) \
85 abort();
86 #endif
87
88 /* Second argument of the builtin is vector unsigned char. */
89 #define TEST_2ARG_UNSIGNED(NAME, TYPE, TYPE_NAME, EXP_RESULT_HI, EXP_RESULT_LO) \
90 { \
91 vector TYPE __int128 vresult; \
92 vector TYPE __int128 expected_vresult; \
93 int i; \
94 \
95 expected_vresult = (vector TYPE __int128) { EXP_RESULT_HI }; \
96 expected_vresult = (expected_vresult << 64) | \
97 (vector TYPE __int128) { EXP_RESULT_LO }; \
98 vresult = vec_##NAME (src_va_##TYPE_NAME, src_vb_uc); \
99 \
100 if (!vec_all_eq (vresult, expected_vresult)) { \
101 ACTION_2ARG_UNSIGNED(NAME, TYPE_NAME) \
102 } \
103 }
104
105 /* Second argument of the builtin is vector signed char. */
106 #define TEST_2ARG_SIGNED(NAME, TYPE, TYPE_NAME, EXP_RESULT_HI, EXP_RESULT_LO) \
107 { \
108 vector TYPE __int128 vresult; \
109 vector TYPE __int128 expected_vresult; \
110 int i; \
111 \
112 expected_vresult = (vector TYPE __int128) { EXP_RESULT_HI }; \
113 expected_vresult = (expected_vresult << 64) | \
114 (vector TYPE __int128) { EXP_RESULT_LO }; \
115 vresult = vec_##NAME (src_va_##TYPE_NAME, src_vb_sc); \
116 \
117 if (!vec_all_eq (vresult, expected_vresult)) { \
118 ACTION_2ARG_SIGNED(NAME, TYPE_NAME) \
119 } \
120 }
121
122 #define TEST_3ARG(NAME, TYPE, TYPE_NAME, CONST, EXP_RESULT_HI, EXP_RESULT_LO) \
123 { \
124 vector TYPE __int128 vresult; \
125 vector TYPE __int128 expected_vresult; \
126 \
127 expected_vresult = (vector TYPE __int128) { EXP_RESULT_HI }; \
128 expected_vresult = (expected_vresult << 64) | \
129 (vector TYPE __int128) { EXP_RESULT_LO }; \
130 vresult = vec_##NAME (src_va_##TYPE_NAME, src_vb_##TYPE_NAME, CONST); \
131 \
132 if (!vec_all_eq (vresult, expected_vresult)) { \
133 ACTION_3ARG(NAME, TYPE_NAME, CONST) \
134 } \
135 }
136
137 int
138 main (int argc, char *argv [])
139 {
140 vector signed __int128 vresult_s128;
141 vector signed __int128 expected_vresult_s128;
142 vector signed __int128 src_va_s128;
143 vector signed __int128 src_vb_s128;
144 vector unsigned __int128 vresult_u128;
145 vector unsigned __int128 expected_vresult_u128;
146 vector unsigned __int128 src_va_u128;
147 vector unsigned __int128 src_vb_u128;
148 vector signed char src_vb_sc;
149 vector unsigned char src_vb_uc;
150
151 /* 128-bit vector shift right tests, vec_srdb. */
152 src_va_s128 = (vector signed __int128) {0x12345678};
153 src_vb_s128 = (vector signed __int128) {0xFEDCBA90};
154 TEST_3ARG(srdb, signed, s128, 4, 0x8000000000000000, 0xFEDCBA9)
155
156 src_va_u128 = (vector unsigned __int128) { 0xFEDCBA98 };
157 src_vb_u128 = (vector unsigned __int128) { 0x76543210};
158 TEST_3ARG(srdb, unsigned, u128, 4, 0x8000000000000000, 0x07654321)
159
160 /* 128-bit vector shift left tests, vec_sldb. */
161 src_va_s128 = (vector signed __int128) {0x123456789ABCDEF0};
162 src_va_s128 = (src_va_s128 << 64)
163 | (vector signed __int128) {0x123456789ABCDEF0};
164 src_vb_s128 = (vector signed __int128) {0xFEDCBA9876543210};
165 src_vb_s128 = (src_vb_s128 << 64)
166 | (vector signed __int128) {0xFEDCBA9876543210};
167 TEST_3ARG(sldb, signed, s128, 4, 0x23456789ABCDEF01, 0x23456789ABCDEF0F)
168
169 src_va_u128 = (vector unsigned __int128) {0xFEDCBA9876543210};
170 src_va_u128 = src_va_u128 << 64
171 | (vector unsigned __int128) {0xFEDCBA9876543210};
172 src_vb_u128 = (vector unsigned __int128) {0x123456789ABCDEF0};
173 src_vb_u128 = src_vb_u128 << 64
174 | (vector unsigned __int128) {0x123456789ABCDEF0};
175 TEST_3ARG(sldb, unsigned, u128, 4, 0xEDCBA9876543210F, 0xEDCBA98765432101)
176
177 /* Shift left by octect tests, vec_sld. Shift is by immediate value
178 times 8. */
179 src_va_s128 = (vector signed __int128) {0x123456789ABCDEF0};
180 src_va_s128 = (src_va_s128 << 64)
181 | (vector signed __int128) {0x123456789ABCDEF0};
182 src_vb_s128 = (vector signed __int128) {0xFEDCBA9876543210};
183 src_vb_s128 = (src_vb_s128 << 64)
184 | (vector signed __int128) {0xFEDCBA9876543210};
185 TEST_3ARG(sld, signed, s128, 4, 0x9abcdef012345678, 0x9abcdef0fedcba98)
186
187 src_va_u128 = (vector unsigned __int128) {0xFEDCBA9876543210};
188 src_va_u128 = src_va_u128 << 64
189 | (vector unsigned __int128) {0xFEDCBA9876543210};
190 src_vb_u128 = (vector unsigned __int128) {0x123456789ABCDEF0};
191 src_vb_u128 = src_vb_u128 << 64
192 | (vector unsigned __int128) {0x123456789ABCDEF0};
193 TEST_3ARG(sld, unsigned, u128, 4, 0x76543210fedcba98, 0x7654321012345678)
194
195 /* Vector left shift bytes within the vector, vec_sll. */
196 src_va_s128 = (vector signed __int128) {0x123456789ABCDEF0};
197 src_va_s128 = (src_va_s128 << 64)
198 | (vector signed __int128) {0x123456789ABCDEF0};
199 src_vb_uc = (vector unsigned char) {0x01, 0x01, 0x01, 0x01,
200 0x01, 0x01, 0x01, 0x01,
201 0x01, 0x01, 0x01, 0x01,
202 0x01, 0x01, 0x01, 0x01};
203 TEST_2ARG_UNSIGNED(sll, signed, s128, 0x2468acf13579bde0,
204 0x2468acf13579bde0)
205
206 src_va_u128 = (vector unsigned __int128) {0x123456789ABCDEF0};
207 src_va_u128 = src_va_u128 << 64
208 | (vector unsigned __int128) {0x123456789ABCDEF0};
209 src_vb_uc = (vector unsigned char) {0x02, 0x02, 0x02, 0x02,
210 0x02, 0x02, 0x02, 0x02,
211 0x02, 0x02, 0x02, 0x02,
212 0x02, 0x02, 0x02, 0x02};
213 TEST_2ARG_UNSIGNED(sll, unsigned, u128, 0x48d159e26af37bc0,
214 0x48d159e26af37bc0)
215
216 /* Vector right shift bytes within the vector, vec_srl. */
217 src_va_s128 = (vector signed __int128) {0x123456789ABCDEF0};
218 src_va_s128 = (src_va_s128 << 64)
219 | (vector signed __int128) {0x123456789ABCDEF0};
220 src_vb_uc = (vector unsigned char) {0x01, 0x01, 0x01, 0x01,
221 0x01, 0x01, 0x01, 0x01,
222 0x01, 0x01, 0x01, 0x01,
223 0x01, 0x01, 0x01, 0x01};
224 TEST_2ARG_UNSIGNED(srl, signed, s128, 0x091a2b3c4d5e6f78,
225 0x091a2b3c4d5e6f78)
226
227 src_va_u128 = (vector unsigned __int128) {0x123456789ABCDEF0};
228 src_va_u128 = src_va_u128 << 64
229 | (vector unsigned __int128) {0x123456789ABCDEF0};
230 src_vb_uc = (vector unsigned char) {0x02, 0x02, 0x02, 0x02,
231 0x02, 0x02, 0x02, 0x02,
232 0x02, 0x02, 0x02, 0x02,
233 0x02, 0x02, 0x02, 0x02};
234 TEST_2ARG_UNSIGNED(srl, unsigned, u128, 0x48d159e26af37bc,
235 0x48d159e26af37bc)
236
237 /* Shift left by octect tests, vec_slo. Shift is by immediate value
238 bytes. Shift amount in bits 121:124. */
239 src_va_s128 = (vector signed __int128) {0x123456789ABCDEF0};
240 src_va_s128 = (src_va_s128 << 64)
241 | (vector signed __int128) {0x123456789ABCDEF0};
242 /* Note vb_sc is Endian specific. */
243 /* The left shift amount is 1 byte, i.e. 1 * 8 bits. */
244 #if __LITTLE_ENDIAN__
245 src_vb_sc = (vector signed char) {0x1 << 3, 0x0, 0x0, 0x0,
246 0x0, 0x0, 0x0, 0x0,
247 0x0, 0x0, 0x0, 0x0,
248 0x0, 0x0, 0x0, 0x0};
249 #else
250 src_vb_sc = (vector signed char) {0x0, 0x0, 0x0, 0x0,
251 0x0, 0x0, 0x0, 0x0,
252 0x0, 0x0, 0x0, 0x0,
253 0x0, 0x0, 0x0, 0x1 << 3};
254 #endif
255
256 TEST_2ARG_SIGNED(slo, signed, s128, 0x3456789ABCDEF012,
257 0x3456789ABCDEF000)
258 src_va_s128 = (vector signed __int128) {0x123456789ABCDEF0};
259 src_va_s128 = (src_va_s128 << 64)
260 | (vector signed __int128) {0x123456789ABCDEF0};
261
262 /* Note vb_sc is Endian specific. */
263 /* The left shift amount is 2 bytes, i.e. 2 * 8 bits. */
264 #if __LITTLE_ENDIAN__
265 src_vb_uc = (vector unsigned char) {0x2 << 3, 0x0, 0x0, 0x0,
266 0x0, 0x0, 0x0, 0x0,
267 0x0, 0x0, 0x0, 0x0,
268 0x0, 0x0, 0x0, 0x0};
269 #else
270 src_vb_uc = (vector unsigned char) {0x0, 0x0, 0x0, 0x0,
271 0x0, 0x0, 0x0, 0x0,
272 0x0, 0x0, 0x0, 0x0,
273 0x0, 0x0, 0x0, 0x2 << 3};
274 #endif
275 TEST_2ARG_UNSIGNED(slo, signed, s128, 0x56789ABCDEF01234,
276 0x56789ABCDEF00000)
277
278 src_va_u128 = (vector unsigned __int128) {0xFEDCBA9876543210};
279 src_va_u128 = src_va_u128 << 64
280 | (vector unsigned __int128) {0xFEDCBA9876543210};
281 /* Note vb_sc is Endian specific. */
282 /* The left shift amount is 3 bytes, i.e. 3 * 8 bits. */
283 #if __LITTLE_ENDIAN__
284 src_vb_sc = (vector signed char) {0x03<<3, 0x0, 0x0, 0x0,
285 0x0, 0x0, 0x0, 0x0,
286 0x0, 0x0, 0x0, 0x0,
287 0x00, 0x00, 0x00, 0x0};
288 #else
289 src_vb_sc = (vector signed char) {0x0, 0x0, 0x0, 0x0,
290 0x0, 0x0, 0x0, 0x0,
291 0x0, 0x0, 0x0, 0x0,
292 0x00, 0x00, 0x00, 0x03<<3};
293 #endif
294 TEST_2ARG_SIGNED(slo, unsigned, u128, 0x9876543210FEDCBA,
295 0x9876543210000000)
296
297 src_va_u128 = (vector unsigned __int128) {0xFEDCBA9876543210};
298 src_va_u128 = src_va_u128 << 64
299 | (vector unsigned __int128) {0xFEDCBA9876543210};
300 /* Note vb_sc is Endian specific. */
301 /* The left shift amount is 4 bytes, i.e. 4 * 8 bits. */
302 #if __LITTLE_ENDIAN__
303 src_vb_uc = (vector unsigned char) {0x04<<3, 0x0, 0x0, 0x0,
304 0x0, 0x0, 0x0, 0x0,
305 0x0, 0x0, 0x0, 0x0,
306 0x0, 0x0, 0x0, 0x0};
307 #else
308 src_vb_uc = (vector unsigned char) {0x0, 0x0, 0x0, 0x0,
309 0x0, 0x0, 0x0, 0x0,
310 0x0, 0x0, 0x0, 0x0,
311 0x00, 0x00, 0x00, 0x04<<3};
312 #endif
313 TEST_2ARG_UNSIGNED(slo, unsigned, u128, 0x76543210FEDCBA98,
314 0x7654321000000000)
315
316 /* Shift right by octect tests, vec_sro. Shift is by immediate value
317 times 8. Shift amount in bits 121:124. */
318 src_va_s128 = (vector signed __int128) {0x123456789ABCDEF0};
319 src_va_s128 = (src_va_s128 << 64)
320 | (vector signed __int128) {0x123456789ABCDEF0};
321 /* Note vb_sc is Endian specific. */
322 /* The left shift amount is 1 byte, i.e. 1 * 8 bits. */
323 #if __LITTLE_ENDIAN__
324 src_vb_sc = (vector signed char) {0x1 << 3, 0x0, 0x0, 0x0,
325 0x0, 0x0, 0x0, 0x0,
326 0x0, 0x0, 0x0, 0x0,
327 0x0, 0x0, 0x0, 0x0};
328 #else
329 src_vb_sc = (vector signed char) {0x0, 0x0, 0x0, 0x0,
330 0x0, 0x0, 0x0, 0x0,
331 0x0, 0x0, 0x0, 0x0,
332 0x0, 0x0, 0x0, 0x1 << 3};
333 #endif
334 TEST_2ARG_SIGNED(sro, signed, s128, 0x00123456789ABCDE, 0xF0123456789ABCDE)
335
336 src_va_s128 = (vector signed __int128) {0x123456789ABCDEF0};
337 src_va_s128 = (src_va_s128 << 64)
338 | (vector signed __int128) {0x123456789ABCDEF0};
339 /* Note vb_sc is Endian specific. */
340 /* The left shift amount is 1 byte, i.e. 1 * 8 bits. */
341 #if __LITTLE_ENDIAN__
342 src_vb_uc = (vector unsigned char) {0x2 << 3, 0x0, 0x0, 0x0,
343 0x0, 0x0, 0x0, 0x0,
344 0x0, 0x0, 0x0, 0x0,
345 0x0, 0x0, 0x0, 0x0};
346 #else
347 src_vb_uc = (vector unsigned char) {0x0, 0x0, 0x0, 0x0,
348 0x0, 0x0, 0x0, 0x0,
349 0x0, 0x0, 0x0, 0x0,
350 0x0, 0x0, 0x0, 0x2 << 3};
351 #endif
352 TEST_2ARG_UNSIGNED(sro, signed, s128, 0x0000123456789ABC,
353 0xDEF0123456789ABC)
354
355 src_va_u128 = (vector unsigned __int128) {0xFEDCBA9876543210};
356 src_va_u128 = src_va_u128 << 64
357 | (vector unsigned __int128) {0xFEDCBA9876543210};
358 /* Note vb_sc is Endian specific. */
359 /* The left shift amount is 4 bytes, i.e. 4 * 8 bits. */
360 #if __LITTLE_ENDIAN__
361 src_vb_sc = (vector signed char) {0x03<<3, 0x0, 0x0, 0x0,
362 0x0, 0x0, 0x0, 0x0,
363 0x0, 0x0, 0x0, 0x0,
364 0x00, 0x00, 0x00, 0x0};
365 #else
366 src_vb_sc = (vector signed char) {0x0, 0x0, 0x0, 0x0,
367 0x0, 0x0, 0x0, 0x0,
368 0x0, 0x0, 0x0, 0x0,
369 0x00, 0x00, 0x00, 0x03<<3};
370 #endif
371 TEST_2ARG_SIGNED(sro, unsigned, u128, 0x000000FEDCBA9876,
372 0x543210FEDCBA9876)
373
374 src_va_u128 = (vector unsigned __int128) {0xFEDCBA9876543210};
375 src_va_u128 = src_va_u128 << 64
376 | (vector unsigned __int128) {0xFEDCBA9876543210};
377 /* Note vb_sc is Endian specific. */
378 /* The left shift amount is 4 bytes, i.e. 4 * 8 bits. */
379 #if __LITTLE_ENDIAN__
380 src_vb_uc = (vector unsigned char) {0x04<<3, 0x0, 0x0, 0x0,
381 0x0, 0x0, 0x0, 0x0,
382 0x0, 0x0, 0x0, 0x0,
383 0x0, 0x0, 0x00, 0x0};
384 #else
385 src_vb_uc = (vector unsigned char) {0x0, 0x0, 0x0, 0x0,
386 0x0, 0x0, 0x0, 0x0,
387 0x0, 0x0, 0x0, 0x0,
388 0x00, 0x0, 0x0, 0x04<<3};
389 #endif
390 TEST_2ARG_UNSIGNED(sro, unsigned, u128, 0x00000000FEDCBA98,
391 0x76543210FEDCBA98)
392
393 /* 128-bit vector shift left tests, vec_sldw. */
394 src_va_s128 = (vector signed __int128) {0x123456789ABCDEF0};
395 src_va_s128 = (src_va_s128 << 64)
396 | (vector signed __int128) {0x123456789ABCDEF0};
397 src_vb_s128 = (vector signed __int128) {0xFEDCBA9876543210};
398 src_vb_s128 = (src_vb_s128 << 64)
399 | (vector signed __int128) {0xFEDCBA9876543210};
400 TEST_3ARG(sldw, signed, s128, 1, 0x9ABCDEF012345678, 0x9ABCDEF0FEDCBA98)
401
402 src_va_u128 = (vector unsigned __int128) {0x123456789ABCDEF0};
403 src_va_u128 = (src_va_u128 << 64)
404 | (vector unsigned __int128) {0x123456789ABCDEF0};
405 src_vb_u128 = (vector unsigned __int128) {0xFEDCBA9876543210};
406 src_vb_u128 = (src_vb_u128 << 64)
407 | (vector unsigned __int128) {0xFEDCBA9876543210};
408 TEST_3ARG(sldw, unsigned, u128, 2, 0x123456789ABCDEF0, 0xFEDCBA9876543210)
409
410
411 return 0;
412 }
413
414 /* { dg-final { scan-assembler-times {\mvsrdbi\M} 2 } } */
415 /* { dg-final { scan-assembler-times {\mvsldbi\M} 2 } } */
416 /* { dg-final { scan-assembler-times {\mvsl\M} 2 } } */
417 /* { dg-final { scan-assembler-times {\mvsr\M} 2 } } */
418 /* { dg-final { scan-assembler-times {\mvslo\M} 4 } } */
419 /* { dg-final { scan-assembler-times {\mvsro\M} 4 } } */