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

   1 /* { dg-do run } */
   2 /* { dg-require-effective-target vsx_hw } */
   3 /* { dg-options "-maltivec -mvsx" } */
   4
   5 #include <inttypes.h>
   6 #include <altivec.h> // vector
   7
   8 #ifdef DEBUG
   9 #include <stdio.h>
  10 #endif
  11
  12 void abort (void);
  13
  14 int main() {
  15   int i;
  16   signed char data_c[100];
  17   unsigned char data_uc[100];
  18
  19   signed short int data_ssi[100];
  20   unsigned short int data_usi[100];
  21
  22   signed int data_si[100];
  23   unsigned int data_ui[100];
  24
  25   signed long long data_sll[100];
  26   unsigned long long data_ull[100];
  27
  28   float data_f[100];
  29   double data_d[100];
  30   signed long long disp;
  31
  32   vector signed char vec_c_expected1, vec_c_expected2, vec_c_result1, vec_c_result2;
  33   vector unsigned char vec_uc_expected1, vec_uc_expected2,
  34     vec_uc_result1, vec_uc_result2;
  35   vector signed short int vec_ssi_expected1, vec_ssi_expected2,
  36     vec_ssi_result1, vec_ssi_result2;
  37   vector unsigned short int  vec_usi_expected1, vec_usi_expected2,
  38     vec_usi_result1, vec_usi_result2;
  39   vector signed int vec_si_expected1, vec_si_expected2, vec_si_result1,
  40     vec_si_result2;
  41   vector unsigned int vec_ui_expected1, vec_ui_expected2, vec_ui_result1,
  42     vec_ui_result2;
  43   vector signed long long vec_sll_expected1, vec_sll_expected2,
  44     vec_sll_result1, vec_sll_result2;
  45   vector unsigned long long vec_ull_expected1, vec_ull_expected2,
  46     vec_ull_result1, vec_ull_result2;
  47   vector float vec_f_expected1, vec_f_expected2, vec_f_result1, vec_f_result2;
  48   vector double vec_d_expected1, vec_d_expected2, vec_d_result1, vec_d_result2;
  49   char buf[20];
  50   signed long long zero = (signed long long) 0;
  51
  52   for (i = 0; i < 100; i++)
  53     {
  54       data_c[i] = i;
  55       data_uc[i] = i+1;
  56       data_ssi[i] = i+10;
  57       data_usi[i] = i+11;
  58       data_si[i] = i+100;
  59       data_ui[i] = i+101;
  60       data_sll[i] = i+1000;
  61       data_ull[i] = i+1001;
  62       data_f[i] = i+100000.0;
  63       data_d[i] = i+1000000.0;
  64     }
  65
  66   // vec_xl() tests
  67   disp = 1;
  68
  69   vec_c_expected1 = (vector signed char){0, 1, 2, 3, 4, 5, 6, 7,
  70                                          8, 9, 10, 11, 12, 13, 14, 15};
  71   vec_c_result1 = vec_xl (0, data_c);
  72
  73   vec_c_expected2 = (vector signed char){1, 2, 3, 4, 5, 6, 7, 8, 9,
  74                                          10, 11, 12, 13, 14, 15, 16};
  75   vec_c_result2 = vec_xl (disp, data_c);
  76
  77   vec_uc_expected1 = (vector unsigned char){1, 2, 3, 4, 5, 6, 7, 8, 9,
  78                                             10, 11, 12, 13, 14, 15, 16};
  79   vec_uc_result1 = vec_xl (0, data_uc);
  80
  81   vec_uc_expected2 = (vector unsigned char){2, 3, 4, 5, 6, 7, 8, 9, 10,
  82                                             11, 12, 13, 14, 15, 16, 17};
  83   vec_uc_result2 = vec_xl (disp, data_uc);
  84
  85   for (i = 0; i < 16; i++)
  86     {
  87       if (vec_c_result1[i] != vec_c_expected1[i])
  88 #ifdef DEBUG
  89         printf("Error: vec_xl(), vec_c_result1[%d] = %d; vec_c_expected1[%d] = %d\n",
  90                i,  vec_c_result1[i], i, vec_c_expected1[i]);
  91 #else
  92         abort ();
  93 #endif
  94       if (vec_c_result2[i] != vec_c_expected2[i])
  95 #ifdef DEBUG
  96         printf("Error: vec_xl(), vec_c_result2[%d] = %d; vec_c_expected2[%d] = %d\n",
  97                i,  vec_c_result2[i], i, vec_c_expected2[i]);
  98 #else
  99         abort ();
 100 #endif
 101
 102       if (vec_uc_result1[i] != vec_uc_expected1[i])
 103 #ifdef DEBUG
 104         printf("Error: vec_xl(), vec_uc_result1[%d] = %d; vec_uc_expected1[%d] = %d\n",
 105                i,  vec_uc_result1[i], i, vec_uc_expected1[i]);
 106 #else
 107         abort ();
 108 #endif
 109
 110       if (vec_uc_result2[i] != vec_uc_expected2[i])
 111 #ifdef DEBUG
 112         printf("Error: vec_xl(), vec_uc_result2[%d] = %d; vec_uc_expected2[%d] = %d\n",
 113                i,  vec_uc_result2[i], i, vec_uc_expected2[i]);
 114 #else
 115         abort ();
 116 #endif
 117     }
 118
 119   disp = 2;
 120   vec_ssi_expected1 = (vector signed short){10, 11, 12, 13, 14, 15, 16, 17};
 121
 122   vec_ssi_result1 = vec_xl (0, data_ssi);
 123
 124   vec_ssi_expected2 = (vector signed short){11, 12, 13, 14, 15, 16, 17, 18};
 125   vec_ssi_result2 = vec_xl (disp, data_ssi);
 126
 127   vec_usi_expected1 = (vector unsigned short){11, 12, 13, 14, 15, 16, 17, 18};
 128   vec_usi_result1 = vec_xl (0, data_usi);
 129
 130   vec_usi_expected2 = (vector unsigned short){12, 13, 14, 15, 16, 17, 18, 19};
 131   vec_usi_result2 = vec_xl (disp, data_usi);
 132
 133
 134   for (i = 0; i < 8; i++)
 135     {
 136       if (vec_ssi_result1[i] != vec_ssi_expected1[i])
 137 #ifdef DEBUG
 138         printf("Error: vec_xl(), vec_ssi_result1[%d] = %d; vec_ssi_expected1[%d] = %d\n",
 139                i,  vec_ssi_result1[i], i, vec_ssi_expected1[i]);
 140 #else
 141         abort ();
 142 #endif
 143       if (vec_ssi_result2[i] != vec_ssi_expected2[i])
 144 #ifdef DEBUG
 145         printf("Error: vec_xl(), vec_ssi_result2[%d] = %d; vec_ssi_expected2[%d] = %d\n",
 146                i,  vec_ssi_result2[i], i, vec_ssi_expected2[i]);
 147 #else
 148         abort ();
 149 #endif
 150
 151       if (vec_usi_result1[i] != vec_usi_expected1[i])
 152 #ifdef DEBUG
 153         printf("Error: vec_xl(), vec_usi_result1[%d] = %d; vec_usi_expected1[%d] = %d\n",
 154                i,  vec_usi_result1[i], i, vec_usi_expected1[i]);
 155 #else
 156         abort ();
 157 #endif
 158
 159       if (vec_usi_result2[i] != vec_usi_expected2[i])
 160 #ifdef DEBUG
 161         printf("Error: vec_xl(), vec_usi_result2[%d] = %d; vec_usi_expected2[%d] = %d\n",
 162                i,  vec_usi_result2[i], i, vec_usi_expected2[i]);
 163 #else
 164         abort ();
 165 #endif
 166     }
 167
 168   disp = 4;
 169   vec_si_result1 = vec_xl (zero, data_si);
 170   vec_si_expected1 = (vector int){100, 101, 102, 103};
 171
 172   vec_si_result2 = vec_xl (disp, data_si);
 173   vec_si_expected2 = (vector int){101, 102, 103, 104};
 174
 175   vec_ui_result1 = vec_xl (zero, data_ui);
 176   vec_ui_expected1 = (vector unsigned int){101, 102, 103, 104};
 177
 178   vec_ui_result2 = vec_xl (disp, data_ui);
 179   vec_ui_expected2 = (vector unsigned int){102, 103, 104, 105};
 180
 181   for (i = 0; i < 4; i++)
 182     {
 183       if (vec_si_result1[i] != vec_si_expected1[i])
 184 #ifdef DEBUG
 185         printf("Error: vec_xl(), vec_si_result1[%d] = %d; vec_si_expected1[%d] = %d\n",
 186                i,  vec_si_result1[i], i, vec_si_expected1[i]);
 187 #else
 188         abort ();
 189 #endif
 190       if (vec_si_result2[i] != vec_si_expected2[i])
 191 #ifdef DEBUG
 192         printf("Error: vec_xl(), vec_si_result2[%d] = %d; vec_si_expected2[%d] = %d\n",
 193                i,  vec_si_result2[i], i, vec_si_expected2[i]);
 194 #else
 195         abort ();
 196 #endif
 197
 198       if (vec_ui_result1[i] != vec_ui_expected1[i])
 199 #ifdef DEBUG
 200         printf("Error: vec_xl(), vec_ui_result1[%d] = %d; vec_ui_expected1[%d] = %d\n",
 201                i,  vec_ui_result1[i], i, vec_ui_expected1[i]);
 202 #else
 203         abort ();
 204 #endif
 205
 206       if (vec_ui_result2[i] != vec_ui_expected2[i])
 207 #ifdef DEBUG
 208         printf("Error: vec_xl(), vec_ui_result2[%d] = %d; vec_ui_expected1[%d] = %d\n",
 209                i,  vec_si_result2[i], i, vec_ui_expected1[i]);
 210 #else
 211         abort ();
 212 #endif
 213     }
 214
 215   disp = 8;
 216   vec_sll_result1 = vec_xl (zero, data_sll);
 217   vec_sll_expected1 = (vector signed long long){1000, 1001};
 218
 219   vec_sll_result2 = vec_xl (disp, data_sll);
 220   vec_sll_expected2 = (vector signed long long){1001, 1002};
 221
 222   vec_ull_result1 = vec_xl (zero, data_ull);
 223   vec_ull_expected1 = (vector unsigned long long){1001, 1002};
 224
 225   vec_ull_result2 = vec_xl (disp, data_ull);
 226   vec_ull_expected2 = (vector unsigned long long){1002, 1003};
 227
 228   for (i = 0; i < 2; i++)
 229     {
 230       if (vec_sll_result1[i] != vec_sll_expected1[i])
 231 #ifdef DEBUG
 232         printf("Error: vec_xl(), vec_sll_result1[%d] = %lld; vec_sll_expected1[%d] = %lld\n",
 233                i,  vec_sll_result1[i], i, vec_sll_expected1[i]);
 234 #else
 235         abort ();
 236 #endif
 237
 238       if (vec_sll_result2[i] != vec_sll_expected2[i])
 239 #ifdef DEBUG
 240         printf("Error: vec_xl(), vec_sll_result2[%d] = %lld; vec_sll_expected2[%d] = %lld\n",
 241                i,  vec_sll_result2[i], i, vec_sll_expected2[i]);
 242 #else
 243         abort ();
 244 #endif
 245
 246       if (vec_ull_result1[i] != vec_ull_expected1[i])
 247 #ifdef DEBUG
 248         printf("Error: vec_xl(), vec_ull_result1[%d] = %lld; vec_ull_expected1[%d] = %lld\n",
 249                i,  vec_ull_result1[i], i, vec_ull_expected1[i]);
 250 #else
 251         abort ();
 252 #endif
 253
 254       if (vec_ull_result2[i] != vec_ull_expected2[i])
 255 #ifdef DEBUG
 256         printf("Error: vec_xl(), vec_ull_result2[%d] = %lld; vec_ull_expected2[%d] = %lld\n",
 257                i,  vec_ull_result2[i], i, vec_ull_expected2[i]);
 258 #else
 259         abort ();
 260 #endif
 261     }
 262
 263   disp = 4;
 264   vec_f_result1 = vec_xl (zero, data_f);
 265   vec_f_expected1 = (vector float){100000.0, 100001.0, 100002.0, 100003.0};
 266
 267   vec_f_result2 = vec_xl (disp, data_f);
 268   vec_f_expected2 = (vector float){100001.0, 100002.0, 100003.0, 100004.0};
 269
 270   for (i = 0; i < 4; i++)
 271     {
 272       if (vec_f_result1[i] != vec_f_expected1[i])
 273 #ifdef DEBUG
 274         printf("Error: vec_xl(), vec_f_result1[%d] = %f; vec_f_expected1[%d] = %f\n",
 275                i,  vec_f_result1[i], i, vec_f_expected1[i]);
 276 #else
 277         abort ();
 278 #endif
 279
 280       if (vec_f_result2[i] != vec_f_expected2[i])
 281 #ifdef DEBUG
 282         printf("Error: vec_xl(), vec_f_result2[%d] = %f; vec_f_expected2[%d] = %f\n",
 283                i,  vec_f_result2[i], i, vec_f_expected2[i]);
 284 #else
 285         abort ();
 286 #endif
 287     }
 288
 289   disp = 8;
 290   vec_d_result1 = vec_xl (zero, data_d);
 291   vec_d_expected1 = (vector double){1000000.0, 1000001.0};
 292
 293   vec_d_result2 = vec_xl (disp, data_d);
 294   vec_d_expected2 = (vector double){1000001.0, 1000002.0};
 295
 296   for (i = 0; i < 2; i++)
 297     {
 298       if (vec_d_result1[i] != vec_d_expected1[i])
 299 #ifdef DEBUG
 300         printf("Error: vec_xl(), vec_d_result1[%d] = %f; vec_f_expected1[%d] = %f\n",
 301                i,  vec_d_result1[i], i, vec_d_expected1[i]);
 302 #else
 303         abort ();
 304 #endif
 305
 306       if (vec_d_result2[i] != vec_d_expected2[i])
 307 #ifdef DEBUG
 308         printf("Error: vec_xl(), vec_d_result2[%d] = %f; vec_f_expected2[%d] = %f\n",
 309                i,  vec_d_result2[i], i, vec_d_expected2[i]);
 310 #else
 311         abort ();
 312 #endif
 313     }
 314
 315   // vec_xl_be() tests
 316   disp = 1;
 317 #ifdef __BIG_ENDIAN__
 318   vec_c_expected1 = (vector signed char){0, 1, 2, 3, 4, 5, 6, 7,
 319                                          8, 9, 10, 11, 12, 13, 14, 15};
 320 #else
 321   vec_c_expected1 = (vector signed char){15, 14, 13, 12, 11, 10, 9, 8,
 322                                          7, 6, 5, 4, 3, 2, 1, 0};
 323 #endif
 324   vec_c_result1 = vec_xl_be (0, data_c);
 325
 326
 327
 328 #ifdef __BIG_ENDIAN__
 329   vec_c_expected2 = (vector signed char){1, 2, 3, 4, 5, 6, 7, 8,
 330                                          9, 10, 11, 12, 13, 14, 15, 16};
 331 #else
 332   vec_c_expected2 = (vector signed char){16, 15, 14, 13, 12, 11, 10, 9,
 333                                          8, 7, 6, 5, 4, 3, 2, 1};
 334 #endif
 335
 336   vec_c_result2 = vec_xl_be (disp, data_c);
 337
 338 #ifdef __BIG_ENDIAN__
 339   vec_uc_expected1 = (vector unsigned char){1, 2, 3, 4, 5, 6, 7, 8,
 340                                             9, 10, 11, 12, 13, 14, 15, 16};
 341 #else
 342   vec_uc_expected1 = (vector unsigned char){16, 15, 14, 13, 12, 11, 10, 9,
 343                                          8, 7, 6, 5, 4, 3, 2, 1};
 344 #endif
 345
 346   vec_uc_result1 = vec_xl_be (0, data_uc);
 347
 348 #ifdef __BIG_ENDIAN__
 349   vec_uc_expected2 = (vector unsigned char){2, 3, 4, 5, 6, 7, 8, 9,
 350                                             10, 11, 12, 13, 14, 15, 16, 17};
 351 #else
 352   vec_uc_expected2 = (vector unsigned char){17, 16, 15, 14, 13, 12, 11, 10,
 353                                             9, 8, 7, 6, 5, 4, 3, 2};
 354 #endif
 355
 356   vec_uc_result2 = vec_xl_be (disp, data_uc);
 357
 358   for (i = 0; i < 16; i++)
 359     {
 360       if (vec_c_result1[i] != vec_c_expected1[i])
 361 #ifdef DEBUG
 362         printf("Error: vec_xl_be(), vec_c_result1[%d] = %d; vec_c_expected1[%d] = %d\n",
 363                i,  vec_c_result1[i], i, vec_c_expected1[i]);
 364 #else
 365         abort ();
 366 #endif
 367
 368       if (vec_c_result2[i] != vec_c_expected2[i])
 369 #ifdef DEBUG
 370         printf("Error: vec_xl_be(), vec_c_result2[%d] = %d; vec_c_expected2[%d] = %d\n",
 371                i,  vec_c_result2[i], i, vec_c_expected2[i]);
 372 #else
 373         abort ();
 374 #endif
 375
 376       if (vec_uc_result1[i] != vec_uc_expected1[i])
 377 #ifdef DEBUG
 378         printf("Error: vec_xl_be(), vec_uc_result1[%d] = %d; vec_uc_expected1[%d] = %d\n",
 379                i,  vec_uc_result1[i], i, vec_uc_expected1[i]);
 380 #else
 381         abort ();
 382 #endif
 383
 384       if (vec_uc_result2[i] != vec_uc_expected2[i])
 385 #ifdef DEBUG
 386         printf("Error: vec_xl_be(), vec_uc_result2[%d] = %d; vec_uc_expected2[%d] = %d\n",
 387                i,  vec_uc_result1[i], i, vec_uc_expected1[i]);
 388 #else
 389         abort ();
 390 #endif
 391     }
 392
 393   vec_ssi_result1 = vec_xl_be (zero, data_ssi);
 394
 395 #ifdef __BIG_ENDIAN__
 396   vec_ssi_expected1 = (vector signed short){10, 11, 12, 13, 14, 15, 16, 17};
 397 #else
 398   vec_ssi_expected1 = (vector signed short){17, 16, 15, 14, 13, 12, 11, 10};
 399 #endif
 400
 401   disp = 2;
 402   vec_ssi_result2 = vec_xl_be (disp, data_ssi);
 403
 404 #ifdef __BIG_ENDIAN__
 405   vec_ssi_expected2 = (vector signed short){11, 12, 13, 14, 15, 16, 17, 18};
 406 #else
 407   vec_ssi_expected2 = (vector signed short){18, 17, 16, 15, 14, 13, 12, 11};
 408 #endif
 409
 410   vec_usi_result1 = vec_xl_be (zero, data_usi);
 411
 412 #ifdef __BIG_ENDIAN__
 413   vec_usi_expected1 = (vector unsigned short){11, 12, 13, 14, 15, 16, 17, 18};
 414 #else
 415   vec_usi_expected1 = (vector unsigned short){18, 17, 16, 15, 14, 13, 12, 11};
 416 #endif
 417
 418   disp = 2;
 419   vec_usi_result2 = vec_xl_be (disp, data_usi);
 420
 421 #ifdef __BIG_ENDIAN__
 422   vec_usi_expected2 = (vector unsigned short){12, 13, 14, 15, 16, 17, 18, 19};
 423 #else
 424   vec_usi_expected2 = (vector unsigned short){19, 18, 17, 16, 15, 14, 13, 12};
 425 #endif
 426
 427   for (i = 0; i < 8; i++)
 428     {
 429       if (vec_ssi_result1[i] != vec_ssi_expected1[i])
 430 #ifdef DEBUG
 431         printf("Error: vec_xl_be(), vec_ssi_result1[%d] = %d; vec_ssi_expected1[%d] = %d\n",
 432                i,  vec_ssi_result1[i], i, vec_ssi_expected1[i]);
 433 #else
 434         abort ();
 435 #endif
 436
 437       if (vec_ssi_result2[i] != vec_ssi_expected2[i])
 438 #ifdef DEBUG
 439         printf("Error: vec_xl_be(), vec_ssi_result2[%d] = %d; vec_ssi_expected2[%d] = %d\n",
 440                i,  vec_ssi_result2[i], i, vec_ssi_expected2[i]);
 441 #else
 442         abort ();
 443 #endif
 444
 445       if (vec_usi_result1[i] != vec_usi_expected1[i])
 446 #ifdef DEBUG
 447         printf("Error: vec_xl_be(), vec_usi_result1[%d] = %d; vec_usi_expected1[%d] = %d\n",
 448                i,  vec_usi_result1[i], i, vec_usi_expected1[i]);
 449 #else
 450         abort ();
 451 #endif
 452
 453       if (vec_usi_result2[i] != vec_usi_expected2[i])
 454 #ifdef DEBUG
 455         printf("Error: vec_xl_be(), vec_usi_result2[%d] = %d; vec_usi_expected2[%d] = %d\n",
 456                i,  vec_usi_result2[i], i, vec_usi_expected2[i]);
 457 #else
 458         abort ();
 459 #endif
 460     }
 461
 462   vec_si_result1 = vec_xl_be (zero, data_si);
 463
 464 #ifdef __BIG_ENDIAN__
 465   vec_si_expected1 = (vector int){100, 101, 102, 103};
 466 #else
 467   vec_si_expected1 = (vector int){103, 102, 101, 100};
 468 #endif
 469
 470   disp = 4;
 471   vec_si_result2 = vec_xl_be (disp, data_si);
 472
 473 #ifdef __BIG_ENDIAN__
 474   vec_si_expected2 = (vector int){101, 102, 103, 104};
 475 #else
 476   vec_si_expected2 = (vector int){104, 103, 102, 101};
 477 #endif
 478
 479   vec_ui_result1 = vec_xl_be (zero, data_ui);
 480
 481 #ifdef __BIG_ENDIAN__
 482   vec_ui_expected1 = (vector unsigned int){101, 102, 103, 104};
 483 #else
 484   vec_ui_expected1 = (vector unsigned int){104, 103, 102, 101};
 485 #endif
 486
 487   disp = 4;
 488   vec_ui_result2 = vec_xl_be (disp, data_ui);
 489
 490 #ifdef __BIG_ENDIAN__
 491   vec_ui_expected2 = (vector unsigned int){102, 103, 104, 105};
 492 #else
 493   vec_ui_expected2 = (vector unsigned int){105, 104, 103, 102};
 494 #endif
 495
 496
 497   for (i = 0; i < 4; i++)
 498     {
 499       if (vec_si_result1[i] != vec_si_expected1[i])
 500 #ifdef DEBUG
 501         printf("Error: vec_xl_be(), vec_si_result1[%d] = %d; vec_si_expected1[%d] = %d\n",
 502                i,  vec_si_result1[i], i, vec_si_expected1[i]);
 503 #else
 504         abort ();
 505 #endif
 506
 507       if (vec_si_result2[i] != vec_si_expected2[i])
 508 #ifdef DEBUG
 509         printf("Error: vec_xl_be(), vec_si_result2[%d] = %d; vec_si_expected2[%d] = %d\n",
 510                i,  vec_si_result2[i], i, vec_si_expected2[i]);
 511 #else
 512         abort ();
 513 #endif
 514
 515       if (vec_ui_result1[i] != vec_ui_expected1[i])
 516 #ifdef DEBUG
 517         printf("Error: vec_xl_be(), vec_ui_result1[%d] = %d; vec_ui_expected1[%d] = %d\n",
 518                i,  vec_ui_result1[i], i, vec_ui_expected1[i]);
 519 #else
 520         abort ();
 521 #endif
 522
 523       if (vec_ui_result2[i] != vec_ui_expected2[i])
 524 #ifdef DEBUG
 525         printf("Error: vec_xl_be(), vec_ui_result2[%d] = %d; vec_ui_expected2[%d] = %d\n",
 526                i,  vec_ui_result2[i], i, vec_ui_expected2[i]);
 527 #else
 528         abort ();
 529 #endif
 530     }
 531
 532   vec_sll_result1 = vec_xl_be (zero, data_sll);
 533
 534 #ifdef __BIG_ENDIAN__
 535   vec_sll_expected1 = (vector signed long long){1000, 1001};
 536 #else
 537   vec_sll_expected1 = (vector signed long long){1001, 1000};
 538 #endif
 539
 540   disp = 8;
 541   vec_sll_result2 = vec_xl_be (disp, data_sll);
 542
 543 #ifdef __BIG_ENDIAN__
 544   vec_sll_expected2 = (vector signed long long){1001, 1002};
 545 #else
 546   vec_sll_expected2 = (vector signed long long){1002, 1001};
 547 #endif
 548
 549   vec_ull_result1 = vec_xl_be (zero, data_ull);
 550
 551 #ifdef __BIG_ENDIAN__
 552   vec_ull_expected1 = (vector unsigned long long){1001, 1002};
 553 #else
 554   vec_ull_expected1 = (vector unsigned long long){1002, 1001};
 555 #endif
 556
 557   disp = 8;
 558   vec_ull_result2 = vec_xl_be (disp, data_ull);
 559
 560 #ifdef __BIG_ENDIAN__
 561   vec_ull_expected2 = (vector unsigned long long){1002, 1003};
 562 #else
 563   vec_ull_expected2 = (vector unsigned long long){1003, 1002};
 564 #endif
 565
 566
 567   for (i = 0; i < 2; i++)
 568     {
 569       if (vec_sll_result1[i] != vec_sll_expected1[i])
 570 #ifdef DEBUG
 571         printf("Error: vec_xl_be(), vec_sll_result1[%d] = %lld; vec_sll_expected1[%d] = %d\n",
 572                i,  vec_sll_result1[i], i, vec_sll_expected1[i]);
 573 #else
 574         abort ();
 575 #endif
 576
 577       if (vec_sll_result2[i] != vec_sll_expected2[i])
 578 #ifdef DEBUG
 579         printf("Error: vec_xl_be(), vec_sll_result2[%d] = %lld; vec_sll_expected2[%d] = %d\n",
 580                i,  vec_sll_result2[i], i, vec_sll_expected2[i]);
 581 #else
 582         abort ();
 583 #endif
 584
 585       if (vec_ull_result1[i] != vec_ull_expected1[i])
 586 #ifdef DEBUG
 587         printf("Error: vec_xl_be(), vec_ull_result1[%d] = %lld; vec_ull_expected1[%d] = %d\n",
 588                i,  vec_ull_result1[i], i, vec_ull_expected1[i]);
 589 #else
 590         abort ();
 591 #endif
 592
 593       if (vec_ull_result2[i] != vec_ull_expected2[i])
 594 #ifdef DEBUG
 595         printf("Error: vec_xl_be(), vec_ull_result2[%d] = %lld; vec_ull_expected2[%d] = %d\n",
 596                i,  vec_ull_result2[i], i, vec_sll_expected2[i]);
 597 #else
 598         abort ();
 599 #endif
 600     }
 601
 602   vec_f_result1 = vec_xl_be (zero, data_f);
 603
 604 #ifdef __BIG_ENDIAN__
 605   vec_f_expected1 = (vector float){100000.0, 100001.0, 100002.0, 100003.0};
 606 #else
 607   vec_f_expected1 = (vector float){100003.0, 100002.0, 100001.0, 100000.0};
 608 #endif
 609
 610   disp = 4;
 611   vec_f_result2 = vec_xl_be (disp, data_f);
 612
 613 #ifdef __BIG_ENDIAN__
 614   vec_f_expected2 = (vector float){100001.0, 100002.0, 100003.0, 100004.0};
 615 #else
 616   vec_f_expected2 = (vector float){100004.0, 100003.0, 100002.0, 100001.0};
 617 #endif
 618
 619   for (i = 0; i < 4; i++)
 620     {
 621       if (vec_f_result1[i] != vec_f_expected1[i])
 622 #ifdef DEBUG
 623         printf("Error: vec_xl_be(), vec_f_result1[%d] = %f; vec_f_expected1[%d] = %f\n",
 624                i,  vec_f_result1[i], i, vec_f_expected1[i]);
 625 #else
 626         abort ();
 627 #endif
 628
 629       if (vec_f_result2[i] != vec_f_expected2[i])
 630 #ifdef DEBUG
 631         printf("Error: vec_xl_be(), vec_f_result2[%d] = %f; vec_f_expected2[%d] = %f\n",
 632                i,  vec_f_result2[i], i, vec_f_expected2[i]);
 633 #else
 634         abort ();
 635 #endif
 636     }
 637
 638   vec_d_result1 = vec_xl_be (zero, data_d);
 639
 640 #ifdef __BIG_ENDIAN__
 641   vec_d_expected1 = (vector double){1000000.0, 1000001.0};
 642 #else
 643   vec_d_expected1 = (vector double){1000001.0, 1000000.0};
 644 #endif
 645
 646   disp = 8;
 647   vec_d_result2 = vec_xl_be (disp, data_d);
 648
 649 #ifdef __BIG_ENDIAN__
 650   vec_d_expected2 = (vector double){1000001.0, 1000002.0};
 651 #else
 652   vec_d_expected2 = (vector double){1000002.0, 1000001.0};
 653 #endif
 654
 655   for (i = 0; i < 2; i++)
 656     {
 657       if (vec_d_result1[i] != vec_d_expected1[i])
 658 #ifdef DEBUG
 659         printf("Error: vec_xl_be(), vec_d_result2[%d] = %f; vec_d_expected2[%d] = %f\n",
 660                i,  vec_d_result2[i], i, vec_d_expected2[i]);
 661 #else
 662         abort ();
 663 #endif
 664
 665       if (vec_d_result2[i] != vec_d_expected2[i])
 666 #ifdef DEBUG
 667         printf("Error: vec_xl_be(), vec_d_result2[%d] = %f; vec_d_expected2[%d] = %f\n",
 668                i,  vec_d_result2[i], i, vec_d_expected2[i]);
 669 #else
 670         abort ();
 671 #endif
 672     }
 673 }