Debian Codegraph @

gcc/testsuite/gcc.target/powerpc/builtins-6-p9-runnable.c

raw
1 /* { dg-do run } */
2 /* { dg-require-effective-target p9vector_hw } */
3 /* { dg-require-effective-target int128 } */
4 /* { dg-options "-mdejagnu-cpu=power9 -O2" } */
5
6 #include <stdint.h>
7 #include <stdio.h>
8 #include <inttypes.h>
9 #include <altivec.h> // vector
10
11 #define TRUE 1
12 #define FALSE 0
13
14 #ifdef DEBUG
15 #include <stdio.h>
16 #endif
17
18 void abort (void);
19
20 int result_wrong_sc (vector signed char vec_expected,
21 vector signed char vec_actual)
22 {
23 int i;
24
25 for (i = 0; i < 16; i++)
26 if (vec_expected[i] != vec_actual[i])
27 return TRUE;
28
29 return FALSE;
30 }
31
32 int result_wrong_uc (vector unsigned char vec_expected,
33 vector unsigned char vec_actual)
34 {
35 int i;
36
37 for (i = 0; i < 16; i++)
38 if (vec_expected[i] != vec_actual[i])
39 return TRUE;
40
41 return FALSE;
42 }
43
44 int result_wrong_us (vector unsigned short vec_expected,
45 vector unsigned short vec_actual)
46 {
47 int i;
48
49 for (i = 0; i < 8; i++)
50 if (vec_expected[i] != vec_actual[i])
51 return TRUE;
52
53 return FALSE;
54 }
55
56 int result_wrong_ss (vector signed short vec_expected,
57 vector signed short vec_actual)
58 {
59 int i;
60
61 for (i = 0; i < 8; i++)
62 if (vec_expected[i] != vec_actual[i])
63 return TRUE;
64
65 return FALSE;
66 }
67
68 int result_wrong_ui (vector unsigned int vec_expected,
69 vector unsigned int vec_actual)
70 {
71 int i;
72
73 for (i = 0; i < 4; i++)
74 if (vec_expected[i] != vec_actual[i])
75 return TRUE;
76
77 return FALSE;
78 }
79
80 int result_wrong_ull (vector unsigned long long vec_expected,
81 vector unsigned long long vec_actual)
82 {
83 int i;
84
85 for (i = 0; i < 2; i++)
86 if (vec_expected[i] != vec_actual[i])
87 return TRUE;
88
89 return FALSE;
90 }
91
92 int result_wrong_sll (vector signed long long vec_expected,
93 vector signed long long vec_actual)
94 {
95 int i;
96
97 for (i = 0; i < 2; i++)
98 {
99 if (vec_expected[i] != vec_actual[i])
100 return TRUE;
101 }
102
103 return FALSE;
104 }
105
106 int result_wrong_si (vector signed int vec_expected,
107 vector signed int vec_actual)
108 {
109 int i;
110
111 for (i = 0; i < 4; i++)
112 if (vec_expected[i] != vec_actual[i])
113 return TRUE;
114
115 return FALSE;
116 }
117
118 int result_wrong_u128 (vector __uint128_t vec_expected,
119 vector __uint128_t vec_actual)
120 {
121 int i;
122
123 if (vec_expected[0] != vec_actual[0])
124 return TRUE;
125
126 return FALSE;
127 }
128
129 int result_wrong_s128 (vector __int128_t vec_expected,
130 vector __int128_t vec_actual)
131 {
132 int i;
133
134 if (vec_expected[0] != vec_actual[0])
135 return TRUE;
136
137 return FALSE;
138 }
139
140 int result_wrong_d (vector double vec_expected,
141 vector double vec_actual)
142 {
143 int i;
144
145 for (i = 0; i < 2; i++)
146 if (vec_expected[i] != vec_actual[i])
147 return TRUE;
148
149 return FALSE;
150 }
151
152 int result_wrong_f (vector float vec_expected,
153 vector float vec_actual)
154 {
155 int i;
156
157 for (i = 0; i < 4; i++)
158 if (vec_expected[i] != vec_actual[i])
159 return TRUE;
160
161 return FALSE;
162 }
163
164 #ifdef DEBUG
165 void print_sc (vector signed char vec_expected,
166 vector signed char vec_actual)
167 {
168 int i;
169
170 printf("expected signed char data\n");
171 for (i = 0; i < 16; i++)
172 printf(" %d,", vec_expected[i]);
173
174 printf("\nactual signed char data\n");
175 for (i = 0; i < 16; i++)
176 printf(" %d,", vec_actual[i]);
177 printf("\n");
178 }
179
180 void print_uc (vector unsigned char vec_expected,
181 vector unsigned char vec_actual)
182 {
183 int i;
184
185 printf("expected signed char data\n");
186 for (i = 0; i < 16; i++)
187 printf(" %d,", vec_expected[i]);
188
189 printf("\nactual signed char data\n");
190 for (i = 0; i < 16; i++)
191 printf(" %d,", vec_actual[i]);
192 printf("\n");
193 }
194
195 void print_us (vector unsigned short vec_expected,
196 vector unsigned short vec_actual)
197 {
198 int i;
199
200 printf("expected unsigned short data\n");
201 for (i = 0; i < 8; i++)
202 printf(" %d,", vec_expected[i]);
203
204 printf("\nactual unsigned short data\n");
205 for (i = 0; i < 8; i++)
206 printf(" %d,", vec_actual[i]);
207 printf("\n");
208 }
209
210 void print_ss (vector signed short vec_expected,
211 vector signed short vec_actual)
212 {
213 int i;
214
215 printf("expected signed short data\n");
216 for (i = 0; i < 8; i++)
217 printf(" %d,", vec_expected[i]);
218
219 printf("\nactual signed short data\n");
220 for (i = 0; i < 8; i++)
221 printf(" %d,", vec_actual[i]);
222 printf("\n");
223 }
224
225 void print_ui (vector unsigned int vec_expected,
226 vector unsigned int vec_actual)
227 {
228 int i;
229
230 printf("expected unsigned int data\n");
231 for (i = 0; i < 4; i++)
232 printf(" %d,", vec_expected[i]);
233
234 printf("\nactual unsigned int data\n");
235 for (i = 0; i < 4; i++)
236 printf(" %d,", vec_actual[i]);
237 printf("\n");
238 }
239
240 void print_si (vector signed int vec_expected,
241 vector signed int vec_actual)
242 {
243 int i;
244
245 printf("expected signed int data\n");
246 for (i = 0; i < 4; i++)
247 printf(" %d,", vec_expected[i]);
248
249 printf("\nactual signed int data\n");
250 for (i = 0; i < 4; i++)
251 printf(" %d,", vec_actual[i]);
252 printf("\n");
253 }
254
255 void print_ull (vector unsigned long long vec_expected,
256 vector unsigned long long vec_actual)
257 {
258 int i;
259
260 printf("expected unsigned long long data\n");
261 for (i = 0; i < 2; i++)
262 printf(" %llu,", vec_expected[i]);
263
264 printf("\nactual unsigned long long data\n");
265 for (i = 0; i < 2; i++)
266 printf(" %llu,", vec_actual[i]);
267 printf("\n");
268 }
269
270 void print_sll (vector signed long long vec_expected,
271 vector signed long long vec_actual)
272 {
273 int i;
274
275 printf("expected signed long long data\n");
276 for (i = 0; i < 2; i++)
277 printf(" %lld,", vec_expected[i]);
278
279 printf("\nactual signed long long data\n");
280 for (i = 0; i < 2; i++)
281 printf(" %lld,", vec_actual[i]);
282 printf("\n");
283 }
284
285 void print_u128 (vector __uint128_t vec_expected,
286 vector __uint128_t vec_actual)
287 {
288 printf("expected uint128 data\n");
289 printf(" %llu%llu\n", (unsigned long long)(vec_expected[0] >> 64),
290 (unsigned long long)(vec_expected[0] & 0xFFFFFFFFFFFFFFFF));
291
292 printf("\nactual uint128 data\n");
293 printf(" %llu%llu\n", (unsigned long long)(vec_actual[0] >> 64),
294 (unsigned long long)(vec_actual[0] & 0xFFFFFFFFFFFFFFFF));
295 }
296
297 void print_s128 (vector __int128 vec_expected,
298 vector __int128 vec_actual)
299 {
300 printf("expected int128 data\n");
301 printf(" %lld%llu\n", (signed long long)(vec_expected[0] >> 64),
302 (unsigned long long)(vec_expected[0] & 0xFFFFFFFFFFFFFFFF));
303
304 printf("\nactual int128 data\n");
305 printf(" %lld%llu\n", (signed long long)(vec_actual[0] >> 64),
306 (unsigned long long)(vec_actual[0] & 0xFFFFFFFFFFFFFFFF));
307 }
308
309 void print_d (vector double vec_expected,
310 vector double vec_actual)
311 {
312 int i;
313
314 printf("expected double data\n");
315 for (i = 0; i < 2; i++)
316 printf(" %f,", vec_expected[i]);
317
318 printf("\nactual double data\n");
319 for (i = 0; i < 2; i++)
320 printf(" %f,", vec_actual[i]);
321 printf("\n");
322 }
323
324 void print_f (vector float vec_expected,
325 vector float vec_actual)
326 {
327 int i;
328
329 printf("expected float data\n");
330 for (i = 0; i < 4; i++)
331 printf(" %f,", vec_expected[i]);
332
333 printf("\nactual float data\n");
334 for (i = 0; i < 4; i++)
335 printf(" %f,", vec_actual[i]);
336 printf("\n");
337 }
338 #endif
339
340 typedef union
341 {
342 vector __int128_t i1;
343 __int128_t i2;
344 vector __uint128_t u1;
345 __uint128_t u2;
346 struct
347 {
348 long long d1;
349 long long d2;
350 };
351 } U128;
352
353 /* For a given long long VALUE, ensure it's stored from the beginning
354 of {u,}int128 memory storage (the low address), it avoids to load
355 unexpected data without the whole vector length. */
356
357 static inline void
358 getU128 (U128 *pu, unsigned long long value)
359 {
360 pu->d1 = value;
361 pu->d2 = 0;
362 }
363
364 int main() {
365 int i, j;
366 size_t len;
367 signed char data_c[100];
368 vector signed char input_c;
369 unsigned char data_uc[100];
370 vector unsigned char input_uc;
371
372 signed short int data_ssi[100];
373 vector signed short int input_ssi;
374 unsigned short int data_usi[100];
375 vector unsigned short int input_usi;
376
377 signed int data_si[100];
378 vector signed int input_si;
379 unsigned int data_ui[100];
380 vector unsigned int input_ui;
381
382 signed long long data_sll[100];
383 vector signed long long input_sll;
384 unsigned long long data_ull[100];
385 vector unsigned long long int input_ull;
386
387 float data_f[100];
388 vector float input_f;
389 double data_d[100];
390 vector double input_d;
391 __uint128_t data_u128[100];
392 vector __uint128_t input_u128;
393 __int128_t data_128[100];
394 vector __int128_t input_128;
395
396 vector signed char store_data_sc;
397 vector unsigned char store_data_uc;
398 vector signed int store_data_si;
399 vector unsigned int store_data_ui;
400 vector __int128_t store_data_s128;
401 vector __uint128_t store_data_u128;
402 vector signed long long int store_data_sll;
403 vector unsigned long long int store_data_ull;
404 vector signed short store_data_ss;
405 vector unsigned short store_data_us;
406 vector double store_data_d;
407 vector float store_data_f;
408
409 signed char *address_sc;
410 unsigned char *address_uc;
411 signed int *address_si;
412 unsigned int *address_ui;
413 __int128_t *address_s128;
414 __uint128_t *address_u128;
415 signed long long int *address_sll;
416 unsigned long long int *address_ull;
417 signed short int *address_ss;
418 unsigned short int *address_us;
419 double *address_d;
420 float *address_f;
421
422 vector unsigned char *datap;
423
424 vector unsigned char vec_uc_expected1, vec_uc_result1;
425 vector signed char vec_sc_expected1, vec_sc_result1;
426 vector signed int vec_si_expected1, vec_si_result1;
427 vector unsigned int vec_ui_expected1, vec_ui_result1;
428 vector __int128_t vec_s128_expected1, vec_s128_result1;
429 vector __uint128_t vec_u128_expected1, vec_u128_result1;
430 vector signed long long int vec_sll_expected1, vec_sll_result1;
431 vector unsigned long long int vec_ull_expected1, vec_ull_result1;
432 vector signed short int vec_ss_expected1, vec_ss_result1;
433 vector unsigned short int vec_us_expected1, vec_us_result1;
434 vector double vec_d_expected1, vec_d_result1;
435 vector float vec_f_expected1, vec_f_result1;
436
437 signed long long disp;
438
439 /* VEC_XST_LEN, ISA 3.0 */
440 len = 16;
441 vec_sc_expected1 = (vector signed char){ -7, -6, -5, -4, -3, -2, -1, 0,
442 1, 2, 3, 4, 5, 6, 7, 8 };
443 store_data_sc = (vector signed char){ -7, -6, -5, -4, -3, -2, -1, 0,
444 1, 2, 3, 4, 5, 6, 7, 8 };
445 vec_sc_result1 = (vector signed char){ 0, 0, 0, 0, 0, 0, 0, 0,
446 0, 0, 0, 0, 0, 0, 0, 0 };
447
448 address_sc = &vec_sc_result1[0];
449
450 vec_xst_len (store_data_sc, address_sc, len);
451
452 if (result_wrong_sc (vec_sc_expected1, vec_sc_result1))
453 {
454 #ifdef DEBUG
455 printf("Error: vec_xst_len, len = %d, sc result does not match expected result\n", len);
456 print_sc (vec_sc_expected1, vec_sc_result1);
457 #else
458 abort();
459 #endif
460 }
461
462 len = 12;
463 vec_sc_expected1 = (vector signed char){ -7, -6, -5, -4, -3, -2, -1, 0,
464 1, 2, 3, 4, 0, 0, 0, 0 };
465 store_data_sc = (vector signed char){ -7, -6, -5, -4, -3, -2, -1, 0,
466 1, 2, 3, 4, 5, 6, 7, 8 };
467 vec_sc_result1 = (vector signed char){ 0, 0, 0, 0, 0, 0, 0, 0,
468 0, 0, 0, 0, 0, 0, 0, 0 };
469
470 address_sc = &vec_sc_result1[0];
471
472 vec_xst_len (store_data_sc, address_sc, len);
473
474 if (result_wrong_sc (vec_sc_expected1, vec_sc_result1))
475 {
476 #ifdef DEBUG
477 printf("Error: vec_xst_len, len = %d, sc result does not match expected result\n",
478 len);
479 print_sc (vec_sc_expected1, vec_sc_result1);
480 #else
481 abort();
482 #endif
483 }
484
485 len = 16;
486 vec_uc_expected1 = (vector unsigned char){ 0, 1, 2, 3, 4, 5, 6, 7,
487 8, 9, 10, 11, 12, 13, 14, 15 };
488
489 store_data_uc = (vector unsigned char){ 0, 1, 2, 3, 4, 5, 6, 7,
490 8, 9, 10, 11, 12, 13, 14, 15 };
491
492 vec_uc_result1 = (vector unsigned char){ 0, 0, 0, 0, 0, 0, 0, 0,
493 0, 0, 0, 0, 0, 0, 0, 0 };
494
495 address_uc = &vec_uc_result1[0];
496
497 vec_xst_len (store_data_uc, address_uc, len);
498
499 if (result_wrong_uc (vec_uc_expected1, vec_uc_result1))
500 {
501 #ifdef DEBUG
502 printf("Error: vec_xst_len, len = %d, uc result does not match expected result\n",
503 len);
504 print_uc (vec_uc_expected1, vec_uc_result1);
505 #else
506 abort();
507 #endif
508 }
509
510 len = 4;
511 vec_uc_expected1 = (vector unsigned char){ 0, 1, 2, 3, 0, 0, 0, 0,
512 0, 0, 0, 0, 0, 0, 0, 0 };
513 store_data_uc = (vector unsigned char){ 0, 1, 2, 3, 4, 5, 6, 7,
514 8, 9, 10, 11, 12, 13, 14, 15 };
515 vec_uc_result1 = (vector unsigned char){ 0, 0, 0, 0, 0, 0, 0, 0,
516 0, 0, 0, 0, 0, 0, 0, 0 };
517
518 address_uc = &vec_uc_result1[0];
519
520 vec_xst_len (store_data_uc, address_uc, len);
521
522 if (result_wrong_uc (vec_uc_expected1, vec_uc_result1))
523 {
524 #ifdef DEBUG
525 printf("Error: vec_xst_len, len = %d, uc result does not match expected result\n",
526 len);
527 print_uc (vec_uc_expected1, vec_uc_result1);
528 #else
529 abort();
530 #endif
531 }
532
533 len = 16;
534 vec_ss_expected1 = (vector signed short int){ 10, 20, 30, 40,
535 50, 60, 70, 80 };
536 store_data_ss = (vector signed short int){ 10, 20, 30, 40,
537 50, 60, 70, 80 };
538 vec_ss_result1 = (vector signed short int){ 0, 0, 0, 0, 0, 0, 0, 0};
539
540 address_ss = &vec_ss_result1[0];
541
542 vec_xst_len (store_data_ss, address_ss, len);
543
544 if (result_wrong_ss (vec_ss_expected1, vec_ss_result1))
545 {
546 #ifdef DEBUG
547 printf("Error: vec_xst_len, len = %d, ss result does not match expected result\n",
548 len);
549 print_ss (vec_ss_expected1, vec_ss_result1);
550 #else
551 abort();
552 #endif
553 }
554
555 len = 14;
556 vec_ss_expected1 = (vector signed short int){ 10, 20, 30, 40,
557 50, 60, 70, 0 };
558 store_data_ss = (vector signed short int){ 10, 20, 30, 40,
559 50, 60, 70, 80 };
560 vec_ss_result1 = (vector signed short int){ 0, 0, 0, 0, 0, 0, 0, 0};
561
562 address_ss = &vec_ss_result1[0];
563
564 vec_xst_len (store_data_ss, address_ss, len);
565
566 if (result_wrong_ss (vec_ss_expected1, vec_ss_result1))
567 {
568 #ifdef DEBUG
569 printf("Error: vec_xst_len, len = %d, ss result does not match expected result\n",
570 len);
571 print_ss (vec_ss_expected1, vec_ss_result1);
572 #else
573 abort();
574 #endif
575 }
576
577 len = 16;
578 vec_us_expected1 = (vector unsigned short int){ 10, 20, 30, 40,
579 50, 60, 70, 80 };
580 store_data_us = (vector unsigned short int){ 10, 20, 30, 40,
581 50, 60, 70, 80 };
582 vec_us_result1 = (vector unsigned short int){ 0, 0, 0, 0, 0, 0, 0, 0};
583
584 address_us = &vec_us_result1[0];
585
586 vec_xst_len (store_data_us, address_us, len);
587
588 if (result_wrong_us (vec_us_expected1, vec_us_result1))
589 {
590 #ifdef DEBUG
591 printf("Error: vec_xst_len, len = %d, us result does not match expected result\n",
592 len);
593 print_us (vec_us_expected1, vec_us_result1);
594 #else
595 abort();
596 #endif
597 }
598
599 len = 2;
600 vec_us_expected1 = (vector unsigned short int){ 10, 0, 0, 0,
601 0, 0, 0, 0 };
602 store_data_us = (vector unsigned short int){ 10, 20, 30, 40,
603 50, 60, 70, 80 };
604 vec_us_result1 = (vector unsigned short int){ 0, 0, 0, 0, 0, 0, 0, 0};
605
606 address_us = &vec_us_result1[0];
607
608 vec_xst_len (store_data_us, address_us, len);
609
610 if (result_wrong_us (vec_us_expected1, vec_us_result1))
611 {
612 #ifdef DEBUG
613 printf("Error: vec_xst_len, len = %d, us result does not match expected result\n",
614 len);
615 print_us (vec_us_expected1, vec_us_result1);
616 #else
617 abort();
618 #endif
619 }
620
621 len = 16;
622 vec_si_expected1 = (vector signed int){ -30, -10, 0, 10 };
623 store_data_si = (vector signed int){ -30, -10, 0, 10 };
624 vec_si_result1 = (vector signed int){ 0, 0, 0, 0};
625
626 address_si = &vec_si_result1[0];
627
628 vec_xst_len (store_data_si, address_si, len);
629
630 if (result_wrong_si (vec_si_expected1, vec_si_result1))
631 {
632 #ifdef DEBUG
633 printf("Error: vec_xst_len, len = %d, si result does not match expected result\n",
634 len);
635 print_si (vec_si_expected1, vec_si_result1);
636 #else
637 abort();
638 #endif
639 }
640
641 len = 8;
642 vec_si_expected1 = (vector signed int){ -30, -10, 0, 0 };
643 store_data_si = (vector signed int){ -30, -10, 0, 10 };
644 vec_si_result1 = (vector signed int){ 0, 0, 0, 0};
645
646 address_si = &vec_si_result1[0];
647
648 vec_xst_len (store_data_si, address_si, len);
649
650 if (result_wrong_si (vec_si_expected1, vec_si_result1))
651 {
652 #ifdef DEBUG
653 printf("Error: vec_xst_len, len = %d, si result does not match expected result\n",
654 len);
655 print_si (vec_si_expected1, vec_si_result1);
656 #else
657 abort();
658 #endif
659 }
660
661 len = 16;
662 vec_sll_expected1 = (vector signed long long int){ -3000, 10000 };
663 store_data_sll = (vector signed long long int){ -3000, 10000 };
664 vec_sll_result1 = (vector signed long long int){ 0, 0};
665
666 address_sll = (signed long long *)&vec_sll_result1[0];
667
668 vec_xst_len (store_data_sll, address_sll, len);
669
670 if (result_wrong_sll (vec_sll_expected1, vec_sll_result1) == TRUE)
671 {
672 #ifdef DEBUG
673 printf("Error: vec_xst_len, len = %d, sll result does not match expected result\n",
674 len);
675 print_sll (vec_sll_expected1, vec_sll_result1);
676 #else
677 abort();
678 #endif
679 }
680
681 len = 8;
682 vec_sll_expected1 = (vector signed long long int){ -3000, 0 };
683 store_data_sll = (vector signed long long int){ -3000, 10000 };
684 vec_sll_result1 = (vector signed long long int){ 0, 0};
685
686 address_sll = (signed long long *)&vec_sll_result1[0];
687
688 vec_xst_len (store_data_sll, address_sll, len);
689
690 if (result_wrong_sll (vec_sll_expected1, vec_sll_result1))
691 {
692 #ifdef DEBUG
693 printf("Error: vec_xst_len, len = %d, sll result does not match expected result\n",
694 len);
695 print_sll (vec_sll_expected1, vec_sll_result1);
696 #else
697 abort();
698 #endif
699 }
700
701 len = 16;
702 vec_ull_expected1 = (vector unsigned long long int){ 50000, 120000 };
703 store_data_ull = (vector unsigned long long int){ 50000, 120000 };
704 vec_ull_result1 = (vector unsigned long long int){ 0, 0};
705
706 address_ull = (unsigned long long *) &vec_ull_result1[0];
707
708 vec_xst_len (store_data_ull, address_ull, len);
709
710 if (result_wrong_ull (vec_ull_expected1, vec_ull_result1))
711 {
712 #ifdef DEBUG
713 printf("Error: vec_xst_len, len = %d, ull result does not match expected result\n",
714 len);
715 print_ull (vec_ull_expected1, vec_ull_result1);
716 #else
717 abort();
718 #endif
719 }
720
721 len = 8;
722 vec_ull_expected1 = (vector unsigned long long int){ 50000, 0 };
723 store_data_ull = (vector unsigned long long int){ 50000, 120000 };
724 vec_ull_result1 = (vector unsigned long long int){ 0, 0};
725
726 address_ull = (unsigned long long *) &vec_ull_result1[0];
727
728 vec_xst_len (store_data_ull, address_ull, len);
729
730 if (result_wrong_ull (vec_ull_expected1, vec_ull_result1))
731 {
732 #ifdef DEBUG
733 printf("Error: vec_xst_len, len = %d, ull result does not match expected result\n",
734 len);
735 print_ull (vec_ull_expected1, vec_ull_result1);
736 #else
737 abort();
738 #endif
739 }
740
741 len = 16;
742 vec_s128_expected1 = (vector __int128_t){ 12345 };
743 store_data_s128 = (vector __int128_t){ 12345 };
744
745 vec_s128_result1[0] = 0;
746
747 address_s128 = (__int128_t *)(&vec_s128_result1[0]);
748
749 vec_xst_len (store_data_s128, address_s128, len);
750
751 if (result_wrong_s128 (vec_s128_expected1, vec_s128_result1))
752 #ifdef DEBUG
753 {
754 printf("Error: vec_xst_len, len = %d, s128, result does not match expected result\n",
755 len);
756 print_s128 (vec_s128_expected1, vec_s128_result1);
757 }
758 #else
759 abort();
760 #endif
761
762 len = 16;
763 vec_u128_expected1 = (vector __uint128_t){ 12345 };
764 store_data_u128 = (vector __uint128_t){ 12345 };
765
766 vec_u128_result1[0] = 0;
767
768 address_u128 = (__int128_t *)(&vec_u128_result1[0]);
769
770 vec_xst_len (store_data_u128, address_u128, len);
771
772 if (result_wrong_u128 (vec_u128_expected1, vec_u128_result1))
773 {
774 #ifdef DEBUG
775 printf("Error: vec_xst_len, len = %d, u128, result does not match expected result\n", len);
776 print_u128 (vec_u128_expected1, vec_u128_result1);
777 #else
778 abort();
779 #endif
780 }
781
782 len = 16;
783 vec_d_expected1 = (vector double){ 1., 2. };
784 store_data_d = (vector double){ 1., 2. };
785 vec_d_result1 = (vector double){ 0., 0. };
786
787 address_d = (double *)(&vec_d_result1[0]);
788
789 vec_xst_len (store_data_d, address_d, len);
790
791 if (result_wrong_d (vec_d_expected1, vec_d_result1))
792 {
793 #ifdef DEBUG
794 printf("Error: vec_xst_len, len = %d, double, result does not match expected result\n",
795 len);
796 print_d (vec_d_expected1, vec_d_result1);
797 #else
798 abort();
799 #endif
800 }
801
802 len = 8;
803 vec_d_expected1 = (vector double){ 1., 0. };
804 store_data_d = (vector double){ 1., 2. };
805 vec_d_result1 = (vector double){ 0., 0. };
806
807 address_d = (double *)(&vec_d_result1[0]);
808
809 vec_xst_len (store_data_d, address_d, len);
810
811 if (result_wrong_d (vec_d_expected1, vec_d_result1))
812 {
813 #ifdef DEBUG
814 printf("Error: vec_xst_len, len = %d, double, result does not match expected result\n",
815 len);
816 print_d (vec_d_expected1, vec_d_result1);
817 #else
818 abort();
819 #endif
820 }
821
822 len = 16;
823 vec_f_expected1 = (vector float){ 1., 2., 3., 4. };
824 store_data_f = (vector float){ 1., 2., 3., 4. };
825 vec_f_result1 = (vector float){ 0., 0., 0., 0. };
826
827 address_f = (float *)(&vec_f_result1[0]);
828
829 vec_xst_len (store_data_f, address_f, len);
830
831 if (result_wrong_f (vec_f_expected1, vec_f_result1))
832 {
833 #ifdef DEBUG
834 printf("Error: vec_xst_len, len = %d, float, result does not match expected result\n",
835 len);
836 print_f (vec_f_expected1, vec_f_result1);
837 #else
838 abort();
839 #endif
840 }
841
842 len = 4;
843 vec_f_expected1 = (vector float){ 1., 0., 0., 0. };
844 store_data_f = (vector float){ 1., 2., 3., 4. };
845 vec_f_result1 = (vector float){ 0., 0., 0., 0. };
846
847 address_f = (float *)(&vec_f_result1[0]);
848
849 vec_xst_len (store_data_f, address_f, len);
850
851 if (result_wrong_f (vec_f_expected1, vec_f_result1))
852 {
853 #ifdef DEBUG
854 printf("Error: vec_xst_len, len = %d, float, result does not match expected result\n",
855 len);
856 print_f (vec_f_expected1, vec_f_result1);
857 #else
858 abort();
859 #endif
860 }
861
862 U128 u_temp;
863 /* vec_xl_len() tests */
864 for (i = 0; i < 100; i++)
865 {
866 data_c[i] = i;
867 data_uc[i] = i + 1;
868 data_ssi[i] = i + 10;
869 data_usi[i] = i + 11;
870 data_si[i] = i + 100;
871 data_ui[i] = i + 101;
872 data_sll[i] = i + 1000;
873 data_ull[i] = i + 1001;
874 data_f[i] = i + 100000.0;
875 data_d[i] = i + 1000000.0;
876 getU128 (&u_temp, i + 12800000);
877 data_128[i] = u_temp.i2;
878 getU128 (&u_temp, i + 12800001);
879 data_u128[i] = u_temp.u2;
880 }
881
882 len = 16;
883 vec_sc_expected1 = (vector signed char){0, 1, 2, 3, 4, 5, 6, 7,
884 8, 9, 10, 11, 12, 13, 14, 15};
885 vec_sc_result1 = vec_xl_len (data_c, len);
886
887 for (i = 0; i < 16; i++)
888 {
889 if (vec_sc_result1[i] != vec_sc_expected1[i])
890 #ifdef DEBUG
891 printf("Error: vec_xl_len(), len = %d, vec_sc_result1[%d] = %d; vec_sc_expected1[%d] = %d\n",
892 len, i, vec_sc_result1[i], i, vec_sc_expected1[i]);
893 #else
894 abort ();
895 #endif
896 }
897
898 len = 12;
899
900 vec_sc_expected1 = (vector signed char){0, 1, 2, 3, 4, 5, 6, 7,
901 8, 9, 10, 11, 0, 0, 0, 0};
902 vec_sc_result1 = vec_xl_len (data_c, len);
903
904 for (i = 0; i < 16; i++)
905 {
906 if (vec_sc_result1[i] != vec_sc_expected1[i])
907 #ifdef DEBUG
908 printf("Error: vec_xl_len(), len = %d, vec_sc_result1[%d] = %d; vec_sc_expected1[%d] = %d\n",
909 len, i, vec_sc_result1[i], i, vec_sc_expected1[i]);
910 #else
911 abort ();
912 #endif
913 }
914
915 len = 16;
916 vec_uc_expected1 = (vector unsigned char){1, 2, 3, 4, 5, 6, 7, 8, 9,
917 10, 11, 12, 13, 14, 15, 16};
918 vec_uc_result1 = vec_xl_len (data_uc, len);
919
920 for (i = 0; i < 16; i++)
921 {
922 if (vec_uc_result1[i] != vec_uc_expected1[i])
923 #ifdef DEBUG
924 printf("Error: vec_xl_len(), len = %d, vec_uc_result1[%d] = %d; vec_uc_expected1[%d] = %d\n",
925 len, i, vec_uc_result1[i], i, vec_uc_expected1[i]);
926 #else
927 abort ();
928 #endif
929 }
930
931 len = 12;
932 vec_uc_expected1 = (vector unsigned char){1, 2, 3, 4, 5, 6, 7, 8, 9,
933 10, 11, 12, 0, 0, 0, 0};
934 vec_uc_result1 = vec_xl_len (data_uc, len);
935
936 for (i = 0; i < 16; i++)
937 {
938 if (vec_uc_result1[i] != vec_uc_expected1[i])
939 #ifdef DEBUG
940 printf("Error: vec_xl_len(), len = %d, vec_uc_result1[%d] = %d; vec_uc_expected1[%d] = %d\n",
941 len, i, vec_uc_result1[i], i, vec_uc_expected1[i]);
942 #else
943 abort ();
944 #endif
945 }
946
947 len = 16;
948 vec_ss_expected1 = (vector signed short){10, 11, 12, 13, 14, 15, 16, 17};
949
950 vec_ss_result1 = vec_xl_len (data_ssi, len);
951
952 for (i = 0; i < 8; i++)
953 {
954 if (vec_ss_result1[i] != vec_ss_expected1[i])
955 #ifdef DEBUG
956 printf("Error: vec_xl_len(), len = %d, vec_ss_result1[%d] = %d; vec_ss_expected1[%d] = %d\n",
957 len, i, vec_ss_result1[i], i, vec_ss_expected1[i]);
958 #else
959 abort ();
960 #endif
961 }
962
963 len = 8;
964 vec_ss_expected1 = (vector signed short){10, 11, 12, 13, 0, 0, 0, 0};
965
966 vec_ss_result1 = vec_xl_len (data_ssi, len);
967
968 for (i = 0; i < 8; i++)
969 {
970 if (vec_ss_result1[i] != vec_ss_expected1[i])
971 #ifdef DEBUG
972 printf("Error: vec_xl_len(), len = %d, vec_ss_result1[%d] = %d; vec_ss_expected1[%d] = %d\n",
973 len, i, vec_ss_result1[i], i, vec_ss_expected1[i]);
974 #else
975 abort ();
976 #endif
977 }
978
979 len = 16;
980 vec_us_expected1 = (vector unsigned short){11, 12, 13, 14, 15, 16, 17, 18};
981 vec_us_result1 = vec_xl_len (data_usi, len);
982
983 for (i = 0; i < 8; i++)
984 {
985 if (vec_us_result1[i] != vec_us_expected1[i])
986 #ifdef DEBUG
987 printf("Error: vec_xl_len(), len = %d, vec_us_result1[%d] = %d; vec_us_expected1[%d] = %d\n",
988 len, i, vec_us_result1[i], i, vec_us_expected1[i]);
989 #else
990 abort ();
991 #endif
992
993 }
994
995 len = 8;
996 vec_us_expected1 = (vector unsigned short){11, 12, 13, 14, 0, 0, 0, 0};
997 vec_us_result1 = vec_xl_len (data_usi, len);
998
999 for (i = 0; i < 8; i++)
1000 {
1001 if (vec_us_result1[i] != vec_us_expected1[i])
1002 #ifdef DEBUG
1003 printf("Error: vec_xl_len(), len = %d, vec_us_result1[%d] = %d; vec_us_expected1[%d] = %d\n",
1004 len, i, vec_us_result1[i], i, vec_us_expected1[i]);
1005 #else
1006 abort ();
1007 #endif
1008 }
1009
1010 len = 16;
1011 vec_si_result1 = vec_xl_len (data_si, len);
1012 vec_si_expected1 = (vector int){100, 101, 102, 103};
1013
1014 for (i = 0; i < 4; i++)
1015 {
1016 if (vec_si_result1[i] != vec_si_expected1[i])
1017 #ifdef DEBUG
1018 printf("Error: vec_xl_len(), len = %d, vec_si_result1[%d] = %d; vec_si_expected1[%d] = %d\n",
1019 len, i, vec_si_result1[i], i, vec_si_expected1[i]);
1020 #else
1021 abort ();
1022 #endif
1023 }
1024
1025 len = 8;
1026 vec_si_result1 = vec_xl_len (data_si, len);
1027 vec_si_expected1 = (vector int){100, 101, 0, 0};
1028
1029 for (i = 0; i < 4; i++)
1030 {
1031 if (vec_si_result1[i] != vec_si_expected1[i])
1032 #ifdef DEBUG
1033 printf("Error: vec_xl_len(), len = %d, vec_si_result1[%d] = %d; vec_si_expected1[%d] = %d\n",
1034 len, i, vec_si_result1[i], i, vec_si_expected1[i]);
1035 #else
1036 abort ();
1037 #endif
1038 }
1039
1040 len = 16;
1041 vec_ui_result1 = vec_xl_len (data_ui, len);
1042 vec_ui_expected1 = (vector unsigned int){101, 102, 103, 104};
1043
1044 for (i = 0; i < 4; i++)
1045 {
1046 if (vec_ui_result1[i] != vec_ui_expected1[i])
1047 #ifdef DEBUG
1048 printf("Error: vec_xl_len(), len = %d, vec_ui_result1[%d] = %d; vec_ui_expected1[%d] = %d\n",
1049 len, i, vec_ui_result1[i], i, vec_ui_expected1[i]);
1050 #else
1051 abort ();
1052 #endif
1053 }
1054
1055 len = 8;
1056 vec_ui_result1 = vec_xl_len (data_ui, len);
1057 vec_ui_expected1 = (vector unsigned int){101, 102, 0, 0};
1058
1059 for (i = 0; i < 4; i++)
1060 {
1061 if (vec_ui_result1[i] != vec_ui_expected1[i])
1062 #ifdef DEBUG
1063 printf("Error: vec_xl_len(), len = %d, vec_ui_result1[%d] = %d; vec_ui_expected1[%d] = %d\n",
1064 len, i, vec_ui_result1[i], i, vec_ui_expected1[i]);
1065 #else
1066 abort ();
1067 #endif
1068 }
1069
1070 len = 16;
1071 vec_sll_result1 = vec_xl_len (data_sll, len);
1072 vec_sll_expected1 = (vector signed long long){1000, 1001};
1073
1074 for (i = 0; i < 2; i++)
1075 {
1076 if (vec_sll_result1[i] != vec_sll_expected1[i])
1077 #ifdef DEBUG
1078 printf("Error: vec_xl_len(), len = %d, vec_sll_result1[%d] = %lld; vec_sll_expected1[%d] = %lld\n",
1079 len, i, vec_sll_result1[i], i, vec_sll_expected1[i]);
1080 #else
1081 abort ();
1082 #endif
1083 }
1084
1085 len = 8;
1086 vec_sll_result1 = vec_xl_len (data_sll, len);
1087 vec_sll_expected1 = (vector signed long long){1000, 0};
1088
1089 for (i = 0; i < 2; i++)
1090 {
1091 if (vec_sll_result1[i] != vec_sll_expected1[i])
1092 #ifdef DEBUG
1093 printf("Error: vec_xl_len(), len = %d, vec_sll_result1[%d] = %lld; vec_sll_expected1[%d] = %lld\n",
1094 len, i, vec_sll_result1[i], i, vec_sll_expected1[i]);
1095 #else
1096 abort ();
1097 #endif
1098 }
1099
1100 len = 16;
1101 vec_ull_result1 = vec_xl_len (data_ull, len);
1102 vec_ull_expected1 = (vector unsigned long long){1001, 1002};
1103
1104 for (i = 0; i < 2; i++)
1105 {
1106 if (vec_ull_result1[i] != vec_ull_expected1[i])
1107 #ifdef DEBUG
1108 printf("Error: vec_xl_len(), len = %d, vec_ull_result1[%d] = %lld; vec_ull_expected1[%d] = %lld\n",
1109 len, i, vec_ull_result1[i], i, vec_ull_expected1[i]);
1110 #else
1111 abort ();
1112 #endif
1113 }
1114
1115 len = 8;
1116 vec_ull_result1 = vec_xl_len (data_ull, len);
1117 vec_ull_expected1 = (vector unsigned long long){1001, 0};
1118
1119 for (i = 0; i < 2; i++)
1120 {
1121 if (vec_ull_result1[i] != vec_ull_expected1[i])
1122 #ifdef DEBUG
1123 printf("Error: vec_xl_len(), len = %d, vec_ull_result1[%d] = %lld; vec_ull_expected1[%d] = %lld\n",
1124 len, i, vec_ull_result1[i], i, vec_ull_expected1[i]);
1125 #else
1126 abort ();
1127 #endif
1128 }
1129
1130 len = 16;
1131 vec_f_result1 = vec_xl_len (data_f, len);
1132 vec_f_expected1 = (vector float){100000.0, 100001.0, 100002.0, 100003.0};
1133
1134 for (i = 0; i < 4; i++)
1135 {
1136 if (vec_f_result1[i] != vec_f_expected1[i])
1137 #ifdef DEBUG
1138 printf("Error: vec_xl_len(), len = %d, vec_f_result1[%d] = %f; vec_f_expected1[%d] = %f\n",
1139 len, i, vec_f_result1[i], i, vec_f_expected1[i]);
1140 #else
1141 abort ();
1142 #endif
1143 }
1144
1145 len = 8;
1146 vec_f_result1 = vec_xl_len (data_f, len);
1147 vec_f_expected1 = (vector float){100000.0, 100001.0, 0.0, 0.0};
1148
1149 for (i = 0; i < 4; i++)
1150 {
1151 if (vec_f_result1[i] != vec_f_expected1[i])
1152 #ifdef DEBUG
1153 printf("Error: vec_xl_len(), len = %d, vec_f_result1[%d] = %f; vec_f_expected1[%d] = %f\n",
1154 len, i, vec_f_result1[i], i, vec_f_expected1[i]);
1155 #else
1156 abort ();
1157 #endif
1158 }
1159
1160 len = 16;
1161 vec_d_result1 = vec_xl_len (data_d, len);
1162 vec_d_expected1 = (vector double){1000000.0, 1000001.0};
1163
1164 for (i = 0; i < 2; i++)
1165 {
1166 if (vec_d_result1[i] != vec_d_expected1[i])
1167 #ifdef DEBUG
1168 printf("Error: vec_xl_len(), len = %d, vec_d_result1[%d] = %f; vec_f_expected1[%d] = %f\n",
1169 len, i, vec_d_result1[i], i, vec_d_expected1[i]);
1170 #else
1171 abort ();
1172 #endif
1173 }
1174
1175 len = 8;
1176 vec_d_result1 = vec_xl_len (data_d, len);
1177 vec_d_expected1 = (vector double){1000000.0, 0.0};
1178
1179 for (i = 0; i < 2; i++)
1180 {
1181 if (vec_d_result1[i] != vec_d_expected1[i])
1182 #ifdef DEBUG
1183 printf("Error: vec_xl_len(), len = %d, vec_d_result1[%d] = %f; vec_f_expected1[%d] = %f\n",
1184 len, i, vec_d_result1[i], i, vec_d_expected1[i]);
1185 #else
1186 abort ();
1187 #endif
1188 }
1189
1190 getU128 (&u_temp, 12800000);
1191 vec_s128_expected1 = u_temp.i1;
1192 vec_s128_result1 = vec_xl_len (data_128, len);
1193
1194 if (vec_s128_expected1[0] != vec_s128_result1[0])
1195 {
1196 #ifdef DEBUG
1197 U128 u1, u2;
1198 u1.i1 = vec_s128_result1;
1199 u2.i1 = vec_s128_expected1;
1200 printf ("Error: vec_xl_len(), len = %d,"
1201 "vec_s128_result1[0] = %llx %llx; ",
1202 len, u1.d1, u1.d2);
1203 printf ("vec_s128_expected1[0] = %llx %llx\n", u2.d1, u2.d2);
1204 #else
1205 abort ();
1206 #endif
1207 }
1208
1209 vec_u128_result1 = vec_xl_len (data_u128, len);
1210 getU128 (&u_temp, 12800001);
1211 vec_u128_expected1 = u_temp.u1;
1212 if (vec_u128_expected1[0] != vec_u128_result1[0])
1213 #ifdef DEBUG
1214 {
1215 U128 u1, u2;
1216 u1.u1 = vec_u128_result1;
1217 u2.u1 = vec_u128_expected1;
1218 printf ("Error: vec_xl_len(), len = %d,"
1219 "vec_u128_result1[0] = %llx %llx; ",
1220 len, u1.d1, u1.d2);
1221 printf ("vec_u128_expected1[0] = %llx %llx\n", u2.d1, u2.d2);
1222 }
1223 #else
1224 abort ();
1225 #endif
1226
1227 /* Tests to ensure the vec_xl_len() is properly optimized with a pre
1228 and post data initialization is done. */
1229
1230 len = 16;
1231
1232 vec_sc_expected1 = (vector signed char){ 1, 2, 3, 4, 5, 6, 7, 8,
1233 0, 0, 0, 0, 0, 0, 0, 0 };
1234
1235 input_c = (vector signed char){ 1, 2, 3, 4, 5, 6, 7, 8,
1236 0, 0, 0, 0, 0, 0, 0, 0 };
1237 vec_sc_result1 = vec_xl_len (&input_c[0], len);
1238 input_c = (vector signed char){ 9, 10, 11, 12, 13, 14, 15, 16,
1239 17, 18, 19, 20, 21, 22, 23, 24 };
1240
1241 for (i = 0; i < 16; i++)
1242 {
1243 if (vec_sc_result1[i] != vec_sc_expected1[i])
1244 #ifdef DEBUG
1245 printf("Error: pre/post initialzation vec_xl_len(), len = %d, vec_sc_result1[%d] = %d; vec_sc_expected1[%d] = %d\n",
1246 len, i, vec_sc_result1[i], i, vec_sc_expected1[i]);
1247 #else
1248 abort ();
1249 #endif
1250 }
1251
1252 len = 16;
1253 vec_uc_expected1 = (vector unsigned char){ 1, 2, 3, 4, 5, 6, 7, 8, 9,
1254 10, 11, 12, 13, 14, 15, 16 };
1255 input_uc = (vector unsigned char){ 1, 2, 3, 4, 5, 6, 7, 8, 9,
1256 10, 11, 12, 13, 14, 15, 16 };
1257 vec_uc_result1 = vec_xl_len (&input_uc[0], len);
1258 input_uc = (vector unsigned char){ 10, 11, 12, 13, 14, 15, 16,
1259 17, 18, 19, 20, 21, 22, 23, 24 };
1260
1261 for (i = 0; i < 16; i++)
1262 {
1263 if (vec_uc_result1[i] != vec_uc_expected1[i])
1264 #ifdef DEBUG
1265 printf("Error: pre/post initialzation vec_xl_len(), len = %d, vec_uc_result1[%d] = %d; vec_uc_expected1[%d] = %d\n",
1266 len, i, vec_uc_result1[i], i, vec_uc_expected1[i]);
1267 #else
1268 abort ();
1269 #endif
1270 }
1271
1272 len = 16;
1273 vec_ss_expected1 = (vector signed short){ 10, 11, 12, 13, 14, 15, 16, 17 };
1274 input_ssi = (vector signed short){ 10, 11, 12, 13, 14, 15, 16, 17 };
1275 vec_ss_result1 = vec_xl_len (&input_ssi[0], len);
1276 input_ssi = (vector signed short){ 14, 15, 16, 17, 18, 19, 20, 21 };
1277
1278 for (i = 0; i < 8; i++)
1279 {
1280 if (vec_ss_result1[i] != vec_ss_expected1[i])
1281 #ifdef DEBUG
1282 printf("Error: pre/post initialzation vec_xl_len(), len = %d, vec_ss_result1[%d] = %d; vec_ss_expected1[%d] = %d\n",
1283 len, i, vec_ss_result1[i], i, vec_ss_expected1[i]);
1284 #else
1285 abort ();
1286 #endif
1287 }
1288
1289 len = 16;
1290 vec_us_expected1 = (vector unsigned short){ 11, 12, 13, 14, 15, 16, 17, 18 };
1291 input_usi = (vector unsigned short){ 11, 12, 13, 14, 15, 16, 17, 18 };
1292 vec_us_result1 = vec_xl_len (&input_usi[0], len);
1293 input_usi = (vector unsigned short){ 15, 16, 17, 18, 19, 20, 21, 22 };
1294
1295 for (i = 0; i < 8; i++)
1296 {
1297 if (vec_us_result1[i] != vec_us_expected1[i])
1298 #ifdef DEBUG
1299 printf("Error: pre/post initialzation vec_xl_len(), len = %d, vec_us_result1[%d] = %d; vec_us_expected1[%d] = %d\n",
1300 len, i, vec_us_result1[i], i, vec_us_expected1[i]);
1301 #else
1302 abort ();
1303 #endif
1304 }
1305
1306 len = 16;
1307 vec_si_expected1 = (vector int){ 100, 101, 102, 103 };
1308 input_si = (vector int){ 100, 101, 102, 103 };
1309 vec_si_result1 = vec_xl_len (&input_si[0], len);
1310 input_si = (vector int){ 102, 103, 104, 105 };
1311
1312 for (i = 0; i < 4; i++)
1313 {
1314 if (vec_si_result1[i] != vec_si_expected1[i])
1315 #ifdef DEBUG
1316 printf("Error: pre/post initialzation vec_xl_len(), len = %d, vec_si_result1[%d] = %d; vec_si_expected1[%d] = %d\n",
1317 len, i, vec_si_result1[i], i, vec_si_expected1[i]);
1318 #else
1319 abort ();
1320 #endif
1321 }
1322
1323 len = 16;
1324 vec_ui_expected1 = (vector unsigned int){101, 102, 103, 104};
1325 input_ui = (vector unsigned int){101, 102, 103, 104};
1326 vec_ui_result1 = vec_xl_len (&input_ui[0], len);
1327 input_ui = (vector unsigned int){ 103, 104, 105, 106 };
1328
1329 for (i = 0; i < 4; i++)
1330 {
1331 if (vec_ui_result1[i] != vec_ui_expected1[i])
1332 #ifdef DEBUG
1333 printf("Error: pre/post initialzation vec_xl_len(), len = %d, vec_ui_result1[%d] = %d; vec_ui_expected1[%d] = %d\n",
1334 len, i, vec_ui_result1[i], i, vec_ui_expected1[i]);
1335 #else
1336 abort ();
1337 #endif
1338 }
1339
1340 #if 1
1341 len = 16;
1342 vec_sll_expected1 = (vector signed long long){1000, 1001};
1343 input_sll = (vector signed long long ){1000, 1001};
1344 vec_sll_result1 = vec_xl_len ((signed long long int *)&input_sll[0], len);
1345 input_sll = (vector signed long long){1001, 1002};
1346
1347 for (i = 0; i < 2; i++)
1348 {
1349 if (vec_sll_result1[i] != vec_sll_expected1[i])
1350 #ifdef DEBUG
1351 printf("Error: pre/post initialzation vec_xl_len(), len = %d, vec_sll_result1[%d] = %lld; vec_sll_expected1[%d] = %lld\n",
1352 len, i, vec_sll_result1[i], i, vec_sll_expected1[i]);
1353 #else
1354 abort ();
1355 #endif
1356 }
1357
1358 len = 16;
1359 vec_ull_expected1 = (vector unsigned long long int){1001, 1002};
1360 input_ull = (vector unsigned long long int){1001, 1002};
1361 vec_ull_result1 = vec_xl_len ((unsigned long long int *)&input_ull[0], len);
1362 input_ull = (vector unsigned long long int){1002, 1003};
1363
1364 for (i = 0; i < 2; i++)
1365 {
1366 if (vec_ull_result1[i] != vec_ull_expected1[i])
1367 #ifdef DEBUG
1368 printf("Error: pre/post initialzation vec_xl_len(), len = %d, vec_ull_result1[%d] = %lld; vec_ull_expected1[%d] = %lld\n",
1369 len, i, vec_ull_result1[i], i, vec_ull_expected1[i]);
1370 #else
1371 abort ();
1372 #endif
1373 }
1374 #endif
1375
1376
1377 len = 16;
1378 vec_f_expected1 = (vector float){100000.0, 100001.0, 100002.0, 100003.0};
1379 input_f = (vector float){100000.0, 100001.0, 100002.0, 100003.0};
1380 vec_f_result1 = vec_xl_len (&input_f[0], len);
1381 input_f = (vector float){100001.0, 100002.0, 100003.0, 100004.0};
1382
1383 for (i = 0; i < 4; i++)
1384 {
1385 if (vec_f_result1[i] != vec_f_expected1[i])
1386 #ifdef DEBUG
1387 printf("Error: pre/post initialzation vec_xl_len(), len = %d, vec_f_result1[%d] = %f; vec_f_expected1[%d] = %f\n",
1388 len, i, vec_f_result1[i], i, vec_f_expected1[i]);
1389 #else
1390 abort ();
1391 #endif
1392 }
1393
1394 len = 16;
1395 vec_d_expected1 = (vector double){1000000.0, 1000001.0};
1396 input_d = (vector double){1000000.0, 1000001.0};
1397 vec_d_result1 = vec_xl_len (&input_d[0], len);
1398 input_d = (vector double){1000001.0, 1000002.0};
1399
1400 for (i = 0; i < 2; i++)
1401 {
1402 if (vec_d_result1[i] != vec_d_expected1[i])
1403 #ifdef DEBUG
1404 printf("Error: pre/post initialzation vec_xl_len(), len = %d, vec_d_result1[%d] = %f; vec_f_expected1[%d] = %f\n",
1405 len, i, vec_d_result1[i], i, vec_d_expected1[i]);
1406 #else
1407 abort ();
1408 #endif
1409 }
1410
1411 len = 16;
1412 vec_s128_expected1 = (vector __int128_t){12800000};
1413 input_128 = (vector __int128_t){12800000};
1414 vec_s128_result1 = vec_xl_len (&input_128[0], len);
1415 input_128 = (vector __int128_t){12345678};
1416
1417 if (vec_s128_expected1[0] != vec_s128_result1[0])
1418 {
1419 #ifdef DEBUG
1420 printf("Error: pre/post initialzation vec_xl_len(), len = %d, vec_s128_result1[0] = %lld %llu; ",
1421 len, vec_s128_result1[0] >> 64,
1422 vec_s128_result1[0] & (__int128_t)0xFFFFFFFFFFFFFFFF);
1423 printf("vec_s128_expected1[0] = %lld %llu\n",
1424 vec_s128_expected1[0] >> 64,
1425 vec_s128_expected1[0] & (__int128_t)0xFFFFFFFFFFFFFFFF);
1426 #else
1427 abort ();
1428 #endif
1429 }
1430
1431 len = 16;
1432 vec_u128_expected1 = (vector __uint128_t){12800001};
1433 input_u128 = (vector __uint128_t){12800001};
1434 vec_u128_result1 = vec_xl_len (&input_u128[0], len);
1435 input_u128 = (vector __uint128_t){98765432};
1436
1437 if (vec_u128_expected1[0] != vec_u128_result1[0])
1438 #ifdef DEBUG
1439 {
1440 printf("Error: pre/post initialzation vec_xl_len(), len = %d, vec_u128_result1[0] = %lld; ",
1441 len, vec_u128_result1[0] >> 64,
1442 vec_u128_result1[0] & (__int128_t)0xFFFFFFFFFFFFFFFF);
1443 printf("vec_u128_expected1[0] = %lld\n",
1444 vec_u128_expected1[0] >> 64,
1445 vec_u128_expected1[0] & (__int128_t)0xFFFFFFFFFFFFFFFF);
1446 }
1447 #else
1448 abort ();
1449 #endif
1450
1451 /* Tests to ensure the vec_xl_len_r() is properly optimized with a pre
1452 and post data initialization is done. */
1453
1454 len = 16;
1455 #if __LITTLE_ENDIAN__
1456 vec_uc_expected1 = (vector unsigned char){16, 15, 14, 13, 12, 11, 10, 9,
1457 8, 7, 6, 5, 4, 3, 2, 1};
1458 #else
1459 vec_uc_expected1 = (vector unsigned char){1, 2, 3, 4, 5, 6, 7, 8,
1460 9, 10, 11, 12, 13, 14, 15, 16};
1461 #endif
1462 input_uc = (vector unsigned char){ 1, 2, 3, 4, 5, 6, 7, 8, 9,
1463 10, 11, 12, 13, 14, 15, 16 };
1464 vec_uc_result1 = vec_xl_len_r (&input_uc[0], len);
1465 input_uc = (vector unsigned char){ 10, 11, 12, 13, 14, 15, 16,
1466 17, 18, 19, 20, 21, 22, 23, 24 };
1467
1468 for (i = 0; i < 16; i++)
1469 {
1470 if (vec_uc_result1[i] != vec_uc_expected1[i])
1471 #ifdef DEBUG
1472 printf("Error: pre/post initialzation vec_xl_len_r(), len = %d, vec_uc_result1[%d] = %d; vec_uc_expected1[%d] = %d\n",
1473 len, i, vec_uc_result1[i], i, vec_uc_expected1[i]);
1474 #else
1475 abort ();
1476 #endif
1477 }
1478
1479 }