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

   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 }