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 int main() {
341 int i, j;
342 size_t len;
343 signed char data_c[100];
344 vector signed char input_c;
345 unsigned char data_uc[100];
346 vector unsigned char input_uc;
347
348 signed short int data_ssi[100];
349 vector signed short int input_ssi;
350 unsigned short int data_usi[100];
351 vector unsigned short int input_usi;
352
353 signed int data_si[100];
354 vector signed int input_si;
355 unsigned int data_ui[100];
356 vector unsigned int input_ui;
357
358 signed long long data_sll[100];
359 vector signed long long input_sll;
360 unsigned long long data_ull[100];
361 vector unsigned long long int input_ull;
362
363 float data_f[100];
364 vector float input_f;
365 double data_d[100];
366 vector double input_d;
367 __uint128_t data_u128[100];
368 vector __uint128_t input_u128;
369 __int128_t data_128[100];
370 vector __int128_t input_128;
371
372 vector signed char store_data_sc;
373 vector unsigned char store_data_uc;
374 vector signed int store_data_si;
375 vector unsigned int store_data_ui;
376 vector __int128_t store_data_s128;
377 vector __uint128_t store_data_u128;
378 vector signed long long int store_data_sll;
379 vector unsigned long long int store_data_ull;
380 vector signed short store_data_ss;
381 vector unsigned short store_data_us;
382 vector double store_data_d;
383 vector float store_data_f;
384
385 signed char *address_sc;
386 unsigned char *address_uc;
387 signed int *address_si;
388 unsigned int *address_ui;
389 __int128_t *address_s128;
390 __uint128_t *address_u128;
391 signed long long int *address_sll;
392 unsigned long long int *address_ull;
393 signed short int *address_ss;
394 unsigned short int *address_us;
395 double *address_d;
396 float *address_f;
397
398 vector unsigned char *datap;
399
400 vector unsigned char vec_uc_expected1, vec_uc_result1;
401 vector signed char vec_sc_expected1, vec_sc_result1;
402 vector signed int vec_si_expected1, vec_si_result1;
403 vector unsigned int vec_ui_expected1, vec_ui_result1;
404 vector __int128_t vec_s128_expected1, vec_s128_result1;
405 vector __uint128_t vec_u128_expected1, vec_u128_result1;
406 vector signed long long int vec_sll_expected1, vec_sll_result1;
407 vector unsigned long long int vec_ull_expected1, vec_ull_result1;
408 vector signed short int vec_ss_expected1, vec_ss_result1;
409 vector unsigned short int vec_us_expected1, vec_us_result1;
410 vector double vec_d_expected1, vec_d_result1;
411 vector float vec_f_expected1, vec_f_result1;
412
413 signed long long disp;
414
415 /* VEC_XST_LEN, ISA 3.0 */
416 len = 16;
417 vec_sc_expected1 = (vector signed char){ -7, -6, -5, -4, -3, -2, -1, 0,
418 1, 2, 3, 4, 5, 6, 7, 8 };
419 store_data_sc = (vector signed char){ -7, -6, -5, -4, -3, -2, -1, 0,
420 1, 2, 3, 4, 5, 6, 7, 8 };
421 vec_sc_result1 = (vector signed char){ 0, 0, 0, 0, 0, 0, 0, 0,
422 0, 0, 0, 0, 0, 0, 0, 0 };
423
424 address_sc = &vec_sc_result1[0];
425
426 vec_xst_len (store_data_sc, address_sc, len);
427
428 if (result_wrong_sc (vec_sc_expected1, vec_sc_result1))
429 {
430 #ifdef DEBUG
431 printf("Error: vec_xst_len, len = %d, sc result does not match expected result\n", len);
432 print_sc (vec_sc_expected1, vec_sc_result1);
433 #else
434 abort();
435 #endif
436 }
437
438 len = 12;
439 vec_sc_expected1 = (vector signed char){ -7, -6, -5, -4, -3, -2, -1, 0,
440 1, 2, 3, 4, 0, 0, 0, 0 };
441 store_data_sc = (vector signed char){ -7, -6, -5, -4, -3, -2, -1, 0,
442 1, 2, 3, 4, 5, 6, 7, 8 };
443 vec_sc_result1 = (vector signed char){ 0, 0, 0, 0, 0, 0, 0, 0,
444 0, 0, 0, 0, 0, 0, 0, 0 };
445
446 address_sc = &vec_sc_result1[0];
447
448 vec_xst_len (store_data_sc, address_sc, len);
449
450 if (result_wrong_sc (vec_sc_expected1, vec_sc_result1))
451 {
452 #ifdef DEBUG
453 printf("Error: vec_xst_len, len = %d, sc result does not match expected result\n",
454 len);
455 print_sc (vec_sc_expected1, vec_sc_result1);
456 #else
457 abort();
458 #endif
459 }
460
461 len = 16;
462 vec_uc_expected1 = (vector unsigned char){ 0, 1, 2, 3, 4, 5, 6, 7,
463 8, 9, 10, 11, 12, 13, 14, 15 };
464
465 store_data_uc = (vector unsigned char){ 0, 1, 2, 3, 4, 5, 6, 7,
466 8, 9, 10, 11, 12, 13, 14, 15 };
467
468 vec_uc_result1 = (vector unsigned char){ 0, 0, 0, 0, 0, 0, 0, 0,
469 0, 0, 0, 0, 0, 0, 0, 0 };
470
471 address_uc = &vec_uc_result1[0];
472
473 vec_xst_len (store_data_uc, address_uc, len);
474
475 if (result_wrong_uc (vec_uc_expected1, vec_uc_result1))
476 {
477 #ifdef DEBUG
478 printf("Error: vec_xst_len, len = %d, uc result does not match expected result\n",
479 len);
480 print_uc (vec_uc_expected1, vec_uc_result1);
481 #else
482 abort();
483 #endif
484 }
485
486 len = 4;
487 vec_uc_expected1 = (vector unsigned char){ 0, 1, 2, 3, 0, 0, 0, 0,
488 0, 0, 0, 0, 0, 0, 0, 0 };
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 vec_uc_result1 = (vector unsigned char){ 0, 0, 0, 0, 0, 0, 0, 0,
492 0, 0, 0, 0, 0, 0, 0, 0 };
493
494 address_uc = &vec_uc_result1[0];
495
496 vec_xst_len (store_data_uc, address_uc, len);
497
498 if (result_wrong_uc (vec_uc_expected1, vec_uc_result1))
499 {
500 #ifdef DEBUG
501 printf("Error: vec_xst_len, len = %d, uc result does not match expected result\n",
502 len);
503 print_uc (vec_uc_expected1, vec_uc_result1);
504 #else
505 abort();
506 #endif
507 }
508
509 len = 16;
510 vec_ss_expected1 = (vector signed short int){ 10, 20, 30, 40,
511 50, 60, 70, 80 };
512 store_data_ss = (vector signed short int){ 10, 20, 30, 40,
513 50, 60, 70, 80 };
514 vec_ss_result1 = (vector signed short int){ 0, 0, 0, 0, 0, 0, 0, 0};
515
516 address_ss = &vec_ss_result1[0];
517
518 vec_xst_len (store_data_ss, address_ss, len);
519
520 if (result_wrong_ss (vec_ss_expected1, vec_ss_result1))
521 {
522 #ifdef DEBUG
523 printf("Error: vec_xst_len, len = %d, ss result does not match expected result\n",
524 len);
525 print_ss (vec_ss_expected1, vec_ss_result1);
526 #else
527 abort();
528 #endif
529 }
530
531 len = 14;
532 vec_ss_expected1 = (vector signed short int){ 10, 20, 30, 40,
533 50, 60, 70, 0 };
534 store_data_ss = (vector signed short int){ 10, 20, 30, 40,
535 50, 60, 70, 80 };
536 vec_ss_result1 = (vector signed short int){ 0, 0, 0, 0, 0, 0, 0, 0};
537
538 address_ss = &vec_ss_result1[0];
539
540 vec_xst_len (store_data_ss, address_ss, len);
541
542 if (result_wrong_ss (vec_ss_expected1, vec_ss_result1))
543 {
544 #ifdef DEBUG
545 printf("Error: vec_xst_len, len = %d, ss result does not match expected result\n",
546 len);
547 print_ss (vec_ss_expected1, vec_ss_result1);
548 #else
549 abort();
550 #endif
551 }
552
553 len = 16;
554 vec_us_expected1 = (vector unsigned short int){ 10, 20, 30, 40,
555 50, 60, 70, 80 };
556 store_data_us = (vector unsigned short int){ 10, 20, 30, 40,
557 50, 60, 70, 80 };
558 vec_us_result1 = (vector unsigned short int){ 0, 0, 0, 0, 0, 0, 0, 0};
559
560 address_us = &vec_us_result1[0];
561
562 vec_xst_len (store_data_us, address_us, len);
563
564 if (result_wrong_us (vec_us_expected1, vec_us_result1))
565 {
566 #ifdef DEBUG
567 printf("Error: vec_xst_len, len = %d, us result does not match expected result\n",
568 len);
569 print_us (vec_us_expected1, vec_us_result1);
570 #else
571 abort();
572 #endif
573 }
574
575 len = 2;
576 vec_us_expected1 = (vector unsigned short int){ 10, 0, 0, 0,
577 0, 0, 0, 0 };
578 store_data_us = (vector unsigned short int){ 10, 20, 30, 40,
579 50, 60, 70, 80 };
580 vec_us_result1 = (vector unsigned short int){ 0, 0, 0, 0, 0, 0, 0, 0};
581
582 address_us = &vec_us_result1[0];
583
584 vec_xst_len (store_data_us, address_us, len);
585
586 if (result_wrong_us (vec_us_expected1, vec_us_result1))
587 {
588 #ifdef DEBUG
589 printf("Error: vec_xst_len, len = %d, us result does not match expected result\n",
590 len);
591 print_us (vec_us_expected1, vec_us_result1);
592 #else
593 abort();
594 #endif
595 }
596
597 len = 16;
598 vec_si_expected1 = (vector signed int){ -30, -10, 0, 10 };
599 store_data_si = (vector signed int){ -30, -10, 0, 10 };
600 vec_si_result1 = (vector signed int){ 0, 0, 0, 0};
601
602 address_si = &vec_si_result1[0];
603
604 vec_xst_len (store_data_si, address_si, len);
605
606 if (result_wrong_si (vec_si_expected1, vec_si_result1))
607 {
608 #ifdef DEBUG
609 printf("Error: vec_xst_len, len = %d, si result does not match expected result\n",
610 len);
611 print_si (vec_si_expected1, vec_si_result1);
612 #else
613 abort();
614 #endif
615 }
616
617 len = 8;
618 vec_si_expected1 = (vector signed int){ -30, -10, 0, 0 };
619 store_data_si = (vector signed int){ -30, -10, 0, 10 };
620 vec_si_result1 = (vector signed int){ 0, 0, 0, 0};
621
622 address_si = &vec_si_result1[0];
623
624 vec_xst_len (store_data_si, address_si, len);
625
626 if (result_wrong_si (vec_si_expected1, vec_si_result1))
627 {
628 #ifdef DEBUG
629 printf("Error: vec_xst_len, len = %d, si result does not match expected result\n",
630 len);
631 print_si (vec_si_expected1, vec_si_result1);
632 #else
633 abort();
634 #endif
635 }
636
637 len = 16;
638 vec_sll_expected1 = (vector signed long long int){ -3000, 10000 };
639 store_data_sll = (vector signed long long int){ -3000, 10000 };
640 vec_sll_result1 = (vector signed long long int){ 0, 0};
641
642 address_sll = (signed long long *)&vec_sll_result1[0];
643
644 vec_xst_len (store_data_sll, address_sll, len);
645
646 if (result_wrong_sll (vec_sll_expected1, vec_sll_result1) == TRUE)
647 {
648 #ifdef DEBUG
649 printf("Error: vec_xst_len, len = %d, sll result does not match expected result\n",
650 len);
651 print_sll (vec_sll_expected1, vec_sll_result1);
652 #else
653 abort();
654 #endif
655 }
656
657 len = 8;
658 vec_sll_expected1 = (vector signed long long int){ -3000, 0 };
659 store_data_sll = (vector signed long long int){ -3000, 10000 };
660 vec_sll_result1 = (vector signed long long int){ 0, 0};
661
662 address_sll = (signed long long *)&vec_sll_result1[0];
663
664 vec_xst_len (store_data_sll, address_sll, len);
665
666 if (result_wrong_sll (vec_sll_expected1, vec_sll_result1))
667 {
668 #ifdef DEBUG
669 printf("Error: vec_xst_len, len = %d, sll result does not match expected result\n",
670 len);
671 print_sll (vec_sll_expected1, vec_sll_result1);
672 #else
673 abort();
674 #endif
675 }
676
677 len = 16;
678 vec_ull_expected1 = (vector unsigned long long int){ 50000, 120000 };
679 store_data_ull = (vector unsigned long long int){ 50000, 120000 };
680 vec_ull_result1 = (vector unsigned long long int){ 0, 0};
681
682 address_ull = (unsigned long long *) &vec_ull_result1[0];
683
684 vec_xst_len (store_data_ull, address_ull, len);
685
686 if (result_wrong_ull (vec_ull_expected1, vec_ull_result1))
687 {
688 #ifdef DEBUG
689 printf("Error: vec_xst_len, len = %d, ull result does not match expected result\n",
690 len);
691 print_ull (vec_ull_expected1, vec_ull_result1);
692 #else
693 abort();
694 #endif
695 }
696
697 len = 8;
698 vec_ull_expected1 = (vector unsigned long long int){ 50000, 0 };
699 store_data_ull = (vector unsigned long long int){ 50000, 120000 };
700 vec_ull_result1 = (vector unsigned long long int){ 0, 0};
701
702 address_ull = (unsigned long long *) &vec_ull_result1[0];
703
704 vec_xst_len (store_data_ull, address_ull, len);
705
706 if (result_wrong_ull (vec_ull_expected1, vec_ull_result1))
707 {
708 #ifdef DEBUG
709 printf("Error: vec_xst_len, len = %d, ull result does not match expected result\n",
710 len);
711 print_ull (vec_ull_expected1, vec_ull_result1);
712 #else
713 abort();
714 #endif
715 }
716
717 len = 16;
718 vec_s128_expected1 = (vector __int128_t){ 12345 };
719 store_data_s128 = (vector __int128_t){ 12345 };
720
721 vec_s128_result1[0] = 0;
722
723 address_s128 = (__int128_t *)(&vec_s128_result1[0]);
724
725 vec_xst_len (store_data_s128, address_s128, len);
726
727 if (result_wrong_s128 (vec_s128_expected1, vec_s128_result1))
728 #ifdef DEBUG
729 {
730 printf("Error: vec_xst_len, len = %d, s128, result does not match expected result\n",
731 len);
732 print_s128 (vec_s128_expected1, vec_s128_result1);
733 }
734 #else
735 abort();
736 #endif
737
738 len = 16;
739 vec_u128_expected1 = (vector __uint128_t){ 12345 };
740 store_data_u128 = (vector __uint128_t){ 12345 };
741
742 vec_u128_result1[0] = 0;
743
744 address_u128 = (__int128_t *)(&vec_u128_result1[0]);
745
746 vec_xst_len (store_data_u128, address_u128, len);
747
748 if (result_wrong_u128 (vec_u128_expected1, vec_u128_result1))
749 {
750 #ifdef DEBUG
751 printf("Error: vec_xst_len, len = %d, u128, result does not match expected result\n", len);
752 print_u128 (vec_u128_expected1, vec_u128_result1);
753 #else
754 abort();
755 #endif
756 }
757
758 len = 16;
759 vec_d_expected1 = (vector double){ 1., 2. };
760 store_data_d = (vector double){ 1., 2. };
761 vec_d_result1 = (vector double){ 0., 0. };
762
763 address_d = (double *)(&vec_d_result1[0]);
764
765 vec_xst_len (store_data_d, address_d, len);
766
767 if (result_wrong_d (vec_d_expected1, vec_d_result1))
768 {
769 #ifdef DEBUG
770 printf("Error: vec_xst_len, len = %d, double, result does not match expected result\n",
771 len);
772 print_d (vec_d_expected1, vec_d_result1);
773 #else
774 abort();
775 #endif
776 }
777
778 len = 8;
779 vec_d_expected1 = (vector double){ 1., 0. };
780 store_data_d = (vector double){ 1., 2. };
781 vec_d_result1 = (vector double){ 0., 0. };
782
783 address_d = (double *)(&vec_d_result1[0]);
784
785 vec_xst_len (store_data_d, address_d, len);
786
787 if (result_wrong_d (vec_d_expected1, vec_d_result1))
788 {
789 #ifdef DEBUG
790 printf("Error: vec_xst_len, len = %d, double, result does not match expected result\n",
791 len);
792 print_d (vec_d_expected1, vec_d_result1);
793 #else
794 abort();
795 #endif
796 }
797
798 len = 16;
799 vec_f_expected1 = (vector float){ 1., 2., 3., 4. };
800 store_data_f = (vector float){ 1., 2., 3., 4. };
801 vec_f_result1 = (vector float){ 0., 0., 0., 0. };
802
803 address_f = (float *)(&vec_f_result1[0]);
804
805 vec_xst_len (store_data_f, address_f, len);
806
807 if (result_wrong_f (vec_f_expected1, vec_f_result1))
808 {
809 #ifdef DEBUG
810 printf("Error: vec_xst_len, len = %d, float, result does not match expected result\n",
811 len);
812 print_f (vec_f_expected1, vec_f_result1);
813 #else
814 abort();
815 #endif
816 }
817
818 len = 4;
819 vec_f_expected1 = (vector float){ 1., 0., 0., 0. };
820 store_data_f = (vector float){ 1., 2., 3., 4. };
821 vec_f_result1 = (vector float){ 0., 0., 0., 0. };
822
823 address_f = (float *)(&vec_f_result1[0]);
824
825 vec_xst_len (store_data_f, address_f, len);
826
827 if (result_wrong_f (vec_f_expected1, vec_f_result1))
828 {
829 #ifdef DEBUG
830 printf("Error: vec_xst_len, len = %d, float, result does not match expected result\n",
831 len);
832 print_f (vec_f_expected1, vec_f_result1);
833 #else
834 abort();
835 #endif
836 }
837
838 /* vec_xl_len() tests */
839 for (i = 0; i < 100; i++)
840 {
841 data_c[i] = i;
842 data_uc[i] = i+1;
843 data_ssi[i] = i+10;
844 data_usi[i] = i+11;
845 data_si[i] = i+100;
846 data_ui[i] = i+101;
847 data_sll[i] = i+1000;
848 data_ull[i] = i+1001;
849 data_f[i] = i+100000.0;
850 data_d[i] = i+1000000.0;
851 data_128[i] = i + 12800000;
852 data_u128[i] = i + 12800001;
853 }
854
855 len = 16;
856 vec_sc_expected1 = (vector signed char){0, 1, 2, 3, 4, 5, 6, 7,
857 8, 9, 10, 11, 12, 13, 14, 15};
858 vec_sc_result1 = vec_xl_len (data_c, len);
859
860 for (i = 0; i < 16; i++)
861 {
862 if (vec_sc_result1[i] != vec_sc_expected1[i])
863 #ifdef DEBUG
864 printf("Error: vec_xl_len(), len = %d, vec_sc_result1[%d] = %d; vec_sc_expected1[%d] = %d\n",
865 len, i, vec_sc_result1[i], i, vec_sc_expected1[i]);
866 #else
867 abort ();
868 #endif
869 }
870
871 len = 12;
872
873 vec_sc_expected1 = (vector signed char){0, 1, 2, 3, 4, 5, 6, 7,
874 8, 9, 10, 11, 0, 0, 0, 0};
875 vec_sc_result1 = vec_xl_len (data_c, len);
876
877 for (i = 0; i < 16; i++)
878 {
879 if (vec_sc_result1[i] != vec_sc_expected1[i])
880 #ifdef DEBUG
881 printf("Error: vec_xl_len(), len = %d, vec_sc_result1[%d] = %d; vec_sc_expected1[%d] = %d\n",
882 len, i, vec_sc_result1[i], i, vec_sc_expected1[i]);
883 #else
884 abort ();
885 #endif
886 }
887
888 len = 16;
889 vec_uc_expected1 = (vector unsigned char){1, 2, 3, 4, 5, 6, 7, 8, 9,
890 10, 11, 12, 13, 14, 15, 16};
891 vec_uc_result1 = vec_xl_len (data_uc, len);
892
893 for (i = 0; i < 16; i++)
894 {
895 if (vec_uc_result1[i] != vec_uc_expected1[i])
896 #ifdef DEBUG
897 printf("Error: vec_xl_len(), len = %d, vec_uc_result1[%d] = %d; vec_uc_expected1[%d] = %d\n",
898 len, i, vec_uc_result1[i], i, vec_uc_expected1[i]);
899 #else
900 abort ();
901 #endif
902 }
903
904 len = 12;
905 vec_uc_expected1 = (vector unsigned char){1, 2, 3, 4, 5, 6, 7, 8, 9,
906 10, 11, 12, 0, 0, 0, 0};
907 vec_uc_result1 = vec_xl_len (data_uc, len);
908
909 for (i = 0; i < 16; i++)
910 {
911 if (vec_uc_result1[i] != vec_uc_expected1[i])
912 #ifdef DEBUG
913 printf("Error: vec_xl_len(), len = %d, vec_uc_result1[%d] = %d; vec_uc_expected1[%d] = %d\n",
914 len, i, vec_uc_result1[i], i, vec_uc_expected1[i]);
915 #else
916 abort ();
917 #endif
918 }
919
920 len = 16;
921 vec_ss_expected1 = (vector signed short){10, 11, 12, 13, 14, 15, 16, 17};
922
923 vec_ss_result1 = vec_xl_len (data_ssi, len);
924
925 for (i = 0; i < 8; i++)
926 {
927 if (vec_ss_result1[i] != vec_ss_expected1[i])
928 #ifdef DEBUG
929 printf("Error: vec_xl_len(), len = %d, vec_ss_result1[%d] = %d; vec_ss_expected1[%d] = %d\n",
930 len, i, vec_ss_result1[i], i, vec_ss_expected1[i]);
931 #else
932 abort ();
933 #endif
934 }
935
936 len = 8;
937 vec_ss_expected1 = (vector signed short){10, 11, 12, 13, 0, 0, 0, 0};
938
939 vec_ss_result1 = vec_xl_len (data_ssi, len);
940
941 for (i = 0; i < 8; i++)
942 {
943 if (vec_ss_result1[i] != vec_ss_expected1[i])
944 #ifdef DEBUG
945 printf("Error: vec_xl_len(), len = %d, vec_ss_result1[%d] = %d; vec_ss_expected1[%d] = %d\n",
946 len, i, vec_ss_result1[i], i, vec_ss_expected1[i]);
947 #else
948 abort ();
949 #endif
950 }
951
952 len = 16;
953 vec_us_expected1 = (vector unsigned short){11, 12, 13, 14, 15, 16, 17, 18};
954 vec_us_result1 = vec_xl_len (data_usi, len);
955
956 for (i = 0; i < 8; i++)
957 {
958 if (vec_us_result1[i] != vec_us_expected1[i])
959 #ifdef DEBUG
960 printf("Error: vec_xl_len(), len = %d, vec_us_result1[%d] = %d; vec_us_expected1[%d] = %d\n",
961 len, i, vec_us_result1[i], i, vec_us_expected1[i]);
962 #else
963 abort ();
964 #endif
965
966 }
967
968 len = 8;
969 vec_us_expected1 = (vector unsigned short){11, 12, 13, 14, 0, 0, 0, 0};
970 vec_us_result1 = vec_xl_len (data_usi, len);
971
972 for (i = 0; i < 8; i++)
973 {
974 if (vec_us_result1[i] != vec_us_expected1[i])
975 #ifdef DEBUG
976 printf("Error: vec_xl_len(), len = %d, vec_us_result1[%d] = %d; vec_us_expected1[%d] = %d\n",
977 len, i, vec_us_result1[i], i, vec_us_expected1[i]);
978 #else
979 abort ();
980 #endif
981 }
982
983 len = 16;
984 vec_si_result1 = vec_xl_len (data_si, len);
985 vec_si_expected1 = (vector int){100, 101, 102, 103};
986
987 for (i = 0; i < 4; i++)
988 {
989 if (vec_si_result1[i] != vec_si_expected1[i])
990 #ifdef DEBUG
991 printf("Error: vec_xl_len(), len = %d, vec_si_result1[%d] = %d; vec_si_expected1[%d] = %d\n",
992 len, i, vec_si_result1[i], i, vec_si_expected1[i]);
993 #else
994 abort ();
995 #endif
996 }
997
998 len = 8;
999 vec_si_result1 = vec_xl_len (data_si, len);
1000 vec_si_expected1 = (vector int){100, 101, 0, 0};
1001
1002 for (i = 0; i < 4; i++)
1003 {
1004 if (vec_si_result1[i] != vec_si_expected1[i])
1005 #ifdef DEBUG
1006 printf("Error: vec_xl_len(), len = %d, vec_si_result1[%d] = %d; vec_si_expected1[%d] = %d\n",
1007 len, i, vec_si_result1[i], i, vec_si_expected1[i]);
1008 #else
1009 abort ();
1010 #endif
1011 }
1012
1013 len = 16;
1014 vec_ui_result1 = vec_xl_len (data_ui, len);
1015 vec_ui_expected1 = (vector unsigned int){101, 102, 103, 104};
1016
1017 for (i = 0; i < 4; i++)
1018 {
1019 if (vec_ui_result1[i] != vec_ui_expected1[i])
1020 #ifdef DEBUG
1021 printf("Error: vec_xl_len(), len = %d, vec_ui_result1[%d] = %d; vec_ui_expected1[%d] = %d\n",
1022 len, i, vec_ui_result1[i], i, vec_ui_expected1[i]);
1023 #else
1024 abort ();
1025 #endif
1026 }
1027
1028 len = 8;
1029 vec_ui_result1 = vec_xl_len (data_ui, len);
1030 vec_ui_expected1 = (vector unsigned int){101, 102, 0, 0};
1031
1032 for (i = 0; i < 4; i++)
1033 {
1034 if (vec_ui_result1[i] != vec_ui_expected1[i])
1035 #ifdef DEBUG
1036 printf("Error: vec_xl_len(), len = %d, vec_ui_result1[%d] = %d; vec_ui_expected1[%d] = %d\n",
1037 len, i, vec_ui_result1[i], i, vec_ui_expected1[i]);
1038 #else
1039 abort ();
1040 #endif
1041 }
1042
1043 len = 16;
1044 vec_sll_result1 = vec_xl_len (data_sll, len);
1045 vec_sll_expected1 = (vector signed long long){1000, 1001};
1046
1047 for (i = 0; i < 2; i++)
1048 {
1049 if (vec_sll_result1[i] != vec_sll_expected1[i])
1050 #ifdef DEBUG
1051 printf("Error: vec_xl_len(), len = %d, vec_sll_result1[%d] = %lld; vec_sll_expected1[%d] = %lld\n",
1052 len, i, vec_sll_result1[i], i, vec_sll_expected1[i]);
1053 #else
1054 abort ();
1055 #endif
1056 }
1057
1058 len = 8;
1059 vec_sll_result1 = vec_xl_len (data_sll, len);
1060 vec_sll_expected1 = (vector signed long long){1000, 0};
1061
1062 for (i = 0; i < 2; i++)
1063 {
1064 if (vec_sll_result1[i] != vec_sll_expected1[i])
1065 #ifdef DEBUG
1066 printf("Error: vec_xl_len(), len = %d, vec_sll_result1[%d] = %lld; vec_sll_expected1[%d] = %lld\n",
1067 len, i, vec_sll_result1[i], i, vec_sll_expected1[i]);
1068 #else
1069 abort ();
1070 #endif
1071 }
1072
1073 len = 16;
1074 vec_ull_result1 = vec_xl_len (data_ull, len);
1075 vec_ull_expected1 = (vector unsigned long long){1001, 1002};
1076
1077 for (i = 0; i < 2; i++)
1078 {
1079 if (vec_ull_result1[i] != vec_ull_expected1[i])
1080 #ifdef DEBUG
1081 printf("Error: vec_xl_len(), len = %d, vec_ull_result1[%d] = %lld; vec_ull_expected1[%d] = %lld\n",
1082 len, i, vec_ull_result1[i], i, vec_ull_expected1[i]);
1083 #else
1084 abort ();
1085 #endif
1086 }
1087
1088 len = 8;
1089 vec_ull_result1 = vec_xl_len (data_ull, len);
1090 vec_ull_expected1 = (vector unsigned long long){1001, 0};
1091
1092 for (i = 0; i < 2; i++)
1093 {
1094 if (vec_ull_result1[i] != vec_ull_expected1[i])
1095 #ifdef DEBUG
1096 printf("Error: vec_xl_len(), len = %d, vec_ull_result1[%d] = %lld; vec_ull_expected1[%d] = %lld\n",
1097 len, i, vec_ull_result1[i], i, vec_ull_expected1[i]);
1098 #else
1099 abort ();
1100 #endif
1101 }
1102
1103 len = 16;
1104 vec_f_result1 = vec_xl_len (data_f, len);
1105 vec_f_expected1 = (vector float){100000.0, 100001.0, 100002.0, 100003.0};
1106
1107 for (i = 0; i < 4; i++)
1108 {
1109 if (vec_f_result1[i] != vec_f_expected1[i])
1110 #ifdef DEBUG
1111 printf("Error: vec_xl_len(), len = %d, vec_f_result1[%d] = %f; vec_f_expected1[%d] = %f\n",
1112 len, i, vec_f_result1[i], i, vec_f_expected1[i]);
1113 #else
1114 abort ();
1115 #endif
1116 }
1117
1118 len = 8;
1119 vec_f_result1 = vec_xl_len (data_f, len);
1120 vec_f_expected1 = (vector float){100000.0, 100001.0, 0.0, 0.0};
1121
1122 for (i = 0; i < 4; i++)
1123 {
1124 if (vec_f_result1[i] != vec_f_expected1[i])
1125 #ifdef DEBUG
1126 printf("Error: vec_xl_len(), len = %d, vec_f_result1[%d] = %f; vec_f_expected1[%d] = %f\n",
1127 len, i, vec_f_result1[i], i, vec_f_expected1[i]);
1128 #else
1129 abort ();
1130 #endif
1131 }
1132
1133 len = 16;
1134 vec_d_result1 = vec_xl_len (data_d, len);
1135 vec_d_expected1 = (vector double){1000000.0, 1000001.0};
1136
1137 for (i = 0; i < 2; i++)
1138 {
1139 if (vec_d_result1[i] != vec_d_expected1[i])
1140 #ifdef DEBUG
1141 printf("Error: vec_xl_len(), len = %d, vec_d_result1[%d] = %f; vec_f_expected1[%d] = %f\n",
1142 len, i, vec_d_result1[i], i, vec_d_expected1[i]);
1143 #else
1144 abort ();
1145 #endif
1146 }
1147
1148 len = 8;
1149 vec_d_result1 = vec_xl_len (data_d, len);
1150 vec_d_expected1 = (vector double){1000000.0, 0.0};
1151
1152 for (i = 0; i < 2; i++)
1153 {
1154 if (vec_d_result1[i] != vec_d_expected1[i])
1155 #ifdef DEBUG
1156 printf("Error: vec_xl_len(), len = %d, vec_d_result1[%d] = %f; vec_f_expected1[%d] = %f\n",
1157 len, i, vec_d_result1[i], i, vec_d_expected1[i]);
1158 #else
1159 abort ();
1160 #endif
1161 }
1162
1163 vec_s128_expected1 = (vector __int128_t){12800000};
1164 vec_s128_result1 = vec_xl_len (data_128, len);
1165
1166 if (vec_s128_expected1[0] != vec_s128_result1[0])
1167 {
1168 #ifdef DEBUG
1169 printf("Error: vec_xl_len(), len = %d, vec_s128_result1[0] = %lld %llu; ",
1170 len, vec_s128_result1[0] >> 64,
1171 vec_s128_result1[0] & (__int128_t)0xFFFFFFFFFFFFFFFF);
1172 printf("vec_s128_expected1[0] = %lld %llu\n",
1173 vec_s128_expected1[0] >> 64,
1174 vec_s128_expected1[0] & (__int128_t)0xFFFFFFFFFFFFFFFF);
1175 #else
1176 abort ();
1177 #endif
1178 }
1179
1180 vec_u128_result1 = vec_xl_len (data_u128, len);
1181 vec_u128_expected1 = (vector __uint128_t){12800001};
1182 if (vec_u128_expected1[0] != vec_u128_result1[0])
1183 #ifdef DEBUG
1184 {
1185 printf("Error: vec_xl_len(), len = %d, vec_u128_result1[0] = %lld; ",
1186 len, vec_u128_result1[0] >> 64,
1187 vec_u128_result1[0] & (__int128_t)0xFFFFFFFFFFFFFFFF);
1188 printf("vec_u128_expected1[0] = %lld\n",
1189 vec_u128_expected1[0] >> 64,
1190 vec_u128_expected1[0] & (__int128_t)0xFFFFFFFFFFFFFFFF);
1191 }
1192 #else
1193 abort ();
1194 #endif
1195
1196 /* Tests to ensure the vec_xl_len() is properly optimized with a pre
1197 and post data initialization is done. */
1198
1199 len = 16;
1200
1201 vec_sc_expected1 = (vector signed char){ 1, 2, 3, 4, 5, 6, 7, 8,
1202 0, 0, 0, 0, 0, 0, 0, 0 };
1203
1204 input_c = (vector signed char){ 1, 2, 3, 4, 5, 6, 7, 8,
1205 0, 0, 0, 0, 0, 0, 0, 0 };
1206 vec_sc_result1 = vec_xl_len (&input_c[0], len);
1207 input_c = (vector signed char){ 9, 10, 11, 12, 13, 14, 15, 16,
1208 17, 18, 19, 20, 21, 22, 23, 24 };
1209
1210 for (i = 0; i < 16; i++)
1211 {
1212 if (vec_sc_result1[i] != vec_sc_expected1[i])
1213 #ifdef DEBUG
1214 printf("Error: pre/post initialzation vec_xl_len(), len = %d, vec_sc_result1[%d] = %d; vec_sc_expected1[%d] = %d\n",
1215 len, i, vec_sc_result1[i], i, vec_sc_expected1[i]);
1216 #else
1217 abort ();
1218 #endif
1219 }
1220
1221 len = 16;
1222 vec_uc_expected1 = (vector unsigned char){ 1, 2, 3, 4, 5, 6, 7, 8, 9,
1223 10, 11, 12, 13, 14, 15, 16 };
1224 input_uc = (vector unsigned char){ 1, 2, 3, 4, 5, 6, 7, 8, 9,
1225 10, 11, 12, 13, 14, 15, 16 };
1226 vec_uc_result1 = vec_xl_len (&input_uc[0], len);
1227 input_uc = (vector unsigned char){ 10, 11, 12, 13, 14, 15, 16,
1228 17, 18, 19, 20, 21, 22, 23, 24 };
1229
1230 for (i = 0; i < 16; i++)
1231 {
1232 if (vec_uc_result1[i] != vec_uc_expected1[i])
1233 #ifdef DEBUG
1234 printf("Error: pre/post initialzation vec_xl_len(), len = %d, vec_uc_result1[%d] = %d; vec_uc_expected1[%d] = %d\n",
1235 len, i, vec_uc_result1[i], i, vec_uc_expected1[i]);
1236 #else
1237 abort ();
1238 #endif
1239 }
1240
1241 len = 16;
1242 vec_ss_expected1 = (vector signed short){ 10, 11, 12, 13, 14, 15, 16, 17 };
1243 input_ssi = (vector signed short){ 10, 11, 12, 13, 14, 15, 16, 17 };
1244 vec_ss_result1 = vec_xl_len (&input_ssi[0], len);
1245 input_ssi = (vector signed short){ 14, 15, 16, 17, 18, 19, 20, 21 };
1246
1247 for (i = 0; i < 8; i++)
1248 {
1249 if (vec_ss_result1[i] != vec_ss_expected1[i])
1250 #ifdef DEBUG
1251 printf("Error: pre/post initialzation vec_xl_len(), len = %d, vec_ss_result1[%d] = %d; vec_ss_expected1[%d] = %d\n",
1252 len, i, vec_ss_result1[i], i, vec_ss_expected1[i]);
1253 #else
1254 abort ();
1255 #endif
1256 }
1257
1258 len = 16;
1259 vec_us_expected1 = (vector unsigned short){ 11, 12, 13, 14, 15, 16, 17, 18 };
1260 input_usi = (vector unsigned short){ 11, 12, 13, 14, 15, 16, 17, 18 };
1261 vec_us_result1 = vec_xl_len (&input_usi[0], len);
1262 input_usi = (vector unsigned short){ 15, 16, 17, 18, 19, 20, 21, 22 };
1263
1264 for (i = 0; i < 8; i++)
1265 {
1266 if (vec_us_result1[i] != vec_us_expected1[i])
1267 #ifdef DEBUG
1268 printf("Error: pre/post initialzation vec_xl_len(), len = %d, vec_us_result1[%d] = %d; vec_us_expected1[%d] = %d\n",
1269 len, i, vec_us_result1[i], i, vec_us_expected1[i]);
1270 #else
1271 abort ();
1272 #endif
1273 }
1274
1275 len = 16;
1276 vec_si_expected1 = (vector int){ 100, 101, 102, 103 };
1277 input_si = (vector int){ 100, 101, 102, 103 };
1278 vec_si_result1 = vec_xl_len (&input_si[0], len);
1279 input_si = (vector int){ 102, 103, 104, 105 };
1280
1281 for (i = 0; i < 4; i++)
1282 {
1283 if (vec_si_result1[i] != vec_si_expected1[i])
1284 #ifdef DEBUG
1285 printf("Error: pre/post initialzation vec_xl_len(), len = %d, vec_si_result1[%d] = %d; vec_si_expected1[%d] = %d\n",
1286 len, i, vec_si_result1[i], i, vec_si_expected1[i]);
1287 #else
1288 abort ();
1289 #endif
1290 }
1291
1292 len = 16;
1293 vec_ui_expected1 = (vector unsigned int){101, 102, 103, 104};
1294 input_ui = (vector unsigned int){101, 102, 103, 104};
1295 vec_ui_result1 = vec_xl_len (&input_ui[0], len);
1296 input_ui = (vector unsigned int){ 103, 104, 105, 106 };
1297
1298 for (i = 0; i < 4; i++)
1299 {
1300 if (vec_ui_result1[i] != vec_ui_expected1[i])
1301 #ifdef DEBUG
1302 printf("Error: pre/post initialzation vec_xl_len(), len = %d, vec_ui_result1[%d] = %d; vec_ui_expected1[%d] = %d\n",
1303 len, i, vec_ui_result1[i], i, vec_ui_expected1[i]);
1304 #else
1305 abort ();
1306 #endif
1307 }
1308
1309 #if 1
1310 len = 16;
1311 vec_sll_expected1 = (vector signed long long){1000, 1001};
1312 input_sll = (vector signed long long ){1000, 1001};
1313 vec_sll_result1 = vec_xl_len ((signed long long int *)&input_sll[0], len);
1314 input_sll = (vector signed long long){1001, 1002};
1315
1316 for (i = 0; i < 2; i++)
1317 {
1318 if (vec_sll_result1[i] != vec_sll_expected1[i])
1319 #ifdef DEBUG
1320 printf("Error: pre/post initialzation vec_xl_len(), len = %d, vec_sll_result1[%d] = %lld; vec_sll_expected1[%d] = %lld\n",
1321 len, i, vec_sll_result1[i], i, vec_sll_expected1[i]);
1322 #else
1323 abort ();
1324 #endif
1325 }
1326
1327 len = 16;
1328 vec_ull_expected1 = (vector unsigned long long int){1001, 1002};
1329 input_ull = (vector unsigned long long int){1001, 1002};
1330 vec_ull_result1 = vec_xl_len ((unsigned long long int *)&input_ull[0], len);
1331 input_ull = (vector unsigned long long int){1002, 1003};
1332
1333 for (i = 0; i < 2; i++)
1334 {
1335 if (vec_ull_result1[i] != vec_ull_expected1[i])
1336 #ifdef DEBUG
1337 printf("Error: pre/post initialzation vec_xl_len(), len = %d, vec_ull_result1[%d] = %lld; vec_ull_expected1[%d] = %lld\n",
1338 len, i, vec_ull_result1[i], i, vec_ull_expected1[i]);
1339 #else
1340 abort ();
1341 #endif
1342 }
1343 #endif
1344
1345
1346 len = 16;
1347 vec_f_expected1 = (vector float){100000.0, 100001.0, 100002.0, 100003.0};
1348 input_f = (vector float){100000.0, 100001.0, 100002.0, 100003.0};
1349 vec_f_result1 = vec_xl_len (&input_f[0], len);
1350 input_f = (vector float){100001.0, 100002.0, 100003.0, 100004.0};
1351
1352 for (i = 0; i < 4; i++)
1353 {
1354 if (vec_f_result1[i] != vec_f_expected1[i])
1355 #ifdef DEBUG
1356 printf("Error: pre/post initialzation vec_xl_len(), len = %d, vec_f_result1[%d] = %f; vec_f_expected1[%d] = %f\n",
1357 len, i, vec_f_result1[i], i, vec_f_expected1[i]);
1358 #else
1359 abort ();
1360 #endif
1361 }
1362
1363 len = 16;
1364 vec_d_expected1 = (vector double){1000000.0, 1000001.0};
1365 input_d = (vector double){1000000.0, 1000001.0};
1366 vec_d_result1 = vec_xl_len (&input_d[0], len);
1367 input_d = (vector double){1000001.0, 1000002.0};
1368
1369 for (i = 0; i < 2; i++)
1370 {
1371 if (vec_d_result1[i] != vec_d_expected1[i])
1372 #ifdef DEBUG
1373 printf("Error: pre/post initialzation vec_xl_len(), len = %d, vec_d_result1[%d] = %f; vec_f_expected1[%d] = %f\n",
1374 len, i, vec_d_result1[i], i, vec_d_expected1[i]);
1375 #else
1376 abort ();
1377 #endif
1378 }
1379
1380 len = 16;
1381 vec_s128_expected1 = (vector __int128_t){12800000};
1382 input_128 = (vector __int128_t){12800000};
1383 vec_s128_result1 = vec_xl_len (&input_128[0], len);
1384 input_128 = (vector __int128_t){12345678};
1385
1386 if (vec_s128_expected1[0] != vec_s128_result1[0])
1387 {
1388 #ifdef DEBUG
1389 printf("Error: pre/post initialzation vec_xl_len(), len = %d, vec_s128_result1[0] = %lld %llu; ",
1390 len, vec_s128_result1[0] >> 64,
1391 vec_s128_result1[0] & (__int128_t)0xFFFFFFFFFFFFFFFF);
1392 printf("vec_s128_expected1[0] = %lld %llu\n",
1393 vec_s128_expected1[0] >> 64,
1394 vec_s128_expected1[0] & (__int128_t)0xFFFFFFFFFFFFFFFF);
1395 #else
1396 abort ();
1397 #endif
1398 }
1399
1400 len = 16;
1401 vec_u128_expected1 = (vector __uint128_t){12800001};
1402 input_u128 = (vector __uint128_t){12800001};
1403 vec_u128_result1 = vec_xl_len (&input_u128[0], len);
1404 input_u128 = (vector __uint128_t){98765432};
1405
1406 if (vec_u128_expected1[0] != vec_u128_result1[0])
1407 #ifdef DEBUG
1408 {
1409 printf("Error: pre/post initialzation vec_xl_len(), len = %d, vec_u128_result1[0] = %lld; ",
1410 len, vec_u128_result1[0] >> 64,
1411 vec_u128_result1[0] & (__int128_t)0xFFFFFFFFFFFFFFFF);
1412 printf("vec_u128_expected1[0] = %lld\n",
1413 vec_u128_expected1[0] >> 64,
1414 vec_u128_expected1[0] & (__int128_t)0xFFFFFFFFFFFFFFFF);
1415 }
1416 #else
1417 abort ();
1418 #endif
1419
1420 /* Tests to ensure the vec_xl_len_r() is properly optimized with a pre
1421 and post data initialization is done. */
1422
1423 len = 16;
1424 vec_uc_expected1 = (vector unsigned char){ 16,15, 14, 13, 12, 11, 10, 9,
1425 8, 7, 6, 5, 4, 3, 2, 1 };
1426 input_uc = (vector unsigned char){ 1, 2, 3, 4, 5, 6, 7, 8, 9,
1427 10, 11, 12, 13, 14, 15, 16 };
1428 vec_uc_result1 = vec_xl_len_r (&input_uc[0], len);
1429 input_uc = (vector unsigned char){ 10, 11, 12, 13, 14, 15, 16,
1430 17, 18, 19, 20, 21, 22, 23, 24 };
1431
1432 for (i = 0; i < 16; i++)
1433 {
1434 if (vec_uc_result1[i] != vec_uc_expected1[i])
1435 #ifdef DEBUG
1436 printf("Error: pre/post initialzation vec_xl_len_r(), len = %d, vec_uc_result1[%d] = %d; vec_uc_expected1[%d] = %d\n",
1437 len, i, vec_uc_result1[i], i, vec_uc_expected1[i]);
1438 #else
1439 abort ();
1440 #endif
1441 }
1442
1443 }
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470