1 /* { dg-do run } */
2 /* { dg-require-effective-target vsx_hw } */
3 /* { dg-options "-maltivec -mvsx" } */
4
5 #include <inttypes.h>
6 #include <altivec.h> // vector
7
8 #ifdef DEBUG
9 #include <stdio.h>
10 #endif
11
12 void abort (void);
13
main()14 int main() {
15 int i;
16 signed char data_c[100];
17 unsigned char data_uc[100];
18
19 signed short int data_ssi[100];
20 unsigned short int data_usi[100];
21
22 signed int data_si[100];
23 unsigned int data_ui[100];
24
25 signed long long data_sll[100];
26 unsigned long long data_ull[100];
27
28 float data_f[100];
29 double data_d[100];
30 signed long long disp;
31
32 vector signed char vec_c_expected1, vec_c_expected2, vec_c_result1, vec_c_result2;
33 vector unsigned char vec_uc_expected1, vec_uc_expected2,
34 vec_uc_result1, vec_uc_result2;
35 vector signed short int vec_ssi_expected1, vec_ssi_expected2,
36 vec_ssi_result1, vec_ssi_result2;
37 vector unsigned short int vec_usi_expected1, vec_usi_expected2,
38 vec_usi_result1, vec_usi_result2;
39 vector signed int vec_si_expected1, vec_si_expected2, vec_si_result1,
40 vec_si_result2;
41 vector unsigned int vec_ui_expected1, vec_ui_expected2, vec_ui_result1,
42 vec_ui_result2;
43 vector signed long long vec_sll_expected1, vec_sll_expected2,
44 vec_sll_result1, vec_sll_result2;
45 vector unsigned long long vec_ull_expected1, vec_ull_expected2,
46 vec_ull_result1, vec_ull_result2;
47 vector float vec_f_expected1, vec_f_expected2, vec_f_result1, vec_f_result2;
48 vector double vec_d_expected1, vec_d_expected2, vec_d_result1, vec_d_result2;
49 char buf[20];
50 signed long long zero = (signed long long) 0;
51
52 for (i = 0; i < 100; i++)
53 {
54 data_c[i] = i;
55 data_uc[i] = i+1;
56 data_ssi[i] = i+10;
57 data_usi[i] = i+11;
58 data_si[i] = i+100;
59 data_ui[i] = i+101;
60 data_sll[i] = i+1000;
61 data_ull[i] = i+1001;
62 data_f[i] = i+100000.0;
63 data_d[i] = i+1000000.0;
64 }
65
66 // vec_xl() tests
67 disp = 1;
68
69 vec_c_expected1 = (vector signed char){0, 1, 2, 3, 4, 5, 6, 7,
70 8, 9, 10, 11, 12, 13, 14, 15};
71 vec_c_result1 = vec_xl (0, data_c);
72
73 vec_c_expected2 = (vector signed char){1, 2, 3, 4, 5, 6, 7, 8, 9,
74 10, 11, 12, 13, 14, 15, 16};
75 vec_c_result2 = vec_xl (disp, data_c);
76
77 vec_uc_expected1 = (vector unsigned char){1, 2, 3, 4, 5, 6, 7, 8, 9,
78 10, 11, 12, 13, 14, 15, 16};
79 vec_uc_result1 = vec_xl (0, data_uc);
80
81 vec_uc_expected2 = (vector unsigned char){2, 3, 4, 5, 6, 7, 8, 9, 10,
82 11, 12, 13, 14, 15, 16, 17};
83 vec_uc_result2 = vec_xl (disp, data_uc);
84
85 for (i = 0; i < 16; i++)
86 {
87 if (vec_c_result1[i] != vec_c_expected1[i])
88 #ifdef DEBUG
89 printf("Error: vec_xl(), vec_c_result1[%d] = %d; vec_c_expected1[%d] = %d\n",
90 i, vec_c_result1[i], i, vec_c_expected1[i]);
91 #else
92 abort ();
93 #endif
94 if (vec_c_result2[i] != vec_c_expected2[i])
95 #ifdef DEBUG
96 printf("Error: vec_xl(), vec_c_result2[%d] = %d; vec_c_expected2[%d] = %d\n",
97 i, vec_c_result2[i], i, vec_c_expected2[i]);
98 #else
99 abort ();
100 #endif
101
102 if (vec_uc_result1[i] != vec_uc_expected1[i])
103 #ifdef DEBUG
104 printf("Error: vec_xl(), vec_uc_result1[%d] = %d; vec_uc_expected1[%d] = %d\n",
105 i, vec_uc_result1[i], i, vec_uc_expected1[i]);
106 #else
107 abort ();
108 #endif
109
110 if (vec_uc_result2[i] != vec_uc_expected2[i])
111 #ifdef DEBUG
112 printf("Error: vec_xl(), vec_uc_result2[%d] = %d; vec_uc_expected2[%d] = %d\n",
113 i, vec_uc_result2[i], i, vec_uc_expected2[i]);
114 #else
115 abort ();
116 #endif
117 }
118
119 disp = 2;
120 vec_ssi_expected1 = (vector signed short){10, 11, 12, 13, 14, 15, 16, 17};
121
122 vec_ssi_result1 = vec_xl (0, data_ssi);
123
124 vec_ssi_expected2 = (vector signed short){11, 12, 13, 14, 15, 16, 17, 18};
125 vec_ssi_result2 = vec_xl (disp, data_ssi);
126
127 vec_usi_expected1 = (vector unsigned short){11, 12, 13, 14, 15, 16, 17, 18};
128 vec_usi_result1 = vec_xl (0, data_usi);
129
130 vec_usi_expected2 = (vector unsigned short){12, 13, 14, 15, 16, 17, 18, 19};
131 vec_usi_result2 = vec_xl (disp, data_usi);
132
133
134 for (i = 0; i < 8; i++)
135 {
136 if (vec_ssi_result1[i] != vec_ssi_expected1[i])
137 #ifdef DEBUG
138 printf("Error: vec_xl(), vec_ssi_result1[%d] = %d; vec_ssi_expected1[%d] = %d\n",
139 i, vec_ssi_result1[i], i, vec_ssi_expected1[i]);
140 #else
141 abort ();
142 #endif
143 if (vec_ssi_result2[i] != vec_ssi_expected2[i])
144 #ifdef DEBUG
145 printf("Error: vec_xl(), vec_ssi_result2[%d] = %d; vec_ssi_expected2[%d] = %d\n",
146 i, vec_ssi_result2[i], i, vec_ssi_expected2[i]);
147 #else
148 abort ();
149 #endif
150
151 if (vec_usi_result1[i] != vec_usi_expected1[i])
152 #ifdef DEBUG
153 printf("Error: vec_xl(), vec_usi_result1[%d] = %d; vec_usi_expected1[%d] = %d\n",
154 i, vec_usi_result1[i], i, vec_usi_expected1[i]);
155 #else
156 abort ();
157 #endif
158
159 if (vec_usi_result2[i] != vec_usi_expected2[i])
160 #ifdef DEBUG
161 printf("Error: vec_xl(), vec_usi_result2[%d] = %d; vec_usi_expected2[%d] = %d\n",
162 i, vec_usi_result2[i], i, vec_usi_expected2[i]);
163 #else
164 abort ();
165 #endif
166 }
167
168 disp = 4;
169 vec_si_result1 = vec_xl (zero, data_si);
170 vec_si_expected1 = (vector int){100, 101, 102, 103};
171
172 vec_si_result2 = vec_xl (disp, data_si);
173 vec_si_expected2 = (vector int){101, 102, 103, 104};
174
175 vec_ui_result1 = vec_xl (zero, data_ui);
176 vec_ui_expected1 = (vector unsigned int){101, 102, 103, 104};
177
178 vec_ui_result2 = vec_xl (disp, data_ui);
179 vec_ui_expected2 = (vector unsigned int){102, 103, 104, 105};
180
181 for (i = 0; i < 4; i++)
182 {
183 if (vec_si_result1[i] != vec_si_expected1[i])
184 #ifdef DEBUG
185 printf("Error: vec_xl(), vec_si_result1[%d] = %d; vec_si_expected1[%d] = %d\n",
186 i, vec_si_result1[i], i, vec_si_expected1[i]);
187 #else
188 abort ();
189 #endif
190 if (vec_si_result2[i] != vec_si_expected2[i])
191 #ifdef DEBUG
192 printf("Error: vec_xl(), vec_si_result2[%d] = %d; vec_si_expected2[%d] = %d\n",
193 i, vec_si_result2[i], i, vec_si_expected2[i]);
194 #else
195 abort ();
196 #endif
197
198 if (vec_ui_result1[i] != vec_ui_expected1[i])
199 #ifdef DEBUG
200 printf("Error: vec_xl(), vec_ui_result1[%d] = %d; vec_ui_expected1[%d] = %d\n",
201 i, vec_ui_result1[i], i, vec_ui_expected1[i]);
202 #else
203 abort ();
204 #endif
205
206 if (vec_ui_result2[i] != vec_ui_expected2[i])
207 #ifdef DEBUG
208 printf("Error: vec_xl(), vec_ui_result2[%d] = %d; vec_ui_expected1[%d] = %d\n",
209 i, vec_si_result2[i], i, vec_ui_expected1[i]);
210 #else
211 abort ();
212 #endif
213 }
214
215 disp = 8;
216 vec_sll_result1 = vec_xl (zero, data_sll);
217 vec_sll_expected1 = (vector signed long long){1000, 1001};
218
219 vec_sll_result2 = vec_xl (disp, data_sll);
220 vec_sll_expected2 = (vector signed long long){1001, 1002};
221
222 vec_ull_result1 = vec_xl (zero, data_ull);
223 vec_ull_expected1 = (vector unsigned long long){1001, 1002};
224
225 vec_ull_result2 = vec_xl (disp, data_ull);
226 vec_ull_expected2 = (vector unsigned long long){1002, 1003};
227
228 for (i = 0; i < 2; i++)
229 {
230 if (vec_sll_result1[i] != vec_sll_expected1[i])
231 #ifdef DEBUG
232 printf("Error: vec_xl(), vec_sll_result1[%d] = %lld; vec_sll_expected1[%d] = %lld\n",
233 i, vec_sll_result1[i], i, vec_sll_expected1[i]);
234 #else
235 abort ();
236 #endif
237
238 if (vec_sll_result2[i] != vec_sll_expected2[i])
239 #ifdef DEBUG
240 printf("Error: vec_xl(), vec_sll_result2[%d] = %lld; vec_sll_expected2[%d] = %lld\n",
241 i, vec_sll_result2[i], i, vec_sll_expected2[i]);
242 #else
243 abort ();
244 #endif
245
246 if (vec_ull_result1[i] != vec_ull_expected1[i])
247 #ifdef DEBUG
248 printf("Error: vec_xl(), vec_ull_result1[%d] = %lld; vec_ull_expected1[%d] = %lld\n",
249 i, vec_ull_result1[i], i, vec_ull_expected1[i]);
250 #else
251 abort ();
252 #endif
253
254 if (vec_ull_result2[i] != vec_ull_expected2[i])
255 #ifdef DEBUG
256 printf("Error: vec_xl(), vec_ull_result2[%d] = %lld; vec_ull_expected2[%d] = %lld\n",
257 i, vec_ull_result2[i], i, vec_ull_expected2[i]);
258 #else
259 abort ();
260 #endif
261 }
262
263 disp = 4;
264 vec_f_result1 = vec_xl (zero, data_f);
265 vec_f_expected1 = (vector float){100000.0, 100001.0, 100002.0, 100003.0};
266
267 vec_f_result2 = vec_xl (disp, data_f);
268 vec_f_expected2 = (vector float){100001.0, 100002.0, 100003.0, 100004.0};
269
270 for (i = 0; i < 4; i++)
271 {
272 if (vec_f_result1[i] != vec_f_expected1[i])
273 #ifdef DEBUG
274 printf("Error: vec_xl(), vec_f_result1[%d] = %f; vec_f_expected1[%d] = %f\n",
275 i, vec_f_result1[i], i, vec_f_expected1[i]);
276 #else
277 abort ();
278 #endif
279
280 if (vec_f_result2[i] != vec_f_expected2[i])
281 #ifdef DEBUG
282 printf("Error: vec_xl(), vec_f_result2[%d] = %f; vec_f_expected2[%d] = %f\n",
283 i, vec_f_result2[i], i, vec_f_expected2[i]);
284 #else
285 abort ();
286 #endif
287 }
288
289 disp = 8;
290 vec_d_result1 = vec_xl (zero, data_d);
291 vec_d_expected1 = (vector double){1000000.0, 1000001.0};
292
293 vec_d_result2 = vec_xl (disp, data_d);
294 vec_d_expected2 = (vector double){1000001.0, 1000002.0};
295
296 for (i = 0; i < 2; i++)
297 {
298 if (vec_d_result1[i] != vec_d_expected1[i])
299 #ifdef DEBUG
300 printf("Error: vec_xl(), vec_d_result1[%d] = %f; vec_f_expected1[%d] = %f\n",
301 i, vec_d_result1[i], i, vec_d_expected1[i]);
302 #else
303 abort ();
304 #endif
305
306 if (vec_d_result2[i] != vec_d_expected2[i])
307 #ifdef DEBUG
308 printf("Error: vec_xl(), vec_d_result2[%d] = %f; vec_f_expected2[%d] = %f\n",
309 i, vec_d_result2[i], i, vec_d_expected2[i]);
310 #else
311 abort ();
312 #endif
313 }
314
315 // vec_xl_be() tests
316 disp = 1;
317 #ifdef __BIG_ENDIAN__
318 vec_c_expected1 = (vector signed char){0, 1, 2, 3, 4, 5, 6, 7,
319 8, 9, 10, 11, 12, 13, 14, 15};
320 #else
321 vec_c_expected1 = (vector signed char){15, 14, 13, 12, 11, 10, 9, 8,
322 7, 6, 5, 4, 3, 2, 1, 0};
323 #endif
324 vec_c_result1 = vec_xl_be (0, data_c);
325
326
327
328 #ifdef __BIG_ENDIAN__
329 vec_c_expected2 = (vector signed char){1, 2, 3, 4, 5, 6, 7, 8,
330 9, 10, 11, 12, 13, 14, 15, 16};
331 #else
332 vec_c_expected2 = (vector signed char){16, 15, 14, 13, 12, 11, 10, 9,
333 8, 7, 6, 5, 4, 3, 2, 1};
334 #endif
335
336 vec_c_result2 = vec_xl_be (disp, data_c);
337
338 #ifdef __BIG_ENDIAN__
339 vec_uc_expected1 = (vector unsigned char){1, 2, 3, 4, 5, 6, 7, 8,
340 9, 10, 11, 12, 13, 14, 15, 16};
341 #else
342 vec_uc_expected1 = (vector unsigned char){16, 15, 14, 13, 12, 11, 10, 9,
343 8, 7, 6, 5, 4, 3, 2, 1};
344 #endif
345
346 vec_uc_result1 = vec_xl_be (0, data_uc);
347
348 #ifdef __BIG_ENDIAN__
349 vec_uc_expected2 = (vector unsigned char){2, 3, 4, 5, 6, 7, 8, 9,
350 10, 11, 12, 13, 14, 15, 16, 17};
351 #else
352 vec_uc_expected2 = (vector unsigned char){17, 16, 15, 14, 13, 12, 11, 10,
353 9, 8, 7, 6, 5, 4, 3, 2};
354 #endif
355
356 vec_uc_result2 = vec_xl_be (disp, data_uc);
357
358 for (i = 0; i < 16; i++)
359 {
360 if (vec_c_result1[i] != vec_c_expected1[i])
361 #ifdef DEBUG
362 printf("Error: vec_xl_be(), vec_c_result1[%d] = %d; vec_c_expected1[%d] = %d\n",
363 i, vec_c_result1[i], i, vec_c_expected1[i]);
364 #else
365 abort ();
366 #endif
367
368 if (vec_c_result2[i] != vec_c_expected2[i])
369 #ifdef DEBUG
370 printf("Error: vec_xl_be(), vec_c_result2[%d] = %d; vec_c_expected2[%d] = %d\n",
371 i, vec_c_result2[i], i, vec_c_expected2[i]);
372 #else
373 abort ();
374 #endif
375
376 if (vec_uc_result1[i] != vec_uc_expected1[i])
377 #ifdef DEBUG
378 printf("Error: vec_xl_be(), vec_uc_result1[%d] = %d; vec_uc_expected1[%d] = %d\n",
379 i, vec_uc_result1[i], i, vec_uc_expected1[i]);
380 #else
381 abort ();
382 #endif
383
384 if (vec_uc_result2[i] != vec_uc_expected2[i])
385 #ifdef DEBUG
386 printf("Error: vec_xl_be(), vec_uc_result2[%d] = %d; vec_uc_expected2[%d] = %d\n",
387 i, vec_uc_result1[i], i, vec_uc_expected1[i]);
388 #else
389 abort ();
390 #endif
391 }
392
393 vec_ssi_result1 = vec_xl_be (zero, data_ssi);
394
395 #ifdef __BIG_ENDIAN__
396 vec_ssi_expected1 = (vector signed short){10, 11, 12, 13, 14, 15, 16, 17};
397 #else
398 vec_ssi_expected1 = (vector signed short){17, 16, 15, 14, 13, 12, 11, 10};
399 #endif
400
401 disp = 2;
402 vec_ssi_result2 = vec_xl_be (disp, data_ssi);
403
404 #ifdef __BIG_ENDIAN__
405 vec_ssi_expected2 = (vector signed short){11, 12, 13, 14, 15, 16, 17, 18};
406 #else
407 vec_ssi_expected2 = (vector signed short){18, 17, 16, 15, 14, 13, 12, 11};
408 #endif
409
410 vec_usi_result1 = vec_xl_be (zero, data_usi);
411
412 #ifdef __BIG_ENDIAN__
413 vec_usi_expected1 = (vector unsigned short){11, 12, 13, 14, 15, 16, 17, 18};
414 #else
415 vec_usi_expected1 = (vector unsigned short){18, 17, 16, 15, 14, 13, 12, 11};
416 #endif
417
418 disp = 2;
419 vec_usi_result2 = vec_xl_be (disp, data_usi);
420
421 #ifdef __BIG_ENDIAN__
422 vec_usi_expected2 = (vector unsigned short){12, 13, 14, 15, 16, 17, 18, 19};
423 #else
424 vec_usi_expected2 = (vector unsigned short){19, 18, 17, 16, 15, 14, 13, 12};
425 #endif
426
427 for (i = 0; i < 8; i++)
428 {
429 if (vec_ssi_result1[i] != vec_ssi_expected1[i])
430 #ifdef DEBUG
431 printf("Error: vec_xl_be(), vec_ssi_result1[%d] = %d; vec_ssi_expected1[%d] = %d\n",
432 i, vec_ssi_result1[i], i, vec_ssi_expected1[i]);
433 #else
434 abort ();
435 #endif
436
437 if (vec_ssi_result2[i] != vec_ssi_expected2[i])
438 #ifdef DEBUG
439 printf("Error: vec_xl_be(), vec_ssi_result2[%d] = %d; vec_ssi_expected2[%d] = %d\n",
440 i, vec_ssi_result2[i], i, vec_ssi_expected2[i]);
441 #else
442 abort ();
443 #endif
444
445 if (vec_usi_result1[i] != vec_usi_expected1[i])
446 #ifdef DEBUG
447 printf("Error: vec_xl_be(), vec_usi_result1[%d] = %d; vec_usi_expected1[%d] = %d\n",
448 i, vec_usi_result1[i], i, vec_usi_expected1[i]);
449 #else
450 abort ();
451 #endif
452
453 if (vec_usi_result2[i] != vec_usi_expected2[i])
454 #ifdef DEBUG
455 printf("Error: vec_xl_be(), vec_usi_result2[%d] = %d; vec_usi_expected2[%d] = %d\n",
456 i, vec_usi_result2[i], i, vec_usi_expected2[i]);
457 #else
458 abort ();
459 #endif
460 }
461
462 vec_si_result1 = vec_xl_be (zero, data_si);
463
464 #ifdef __BIG_ENDIAN__
465 vec_si_expected1 = (vector int){100, 101, 102, 103};
466 #else
467 vec_si_expected1 = (vector int){103, 102, 101, 100};
468 #endif
469
470 disp = 4;
471 vec_si_result2 = vec_xl_be (disp, data_si);
472
473 #ifdef __BIG_ENDIAN__
474 vec_si_expected2 = (vector int){101, 102, 103, 104};
475 #else
476 vec_si_expected2 = (vector int){104, 103, 102, 101};
477 #endif
478
479 vec_ui_result1 = vec_xl_be (zero, data_ui);
480
481 #ifdef __BIG_ENDIAN__
482 vec_ui_expected1 = (vector unsigned int){101, 102, 103, 104};
483 #else
484 vec_ui_expected1 = (vector unsigned int){104, 103, 102, 101};
485 #endif
486
487 disp = 4;
488 vec_ui_result2 = vec_xl_be (disp, data_ui);
489
490 #ifdef __BIG_ENDIAN__
491 vec_ui_expected2 = (vector unsigned int){102, 103, 104, 105};
492 #else
493 vec_ui_expected2 = (vector unsigned int){105, 104, 103, 102};
494 #endif
495
496
497 for (i = 0; i < 4; i++)
498 {
499 if (vec_si_result1[i] != vec_si_expected1[i])
500 #ifdef DEBUG
501 printf("Error: vec_xl_be(), vec_si_result1[%d] = %d; vec_si_expected1[%d] = %d\n",
502 i, vec_si_result1[i], i, vec_si_expected1[i]);
503 #else
504 abort ();
505 #endif
506
507 if (vec_si_result2[i] != vec_si_expected2[i])
508 #ifdef DEBUG
509 printf("Error: vec_xl_be(), vec_si_result2[%d] = %d; vec_si_expected2[%d] = %d\n",
510 i, vec_si_result2[i], i, vec_si_expected2[i]);
511 #else
512 abort ();
513 #endif
514
515 if (vec_ui_result1[i] != vec_ui_expected1[i])
516 #ifdef DEBUG
517 printf("Error: vec_xl_be(), vec_ui_result1[%d] = %d; vec_ui_expected1[%d] = %d\n",
518 i, vec_ui_result1[i], i, vec_ui_expected1[i]);
519 #else
520 abort ();
521 #endif
522
523 if (vec_ui_result2[i] != vec_ui_expected2[i])
524 #ifdef DEBUG
525 printf("Error: vec_xl_be(), vec_ui_result2[%d] = %d; vec_ui_expected2[%d] = %d\n",
526 i, vec_ui_result2[i], i, vec_ui_expected2[i]);
527 #else
528 abort ();
529 #endif
530 }
531
532 vec_sll_result1 = vec_xl_be (zero, data_sll);
533
534 #ifdef __BIG_ENDIAN__
535 vec_sll_expected1 = (vector signed long long){1000, 1001};
536 #else
537 vec_sll_expected1 = (vector signed long long){1001, 1000};
538 #endif
539
540 disp = 8;
541 vec_sll_result2 = vec_xl_be (disp, data_sll);
542
543 #ifdef __BIG_ENDIAN__
544 vec_sll_expected2 = (vector signed long long){1001, 1002};
545 #else
546 vec_sll_expected2 = (vector signed long long){1002, 1001};
547 #endif
548
549 vec_ull_result1 = vec_xl_be (zero, data_ull);
550
551 #ifdef __BIG_ENDIAN__
552 vec_ull_expected1 = (vector unsigned long long){1001, 1002};
553 #else
554 vec_ull_expected1 = (vector unsigned long long){1002, 1001};
555 #endif
556
557 disp = 8;
558 vec_ull_result2 = vec_xl_be (disp, data_ull);
559
560 #ifdef __BIG_ENDIAN__
561 vec_ull_expected2 = (vector unsigned long long){1002, 1003};
562 #else
563 vec_ull_expected2 = (vector unsigned long long){1003, 1002};
564 #endif
565
566
567 for (i = 0; i < 2; i++)
568 {
569 if (vec_sll_result1[i] != vec_sll_expected1[i])
570 #ifdef DEBUG
571 printf("Error: vec_xl_be(), vec_sll_result1[%d] = %lld; vec_sll_expected1[%d] = %d\n",
572 i, vec_sll_result1[i], i, vec_sll_expected1[i]);
573 #else
574 abort ();
575 #endif
576
577 if (vec_sll_result2[i] != vec_sll_expected2[i])
578 #ifdef DEBUG
579 printf("Error: vec_xl_be(), vec_sll_result2[%d] = %lld; vec_sll_expected2[%d] = %d\n",
580 i, vec_sll_result2[i], i, vec_sll_expected2[i]);
581 #else
582 abort ();
583 #endif
584
585 if (vec_ull_result1[i] != vec_ull_expected1[i])
586 #ifdef DEBUG
587 printf("Error: vec_xl_be(), vec_ull_result1[%d] = %lld; vec_ull_expected1[%d] = %d\n",
588 i, vec_ull_result1[i], i, vec_ull_expected1[i]);
589 #else
590 abort ();
591 #endif
592
593 if (vec_ull_result2[i] != vec_ull_expected2[i])
594 #ifdef DEBUG
595 printf("Error: vec_xl_be(), vec_ull_result2[%d] = %lld; vec_ull_expected2[%d] = %d\n",
596 i, vec_ull_result2[i], i, vec_sll_expected2[i]);
597 #else
598 abort ();
599 #endif
600 }
601
602 vec_f_result1 = vec_xl_be (zero, data_f);
603
604 #ifdef __BIG_ENDIAN__
605 vec_f_expected1 = (vector float){100000.0, 100001.0, 100002.0, 100003.0};
606 #else
607 vec_f_expected1 = (vector float){100003.0, 100002.0, 100001.0, 100000.0};
608 #endif
609
610 disp = 4;
611 vec_f_result2 = vec_xl_be (disp, data_f);
612
613 #ifdef __BIG_ENDIAN__
614 vec_f_expected2 = (vector float){100001.0, 100002.0, 100003.0, 100004.0};
615 #else
616 vec_f_expected2 = (vector float){100004.0, 100003.0, 100002.0, 100001.0};
617 #endif
618
619 for (i = 0; i < 4; i++)
620 {
621 if (vec_f_result1[i] != vec_f_expected1[i])
622 #ifdef DEBUG
623 printf("Error: vec_xl_be(), vec_f_result1[%d] = %f; vec_f_expected1[%d] = %f\n",
624 i, vec_f_result1[i], i, vec_f_expected1[i]);
625 #else
626 abort ();
627 #endif
628
629 if (vec_f_result2[i] != vec_f_expected2[i])
630 #ifdef DEBUG
631 printf("Error: vec_xl_be(), vec_f_result2[%d] = %f; vec_f_expected2[%d] = %f\n",
632 i, vec_f_result2[i], i, vec_f_expected2[i]);
633 #else
634 abort ();
635 #endif
636 }
637
638 vec_d_result1 = vec_xl_be (zero, data_d);
639
640 #ifdef __BIG_ENDIAN__
641 vec_d_expected1 = (vector double){1000000.0, 1000001.0};
642 #else
643 vec_d_expected1 = (vector double){1000001.0, 1000000.0};
644 #endif
645
646 disp = 8;
647 vec_d_result2 = vec_xl_be (disp, data_d);
648
649 #ifdef __BIG_ENDIAN__
650 vec_d_expected2 = (vector double){1000001.0, 1000002.0};
651 #else
652 vec_d_expected2 = (vector double){1000002.0, 1000001.0};
653 #endif
654
655 for (i = 0; i < 2; i++)
656 {
657 if (vec_d_result1[i] != vec_d_expected1[i])
658 #ifdef DEBUG
659 printf("Error: vec_xl_be(), vec_d_result2[%d] = %f; vec_d_expected2[%d] = %f\n",
660 i, vec_d_result2[i], i, vec_d_expected2[i]);
661 #else
662 abort ();
663 #endif
664
665 if (vec_d_result2[i] != vec_d_expected2[i])
666 #ifdef DEBUG
667 printf("Error: vec_xl_be(), vec_d_result2[%d] = %f; vec_d_expected2[%d] = %f\n",
668 i, vec_d_result2[i], i, vec_d_expected2[i]);
669 #else
670 abort ();
671 #endif
672 }
673 }
674