1 /* { dg-do run } */
2 /* { dg-require-effective-target p8vector_hw } */
3 /* { dg-require-effective-target int128 } */
4 /* { dg-options "-mdejagnu-cpu=power8 -O3" } */
5
6 #include <stdint.h>
7 #include <stdio.h>
8 #include <inttypes.h>
9 #include <altivec.h>
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 void print_sc (vector signed char vec_expected,
33 vector signed char vec_actual)
34 {
35 int i;
36
37 printf("expected signed char data\n");
38 for (i = 0; i < 16; i++)
39 printf(" %d,", vec_expected[i]);
40
41 printf("\nactual signed char data\n");
42 for (i = 0; i < 16; i++)
43 printf(" %d,", vec_actual[i]);
44 printf("\n");
45 }
46
47 int result_wrong_uc (vector unsigned char vec_expected,
48 vector unsigned char vec_actual)
49 {
50 int i;
51
52 for (i = 0; i < 16; i++)
53 if (vec_expected[i] != vec_actual[i])
54 return TRUE;
55
56 return FALSE;
57 }
58
59 void print_uc (vector unsigned char vec_expected,
60 vector unsigned char vec_actual)
61 {
62 int i;
63
64 printf("expected unsigned char data\n");
65 for (i = 0; i < 16; i++)
66 printf(" %d,", vec_expected[i]);
67
68 printf("\nactual unsigned char data\n");
69 for (i = 0; i < 16; i++)
70 printf(" %d,", vec_actual[i]);
71 printf("\n");
72 }
73
74 int result_wrong_us (vector unsigned short vec_expected,
75 vector unsigned short vec_actual)
76 {
77 int i;
78
79 for (i = 0; i < 8; i++)
80 if (vec_expected[i] != vec_actual[i])
81 return TRUE;
82
83 return FALSE;
84 }
85
86 void print_us (vector unsigned short vec_expected,
87 vector unsigned short vec_actual)
88 {
89 int i;
90
91 printf("expected unsigned short data\n");
92 for (i = 0; i < 8; i++)
93 printf(" %d,", vec_expected[i]);
94
95 printf("\nactual unsigned short data\n");
96 for (i = 0; i < 8; i++)
97 printf(" %d,", vec_actual[i]);
98 printf("\n");
99 }
100
101 int result_wrong_ss (vector signed short vec_expected,
102 vector signed short vec_actual)
103 {
104 int i;
105
106 for (i = 0; i < 8; i++)
107 if (vec_expected[i] != vec_actual[i])
108 return TRUE;
109
110 return FALSE;
111 }
112
113 void print_ss (vector signed short vec_expected,
114 vector signed short vec_actual)
115 {
116 int i;
117
118 printf("expected signed short data\n");
119 for (i = 0; i < 8; i++)
120 printf(" %d,", vec_expected[i]);
121
122 printf("\nactual signed short data\n");
123 for (i = 0; i < 8; i++)
124 printf(" %d,", vec_actual[i]);
125 printf("\n");
126 }
127
128 int result_wrong_ui (vector unsigned int vec_expected,
129 vector unsigned int vec_actual)
130 {
131 int i;
132
133 for (i = 0; i < 4; i++)
134 if (vec_expected[i] != vec_actual[i])
135 return TRUE;
136
137 return FALSE;
138 }
139
140 void print_ui (vector unsigned int vec_expected,
141 vector unsigned int vec_actual)
142 {
143 int i;
144
145 printf("expected unsigned int data\n");
146 for (i = 0; i < 4; i++)
147 printf(" %d,", vec_expected[i]);
148
149 printf("\nactual unsigned int data\n");
150 for (i = 0; i < 4; i++)
151 printf(" %d,", vec_actual[i]);
152 printf("\n");
153 }
154
155 int result_wrong_si (vector signed int vec_expected,
156 vector signed int vec_actual)
157 {
158 int i;
159
160 for (i = 0; i < 4; i++)
161 if (vec_expected[i] != vec_actual[i])
162 return TRUE;
163
164 return FALSE;
165 }
166
167 void print_si (vector signed int vec_expected,
168 vector signed int vec_actual)
169 {
170 int i;
171
172 printf("expected signed int data\n");
173 for (i = 0; i < 4; i++)
174 printf(" %d,", vec_expected[i]);
175
176 printf("\nactual signed int data\n");
177 for (i = 0; i < 4; i++)
178 printf(" %d,", vec_actual[i]);
179 printf("\n");
180 }
181
182 int result_wrong_ull (vector unsigned long long vec_expected,
183 vector unsigned long long vec_actual)
184 {
185 int i;
186
187 for (i = 0; i < 2; i++)
188 if (vec_expected[i] != vec_actual[i])
189 return TRUE;
190
191 return FALSE;
192 }
193
194 void print_ull (vector unsigned long long vec_expected,
195 vector unsigned long long vec_actual)
196 {
197 int i;
198
199 printf("expected unsigned long long data\n");
200 for (i = 0; i < 2; i++)
201 printf(" %llu,", vec_expected[i]);
202
203 printf("\nactual unsigned long long data\n");
204 for (i = 0; i < 2; i++)
205 printf(" %llu,", vec_actual[i]);
206 printf("\n");
207 }
208
209 int result_wrong_sll (vector signed long long vec_expected,
210 vector signed long long vec_actual)
211 {
212 int i;
213
214 for (i = 0; i < 2; i++)
215 if (vec_expected[i] != vec_actual[i])
216 return TRUE;
217
218 return FALSE;
219 }
220
221 void print_sll (vector signed long long vec_expected,
222 vector signed long long vec_actual)
223 {
224 int i;
225
226 printf("expected signed long long data\n");
227 for (i = 0; i < 2; i++)
228 printf(" %lld,", vec_expected[i]);
229
230 printf("\nactual signed long long data\n");
231 for (i = 0; i < 2; i++)
232 printf(" %lld,", vec_actual[i]);
233 printf("\n");
234 }
235
236 int result_wrong_u128 (vector __uint128_t vec_expected,
237 vector __uint128_t vec_actual)
238 {
239 int i;
240
241 if (vec_expected[0] != vec_actual[0])
242 return TRUE;
243
244 return FALSE;
245 }
246
247 void print_u128 (vector __uint128_t vec_expected,
248 vector __uint128_t vec_actual)
249 {
250 printf("expected uint128 data\n");
251 printf(" %llu%llu\n", (unsigned long long)(vec_expected[0] >> 64),
252 (unsigned long long)(vec_expected[0] & 0xFFFFFFFFFFFFFFFF));
253
254 printf("\nactual uint128 data\n");
255 printf(" %llu%llu\n", (unsigned long long)(vec_actual[0] >> 64),
256 (unsigned long long)(vec_actual[0] & 0xFFFFFFFFFFFFFFFF));
257 }
258
259
260 int result_wrong_s128 (vector __int128_t vec_expected,
261 vector __int128_t vec_actual)
262 {
263 int i;
264
265 if (vec_expected[0] != vec_actual[0])
266 return TRUE;
267
268 return FALSE;
269 }
270
271 void print_s128 (vector __int128 vec_expected,
272 vector __int128 vec_actual)
273 {
274 printf("expected int128 data\n");
275 printf(" %lld%llu\n", (signed long long)(vec_expected[0] >> 64),
276 (unsigned long long)(vec_expected[0] & 0xFFFFFFFFFFFFFFFF));
277
278 printf("\nactual int128 data\n");
279 printf(" %lld%llu\n", (signed long long)(vec_actual[0] >> 64),
280 (unsigned long long)(vec_actual[0] & 0xFFFFFFFFFFFFFFFF));
281 }
282
283 int result_wrong_d (vector double vec_expected,
284 vector double vec_actual)
285 {
286 int i;
287
288 for (i = 0; i < 2; i++)
289 if (vec_expected[i] != vec_actual[i])
290 return TRUE;
291
292 return FALSE;
293 }
294
295 void print_d (vector double vec_expected,
296 vector double vec_actual)
297 {
298 int i;
299
300 printf("expected double data\n");
301 for (i = 0; i < 2; i++)
302 printf(" %f,", vec_expected[i]);
303
304 printf("\nactual double data\n");
305 for (i = 0; i < 2; i++)
306 printf(" %f,", vec_actual[i]);
307 printf("\n");
308 }
309
310 int result_wrong_f (vector float vec_expected,
311 vector float vec_actual)
312 {
313 int i;
314
315 for (i = 0; i < 4; i++)
316 if (vec_expected[i] != vec_actual[i])
317 return TRUE;
318
319 return FALSE;
320 }
321
322 void print_f (vector float vec_expected,
323 vector float vec_actual)
324 {
325 int i;
326
327 printf("expected float data\n");
328 for (i = 0; i < 4; i++)
329 printf(" %f,", vec_expected[i]);
330
331 printf("\nactual float data\n");
332 for (i = 0; i < 4; i++)
333 printf(" %f,", vec_actual[i]);
334 printf("\n");
335 }
336
337 int main() {
338 int i, j;
339 size_t len;
340 vector signed char store_data_sc;
341 vector unsigned char store_data_uc;
342 vector signed int store_data_si;
343 vector unsigned int store_data_ui;
344 vector __int128_t store_data_s128;
345 vector __uint128_t store_data_u128;
346 vector signed long long int store_data_sll;
347 vector unsigned long long int store_data_ull;
348 vector signed short store_data_ss;
349 vector unsigned short store_data_us;
350 vector double store_data_d;
351 vector float store_data_f;
352
353 signed char *address_sc;
354 unsigned char *address_uc;
355 signed int *address_si;
356 unsigned int *address_ui;
357 __int128_t *address_s128;
358 __uint128_t *address_u128;
359 signed long long int *address_sll;
360 unsigned long long int *address_ull;
361 signed short int *address_ss;
362 unsigned short int *address_us;
363 double *address_d;
364 float *address_f;
365
366 vector unsigned char *datap;
367
368 vector unsigned char vec_uc_expected1, vec_uc_result1;
369 vector signed char vec_sc_expected1, vec_sc_result1;
370 vector signed int vec_si_expected1, vec_si_result1;
371 vector unsigned int vec_ui_expected1, vec_ui_result1;
372 vector __int128_t vec_s128_expected1, vec_s128_result1;
373 vector __uint128_t vec_u128_expected1, vec_u128_result1;
374 vector signed long long int vec_sll_expected1, vec_sll_result1;
375 vector unsigned long long int vec_ull_expected1, vec_ull_result1;
376 vector signed short int vec_ss_expected1, vec_ss_result1;
377 vector unsigned short int vec_us_expected1, vec_us_result1;
378 vector double vec_d_expected1, vec_d_result1;
379 vector float vec_f_expected1, vec_f_result1;
380
381 signed long long disp;
382
383 /* VEC_XST */
384 disp = 0;
385 vec_sc_expected1 = (vector signed char){ -7, -6, -5, -4, -3, -2, -1, 0,
386 1, 2, 3, 4, 5, 6, 7, 8 };
387 store_data_sc = (vector signed char){ -7, -6, -5, -4, -3, -2, -1, 0,
388 1, 2, 3, 4, 5, 6, 7, 8 };
389
390 for (i=0; i<16; i++)
391 vec_sc_result1[i] = 0;
392
393 address_sc = &vec_sc_result1[0];
394
395 vec_xst (store_data_sc, disp, address_sc);
396
397 if (result_wrong_sc (vec_sc_expected1, vec_sc_result1))
398 {
399 #ifdef DEBUG
400 printf("Error: vec_xst, sc disp = 0, result does not match expected result\n");
401 print_sc (vec_sc_expected1, vec_sc_result1);
402 #else
403 abort();
404 #endif
405 }
406
407 disp = 2;
408 vec_sc_expected1 = (vector signed char){ 0, 0, -7, -6, -5, -4, -3, -2,
409 -1, 0, 1, 2, 3, 4, 5, 6 };
410 store_data_sc = (vector signed char){ -7, -6, -5, -4, -3, -2, -1, 0,
411 1, 2, 3, 4, 5, 6, 7, 8 };
412
413 for (i=0; i<16; i++)
414 vec_sc_result1[i] = 0;
415
416 address_sc = &vec_sc_result1[0];
417
418 vec_xst (store_data_sc, disp, address_sc);
419
420 if (result_wrong_sc (vec_sc_expected1, vec_sc_result1))
421 {
422 #ifdef DEBUG
423 printf("Error: vec_xst, sc disp = 2, result does not match expected result\n");
424 print_sc (vec_sc_expected1, vec_sc_result1);
425 #else
426 abort();
427 #endif
428 }
429
430 disp = 0;
431 vec_uc_expected1 = (vector unsigned char){ 0, 1, 2, 3, 4, 5, 6, 7,
432 8, 9, 10, 11, 12, 13, 14, 15 };
433 store_data_uc = (vector unsigned char){ 0, 1, 2, 3, 4, 5, 6, 7,
434 8, 9, 10, 11, 12, 13, 14, 15 };
435
436 for (i=0; i<16; i++)
437 vec_uc_result1[i] = 0;
438
439 address_uc = &vec_uc_result1[0];
440
441 vec_xst (store_data_uc, disp, address_uc);
442
443 if (result_wrong_uc (vec_uc_expected1, vec_uc_result1))
444 {
445 #ifdef DEBUG
446 printf("Error: vec_xst, uc disp = 0, result does not match expected result\n");
447 print_uc (vec_uc_expected1, vec_uc_result1);
448 #else
449 abort();
450 #endif
451 }
452
453 disp = 0;
454 vec_ss_expected1 = (vector signed short int){ -4, -3, -2, -1, 0, 1, 2, 3 };
455 store_data_ss = (vector signed short int){ -4, -3, -2, -1, 0, 1, 2, 3 };
456
457 for (i=0; i<8; i++)
458 vec_ss_result1[i] = 0;
459
460 address_ss = &vec_ss_result1[0];
461
462 vec_xst (store_data_ss, disp, address_ss);
463
464 if (result_wrong_ss (vec_ss_expected1, vec_ss_result1))
465 {
466 #ifdef DEBUG
467 printf("Error: vec_xst, ss disp = 0, result does not match expected result\n");
468 print_ss (vec_ss_expected1, vec_ss_result1);
469 #else
470 abort();
471 #endif
472 }
473
474 disp = 0;
475 vec_us_expected1 = (vector unsigned short int){ 0, 1, 2, 3, 4, 5, 6, 7 };
476 store_data_us = (vector unsigned short int){ 0, 1, 2, 3, 4, 5, 6, 7 };
477
478 for (i=0; i<8; i++)
479 vec_us_result1[i] = 0;
480
481 address_us = &vec_us_result1[0];
482
483 vec_xst (store_data_us, disp, address_us);
484
485 if (result_wrong_us (vec_us_expected1, vec_us_result1))
486 {
487 #ifdef DEBUG
488 printf("Error: vec_xst, us disp = 0, result does not match expected result\n");
489 print_us (vec_us_expected1, vec_us_result1);
490 #else
491 abort();
492 #endif
493 }
494
495 disp = 0;
496 vec_si_expected1 = (vector signed int){ -2, -1, 0, 1 };
497 store_data_si = (vector signed int){ -2, -1, 0, 1 };
498
499 for (i=0; i<4; i++)
500 vec_si_result1[i] = 0;
501
502 address_si = &vec_si_result1[0];
503
504 vec_xst (store_data_si, disp, address_si);
505
506 if (result_wrong_si (vec_si_expected1, vec_si_result1))
507 {
508 #ifdef DEBUG
509 printf("Error: vec_xst, si disp = 0, result does not match expected result\n");
510 print_si (vec_si_expected1, vec_si_result1);
511 #else
512 abort();
513 #endif
514 }
515
516 disp = 0;
517 vec_ui_expected1 = (vector unsigned int){ -2, -1, 0, 1 };
518 store_data_ui = (vector unsigned int){ -2, -1, 0, 1 };
519
520 for (i=0; i<4; i++)
521 vec_ui_result1[i] = 0;
522
523 address_ui = &vec_ui_result1[0];
524
525 vec_xst (store_data_ui, disp, address_ui);
526
527 if (result_wrong_ui (vec_ui_expected1, vec_ui_result1))
528 {
529 #ifdef DEBUG
530 printf("Error: vec_xst, ui disp = 0, result does not match expected result\n");
531 print_ui (vec_ui_expected1, vec_ui_result1);
532 #else
533 abort();
534 #endif
535 }
536
537 disp = 0;
538 vec_sll_expected1 = (vector signed long long){ -1, 0 };
539 store_data_sll = (vector signed long long ){ -1, 0 };
540
541 for (i=0; i<2; i++)
542 vec_sll_result1[i] = 0;
543
544 address_sll = (signed long long *)(&vec_sll_result1[0]);
545
546 vec_xst (store_data_sll, disp, address_sll);
547
548 if (result_wrong_sll (vec_sll_expected1, vec_sll_result1))
549 {
550 #ifdef DEBUG
551 printf("Error: vec_xst, sll disp = 0, result does not match expected result\n");
552 print_sll (vec_sll_expected1, vec_sll_result1);
553 #else
554 abort();
555 #endif
556 }
557
558 disp = 0;
559 vec_ull_expected1 = (vector unsigned long long){ 0, 1 };
560 store_data_ull = (vector unsigned long long){ 0, 1 };
561
562 for (i=0; i<2; i++)
563 vec_ull_result1[i] = 0;
564
565 address_ull = (unsigned long long int *)(&vec_ull_result1[0]);
566
567 vec_xst (store_data_ull, disp, address_ull);
568
569 if (result_wrong_ull (vec_ull_expected1, vec_ull_result1))
570 {
571 #ifdef DEBUG
572 printf("Error: vec_xst, ull disp = 0, result does not match expected result\n");
573 print_ull (vec_ull_expected1, vec_ull_result1);
574 #else
575 abort();
576 #endif
577 }
578
579 disp = 0;
580 vec_s128_expected1 = (vector __int128_t){ 12345 };
581 store_data_s128 = (vector __int128_t){ 12345 };
582
583 vec_s128_result1[0] = 0;
584
585 address_s128 = (__int128_t *)(&vec_s128_result1[0]);
586
587 vec_xst (store_data_s128, disp, address_s128);
588
589 if (result_wrong_s128 (vec_s128_expected1, vec_s128_result1))
590 {
591 #ifdef DEBUG
592 printf("Error: vec_xst, s128 disp = 0, result does not match expected result\n");
593 print_s128 (vec_s128_expected1, vec_s128_result1);
594 #else
595 abort();
596 #endif
597 }
598
599 disp = 0;
600 vec_u128_expected1 = (vector __uint128_t){ 12345 };
601 store_data_u128 = (vector __uint128_t){ 12345 };
602
603 vec_u128_result1[0] = 0;
604
605 address_u128 = (__int128_t *)(&vec_u128_result1[0]);
606
607 vec_xst (store_data_u128, disp, address_u128);
608
609 if (result_wrong_u128 (vec_u128_expected1, vec_u128_result1))
610 {
611 #ifdef DEBUG
612 printf("Error: vec_xst, u128 disp = 0, result does not match expected result\n");
613 print_u128 (vec_u128_expected1, vec_u128_result1);
614 #else
615 abort();
616 #endif
617 }
618
619 disp = 0;
620 vec_d_expected1 = (vector double){ 0, 1 };
621 store_data_d = (vector double){ 0, 1 };
622
623 for (i=0; i<2; i++)
624 vec_d_result1[i] = 0;
625
626 address_d = (double *)(&vec_d_result1[0]);
627
628 vec_xst (store_data_d, disp, address_d);
629
630 if (result_wrong_d (vec_d_expected1, vec_d_result1))
631 {
632 #ifdef DEBUG
633 printf("Error: vec_xst, double disp = 0, result does not match expected result\n");
634 print_d (vec_d_expected1, vec_d_result1);
635 #else
636 abort();
637 #endif
638 }
639
640 disp = 0;
641 vec_f_expected1 = (vector float){ 0, 1 };
642 store_data_f = (vector float){ 0, 1 };
643
644 for (i=0; i<4; i++)
645 vec_f_result1[i] = 0;
646
647 address_f = (float *)(&vec_f_result1[0]);
648
649 vec_xst (store_data_f, disp, address_f);
650
651 if (result_wrong_f (vec_f_expected1, vec_f_result1))
652 {
653 #ifdef DEBUG
654 printf("Error: vec_xst, float disp = 0, result does not match expected result\n");
655 print_f (vec_f_expected1, vec_f_result1);
656 #else
657 abort();
658 #endif
659 }
660
661 /* VEC_XST_BE, these always load in BE order regardless of
662 machine endianess. */
663 disp = 0;
664 #ifdef __BIG_ENDIAN__
665 vec_sc_expected1 = (vector signed char){ -7, -6, -5, -4, -3, -2, -1, 0,
666 1, 2, 3, 4, 5, 6, 7, 8 };
667 #else
668 vec_sc_expected1 = (vector signed char){ 8, 7, 6, 5, 4, 3, 2, 1,
669 0, -1, -2, -3, -4, -5, -6, -7 };
670 #endif
671 store_data_sc = (vector signed char){ -7, -6, -5, -4, -3, -2, -1, 0,
672 1, 2, 3, 4, 5, 6, 7, 8 };
673
674 for (i=0; i<16; i++)
675 vec_sc_result1[i] = 0;
676
677 address_sc = &vec_sc_result1[0];
678
679 vec_xst_be (store_data_sc, disp, address_sc);
680
681 if (result_wrong_sc (vec_sc_expected1, vec_sc_result1))
682 {
683 #ifdef DEBUG
684 printf("Error: vec_xst_be, sc disp = 0, result does not match expected result\n");
685 print_sc (vec_sc_expected1, vec_sc_result1);
686 #else
687 abort();
688 #endif
689 }
690
691 disp = 2;
692 #ifdef __BIG_ENDIAN__
693 vec_sc_expected1 = (vector signed char){ 0, 0, -7, -6, -5, -4, -3, -2,
694 -1, 0, 1, 2, 3, 4, 5, 6 };
695 #else
696 vec_sc_expected1 = (vector signed char){ 0, 0, 8, 7, 6, 5, 4, 3,
697 2, 1, 0, -1, -2, -3, -4, -5 };
698 #endif
699 store_data_sc = (vector signed char){ -7, -6, -5, -4, -3, -2, -1, 0,
700 1, 2, 3, 4, 5, 6, 7, 8 };
701
702 for (i=0; i<16; i++)
703 vec_sc_result1[i] = 0;
704
705 address_sc = &vec_sc_result1[0];
706
707 vec_xst_be (store_data_sc, disp, address_sc);
708
709 if (result_wrong_sc (vec_sc_expected1, vec_sc_result1))
710 {
711 #ifdef DEBUG
712 printf("Error: vec_xst_be, sc disp = 2, result does not match expected result\n");
713 print_sc (vec_sc_expected1, vec_sc_result1);
714 #else
715 abort();
716 #endif
717 }
718
719 disp = 0;
720 #ifdef __BIG_ENDIAN__
721 vec_uc_expected1 = (vector unsigned char){ 0, 1, 2, 3, 4, 5, 6, 7,
722 8, 9, 10, 11, 12, 13, 14, 15 };
723 #else
724 vec_uc_expected1 = (vector unsigned char){ 15, 14, 13, 12, 11, 10, 9, 8,
725 7, 6, 5, 4, 3, 2, 1 };
726 #endif
727 store_data_uc = (vector unsigned char){ 0, 1, 2, 3, 4, 5, 6, 7,
728 8, 9, 10, 11, 12, 13, 14, 15 };
729
730 for (i=0; i<16; i++)
731 vec_uc_result1[i] = 0;
732
733 address_uc = &vec_uc_result1[0];
734
735 vec_xst_be (store_data_uc, disp, address_uc);
736
737 if (result_wrong_uc (vec_uc_expected1, vec_uc_result1))
738 {
739 #ifdef DEBUG
740 printf("Error: vec_xst_be, uc disp = 0, result does not match expected result\n");
741 print_uc (vec_uc_expected1, vec_uc_result1);
742 #else
743 abort();
744 #endif
745 }
746
747 disp = 8;
748 #ifdef __BIG_ENDIAN__
749 vec_si_expected1 = (vector signed int){ 0, 0, -8, -7 };
750 #else
751 vec_si_expected1 = (vector signed int){ 0, 0, -5, -6 };
752 #endif
753 store_data_si = (vector signed int){ -8, -7, -6, -5 };
754
755 for (i=0; i<4; i++)
756 vec_si_result1[i] = 0;
757
758 address_si = &vec_si_result1[0];
759
760 vec_xst_be (store_data_si, disp, address_si);
761
762 if (result_wrong_si (vec_si_expected1, vec_si_result1))
763 {
764 #ifdef DEBUG
765 printf("Error: vec_xst_be, si disp = %d, result does not match expected result\n", disp);
766 print_si (vec_si_expected1, vec_si_result1);
767 #else
768 abort();
769 #endif
770 }
771
772 disp = 0;
773 #ifdef __BIG_ENDIAN__
774 vec_ui_expected1 = (vector unsigned int){ 0, 1, 2, 3 };
775 #else
776 vec_ui_expected1 = (vector unsigned int){ 3, 2, 1, 0 };
777 #endif
778 store_data_ui = (vector unsigned int){ 0, 1, 2, 3 };
779
780 for (i=0; i<4; i++)
781 vec_ui_result1[i] = 0;
782
783 address_ui = &vec_ui_result1[0];
784
785 vec_xst_be (store_data_ui, disp, address_ui);
786
787 if (result_wrong_ui (vec_ui_expected1, vec_ui_result1))
788 {
789 #ifdef DEBUG
790 printf("Error: vec_xst_be, ui disp = 0, result does not match expected result\n");
791 print_ui (vec_ui_expected1, vec_ui_result1);
792 #else
793 abort();
794 #endif
795 }
796
797 disp = 0;
798 #ifdef __BIG_ENDIAN__
799 vec_ss_expected1 = (vector signed short int){ -4, -3, -2, -1, 0, 1, 2, 3 };
800 #else
801 vec_ss_expected1 = (vector signed short int){ 3, 2, 1, 0, -1, -2, -3, -4 };
802 #endif
803 store_data_ss = (vector signed short int){ -4, -3, -2, -1, 0, 1, 2, 3 };
804
805 for (i=0; i<8; i++)
806 vec_ss_result1[i] = 0;
807
808 address_ss = &vec_ss_result1[0];
809
810 vec_xst_be (store_data_ss, disp, address_ss);
811
812 if (result_wrong_ss (vec_ss_expected1, vec_ss_result1))
813 {
814 #ifdef DEBUG
815 printf("Error: vec_xst_be, ss disp = 0, result does not match expected result\n");
816 print_ss (vec_ss_expected1, vec_ss_result1);
817 #else
818 abort();
819 #endif
820 }
821
822 disp = 0;
823 #ifdef __BIG_ENDIAN__
824 vec_us_expected1 = (vector unsigned short int){ 0, 1, 2, 3, 4, 5, 6, 7 };
825 #else
826 vec_us_expected1 = (vector unsigned short int){ 7, 6, 5, 4, 3, 2, 1, 0 };
827 #endif
828 store_data_us = (vector unsigned short int){ 0, 1, 2, 3, 4, 5, 6, 7 };
829
830 for (i=0; i<8; i++)
831 vec_us_result1[i] = 0;
832
833 address_us = &vec_us_result1[0];
834
835 vec_xst_be (store_data_us, disp, address_us);
836
837 if (result_wrong_us (vec_us_expected1, vec_us_result1))
838 {
839 #ifdef DEBUG
840 printf("Error: vec_xst_be, us disp = 0, result does not match expected result\n");
841 print_us (vec_us_expected1, vec_us_result1);
842 #else
843 abort();
844 #endif
845 }
846
847 #if 0
848 disp = 0;
849 #ifdef __BIG_ENDIAN__
850 vec_si_expected1 = (vector signed int){ -2, -1, 0, 1 };
851 #else
852 vec_si_expected1 = (vector signed int){ 1, 0, -1, -2 };
853 #endif
854 store_data_si = (vector signed int){ -2, -1, 0, 1 };
855
856 for (i=0; i<4; i++)
857 vec_si_result1[i] = 0;
858
859 address_si = &vec_si_result1[0];
860
861 vec_xst_be (store_data_si, disp, address_si);
862 if (result_wrong_si (vec_si_expected1, vec_si_result1))
863 {
864 #ifdef DEBUG
865 printf("Error: vec_xst_be, si disp = 0, result does not match expected result\n");
866 print_si (vec_si_expected1, vec_si_result1);
867 #else
868 abort();
869 #endif
870 }
871 #endif
872
873 #if 0
874 disp = 0;
875 #ifdef __BIG_ENDIAN__
876 vec_ui_expected1 = (vector unsigned int){ -2, -1, 0, 1 };
877 #else
878 vec_ui_expected1 = (vector unsigned int){ 1, 0, -1, -2 };
879 #endif
880 store_data_ui = (vector unsigned int){ -2, -1, 0, 1 };
881
882 for (i=0; i<4; i++)
883 vec_ui_result1[i] = 0;
884
885 address_ui = &vec_ui_result1[0];
886
887 vec_xst_be (store_data_ui, disp, address_ui);
888
889 if (result_wrong_ui (vec_ui_expected1, vec_ui_result1))
890 {
891 #ifdef DEBUG
892 printf("Error: vec_xst_be, ui disp = 0, result does not match expected result\n");
893 print_ui (vec_ui_expected1, vec_ui_result1);
894 #else
895 abort();
896 #endif
897 }
898 #endif
899
900 disp = 0;
901 #ifdef __BIG_ENDIAN__
902 vec_sll_expected1 = (vector signed long long){ -1, 0 };
903 #else
904 vec_sll_expected1 = (vector signed long long){ 0, -1 };
905 #endif
906 store_data_sll = (vector signed long long ){ -1, 0 };
907
908 for (i=0; i<2; i++)
909 vec_sll_result1[i] = 0;
910
911 address_sll = (signed long long *)(&vec_sll_result1[0]);
912
913 vec_xst_be (store_data_sll, disp, address_sll);
914
915 if (result_wrong_sll (vec_sll_expected1, vec_sll_result1))
916 {
917 #ifdef DEBUG
918 printf("Error: vec_xst_be, sll disp = 0, result does not match expected result\n");
919 print_sll (vec_sll_expected1, vec_sll_result1);
920 #else
921 abort();
922 #endif
923 }
924
925 disp = 0;
926 #ifdef __BIG_ENDIAN__
927 vec_ull_expected1 = (vector unsigned long long){ 0, 1234567890123456 };
928 #else
929 vec_ull_expected1 = (vector unsigned long long){1234567890123456, 0 };
930 #endif
931 store_data_ull = (vector unsigned long long){ 0, 1234567890123456 };
932
933 for (i=0; i<2; i++)
934 vec_ull_result1[i] = 0;
935
936 address_ull = (unsigned long long int *)(&vec_ull_result1[0]);
937
938 vec_xst_be (store_data_ull, disp, address_ull);
939
940 if (result_wrong_ull (vec_ull_expected1, vec_ull_result1))
941 {
942 #ifdef DEBUG
943 printf("Error: vec_xst_be, ull disp = 0, result does not match expected result\n");
944 print_ull (vec_ull_expected1, vec_ull_result1);
945 #else
946 abort();
947 #endif
948 }
949
950 disp = 0;
951
952 #ifdef __BIG_ENDIAN__
953 vec_s128_expected1 = (vector __int128_t){ (__uint128_t)12345678911121314 };
954 #else
955 vec_s128_expected1 = (vector __int128_t){ (__uint128_t)12345678911121314 };
956 #endif
957 store_data_s128 = (vector __int128_t)(__uint128_t){ 12345678911121314 };
958
959 vec_s128_result1[0] = 0;
960
961 address_s128 = (__int128_t *)(&vec_s128_result1[0]);
962
963 vec_xst_be (store_data_s128, disp, address_s128);
964
965 if (result_wrong_s128 (vec_s128_expected1, vec_s128_result1))
966 {
967 #ifdef DEBUG
968 printf("Error: vec_xst_be, s128 disp = 0, result does not match expected result\n");
969 print_s128 (vec_s128_expected1, vec_s128_result1);
970 #else
971 abort();
972 #endif
973 }
974
975 disp = 0;
976 #ifdef __BIG_ENDIAN__
977 vec_u128_expected1 = (vector __uint128_t){ (__uint128_t)1234567891112131415 };
978 #else
979 vec_u128_expected1 = (vector __uint128_t){ (__uint128_t)1234567891112131415 };
980 #endif
981 store_data_u128 = (vector __uint128_t){ (__uint128_t)1234567891112131415 };
982
983 vec_u128_result1[0] = 0;
984
985 address_u128 = (__int128_t *)(&vec_u128_result1[0]);
986
987 vec_xst_be (store_data_u128, disp, address_u128);
988
989 if (result_wrong_u128 (vec_u128_expected1, vec_u128_result1))
990 {
991 #ifdef DEBUG
992 printf("Error: vec_xst_be, u128 disp = 0, result does not match expected result\n");
993 print_u128 (vec_u128_expected1, vec_u128_result1);
994 #else
995 abort();
996 #endif
997 }
998
999 disp = 0;
1000 #ifdef __BIG_ENDIAN__
1001 vec_d_expected1 = (vector double){ 0.0, 1.1 };
1002 #else
1003 vec_d_expected1 = (vector double){ 1.1, 0.0 };
1004 #endif
1005 store_data_d = (vector double){ 0.0, 1.1 };
1006
1007 for (i=0; i<2; i++)
1008 vec_d_result1[i] = 0;
1009
1010 address_d = (double *)(&vec_d_result1[0]);
1011
1012 vec_xst_be (store_data_d, disp, address_d);
1013
1014 if (result_wrong_d (vec_d_expected1, vec_d_result1))
1015 {
1016 #ifdef DEBUG
1017 printf("Error: vec_xst_be, double disp = 0, result does not match expected result\n");
1018 print_d (vec_d_expected1, vec_d_result1);
1019 #else
1020 abort();
1021 #endif
1022 }
1023
1024 disp = 0;
1025 #ifdef __BIG_ENDIAN__
1026 vec_f_expected1 = (vector float){ 0.0, 1.2, 2.3, 3.4 };
1027 #else
1028 vec_f_expected1 = (vector float){ 3.4, 2.3, 1.2, 0.0 };
1029 #endif
1030 store_data_f = (vector float){ 0.0, 1.2, 2.3, 3.4 };
1031
1032 for (i=0; i<4; i++)
1033 vec_f_result1[i] = 0;
1034
1035 address_f = (float *)(&vec_f_result1[0]);
1036
1037 vec_xst_be (store_data_f, disp, address_f);
1038
1039 if (result_wrong_f (vec_f_expected1, vec_f_result1))
1040 {
1041 #ifdef DEBUG
1042 printf("Error: vec_xst_be, float disp = 0, result does not match expected result\n");
1043 print_f (vec_f_expected1, vec_f_result1);
1044 #else
1045 abort();
1046 #endif
1047 }
1048 }