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

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