1 /* { dg-do run } */
2 /* { dg-require-effective-target p8vector_hw } */
3 /* { dg-require-effective-target int128 } */
4 /* { dg-options "-mdejagnu-cpu=power8 -O3" } */
5
6 #include <altivec.h>
7
8 #ifdef DEBUG
9 #include <stdio.h>
10 #endif
11
12 void abort (void);
13
14 /* Verify vec_revb builtins */
15
16 int
17 main()
18 {
19 int i;
20 vector bool char arg_bc, result_bc, expected_bc;
21 vector unsigned char arg_uc, result_uc, expected_uc;
22 vector signed char arg_sc, result_sc, expected_sc;
23
24 vector bool short int arg_bsi, result_bsi, expected_bsi;
25 vector unsigned short int arg_usi, result_usi, expected_usi;
26 vector short int arg_si, result_si, expected_si;
27
28 vector bool int arg_bi, result_bi, expected_bi;
29 vector unsigned int arg_ui, result_ui, expected_ui;
30 vector int arg_int, result_int, expected_int;
31
32 vector bool long long int arg_blli, result_blli, expected_blli;
33 vector unsigned long long int arg_ulli, result_ulli, expected_ulli;
34 vector long long int arg_lli, result_lli, expected_lli;
35
36 vector __uint128_t arg_uint128, result_uint128, expected_uint128;
37 vector __int128_t arg_int128, result_int128, expected_int128;
38
39 vector float arg_f, result_f, expected_f;
40 vector double arg_d, result_d, expected_d;
41
42 /* 8-bit ints */
43 /* The element is a byte. Reversing the byte in each byte element
44 gives the same value. */
45 arg_bc = (vector bool char) {0x01, 0x23, 0x45, 0x67,
46 0x7E, 0x7C, 0x7A, 0x78,
47 0x02, 0x46, 0x7A, 0x7E,
48 0x13, 0x57, 0x7B, 0x7F};
49 expected_bc = arg_bc;
50
51 result_bc = vec_revb (arg_bc);
52
53 for (i = 0; i < 16; i++) {
54 if (result_bc[i] != expected_bc[i])
55 #ifdef DEBUG
56 printf("arg_bc[%d] = 0x%x, result_bc[%d] = 0x%x, expected_bc[%d] = 0x%x\n",
57 i, arg_bc[i], i, result_bc[i], i, expected_bc[i]);
58 #else
59 abort();
60 #endif
61 }
62
63 arg_uc = (vector unsigned char) {0x01, 0x23, 0x45, 0x67,
64 0x7E, 0x7C, 0x7A, 0x78,
65 0x02, 0x46, 0x7A, 0x7E,
66 0x13, 0x57, 0x7B, 0x7F};
67 expected_uc = arg_uc;
68
69 result_uc = vec_revb (arg_uc);
70
71 for (i = 0; i < 16; i++) {
72 if (result_uc[i] != expected_uc[i])
73 #ifdef DEBUG
74 printf("arg_uc[%d] = 0x%x, result_uc[%d] = 0x%x, expected_uc[%d] = 0x%x\n",
75 i, arg_uc[i], i, result_uc[i], i, expected_uc[i]);
76 #else
77 abort();
78 #endif
79 }
80
81 arg_sc = (vector signed char) {0x01, 0x23, 0x45, 0x67,
82 0x7E, 0x7C, 0x7A, 0x78,
83 0x02, 0x46, 0x7A, 0x7E,
84 0x13, 0x57, 0x7B, 0x7F};
85 expected_sc = arg_sc;
86
87 result_sc = vec_revb (arg_sc);
88
89 for (i = 0; i < 16; i++) {
90 if (result_sc[i] != expected_sc[i])
91 #ifdef DEBUG
92 printf("arg_sc[%d] = 0x%x, result_sc[%d] = 0x%x, expected_sc[%d] = 0x%x\n",
93 i, arg_sc[i], i, result_sc[i], i, expected_sc[i]);
94 #else
95 abort();
96 #endif
97 }
98
99 /* 16-bit ints */
100 arg_bsi = (vector bool short int) {0x0123, 0x4567, 0xFEDC, 0xBA98, 0x0246,
101 0x8ACE, 0x1357, 0x9BDF};
102 expected_bsi = (vector bool short int) {0x2301, 0x6745, 0xDCFE, 0x98BA,
103 0x4602, 0xCE8A, 0x5713, 0xDF9B};
104
105 result_bsi = vec_revb (arg_bsi);
106
107 for (i = 0; i < 8; i++) {
108 if (result_bsi[i] != expected_bsi[i])
109 #ifdef DEBUG
110 printf("arg_bsi[%d] = 0x%x, result_bsi[%d] = 0x%x, expected_bsi[%d] = 0x%x\n",
111 i, arg_bsi[i], i, result_bsi[i], i, expected_bsi[i]);
112 #else
113 abort();
114 #endif
115 }
116
117 arg_usi = (vector unsigned short int) {0x0123, 0x4567, 0xFEDC, 0xBA98,
118 0x0246, 0x8ACE, 0x1357, 0x9BDF};
119 expected_usi = (vector unsigned short int) {0x2301, 0x6745, 0xDCFE, 0x98BA,
120 0x4602, 0xCE8A, 0x5713, 0xDF9B};
121
122 result_usi = vec_revb (arg_usi);
123
124 for (i = 0; i < 8; i++) {
125 if (result_usi[i] != expected_usi[i])
126 #ifdef DEBUG
127 printf("arg_usi[%d] = 0x%x, result_usi[%d] = 0x%x, expected_usi[%d] = 0x%x\n",
128 i, arg_usi[i], i, result_usi[i], i, expected_usi[i]);
129 #else
130 abort();
131 #endif
132 }
133
134 arg_si = (vector short int) {0x0123, 0x4567, 0xFEDC, 0xBA98, 0x0246, 0x8ACE,
135 0x1357, 0x9BDF};
136 expected_si = (vector short int) {0x2301, 0x6745, 0xDCFE, 0x98BA, 0x4602,
137 0xCE8A, 0x5713, 0xDF9B};
138
139 result_si = vec_revb (arg_si);
140
141 for (i = 0; i < 8; i++) {
142 if (result_si[i] != expected_si[i])
143 #ifdef DEBUG
144 printf("arg_si[%d] = 0x%x, result_si[%d] = 0x%x, expected_si[%d] = 0x%x\n",
145 i, arg_si[i], i, result_si[i], i, expected_si[i]);
146 #else
147 abort();
148 #endif
149 }
150
151 /* 32-bit ints */
152 arg_bi = (vector bool int) {0x01234567, 0xFEDCBA98, 0x02468ACE, 0x13579BDF};
153 expected_bi = (vector bool int) {0x67452301, 0x98BADCFE, 0xCE8A4602,
154 0xDF9B5713};
155
156 result_bi = vec_revb (arg_bi);
157
158 for (i = 0; i < 4; i++) {
159 if (result_bi[i] != expected_bi[i])
160 #ifdef DEBUG
161 printf("arg_bi[%d] = 0x%x, result_bi[%d] = 0x%x, expected_bi[%d] = 0x%x\n",
162 i, arg_bi[i], i, result_bi[i], i, expected_bi[i]);
163 #else
164 abort();
165 #endif
166 }
167
168 arg_ui = (vector unsigned int) {0x01234567, 0xFEDCBA98, 0x02468ACE,
169 0x13579BDF};
170 expected_ui = (vector unsigned int) {0x67452301, 0x98BADCFE, 0xCE8A4602,
171 0xDF9B5713};
172
173 result_ui = vec_revb (arg_ui);
174
175 for (i = 0; i < 4; i++) {
176 if (result_ui[i] != expected_ui[i])
177 #ifdef DEBUG
178 printf("arg_ui[%d] = 0x%x, result_ui[%d] = 0x%x, expected_ui[%d] = 0x%x\n",
179 i, arg_ui[i], i, result_ui[i], i, expected_ui[i]);
180 #else
181 abort();
182 #endif
183 }
184
185 arg_int = (vector int) {0x01234567, 0xFEDCBA98, 0x02468ACE, 0x13579BDF};
186 expected_int = (vector int) {0x67452301, 0x98BADCFE, 0xCE8A4602, 0xDF9B5713};
187
188 result_int = vec_revb (arg_int);
189
190 for (i = 0; i < 4; i++) {
191 if (result_int[i] != expected_int[i])
192 #ifdef DEBUG
193 printf("arg_int[%d] = 0x%x, result_int[%d] = 0x%x, expected_int[%d] = 0x%x\n",
194 i, arg_int[i], i, result_int[i], i, expected_int[i]);
195 #else
196 abort();
197 #endif
198 }
199
200 /* 64-bit ints */
201 arg_blli = (vector bool long long int) {0x01234567FEDCBA98,
202 0x02468ACE13579BDF};
203 expected_blli = (vector bool long long int) {0x98BADCFE67452301,
204 0xDF9B5713CE8A4602};
205
206 result_blli = vec_revb (arg_blli);
207
208 for (i = 0; i < 2; i++) {
209 if (result_blli[i] != expected_blli[i])
210 #ifdef DEBUG
211 printf("arg_blli[%d] = 0x%x, result_blli[%d] = 0x%llx, expected_blli[%d] = 0x%llx\n",
212 i, arg_blli[i], i, result_blli[i], i, expected_blli[i]);
213 #else
214 abort();
215 #endif
216 }
217
218 arg_ulli = (vector unsigned long long int) {0x01234567FEDCBA98,
219 0x02468ACE13579BDF};
220 expected_ulli = (vector unsigned long long int) {0x98BADCFE67452301,
221 0xDF9B5713CE8A4602};
222
223 result_ulli = vec_revb (arg_ulli);
224
225 for (i = 0; i < 2; i++) {
226 if (result_ulli[i] != expected_ulli[i])
227 #ifdef DEBUG
228 printf("arg_ulli[%d] = 0x%x, result_ulli[%d] = 0x%llx, expected_ulli[%d] = 0x%llx\n",
229 i, arg_ulli[i], i, result_ulli[i], i, expected_ulli[i]);
230 #else
231 abort();
232 #endif
233 }
234
235 arg_lli = (vector long long int) {0x01234567FEDCBA98, 0x02468ACE13579BDF};
236 expected_lli = (vector long long int) {0x98BADCFE67452301,
237 0xDF9B5713CE8A4602};
238
239 result_lli = vec_revb (arg_lli);
240
241 for (i = 0; i < 2; i++) {
242 if (result_lli[i] != expected_lli[i])
243 #ifdef DEBUG
244 printf("arg_lli[%d] = 0x%x, result_lli[%d] = 0x%llx, expected_lli[%d] = 0x%llx\n",
245 i, arg_lli[i], i, result_lli[i], i, expected_lli[i]);
246 #else
247 abort();
248 #endif
249 }
250
251 /* 128-bit ints */
252 arg_uint128[0] = 0x1627384950617243;
253 arg_uint128[0] = arg_uint128[0] << 64;
254 arg_uint128[0] |= 0x9405182930415263;
255 expected_uint128[0] = 0x6352413029180594;
256 expected_uint128[0] = expected_uint128[0] << 64;
257 expected_uint128[0] |= 0x4372615049382716;
258
259 result_uint128 = vec_revb (arg_uint128);
260
261 if (result_uint128[0] != expected_uint128[0])
262 {
263 #ifdef DEBUG
264 printf("result_uint128[0] doesn't match expected_u128[0]\n");
265 printf("arg_uint128[0] = %llx ", arg_uint128[0] >> 64);
266 printf(" %llx\n", arg_uint128[0] & 0xFFFFFFFFFFFFFFFF);
267
268 printf("result_uint128[0] = %llx ", result_uint128[0] >> 64);
269 printf(" %llx\n", result_uint128[0] & 0xFFFFFFFFFFFFFFFF);
270
271 printf("expected_uint128[0] = %llx ", expected_uint128[0] >> 64);
272 printf(" %llx\n", expected_uint128[0] & 0xFFFFFFFFFFFFFFFF);
273 #else
274 abort();
275 #endif
276 }
277
278 arg_int128[0] = 0x1627384950617283;
279 arg_int128[0] = arg_int128[0] << 64;
280 arg_int128[0] |= 0x9405182930415263;
281 expected_int128[0] = 0x6352413029180594;
282 expected_int128[0] = expected_int128[0] << 64;
283 expected_int128[0] |= 0x8372615049382716;;
284
285 result_int128 = vec_revb (arg_int128);
286
287 if (result_int128[0] != expected_int128[0])
288 {
289 #ifdef DEBUG
290 printf("result_int128[0] doesn't match expected128[0]\n");
291 printf("arg_int128[0] = %llx ", arg_int128[0] >> 64);
292 printf(" %llx\n", arg_int128[0] & 0xFFFFFFFFFFFFFFFF);
293
294 printf("result_int128[0] = %llx ", result_int128[0] >> 64);
295 printf(" %llx\n", result_int128[0] & 0xFFFFFFFFFFFFFFFF);
296
297 printf("expected_int128[0] = %llx ", expected_int128[0] >> 64);
298 printf(" %llx\n", expected_int128[0] & 0xFFFFFFFFFFFFFFFF);
299 #else
300 abort();
301 #endif
302 }
303
304 /* 32-bit floats */
305 /* 0x42f7224e, 0x43e471ec, 0x49712062, 0x4a0f2b38 */
306 arg_f = (vector float) {123.567, 456.89, 987654.123456, 2345678.0};
307 /* 0x4e22F742, 0xec71e443, 0x62207149, 0x382b0f4a */
308 expected_f = (vector float) {683528320.0,
309 -1169716232068291395011477504.0,
310 739910526898278498304.0,
311 0.0000407838160754181444644927978515625};
312
313 result_f = vec_revb (arg_f);
314
315 for (i = 0; i < 4; i++) {
316 if (result_f[i] != expected_f[i])
317 #ifdef DEBUG
318 printf(" arg_f[%d] = %f, result_f[%d] = %f, expected_f[%d] = %f\n",
319 i, arg_f[i], i, result_f[i], i, expected_f[i]);
320 #else
321 abort();
322 #endif
323 }
324
325 /* 64-bit floats */
326 /* 0x419D6F34547E6B75 0x4194E5FEC781948B */
327 arg_d = (vector double) {123456789.123456789, 87654321.87654321};
328 /* 0x756B7E54346F9D41 0x8B9481C7FEE59441 */
329 expected_d = (vector double) {4.12815412905659550518671402044E257,
330 -6.99269992046390236552018719554E-253};
331
332 result_d = vec_revb (arg_d);
333
334 for (i = 0; i < 2; i++) {
335 if (result_d[i] != expected_d[i])
336 #ifdef DEBUG
337 printf("arg_d[%d] = %f, result_d[%d] = %f, expected_d[%d] = %f\n",
338 i, arg_d[i], i, result_d[i], i, expected_d[i]);
339 #else
340 abort();
341 #endif
342 }
343 }