contrib/llvm-project/clang/lib/Headers/altivec.h

   1 /*===---- altivec.h - Standard header for type generic math ---------------===*\
   2  *
   3  * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4  * See https://llvm.org/LICENSE.txt for license information.
   5  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6  *
   7 \*===----------------------------------------------------------------------===*/
   8
   9 #ifndef __ALTIVEC_H
  10 #define __ALTIVEC_H
  11
  12 #ifndef __ALTIVEC__
  13 #error "AltiVec support not enabled"
  14 #endif
  15
  16 /* Constants for mapping CR6 bits to predicate result. */
  17
  18 #define __CR6_EQ 0
  19 #define __CR6_EQ_REV 1
  20 #define __CR6_LT 2
  21 #define __CR6_LT_REV 3
  22
  23 /* Constants for vec_test_data_class */
  24 #define __VEC_CLASS_FP_SUBNORMAL_N (1 << 0)
  25 #define __VEC_CLASS_FP_SUBNORMAL_P (1 << 1)
  26 #define __VEC_CLASS_FP_SUBNORMAL (__VEC_CLASS_FP_SUBNORMAL_P | \
  27                                   __VEC_CLASS_FP_SUBNORMAL_N)
  28 #define __VEC_CLASS_FP_ZERO_N (1<<2)
  29 #define __VEC_CLASS_FP_ZERO_P (1<<3)
  30 #define __VEC_CLASS_FP_ZERO (__VEC_CLASS_FP_ZERO_P           | \
  31                              __VEC_CLASS_FP_ZERO_N)
  32 #define __VEC_CLASS_FP_INFINITY_N (1<<4)
  33 #define __VEC_CLASS_FP_INFINITY_P (1<<5)
  34 #define __VEC_CLASS_FP_INFINITY (__VEC_CLASS_FP_INFINITY_P   | \
  35                                  __VEC_CLASS_FP_INFINITY_N)
  36 #define __VEC_CLASS_FP_NAN (1<<6)
  37 #define __VEC_CLASS_FP_NOT_NORMAL (__VEC_CLASS_FP_NAN        | \
  38                                    __VEC_CLASS_FP_SUBNORMAL  | \
  39                                    __VEC_CLASS_FP_ZERO       | \
  40                                    __VEC_CLASS_FP_INFINITY)
  41
  42 #define __ATTRS_o_ai __attribute__((__overloadable__, __always_inline__))
  43
  44 #include <stddef.h>
  45
  46 static __inline__ vector signed char __ATTRS_o_ai vec_perm(
  47     vector signed char __a, vector signed char __b, vector unsigned char __c);
  48
  49 static __inline__ vector unsigned char __ATTRS_o_ai
  50 vec_perm(vector unsigned char __a, vector unsigned char __b,
  51          vector unsigned char __c);
  52
  53 static __inline__ vector bool char __ATTRS_o_ai
  54 vec_perm(vector bool char __a, vector bool char __b, vector unsigned char __c);
  55
  56 static __inline__ vector short __ATTRS_o_ai vec_perm(vector signed short __a,
  57                                                      vector signed short __b,
  58                                                      vector unsigned char __c);
  59
  60 static __inline__ vector unsigned short __ATTRS_o_ai
  61 vec_perm(vector unsigned short __a, vector unsigned short __b,
  62          vector unsigned char __c);
  63
  64 static __inline__ vector bool short __ATTRS_o_ai vec_perm(
  65     vector bool short __a, vector bool short __b, vector unsigned char __c);
  66
  67 static __inline__ vector pixel __ATTRS_o_ai vec_perm(vector pixel __a,
  68                                                      vector pixel __b,
  69                                                      vector unsigned char __c);
  70
  71 static __inline__ vector int __ATTRS_o_ai vec_perm(vector signed int __a,
  72                                                    vector signed int __b,
  73                                                    vector unsigned char __c);
  74
  75 static __inline__ vector unsigned int __ATTRS_o_ai vec_perm(
  76     vector unsigned int __a, vector unsigned int __b, vector unsigned char __c);
  77
  78 static __inline__ vector bool int __ATTRS_o_ai
  79 vec_perm(vector bool int __a, vector bool int __b, vector unsigned char __c);
  80
  81 static __inline__ vector float __ATTRS_o_ai vec_perm(vector float __a,
  82                                                      vector float __b,
  83                                                      vector unsigned char __c);
  84
  85 #ifdef __VSX__
  86 static __inline__ vector long long __ATTRS_o_ai
  87 vec_perm(vector signed long long __a, vector signed long long __b,
  88          vector unsigned char __c);
  89
  90 static __inline__ vector unsigned long long __ATTRS_o_ai
  91 vec_perm(vector unsigned long long __a, vector unsigned long long __b,
  92          vector unsigned char __c);
  93
  94 static __inline__ vector bool long long __ATTRS_o_ai
  95 vec_perm(vector bool long long __a, vector bool long long __b,
  96          vector unsigned char __c);
  97
  98 static __inline__ vector double __ATTRS_o_ai vec_perm(vector double __a,
  99                                                       vector double __b,
 100                                                       vector unsigned char __c);
 101 #endif
 102
 103 static __inline__ vector unsigned char __ATTRS_o_ai
 104 vec_xor(vector unsigned char __a, vector unsigned char __b);
 105
 106 /* vec_abs */
 107
 108 #define __builtin_altivec_abs_v16qi vec_abs
 109 #define __builtin_altivec_abs_v8hi vec_abs
 110 #define __builtin_altivec_abs_v4si vec_abs
 111
 112 static __inline__ vector signed char __ATTRS_o_ai
 113 vec_abs(vector signed char __a) {
 114   return __builtin_altivec_vmaxsb(__a, -__a);
 115 }
 116
 117 static __inline__ vector signed short __ATTRS_o_ai
 118 vec_abs(vector signed short __a) {
 119   return __builtin_altivec_vmaxsh(__a, -__a);
 120 }
 121
 122 static __inline__ vector signed int __ATTRS_o_ai
 123 vec_abs(vector signed int __a) {
 124   return __builtin_altivec_vmaxsw(__a, -__a);
 125 }
 126
 127 #ifdef __POWER8_VECTOR__
 128 static __inline__ vector signed long long __ATTRS_o_ai
 129 vec_abs(vector signed long long __a) {
 130   return __builtin_altivec_vmaxsd(__a, -__a);
 131 }
 132 #endif
 133
 134 static __inline__ vector float __ATTRS_o_ai vec_abs(vector float __a) {
 135 #ifdef __VSX__
 136   return __builtin_vsx_xvabssp(__a);
 137 #else
 138   vector unsigned int __res =
 139       (vector unsigned int)__a & (vector unsigned int)(0x7FFFFFFF);
 140   return (vector float)__res;
 141 #endif
 142 }
 143
 144 #ifdef __VSX__
 145 static __inline__ vector double __ATTRS_o_ai vec_abs(vector double __a) {
 146   return __builtin_vsx_xvabsdp(__a);
 147 }
 148 #endif
 149
 150 /* vec_abss */
 151 #define __builtin_altivec_abss_v16qi vec_abss
 152 #define __builtin_altivec_abss_v8hi vec_abss
 153 #define __builtin_altivec_abss_v4si vec_abss
 154
 155 static __inline__ vector signed char __ATTRS_o_ai
 156 vec_abss(vector signed char __a) {
 157   return __builtin_altivec_vmaxsb(
 158       __a, __builtin_altivec_vsubsbs((vector signed char)(0), __a));
 159 }
 160
 161 static __inline__ vector signed short __ATTRS_o_ai
 162 vec_abss(vector signed short __a) {
 163   return __builtin_altivec_vmaxsh(
 164       __a, __builtin_altivec_vsubshs((vector signed short)(0), __a));
 165 }
 166
 167 static __inline__ vector signed int __ATTRS_o_ai
 168 vec_abss(vector signed int __a) {
 169   return __builtin_altivec_vmaxsw(
 170       __a, __builtin_altivec_vsubsws((vector signed int)(0), __a));
 171 }
 172
 173 /* vec_absd */
 174 #if defined(__POWER9_VECTOR__)
 175
 176 static __inline__ vector unsigned char __ATTRS_o_ai
 177 vec_absd(vector unsigned char __a, vector unsigned char __b) {
 178   return __builtin_altivec_vabsdub(__a, __b);
 179 }
 180
 181 static __inline__ vector unsigned short __ATTRS_o_ai
 182 vec_absd(vector unsigned short __a, vector unsigned short __b) {
 183   return __builtin_altivec_vabsduh(__a, __b);
 184 }
 185
 186 static __inline__ vector unsigned int __ATTRS_o_ai
 187 vec_absd(vector unsigned int __a,  vector unsigned int __b) {
 188   return __builtin_altivec_vabsduw(__a, __b);
 189 }
 190
 191 #endif /* End __POWER9_VECTOR__ */
 192
 193 /* vec_add */
 194
 195 static __inline__ vector signed char __ATTRS_o_ai
 196 vec_add(vector signed char __a, vector signed char __b) {
 197   return __a + __b;
 198 }
 199
 200 static __inline__ vector signed char __ATTRS_o_ai
 201 vec_add(vector bool char __a, vector signed char __b) {
 202   return (vector signed char)__a + __b;
 203 }
 204
 205 static __inline__ vector signed char __ATTRS_o_ai
 206 vec_add(vector signed char __a, vector bool char __b) {
 207   return __a + (vector signed char)__b;
 208 }
 209
 210 static __inline__ vector unsigned char __ATTRS_o_ai
 211 vec_add(vector unsigned char __a, vector unsigned char __b) {
 212   return __a + __b;
 213 }
 214
 215 static __inline__ vector unsigned char __ATTRS_o_ai
 216 vec_add(vector bool char __a, vector unsigned char __b) {
 217   return (vector unsigned char)__a + __b;
 218 }
 219
 220 static __inline__ vector unsigned char __ATTRS_o_ai
 221 vec_add(vector unsigned char __a, vector bool char __b) {
 222   return __a + (vector unsigned char)__b;
 223 }
 224
 225 static __inline__ vector short __ATTRS_o_ai vec_add(vector short __a,
 226                                                     vector short __b) {
 227   return __a + __b;
 228 }
 229
 230 static __inline__ vector short __ATTRS_o_ai vec_add(vector bool short __a,
 231                                                     vector short __b) {
 232   return (vector short)__a + __b;
 233 }
 234
 235 static __inline__ vector short __ATTRS_o_ai vec_add(vector short __a,
 236                                                     vector bool short __b) {
 237   return __a + (vector short)__b;
 238 }
 239
 240 static __inline__ vector unsigned short __ATTRS_o_ai
 241 vec_add(vector unsigned short __a, vector unsigned short __b) {
 242   return __a + __b;
 243 }
 244
 245 static __inline__ vector unsigned short __ATTRS_o_ai
 246 vec_add(vector bool short __a, vector unsigned short __b) {
 247   return (vector unsigned short)__a + __b;
 248 }
 249
 250 static __inline__ vector unsigned short __ATTRS_o_ai
 251 vec_add(vector unsigned short __a, vector bool short __b) {
 252   return __a + (vector unsigned short)__b;
 253 }
 254
 255 static __inline__ vector int __ATTRS_o_ai vec_add(vector int __a,
 256                                                   vector int __b) {
 257   return __a + __b;
 258 }
 259
 260 static __inline__ vector int __ATTRS_o_ai vec_add(vector bool int __a,
 261                                                   vector int __b) {
 262   return (vector int)__a + __b;
 263 }
 264
 265 static __inline__ vector int __ATTRS_o_ai vec_add(vector int __a,
 266                                                   vector bool int __b) {
 267   return __a + (vector int)__b;
 268 }
 269
 270 static __inline__ vector unsigned int __ATTRS_o_ai
 271 vec_add(vector unsigned int __a, vector unsigned int __b) {
 272   return __a + __b;
 273 }
 274
 275 static __inline__ vector unsigned int __ATTRS_o_ai
 276 vec_add(vector bool int __a, vector unsigned int __b) {
 277   return (vector unsigned int)__a + __b;
 278 }
 279
 280 static __inline__ vector unsigned int __ATTRS_o_ai
 281 vec_add(vector unsigned int __a, vector bool int __b) {
 282   return __a + (vector unsigned int)__b;
 283 }
 284
 285 #ifdef __POWER8_VECTOR__
 286 static __inline__ vector signed long long __ATTRS_o_ai
 287 vec_add(vector signed long long __a, vector signed long long __b) {
 288   return __a + __b;
 289 }
 290
 291 static __inline__ vector unsigned long long __ATTRS_o_ai
 292 vec_add(vector unsigned long long __a, vector unsigned long long __b) {
 293   return __a + __b;
 294 }
 295
 296 #ifdef __SIZEOF_INT128__
 297 static __inline__ vector signed __int128 __ATTRS_o_ai
 298 vec_add(vector signed __int128 __a, vector signed __int128 __b) {
 299   return __a + __b;
 300 }
 301
 302 static __inline__ vector unsigned __int128 __ATTRS_o_ai
 303 vec_add(vector unsigned __int128 __a, vector unsigned __int128 __b) {
 304   return __a + __b;
 305 }
 306 #endif
 307
 308 static __inline__ vector unsigned char __attribute__((__always_inline__))
 309 vec_add_u128(vector unsigned char __a, vector unsigned char __b) {
 310   return __builtin_altivec_vadduqm(__a, __b);
 311 }
 312 #elif defined(__VSX__)
 313 static __inline__ vector signed long long __ATTRS_o_ai
 314 vec_add(vector signed long long __a, vector signed long long __b) {
 315 #ifdef __LITTLE_ENDIAN__
 316   // Little endian systems on CPU's prior to Power8 don't really exist
 317   // so scalarizing is fine.
 318   return __a + __b;
 319 #else
 320   vector unsigned int __res =
 321       (vector unsigned int)__a + (vector unsigned int)__b;
 322   vector unsigned int __carry = __builtin_altivec_vaddcuw(
 323       (vector unsigned int)__a, (vector unsigned int)__b);
 324   __carry = __builtin_shufflevector((vector unsigned char)__carry,
 325                                     (vector unsigned char)__carry, 0, 0, 0, 7,
 326                                     0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 0);
 327   return (vector signed long long)(__res + __carry);
 328 #endif
 329 }
 330
 331 static __inline__ vector unsigned long long __ATTRS_o_ai
 332 vec_add(vector unsigned long long __a, vector unsigned long long __b) {
 333   return (vector unsigned long long)vec_add((vector signed long long)__a,
 334                                             (vector signed long long)__b);
 335 }
 336 #endif // __POWER8_VECTOR__
 337
 338 static __inline__ vector float __ATTRS_o_ai vec_add(vector float __a,
 339                                                     vector float __b) {
 340   return __a + __b;
 341 }
 342
 343 #ifdef __VSX__
 344 static __inline__ vector double __ATTRS_o_ai vec_add(vector double __a,
 345                                                      vector double __b) {
 346   return __a + __b;
 347 }
 348 #endif // __VSX__
 349
 350 /* vec_adde */
 351
 352 #ifdef __POWER8_VECTOR__
 353 #ifdef __SIZEOF_INT128__
 354 static __inline__ vector signed __int128 __ATTRS_o_ai
 355 vec_adde(vector signed __int128 __a, vector signed __int128 __b,
 356          vector signed __int128 __c) {
 357   return __builtin_altivec_vaddeuqm(__a, __b, __c);
 358 }
 359
 360 static __inline__ vector unsigned __int128 __ATTRS_o_ai
 361 vec_adde(vector unsigned __int128 __a, vector unsigned __int128 __b,
 362          vector unsigned __int128 __c) {
 363   return __builtin_altivec_vaddeuqm(__a, __b, __c);
 364 }
 365 #endif
 366
 367 static __inline__ vector unsigned char __attribute__((__always_inline__))
 368 vec_adde_u128(vector unsigned char __a, vector unsigned char __b,
 369               vector unsigned char __c) {
 370   return (vector unsigned char)__builtin_altivec_vaddeuqm(__a, __b, __c);
 371 }
 372 #endif
 373
 374 static __inline__ vector signed int __ATTRS_o_ai
 375 vec_adde(vector signed int __a, vector signed int __b,
 376          vector signed int __c) {
 377   vector signed int __mask = {1, 1, 1, 1};
 378   vector signed int __carry = __c & __mask;
 379   return vec_add(vec_add(__a, __b), __carry);
 380 }
 381
 382 static __inline__ vector unsigned int __ATTRS_o_ai
 383 vec_adde(vector unsigned int __a, vector unsigned int __b,
 384          vector unsigned int __c) {
 385   vector unsigned int __mask = {1, 1, 1, 1};
 386   vector unsigned int __carry = __c & __mask;
 387   return vec_add(vec_add(__a, __b), __carry);
 388 }
 389
 390 /* vec_addec */
 391
 392 #ifdef __POWER8_VECTOR__
 393 #ifdef __SIZEOF_INT128__
 394 static __inline__ vector signed __int128 __ATTRS_o_ai
 395 vec_addec(vector signed __int128 __a, vector signed __int128 __b,
 396           vector signed __int128 __c) {
 397   return __builtin_altivec_vaddecuq(__a, __b, __c);
 398 }
 399
 400 static __inline__ vector unsigned __int128 __ATTRS_o_ai
 401 vec_addec(vector unsigned __int128 __a, vector unsigned __int128 __b,
 402           vector unsigned __int128 __c) {
 403   return __builtin_altivec_vaddecuq(__a, __b, __c);
 404 }
 405 #endif
 406
 407 static __inline__ vector unsigned char __attribute__((__always_inline__))
 408 vec_addec_u128(vector unsigned char __a, vector unsigned char __b,
 409                vector unsigned char __c) {
 410   return (vector unsigned char)__builtin_altivec_vaddecuq(__a, __b, __c);
 411 }
 412
 413 #ifdef __powerpc64__
 414 static __inline__ vector signed int __ATTRS_o_ai
 415 vec_addec(vector signed int __a, vector signed int __b,
 416           vector signed int __c) {
 417
 418   signed int __result[4];
 419   for (int i = 0; i < 4; i++) {
 420     unsigned int __tempa = (unsigned int) __a[i];
 421     unsigned int __tempb = (unsigned int) __b[i];
 422     unsigned int __tempc = (unsigned int) __c[i];
 423     __tempc = __tempc & 0x00000001;
 424     unsigned long long __longa = (unsigned long long) __tempa;
 425     unsigned long long __longb = (unsigned long long) __tempb;
 426     unsigned long long __longc = (unsigned long long) __tempc;
 427     unsigned long long __sum = __longa + __longb + __longc;
 428     unsigned long long __res = (__sum >> 32) & 0x01;
 429     unsigned long long __tempres = (unsigned int) __res;
 430     __result[i] = (signed int) __tempres;
 431   }
 432
 433   vector signed int ret = { __result[0], __result[1], __result[2], __result[3] };
 434   return ret;
 435 }
 436
 437 static __inline__ vector unsigned int __ATTRS_o_ai
 438 vec_addec(vector unsigned int __a, vector unsigned int __b,
 439           vector unsigned int __c) {
 440
 441   unsigned int __result[4];
 442   for (int i = 0; i < 4; i++) {
 443     unsigned int __tempc = __c[i] & 1;
 444     unsigned long long __longa = (unsigned long long) __a[i];
 445     unsigned long long __longb = (unsigned long long) __b[i];
 446     unsigned long long __longc = (unsigned long long) __tempc;
 447     unsigned long long __sum = __longa + __longb + __longc;
 448     unsigned long long __res = (__sum >> 32) & 0x01;
 449     unsigned long long __tempres = (unsigned int) __res;
 450     __result[i] = (signed int) __tempres;
 451   }
 452
 453   vector unsigned int ret = { __result[0], __result[1], __result[2], __result[3] };
 454   return ret;
 455 }
 456 #endif // __powerpc64__
 457 #endif // __POWER8_VECTOR__
 458
 459 /* vec_vaddubm */
 460
 461 #define __builtin_altivec_vaddubm vec_vaddubm
 462
 463 static __inline__ vector signed char __ATTRS_o_ai
 464 vec_vaddubm(vector signed char __a, vector signed char __b) {
 465   return __a + __b;
 466 }
 467
 468 static __inline__ vector signed char __ATTRS_o_ai
 469 vec_vaddubm(vector bool char __a, vector signed char __b) {
 470   return (vector signed char)__a + __b;
 471 }
 472
 473 static __inline__ vector signed char __ATTRS_o_ai
 474 vec_vaddubm(vector signed char __a, vector bool char __b) {
 475   return __a + (vector signed char)__b;
 476 }
 477
 478 static __inline__ vector unsigned char __ATTRS_o_ai
 479 vec_vaddubm(vector unsigned char __a, vector unsigned char __b) {
 480   return __a + __b;
 481 }
 482
 483 static __inline__ vector unsigned char __ATTRS_o_ai
 484 vec_vaddubm(vector bool char __a, vector unsigned char __b) {
 485   return (vector unsigned char)__a + __b;
 486 }
 487
 488 static __inline__ vector unsigned char __ATTRS_o_ai
 489 vec_vaddubm(vector unsigned char __a, vector bool char __b) {
 490   return __a + (vector unsigned char)__b;
 491 }
 492
 493 /* vec_vadduhm */
 494
 495 #define __builtin_altivec_vadduhm vec_vadduhm
 496
 497 static __inline__ vector short __ATTRS_o_ai vec_vadduhm(vector short __a,
 498                                                         vector short __b) {
 499   return __a + __b;
 500 }
 501
 502 static __inline__ vector short __ATTRS_o_ai vec_vadduhm(vector bool short __a,
 503                                                         vector short __b) {
 504   return (vector short)__a + __b;
 505 }
 506
 507 static __inline__ vector short __ATTRS_o_ai vec_vadduhm(vector short __a,
 508                                                         vector bool short __b) {
 509   return __a + (vector short)__b;
 510 }
 511
 512 static __inline__ vector unsigned short __ATTRS_o_ai
 513 vec_vadduhm(vector unsigned short __a, vector unsigned short __b) {
 514   return __a + __b;
 515 }
 516
 517 static __inline__ vector unsigned short __ATTRS_o_ai
 518 vec_vadduhm(vector bool short __a, vector unsigned short __b) {
 519   return (vector unsigned short)__a + __b;
 520 }
 521
 522 static __inline__ vector unsigned short __ATTRS_o_ai
 523 vec_vadduhm(vector unsigned short __a, vector bool short __b) {
 524   return __a + (vector unsigned short)__b;
 525 }
 526
 527 /* vec_vadduwm */
 528
 529 #define __builtin_altivec_vadduwm vec_vadduwm
 530
 531 static __inline__ vector int __ATTRS_o_ai vec_vadduwm(vector int __a,
 532                                                       vector int __b) {
 533   return __a + __b;
 534 }
 535
 536 static __inline__ vector int __ATTRS_o_ai vec_vadduwm(vector bool int __a,
 537                                                       vector int __b) {
 538   return (vector int)__a + __b;
 539 }
 540
 541 static __inline__ vector int __ATTRS_o_ai vec_vadduwm(vector int __a,
 542                                                       vector bool int __b) {
 543   return __a + (vector int)__b;
 544 }
 545
 546 static __inline__ vector unsigned int __ATTRS_o_ai
 547 vec_vadduwm(vector unsigned int __a, vector unsigned int __b) {
 548   return __a + __b;
 549 }
 550
 551 static __inline__ vector unsigned int __ATTRS_o_ai
 552 vec_vadduwm(vector bool int __a, vector unsigned int __b) {
 553   return (vector unsigned int)__a + __b;
 554 }
 555
 556 static __inline__ vector unsigned int __ATTRS_o_ai
 557 vec_vadduwm(vector unsigned int __a, vector bool int __b) {
 558   return __a + (vector unsigned int)__b;
 559 }
 560
 561 /* vec_vaddfp */
 562
 563 #define __builtin_altivec_vaddfp vec_vaddfp
 564
 565 static __inline__ vector float __attribute__((__always_inline__))
 566 vec_vaddfp(vector float __a, vector float __b) {
 567   return __a + __b;
 568 }
 569
 570 /* vec_addc */
 571
 572 static __inline__ vector signed int __ATTRS_o_ai
 573 vec_addc(vector signed int __a, vector signed int __b) {
 574   return (vector signed int)__builtin_altivec_vaddcuw((vector unsigned int)__a,
 575                                                       (vector unsigned int)__b);
 576 }
 577
 578 static __inline__ vector unsigned int __ATTRS_o_ai
 579 vec_addc(vector unsigned int __a, vector unsigned int __b) {
 580   return __builtin_altivec_vaddcuw(__a, __b);
 581 }
 582
 583 #ifdef __POWER8_VECTOR__
 584 #ifdef __SIZEOF_INT128__
 585 static __inline__ vector signed __int128 __ATTRS_o_ai
 586 vec_addc(vector signed __int128 __a, vector signed __int128 __b) {
 587   return (vector signed __int128)__builtin_altivec_vaddcuq(
 588       (vector unsigned __int128)__a, (vector unsigned __int128)__b);
 589 }
 590
 591 static __inline__ vector unsigned __int128 __ATTRS_o_ai
 592 vec_addc(vector unsigned __int128 __a, vector unsigned __int128 __b) {
 593   return __builtin_altivec_vaddcuq(__a, __b);
 594 }
 595 #endif
 596
 597 static __inline__ vector unsigned char __attribute__((__always_inline__))
 598 vec_addc_u128(vector unsigned char __a, vector unsigned char __b) {
 599   return (vector unsigned char)__builtin_altivec_vaddcuq(__a, __b);
 600 }
 601 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
 602
 603 /* vec_vaddcuw */
 604
 605 static __inline__ vector unsigned int __attribute__((__always_inline__))
 606 vec_vaddcuw(vector unsigned int __a, vector unsigned int __b) {
 607   return __builtin_altivec_vaddcuw(__a, __b);
 608 }
 609
 610 /* vec_adds */
 611
 612 static __inline__ vector signed char __ATTRS_o_ai
 613 vec_adds(vector signed char __a, vector signed char __b) {
 614   return __builtin_altivec_vaddsbs(__a, __b);
 615 }
 616
 617 static __inline__ vector signed char __ATTRS_o_ai
 618 vec_adds(vector bool char __a, vector signed char __b) {
 619   return __builtin_altivec_vaddsbs((vector signed char)__a, __b);
 620 }
 621
 622 static __inline__ vector signed char __ATTRS_o_ai
 623 vec_adds(vector signed char __a, vector bool char __b) {
 624   return __builtin_altivec_vaddsbs(__a, (vector signed char)__b);
 625 }
 626
 627 static __inline__ vector unsigned char __ATTRS_o_ai
 628 vec_adds(vector unsigned char __a, vector unsigned char __b) {
 629   return __builtin_altivec_vaddubs(__a, __b);
 630 }
 631
 632 static __inline__ vector unsigned char __ATTRS_o_ai
 633 vec_adds(vector bool char __a, vector unsigned char __b) {
 634   return __builtin_altivec_vaddubs((vector unsigned char)__a, __b);
 635 }
 636
 637 static __inline__ vector unsigned char __ATTRS_o_ai
 638 vec_adds(vector unsigned char __a, vector bool char __b) {
 639   return __builtin_altivec_vaddubs(__a, (vector unsigned char)__b);
 640 }
 641
 642 static __inline__ vector short __ATTRS_o_ai vec_adds(vector short __a,
 643                                                      vector short __b) {
 644   return __builtin_altivec_vaddshs(__a, __b);
 645 }
 646
 647 static __inline__ vector short __ATTRS_o_ai vec_adds(vector bool short __a,
 648                                                      vector short __b) {
 649   return __builtin_altivec_vaddshs((vector short)__a, __b);
 650 }
 651
 652 static __inline__ vector short __ATTRS_o_ai vec_adds(vector short __a,
 653                                                      vector bool short __b) {
 654   return __builtin_altivec_vaddshs(__a, (vector short)__b);
 655 }
 656
 657 static __inline__ vector unsigned short __ATTRS_o_ai
 658 vec_adds(vector unsigned short __a, vector unsigned short __b) {
 659   return __builtin_altivec_vadduhs(__a, __b);
 660 }
 661
 662 static __inline__ vector unsigned short __ATTRS_o_ai
 663 vec_adds(vector bool short __a, vector unsigned short __b) {
 664   return __builtin_altivec_vadduhs((vector unsigned short)__a, __b);
 665 }
 666
 667 static __inline__ vector unsigned short __ATTRS_o_ai
 668 vec_adds(vector unsigned short __a, vector bool short __b) {
 669   return __builtin_altivec_vadduhs(__a, (vector unsigned short)__b);
 670 }
 671
 672 static __inline__ vector int __ATTRS_o_ai vec_adds(vector int __a,
 673                                                    vector int __b) {
 674   return __builtin_altivec_vaddsws(__a, __b);
 675 }
 676
 677 static __inline__ vector int __ATTRS_o_ai vec_adds(vector bool int __a,
 678                                                    vector int __b) {
 679   return __builtin_altivec_vaddsws((vector int)__a, __b);
 680 }
 681
 682 static __inline__ vector int __ATTRS_o_ai vec_adds(vector int __a,
 683                                                    vector bool int __b) {
 684   return __builtin_altivec_vaddsws(__a, (vector int)__b);
 685 }
 686
 687 static __inline__ vector unsigned int __ATTRS_o_ai
 688 vec_adds(vector unsigned int __a, vector unsigned int __b) {
 689   return __builtin_altivec_vadduws(__a, __b);
 690 }
 691
 692 static __inline__ vector unsigned int __ATTRS_o_ai
 693 vec_adds(vector bool int __a, vector unsigned int __b) {
 694   return __builtin_altivec_vadduws((vector unsigned int)__a, __b);
 695 }
 696
 697 static __inline__ vector unsigned int __ATTRS_o_ai
 698 vec_adds(vector unsigned int __a, vector bool int __b) {
 699   return __builtin_altivec_vadduws(__a, (vector unsigned int)__b);
 700 }
 701
 702 /* vec_vaddsbs */
 703
 704 static __inline__ vector signed char __ATTRS_o_ai
 705 vec_vaddsbs(vector signed char __a, vector signed char __b) {
 706   return __builtin_altivec_vaddsbs(__a, __b);
 707 }
 708
 709 static __inline__ vector signed char __ATTRS_o_ai
 710 vec_vaddsbs(vector bool char __a, vector signed char __b) {
 711   return __builtin_altivec_vaddsbs((vector signed char)__a, __b);
 712 }
 713
 714 static __inline__ vector signed char __ATTRS_o_ai
 715 vec_vaddsbs(vector signed char __a, vector bool char __b) {
 716   return __builtin_altivec_vaddsbs(__a, (vector signed char)__b);
 717 }
 718
 719 /* vec_vaddubs */
 720
 721 static __inline__ vector unsigned char __ATTRS_o_ai
 722 vec_vaddubs(vector unsigned char __a, vector unsigned char __b) {
 723   return __builtin_altivec_vaddubs(__a, __b);
 724 }
 725
 726 static __inline__ vector unsigned char __ATTRS_o_ai
 727 vec_vaddubs(vector bool char __a, vector unsigned char __b) {
 728   return __builtin_altivec_vaddubs((vector unsigned char)__a, __b);
 729 }
 730
 731 static __inline__ vector unsigned char __ATTRS_o_ai
 732 vec_vaddubs(vector unsigned char __a, vector bool char __b) {
 733   return __builtin_altivec_vaddubs(__a, (vector unsigned char)__b);
 734 }
 735
 736 /* vec_vaddshs */
 737
 738 static __inline__ vector short __ATTRS_o_ai vec_vaddshs(vector short __a,
 739                                                         vector short __b) {
 740   return __builtin_altivec_vaddshs(__a, __b);
 741 }
 742
 743 static __inline__ vector short __ATTRS_o_ai vec_vaddshs(vector bool short __a,
 744                                                         vector short __b) {
 745   return __builtin_altivec_vaddshs((vector short)__a, __b);
 746 }
 747
 748 static __inline__ vector short __ATTRS_o_ai vec_vaddshs(vector short __a,
 749                                                         vector bool short __b) {
 750   return __builtin_altivec_vaddshs(__a, (vector short)__b);
 751 }
 752
 753 /* vec_vadduhs */
 754
 755 static __inline__ vector unsigned short __ATTRS_o_ai
 756 vec_vadduhs(vector unsigned short __a, vector unsigned short __b) {
 757   return __builtin_altivec_vadduhs(__a, __b);
 758 }
 759
 760 static __inline__ vector unsigned short __ATTRS_o_ai
 761 vec_vadduhs(vector bool short __a, vector unsigned short __b) {
 762   return __builtin_altivec_vadduhs((vector unsigned short)__a, __b);
 763 }
 764
 765 static __inline__ vector unsigned short __ATTRS_o_ai
 766 vec_vadduhs(vector unsigned short __a, vector bool short __b) {
 767   return __builtin_altivec_vadduhs(__a, (vector unsigned short)__b);
 768 }
 769
 770 /* vec_vaddsws */
 771
 772 static __inline__ vector int __ATTRS_o_ai vec_vaddsws(vector int __a,
 773                                                       vector int __b) {
 774   return __builtin_altivec_vaddsws(__a, __b);
 775 }
 776
 777 static __inline__ vector int __ATTRS_o_ai vec_vaddsws(vector bool int __a,
 778                                                       vector int __b) {
 779   return __builtin_altivec_vaddsws((vector int)__a, __b);
 780 }
 781
 782 static __inline__ vector int __ATTRS_o_ai vec_vaddsws(vector int __a,
 783                                                       vector bool int __b) {
 784   return __builtin_altivec_vaddsws(__a, (vector int)__b);
 785 }
 786
 787 /* vec_vadduws */
 788
 789 static __inline__ vector unsigned int __ATTRS_o_ai
 790 vec_vadduws(vector unsigned int __a, vector unsigned int __b) {
 791   return __builtin_altivec_vadduws(__a, __b);
 792 }
 793
 794 static __inline__ vector unsigned int __ATTRS_o_ai
 795 vec_vadduws(vector bool int __a, vector unsigned int __b) {
 796   return __builtin_altivec_vadduws((vector unsigned int)__a, __b);
 797 }
 798
 799 static __inline__ vector unsigned int __ATTRS_o_ai
 800 vec_vadduws(vector unsigned int __a, vector bool int __b) {
 801   return __builtin_altivec_vadduws(__a, (vector unsigned int)__b);
 802 }
 803
 804 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__) &&                    \
 805     defined(__SIZEOF_INT128__)
 806 /* vec_vadduqm */
 807
 808 static __inline__ vector signed __int128 __ATTRS_o_ai
 809 vec_vadduqm(vector signed __int128 __a, vector signed __int128 __b) {
 810   return __a + __b;
 811 }
 812
 813 static __inline__ vector unsigned __int128 __ATTRS_o_ai
 814 vec_vadduqm(vector unsigned __int128 __a, vector unsigned __int128 __b) {
 815   return __a + __b;
 816 }
 817
 818 /* vec_vaddeuqm */
 819
 820 static __inline__ vector signed __int128 __ATTRS_o_ai
 821 vec_vaddeuqm(vector signed __int128 __a, vector signed __int128 __b,
 822              vector signed __int128 __c) {
 823   return __builtin_altivec_vaddeuqm(__a, __b, __c);
 824 }
 825
 826 static __inline__ vector unsigned __int128 __ATTRS_o_ai
 827 vec_vaddeuqm(vector unsigned __int128 __a, vector unsigned __int128 __b,
 828              vector unsigned __int128 __c) {
 829   return __builtin_altivec_vaddeuqm(__a, __b, __c);
 830 }
 831
 832 /* vec_vaddcuq */
 833
 834 static __inline__ vector signed __int128 __ATTRS_o_ai
 835 vec_vaddcuq(vector signed __int128 __a, vector signed __int128 __b) {
 836   return __builtin_altivec_vaddcuq(__a, __b);
 837 }
 838
 839 static __inline__ vector unsigned __int128 __ATTRS_o_ai
 840 vec_vaddcuq(vector unsigned __int128 __a, vector unsigned __int128 __b) {
 841   return __builtin_altivec_vaddcuq(__a, __b);
 842 }
 843
 844 /* vec_vaddecuq */
 845
 846 static __inline__ vector signed __int128 __ATTRS_o_ai
 847 vec_vaddecuq(vector signed __int128 __a, vector signed __int128 __b,
 848              vector signed __int128 __c) {
 849   return __builtin_altivec_vaddecuq(__a, __b, __c);
 850 }
 851
 852 static __inline__ vector unsigned __int128 __ATTRS_o_ai
 853 vec_vaddecuq(vector unsigned __int128 __a, vector unsigned __int128 __b,
 854              vector unsigned __int128 __c) {
 855   return __builtin_altivec_vaddecuq(__a, __b, __c);
 856 }
 857 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
 858
 859 /* vec_and */
 860
 861 #define __builtin_altivec_vand vec_and
 862
 863 static __inline__ vector signed char __ATTRS_o_ai
 864 vec_and(vector signed char __a, vector signed char __b) {
 865   return __a & __b;
 866 }
 867
 868 static __inline__ vector signed char __ATTRS_o_ai
 869 vec_and(vector bool char __a, vector signed char __b) {
 870   return (vector signed char)__a & __b;
 871 }
 872
 873 static __inline__ vector signed char __ATTRS_o_ai
 874 vec_and(vector signed char __a, vector bool char __b) {
 875   return __a & (vector signed char)__b;
 876 }
 877
 878 static __inline__ vector unsigned char __ATTRS_o_ai
 879 vec_and(vector unsigned char __a, vector unsigned char __b) {
 880   return __a & __b;
 881 }
 882
 883 static __inline__ vector unsigned char __ATTRS_o_ai
 884 vec_and(vector bool char __a, vector unsigned char __b) {
 885   return (vector unsigned char)__a & __b;
 886 }
 887
 888 static __inline__ vector unsigned char __ATTRS_o_ai
 889 vec_and(vector unsigned char __a, vector bool char __b) {
 890   return __a & (vector unsigned char)__b;
 891 }
 892
 893 static __inline__ vector bool char __ATTRS_o_ai vec_and(vector bool char __a,
 894                                                         vector bool char __b) {
 895   return __a & __b;
 896 }
 897
 898 static __inline__ vector short __ATTRS_o_ai vec_and(vector short __a,
 899                                                     vector short __b) {
 900   return __a & __b;
 901 }
 902
 903 static __inline__ vector short __ATTRS_o_ai vec_and(vector bool short __a,
 904                                                     vector short __b) {
 905   return (vector short)__a & __b;
 906 }
 907
 908 static __inline__ vector short __ATTRS_o_ai vec_and(vector short __a,
 909                                                     vector bool short __b) {
 910   return __a & (vector short)__b;
 911 }
 912
 913 static __inline__ vector unsigned short __ATTRS_o_ai
 914 vec_and(vector unsigned short __a, vector unsigned short __b) {
 915   return __a & __b;
 916 }
 917
 918 static __inline__ vector unsigned short __ATTRS_o_ai
 919 vec_and(vector bool short __a, vector unsigned short __b) {
 920   return (vector unsigned short)__a & __b;
 921 }
 922
 923 static __inline__ vector unsigned short __ATTRS_o_ai
 924 vec_and(vector unsigned short __a, vector bool short __b) {
 925   return __a & (vector unsigned short)__b;
 926 }
 927
 928 static __inline__ vector bool short __ATTRS_o_ai
 929 vec_and(vector bool short __a, vector bool short __b) {
 930   return __a & __b;
 931 }
 932
 933 static __inline__ vector int __ATTRS_o_ai vec_and(vector int __a,
 934                                                   vector int __b) {
 935   return __a & __b;
 936 }
 937
 938 static __inline__ vector int __ATTRS_o_ai vec_and(vector bool int __a,
 939                                                   vector int __b) {
 940   return (vector int)__a & __b;
 941 }
 942
 943 static __inline__ vector int __ATTRS_o_ai vec_and(vector int __a,
 944                                                   vector bool int __b) {
 945   return __a & (vector int)__b;
 946 }
 947
 948 static __inline__ vector unsigned int __ATTRS_o_ai
 949 vec_and(vector unsigned int __a, vector unsigned int __b) {
 950   return __a & __b;
 951 }
 952
 953 static __inline__ vector unsigned int __ATTRS_o_ai
 954 vec_and(vector bool int __a, vector unsigned int __b) {
 955   return (vector unsigned int)__a & __b;
 956 }
 957
 958 static __inline__ vector unsigned int __ATTRS_o_ai
 959 vec_and(vector unsigned int __a, vector bool int __b) {
 960   return __a & (vector unsigned int)__b;
 961 }
 962
 963 static __inline__ vector bool int __ATTRS_o_ai vec_and(vector bool int __a,
 964                                                        vector bool int __b) {
 965   return __a & __b;
 966 }
 967
 968 static __inline__ vector float __ATTRS_o_ai vec_and(vector float __a,
 969                                                     vector float __b) {
 970   vector unsigned int __res =
 971       (vector unsigned int)__a & (vector unsigned int)__b;
 972   return (vector float)__res;
 973 }
 974
 975 static __inline__ vector float __ATTRS_o_ai vec_and(vector bool int __a,
 976                                                     vector float __b) {
 977   vector unsigned int __res =
 978       (vector unsigned int)__a & (vector unsigned int)__b;
 979   return (vector float)__res;
 980 }
 981
 982 static __inline__ vector float __ATTRS_o_ai vec_and(vector float __a,
 983                                                     vector bool int __b) {
 984   vector unsigned int __res =
 985       (vector unsigned int)__a & (vector unsigned int)__b;
 986   return (vector float)__res;
 987 }
 988
 989 #ifdef __VSX__
 990 static __inline__ vector double __ATTRS_o_ai vec_and(vector bool long long __a,
 991                                                      vector double __b) {
 992   vector unsigned long long __res =
 993       (vector unsigned long long)__a & (vector unsigned long long)__b;
 994   return (vector double)__res;
 995 }
 996
 997 static __inline__ vector double __ATTRS_o_ai
 998 vec_and(vector double __a, vector bool long long __b) {
 999   vector unsigned long long __res =
1000       (vector unsigned long long)__a & (vector unsigned long long)__b;
1001   return (vector double)__res;
1002 }
1003
1004 static __inline__ vector double __ATTRS_o_ai vec_and(vector double __a,
1005                                                      vector double __b) {
1006   vector unsigned long long __res =
1007       (vector unsigned long long)__a & (vector unsigned long long)__b;
1008   return (vector double)__res;
1009 }
1010
1011 static __inline__ vector signed long long __ATTRS_o_ai
1012 vec_and(vector signed long long __a, vector signed long long __b) {
1013   return __a & __b;
1014 }
1015
1016 static __inline__ vector signed long long __ATTRS_o_ai
1017 vec_and(vector bool long long __a, vector signed long long __b) {
1018   return (vector signed long long)__a & __b;
1019 }
1020
1021 static __inline__ vector signed long long __ATTRS_o_ai
1022 vec_and(vector signed long long __a, vector bool long long __b) {
1023   return __a & (vector signed long long)__b;
1024 }
1025
1026 static __inline__ vector unsigned long long __ATTRS_o_ai
1027 vec_and(vector unsigned long long __a, vector unsigned long long __b) {
1028   return __a & __b;
1029 }
1030
1031 static __inline__ vector unsigned long long __ATTRS_o_ai
1032 vec_and(vector bool long long __a, vector unsigned long long __b) {
1033   return (vector unsigned long long)__a & __b;
1034 }
1035
1036 static __inline__ vector unsigned long long __ATTRS_o_ai
1037 vec_and(vector unsigned long long __a, vector bool long long __b) {
1038   return __a & (vector unsigned long long)__b;
1039 }
1040
1041 static __inline__ vector bool long long __ATTRS_o_ai
1042 vec_and(vector bool long long __a, vector bool long long __b) {
1043   return __a & __b;
1044 }
1045 #endif
1046
1047 /* vec_vand */
1048
1049 static __inline__ vector signed char __ATTRS_o_ai
1050 vec_vand(vector signed char __a, vector signed char __b) {
1051   return __a & __b;
1052 }
1053
1054 static __inline__ vector signed char __ATTRS_o_ai
1055 vec_vand(vector bool char __a, vector signed char __b) {
1056   return (vector signed char)__a & __b;
1057 }
1058
1059 static __inline__ vector signed char __ATTRS_o_ai
1060 vec_vand(vector signed char __a, vector bool char __b) {
1061   return __a & (vector signed char)__b;
1062 }
1063
1064 static __inline__ vector unsigned char __ATTRS_o_ai
1065 vec_vand(vector unsigned char __a, vector unsigned char __b) {
1066   return __a & __b;
1067 }
1068
1069 static __inline__ vector unsigned char __ATTRS_o_ai
1070 vec_vand(vector bool char __a, vector unsigned char __b) {
1071   return (vector unsigned char)__a & __b;
1072 }
1073
1074 static __inline__ vector unsigned char __ATTRS_o_ai
1075 vec_vand(vector unsigned char __a, vector bool char __b) {
1076   return __a & (vector unsigned char)__b;
1077 }
1078
1079 static __inline__ vector bool char __ATTRS_o_ai vec_vand(vector bool char __a,
1080                                                          vector bool char __b) {
1081   return __a & __b;
1082 }
1083
1084 static __inline__ vector short __ATTRS_o_ai vec_vand(vector short __a,
1085                                                      vector short __b) {
1086   return __a & __b;
1087 }
1088
1089 static __inline__ vector short __ATTRS_o_ai vec_vand(vector bool short __a,
1090                                                      vector short __b) {
1091   return (vector short)__a & __b;
1092 }
1093
1094 static __inline__ vector short __ATTRS_o_ai vec_vand(vector short __a,
1095                                                      vector bool short __b) {
1096   return __a & (vector short)__b;
1097 }
1098
1099 static __inline__ vector unsigned short __ATTRS_o_ai
1100 vec_vand(vector unsigned short __a, vector unsigned short __b) {
1101   return __a & __b;
1102 }
1103
1104 static __inline__ vector unsigned short __ATTRS_o_ai
1105 vec_vand(vector bool short __a, vector unsigned short __b) {
1106   return (vector unsigned short)__a & __b;
1107 }
1108
1109 static __inline__ vector unsigned short __ATTRS_o_ai
1110 vec_vand(vector unsigned short __a, vector bool short __b) {
1111   return __a & (vector unsigned short)__b;
1112 }
1113
1114 static __inline__ vector bool short __ATTRS_o_ai
1115 vec_vand(vector bool short __a, vector bool short __b) {
1116   return __a & __b;
1117 }
1118
1119 static __inline__ vector int __ATTRS_o_ai vec_vand(vector int __a,
1120                                                    vector int __b) {
1121   return __a & __b;
1122 }
1123
1124 static __inline__ vector int __ATTRS_o_ai vec_vand(vector bool int __a,
1125                                                    vector int __b) {
1126   return (vector int)__a & __b;
1127 }
1128
1129 static __inline__ vector int __ATTRS_o_ai vec_vand(vector int __a,
1130                                                    vector bool int __b) {
1131   return __a & (vector int)__b;
1132 }
1133
1134 static __inline__ vector unsigned int __ATTRS_o_ai
1135 vec_vand(vector unsigned int __a, vector unsigned int __b) {
1136   return __a & __b;
1137 }
1138
1139 static __inline__ vector unsigned int __ATTRS_o_ai
1140 vec_vand(vector bool int __a, vector unsigned int __b) {
1141   return (vector unsigned int)__a & __b;
1142 }
1143
1144 static __inline__ vector unsigned int __ATTRS_o_ai
1145 vec_vand(vector unsigned int __a, vector bool int __b) {
1146   return __a & (vector unsigned int)__b;
1147 }
1148
1149 static __inline__ vector bool int __ATTRS_o_ai vec_vand(vector bool int __a,
1150                                                         vector bool int __b) {
1151   return __a & __b;
1152 }
1153
1154 static __inline__ vector float __ATTRS_o_ai vec_vand(vector float __a,
1155                                                      vector float __b) {
1156   vector unsigned int __res =
1157       (vector unsigned int)__a & (vector unsigned int)__b;
1158   return (vector float)__res;
1159 }
1160
1161 static __inline__ vector float __ATTRS_o_ai vec_vand(vector bool int __a,
1162                                                      vector float __b) {
1163   vector unsigned int __res =
1164       (vector unsigned int)__a & (vector unsigned int)__b;
1165   return (vector float)__res;
1166 }
1167
1168 static __inline__ vector float __ATTRS_o_ai vec_vand(vector float __a,
1169                                                      vector bool int __b) {
1170   vector unsigned int __res =
1171       (vector unsigned int)__a & (vector unsigned int)__b;
1172   return (vector float)__res;
1173 }
1174
1175 #ifdef __VSX__
1176 static __inline__ vector signed long long __ATTRS_o_ai
1177 vec_vand(vector signed long long __a, vector signed long long __b) {
1178   return __a & __b;
1179 }
1180
1181 static __inline__ vector signed long long __ATTRS_o_ai
1182 vec_vand(vector bool long long __a, vector signed long long __b) {
1183   return (vector signed long long)__a & __b;
1184 }
1185
1186 static __inline__ vector signed long long __ATTRS_o_ai
1187 vec_vand(vector signed long long __a, vector bool long long __b) {
1188   return __a & (vector signed long long)__b;
1189 }
1190
1191 static __inline__ vector unsigned long long __ATTRS_o_ai
1192 vec_vand(vector unsigned long long __a, vector unsigned long long __b) {
1193   return __a & __b;
1194 }
1195
1196 static __inline__ vector unsigned long long __ATTRS_o_ai
1197 vec_vand(vector bool long long __a, vector unsigned long long __b) {
1198   return (vector unsigned long long)__a & __b;
1199 }
1200
1201 static __inline__ vector unsigned long long __ATTRS_o_ai
1202 vec_vand(vector unsigned long long __a, vector bool long long __b) {
1203   return __a & (vector unsigned long long)__b;
1204 }
1205
1206 static __inline__ vector bool long long __ATTRS_o_ai
1207 vec_vand(vector bool long long __a, vector bool long long __b) {
1208   return __a & __b;
1209 }
1210 #endif
1211
1212 /* vec_andc */
1213
1214 #define __builtin_altivec_vandc vec_andc
1215
1216 static __inline__ vector signed char __ATTRS_o_ai
1217 vec_andc(vector signed char __a, vector signed char __b) {
1218   return __a & ~__b;
1219 }
1220
1221 static __inline__ vector signed char __ATTRS_o_ai
1222 vec_andc(vector bool char __a, vector signed char __b) {
1223   return (vector signed char)__a & ~__b;
1224 }
1225
1226 static __inline__ vector signed char __ATTRS_o_ai
1227 vec_andc(vector signed char __a, vector bool char __b) {
1228   return __a & ~(vector signed char)__b;
1229 }
1230
1231 static __inline__ vector unsigned char __ATTRS_o_ai
1232 vec_andc(vector unsigned char __a, vector unsigned char __b) {
1233   return __a & ~__b;
1234 }
1235
1236 static __inline__ vector unsigned char __ATTRS_o_ai
1237 vec_andc(vector bool char __a, vector unsigned char __b) {
1238   return (vector unsigned char)__a & ~__b;
1239 }
1240
1241 static __inline__ vector unsigned char __ATTRS_o_ai
1242 vec_andc(vector unsigned char __a, vector bool char __b) {
1243   return __a & ~(vector unsigned char)__b;
1244 }
1245
1246 static __inline__ vector bool char __ATTRS_o_ai vec_andc(vector bool char __a,
1247                                                          vector bool char __b) {
1248   return __a & ~__b;
1249 }
1250
1251 static __inline__ vector short __ATTRS_o_ai vec_andc(vector short __a,
1252                                                      vector short __b) {
1253   return __a & ~__b;
1254 }
1255
1256 static __inline__ vector short __ATTRS_o_ai vec_andc(vector bool short __a,
1257                                                      vector short __b) {
1258   return (vector short)__a & ~__b;
1259 }
1260
1261 static __inline__ vector short __ATTRS_o_ai vec_andc(vector short __a,
1262                                                      vector bool short __b) {
1263   return __a & ~(vector short)__b;
1264 }
1265
1266 static __inline__ vector unsigned short __ATTRS_o_ai
1267 vec_andc(vector unsigned short __a, vector unsigned short __b) {
1268   return __a & ~__b;
1269 }
1270
1271 static __inline__ vector unsigned short __ATTRS_o_ai
1272 vec_andc(vector bool short __a, vector unsigned short __b) {
1273   return (vector unsigned short)__a & ~__b;
1274 }
1275
1276 static __inline__ vector unsigned short __ATTRS_o_ai
1277 vec_andc(vector unsigned short __a, vector bool short __b) {
1278   return __a & ~(vector unsigned short)__b;
1279 }
1280
1281 static __inline__ vector bool short __ATTRS_o_ai
1282 vec_andc(vector bool short __a, vector bool short __b) {
1283   return __a & ~__b;
1284 }
1285
1286 static __inline__ vector int __ATTRS_o_ai vec_andc(vector int __a,
1287                                                    vector int __b) {
1288   return __a & ~__b;
1289 }
1290
1291 static __inline__ vector int __ATTRS_o_ai vec_andc(vector bool int __a,
1292                                                    vector int __b) {
1293   return (vector int)__a & ~__b;
1294 }
1295
1296 static __inline__ vector int __ATTRS_o_ai vec_andc(vector int __a,
1297                                                    vector bool int __b) {
1298   return __a & ~(vector int)__b;
1299 }
1300
1301 static __inline__ vector unsigned int __ATTRS_o_ai
1302 vec_andc(vector unsigned int __a, vector unsigned int __b) {
1303   return __a & ~__b;
1304 }
1305
1306 static __inline__ vector unsigned int __ATTRS_o_ai
1307 vec_andc(vector bool int __a, vector unsigned int __b) {
1308   return (vector unsigned int)__a & ~__b;
1309 }
1310
1311 static __inline__ vector unsigned int __ATTRS_o_ai
1312 vec_andc(vector unsigned int __a, vector bool int __b) {
1313   return __a & ~(vector unsigned int)__b;
1314 }
1315
1316 static __inline__ vector bool int __ATTRS_o_ai vec_andc(vector bool int __a,
1317                                                         vector bool int __b) {
1318   return __a & ~__b;
1319 }
1320
1321 static __inline__ vector float __ATTRS_o_ai vec_andc(vector float __a,
1322                                                      vector float __b) {
1323   vector unsigned int __res =
1324       (vector unsigned int)__a & ~(vector unsigned int)__b;
1325   return (vector float)__res;
1326 }
1327
1328 static __inline__ vector float __ATTRS_o_ai vec_andc(vector bool int __a,
1329                                                      vector float __b) {
1330   vector unsigned int __res =
1331       (vector unsigned int)__a & ~(vector unsigned int)__b;
1332   return (vector float)__res;
1333 }
1334
1335 static __inline__ vector float __ATTRS_o_ai vec_andc(vector float __a,
1336                                                      vector bool int __b) {
1337   vector unsigned int __res =
1338       (vector unsigned int)__a & ~(vector unsigned int)__b;
1339   return (vector float)__res;
1340 }
1341
1342 #ifdef __VSX__
1343 static __inline__ vector double __ATTRS_o_ai vec_andc(vector bool long long __a,
1344                                                       vector double __b) {
1345   vector unsigned long long __res =
1346       (vector unsigned long long)__a & ~(vector unsigned long long)__b;
1347   return (vector double)__res;
1348 }
1349
1350 static __inline__ vector double __ATTRS_o_ai
1351 vec_andc(vector double __a, vector bool long long __b) {
1352   vector unsigned long long __res =
1353       (vector unsigned long long)__a & ~(vector unsigned long long)__b;
1354   return (vector double)__res;
1355 }
1356
1357 static __inline__ vector double __ATTRS_o_ai vec_andc(vector double __a,
1358                                                       vector double __b) {
1359   vector unsigned long long __res =
1360       (vector unsigned long long)__a & ~(vector unsigned long long)__b;
1361   return (vector double)__res;
1362 }
1363
1364 static __inline__ vector signed long long __ATTRS_o_ai
1365 vec_andc(vector signed long long __a, vector signed long long __b) {
1366   return __a & ~__b;
1367 }
1368
1369 static __inline__ vector signed long long __ATTRS_o_ai
1370 vec_andc(vector bool long long __a, vector signed long long __b) {
1371   return (vector signed long long)__a & ~__b;
1372 }
1373
1374 static __inline__ vector signed long long __ATTRS_o_ai
1375 vec_andc(vector signed long long __a, vector bool long long __b) {
1376   return __a & ~(vector signed long long)__b;
1377 }
1378
1379 static __inline__ vector unsigned long long __ATTRS_o_ai
1380 vec_andc(vector unsigned long long __a, vector unsigned long long __b) {
1381   return __a & ~__b;
1382 }
1383
1384 static __inline__ vector unsigned long long __ATTRS_o_ai
1385 vec_andc(vector bool long long __a, vector unsigned long long __b) {
1386   return (vector unsigned long long)__a & ~__b;
1387 }
1388
1389 static __inline__ vector unsigned long long __ATTRS_o_ai
1390 vec_andc(vector unsigned long long __a, vector bool long long __b) {
1391   return __a & ~(vector unsigned long long)__b;
1392 }
1393
1394 static __inline__ vector bool long long __ATTRS_o_ai
1395 vec_andc(vector bool long long __a, vector bool long long __b) {
1396   return __a & ~__b;
1397 }
1398 #endif
1399
1400 /* vec_vandc */
1401
1402 static __inline__ vector signed char __ATTRS_o_ai
1403 vec_vandc(vector signed char __a, vector signed char __b) {
1404   return __a & ~__b;
1405 }
1406
1407 static __inline__ vector signed char __ATTRS_o_ai
1408 vec_vandc(vector bool char __a, vector signed char __b) {
1409   return (vector signed char)__a & ~__b;
1410 }
1411
1412 static __inline__ vector signed char __ATTRS_o_ai
1413 vec_vandc(vector signed char __a, vector bool char __b) {
1414   return __a & ~(vector signed char)__b;
1415 }
1416
1417 static __inline__ vector unsigned char __ATTRS_o_ai
1418 vec_vandc(vector unsigned char __a, vector unsigned char __b) {
1419   return __a & ~__b;
1420 }
1421
1422 static __inline__ vector unsigned char __ATTRS_o_ai
1423 vec_vandc(vector bool char __a, vector unsigned char __b) {
1424   return (vector unsigned char)__a & ~__b;
1425 }
1426
1427 static __inline__ vector unsigned char __ATTRS_o_ai
1428 vec_vandc(vector unsigned char __a, vector bool char __b) {
1429   return __a & ~(vector unsigned char)__b;
1430 }
1431
1432 static __inline__ vector bool char __ATTRS_o_ai
1433 vec_vandc(vector bool char __a, vector bool char __b) {
1434   return __a & ~__b;
1435 }
1436
1437 static __inline__ vector short __ATTRS_o_ai vec_vandc(vector short __a,
1438                                                       vector short __b) {
1439   return __a & ~__b;
1440 }
1441
1442 static __inline__ vector short __ATTRS_o_ai vec_vandc(vector bool short __a,
1443                                                       vector short __b) {
1444   return (vector short)__a & ~__b;
1445 }
1446
1447 static __inline__ vector short __ATTRS_o_ai vec_vandc(vector short __a,
1448                                                       vector bool short __b) {
1449   return __a & ~(vector short)__b;
1450 }
1451
1452 static __inline__ vector unsigned short __ATTRS_o_ai
1453 vec_vandc(vector unsigned short __a, vector unsigned short __b) {
1454   return __a & ~__b;
1455 }
1456
1457 static __inline__ vector unsigned short __ATTRS_o_ai
1458 vec_vandc(vector bool short __a, vector unsigned short __b) {
1459   return (vector unsigned short)__a & ~__b;
1460 }
1461
1462 static __inline__ vector unsigned short __ATTRS_o_ai
1463 vec_vandc(vector unsigned short __a, vector bool short __b) {
1464   return __a & ~(vector unsigned short)__b;
1465 }
1466
1467 static __inline__ vector bool short __ATTRS_o_ai
1468 vec_vandc(vector bool short __a, vector bool short __b) {
1469   return __a & ~__b;
1470 }
1471
1472 static __inline__ vector int __ATTRS_o_ai vec_vandc(vector int __a,
1473                                                     vector int __b) {
1474   return __a & ~__b;
1475 }
1476
1477 static __inline__ vector int __ATTRS_o_ai vec_vandc(vector bool int __a,
1478                                                     vector int __b) {
1479   return (vector int)__a & ~__b;
1480 }
1481
1482 static __inline__ vector int __ATTRS_o_ai vec_vandc(vector int __a,
1483                                                     vector bool int __b) {
1484   return __a & ~(vector int)__b;
1485 }
1486
1487 static __inline__ vector unsigned int __ATTRS_o_ai
1488 vec_vandc(vector unsigned int __a, vector unsigned int __b) {
1489   return __a & ~__b;
1490 }
1491
1492 static __inline__ vector unsigned int __ATTRS_o_ai
1493 vec_vandc(vector bool int __a, vector unsigned int __b) {
1494   return (vector unsigned int)__a & ~__b;
1495 }
1496
1497 static __inline__ vector unsigned int __ATTRS_o_ai
1498 vec_vandc(vector unsigned int __a, vector bool int __b) {
1499   return __a & ~(vector unsigned int)__b;
1500 }
1501
1502 static __inline__ vector bool int __ATTRS_o_ai vec_vandc(vector bool int __a,
1503                                                          vector bool int __b) {
1504   return __a & ~__b;
1505 }
1506
1507 static __inline__ vector float __ATTRS_o_ai vec_vandc(vector float __a,
1508                                                       vector float __b) {
1509   vector unsigned int __res =
1510       (vector unsigned int)__a & ~(vector unsigned int)__b;
1511   return (vector float)__res;
1512 }
1513
1514 static __inline__ vector float __ATTRS_o_ai vec_vandc(vector bool int __a,
1515                                                       vector float __b) {
1516   vector unsigned int __res =
1517       (vector unsigned int)__a & ~(vector unsigned int)__b;
1518   return (vector float)__res;
1519 }
1520
1521 static __inline__ vector float __ATTRS_o_ai vec_vandc(vector float __a,
1522                                                       vector bool int __b) {
1523   vector unsigned int __res =
1524       (vector unsigned int)__a & ~(vector unsigned int)__b;
1525   return (vector float)__res;
1526 }
1527
1528 #ifdef __VSX__
1529 static __inline__ vector signed long long __ATTRS_o_ai
1530 vec_vandc(vector signed long long __a, vector signed long long __b) {
1531   return __a & ~__b;
1532 }
1533
1534 static __inline__ vector signed long long __ATTRS_o_ai
1535 vec_vandc(vector bool long long __a, vector signed long long __b) {
1536   return (vector signed long long)__a & ~__b;
1537 }
1538
1539 static __inline__ vector signed long long __ATTRS_o_ai
1540 vec_vandc(vector signed long long __a, vector bool long long __b) {
1541   return __a & ~(vector signed long long)__b;
1542 }
1543
1544 static __inline__ vector unsigned long long __ATTRS_o_ai
1545 vec_vandc(vector unsigned long long __a, vector unsigned long long __b) {
1546   return __a & ~__b;
1547 }
1548
1549 static __inline__ vector unsigned long long __ATTRS_o_ai
1550 vec_vandc(vector bool long long __a, vector unsigned long long __b) {
1551   return (vector unsigned long long)__a & ~__b;
1552 }
1553
1554 static __inline__ vector unsigned long long __ATTRS_o_ai
1555 vec_vandc(vector unsigned long long __a, vector bool long long __b) {
1556   return __a & ~(vector unsigned long long)__b;
1557 }
1558
1559 static __inline__ vector bool long long __ATTRS_o_ai
1560 vec_vandc(vector bool long long __a, vector bool long long __b) {
1561   return __a & ~__b;
1562 }
1563 #endif
1564
1565 /* vec_avg */
1566
1567 static __inline__ vector signed char __ATTRS_o_ai
1568 vec_avg(vector signed char __a, vector signed char __b) {
1569   return __builtin_altivec_vavgsb(__a, __b);
1570 }
1571
1572 static __inline__ vector unsigned char __ATTRS_o_ai
1573 vec_avg(vector unsigned char __a, vector unsigned char __b) {
1574   return __builtin_altivec_vavgub(__a, __b);
1575 }
1576
1577 static __inline__ vector short __ATTRS_o_ai vec_avg(vector short __a,
1578                                                     vector short __b) {
1579   return __builtin_altivec_vavgsh(__a, __b);
1580 }
1581
1582 static __inline__ vector unsigned short __ATTRS_o_ai
1583 vec_avg(vector unsigned short __a, vector unsigned short __b) {
1584   return __builtin_altivec_vavguh(__a, __b);
1585 }
1586
1587 static __inline__ vector int __ATTRS_o_ai vec_avg(vector int __a,
1588                                                   vector int __b) {
1589   return __builtin_altivec_vavgsw(__a, __b);
1590 }
1591
1592 static __inline__ vector unsigned int __ATTRS_o_ai
1593 vec_avg(vector unsigned int __a, vector unsigned int __b) {
1594   return __builtin_altivec_vavguw(__a, __b);
1595 }
1596
1597 /* vec_vavgsb */
1598
1599 static __inline__ vector signed char __attribute__((__always_inline__))
1600 vec_vavgsb(vector signed char __a, vector signed char __b) {
1601   return __builtin_altivec_vavgsb(__a, __b);
1602 }
1603
1604 /* vec_vavgub */
1605
1606 static __inline__ vector unsigned char __attribute__((__always_inline__))
1607 vec_vavgub(vector unsigned char __a, vector unsigned char __b) {
1608   return __builtin_altivec_vavgub(__a, __b);
1609 }
1610
1611 /* vec_vavgsh */
1612
1613 static __inline__ vector short __attribute__((__always_inline__))
1614 vec_vavgsh(vector short __a, vector short __b) {
1615   return __builtin_altivec_vavgsh(__a, __b);
1616 }
1617
1618 /* vec_vavguh */
1619
1620 static __inline__ vector unsigned short __attribute__((__always_inline__))
1621 vec_vavguh(vector unsigned short __a, vector unsigned short __b) {
1622   return __builtin_altivec_vavguh(__a, __b);
1623 }
1624
1625 /* vec_vavgsw */
1626
1627 static __inline__ vector int __attribute__((__always_inline__))
1628 vec_vavgsw(vector int __a, vector int __b) {
1629   return __builtin_altivec_vavgsw(__a, __b);
1630 }
1631
1632 /* vec_vavguw */
1633
1634 static __inline__ vector unsigned int __attribute__((__always_inline__))
1635 vec_vavguw(vector unsigned int __a, vector unsigned int __b) {
1636   return __builtin_altivec_vavguw(__a, __b);
1637 }
1638
1639 /* vec_ceil */
1640
1641 static __inline__ vector float __ATTRS_o_ai vec_ceil(vector float __a) {
1642 #ifdef __VSX__
1643   return __builtin_vsx_xvrspip(__a);
1644 #else
1645   return __builtin_altivec_vrfip(__a);
1646 #endif
1647 }
1648
1649 #ifdef __VSX__
1650 static __inline__ vector double __ATTRS_o_ai vec_ceil(vector double __a) {
1651   return __builtin_vsx_xvrdpip(__a);
1652 }
1653 #endif
1654
1655 /* vec_roundp */
1656 static __inline__ vector float __ATTRS_o_ai vec_roundp(vector float __a) {
1657   return vec_ceil(__a);
1658 }
1659
1660 #ifdef __VSX__
1661 static __inline__ vector double __ATTRS_o_ai vec_roundp(vector double __a) {
1662   return vec_ceil(__a);
1663 }
1664 #endif
1665
1666 /* vec_vrfip */
1667
1668 static __inline__ vector float __attribute__((__always_inline__))
1669 vec_vrfip(vector float __a) {
1670   return __builtin_altivec_vrfip(__a);
1671 }
1672
1673 /* vec_cmpb */
1674
1675 static __inline__ vector int __attribute__((__always_inline__))
1676 vec_cmpb(vector float __a, vector float __b) {
1677   return __builtin_altivec_vcmpbfp(__a, __b);
1678 }
1679
1680 /* vec_vcmpbfp */
1681
1682 static __inline__ vector int __attribute__((__always_inline__))
1683 vec_vcmpbfp(vector float __a, vector float __b) {
1684   return __builtin_altivec_vcmpbfp(__a, __b);
1685 }
1686
1687 /* vec_cmpeq */
1688
1689 static __inline__ vector bool char __ATTRS_o_ai
1690 vec_cmpeq(vector signed char __a, vector signed char __b) {
1691   return (vector bool char)__builtin_altivec_vcmpequb((vector char)__a,
1692                                                       (vector char)__b);
1693 }
1694
1695 static __inline__ vector bool char __ATTRS_o_ai
1696 vec_cmpeq(vector unsigned char __a, vector unsigned char __b) {
1697   return (vector bool char)__builtin_altivec_vcmpequb((vector char)__a,
1698                                                       (vector char)__b);
1699 }
1700
1701 static __inline__ vector bool char __ATTRS_o_ai
1702 vec_cmpeq(vector bool char __a, vector bool char __b) {
1703   return (vector bool char)__builtin_altivec_vcmpequb((vector char)__a,
1704                                                       (vector char)__b);
1705 }
1706
1707 static __inline__ vector bool short __ATTRS_o_ai vec_cmpeq(vector short __a,
1708                                                            vector short __b) {
1709   return (vector bool short)__builtin_altivec_vcmpequh(__a, __b);
1710 }
1711
1712 static __inline__ vector bool short __ATTRS_o_ai
1713 vec_cmpeq(vector unsigned short __a, vector unsigned short __b) {
1714   return (vector bool short)__builtin_altivec_vcmpequh((vector short)__a,
1715                                                        (vector short)__b);
1716 }
1717
1718 static __inline__ vector bool short __ATTRS_o_ai
1719 vec_cmpeq(vector bool short __a, vector bool short __b) {
1720   return (vector bool short)__builtin_altivec_vcmpequh((vector short)__a,
1721                                                        (vector short)__b);
1722 }
1723
1724 static __inline__ vector bool int __ATTRS_o_ai vec_cmpeq(vector int __a,
1725                                                          vector int __b) {
1726   return (vector bool int)__builtin_altivec_vcmpequw(__a, __b);
1727 }
1728
1729 static __inline__ vector bool int __ATTRS_o_ai
1730 vec_cmpeq(vector unsigned int __a, vector unsigned int __b) {
1731   return (vector bool int)__builtin_altivec_vcmpequw((vector int)__a,
1732                                                      (vector int)__b);
1733 }
1734
1735 static __inline__ vector bool int __ATTRS_o_ai vec_cmpeq(vector bool int __a,
1736                                                          vector bool int __b) {
1737   return (vector bool int)__builtin_altivec_vcmpequw((vector int)__a,
1738                                                      (vector int)__b);
1739 }
1740
1741 #ifdef __POWER8_VECTOR__
1742 static __inline__ vector bool long long __ATTRS_o_ai
1743 vec_cmpeq(vector signed long long __a, vector signed long long __b) {
1744   return (vector bool long long)__builtin_altivec_vcmpequd(__a, __b);
1745 }
1746
1747 static __inline__ vector bool long long __ATTRS_o_ai
1748 vec_cmpeq(vector unsigned long long __a, vector unsigned long long __b) {
1749   return (vector bool long long)__builtin_altivec_vcmpequd(
1750       (vector long long)__a, (vector long long)__b);
1751 }
1752
1753 static __inline__ vector bool long long __ATTRS_o_ai
1754 vec_cmpeq(vector bool long long __a, vector bool long long __b) {
1755   return (vector bool long long)__builtin_altivec_vcmpequd(
1756       (vector long long)__a, (vector long long)__b);
1757 }
1758 #elif defined(__VSX__)
1759 static __inline__ vector bool long long __ATTRS_o_ai
1760 vec_cmpeq(vector signed long long __a, vector signed long long __b) {
1761   vector bool int __wordcmp =
1762       vec_cmpeq((vector signed int)__a, (vector signed int)__b);
1763 #ifdef __LITTLE_ENDIAN__
1764   __wordcmp &= __builtin_shufflevector(__wordcmp, __wordcmp, 3, 0, 1, 2);
1765   return (vector bool long long)__builtin_shufflevector(__wordcmp, __wordcmp, 1,
1766                                                         1, 3, 3);
1767 #else
1768   __wordcmp &= __builtin_shufflevector(__wordcmp, __wordcmp, 1, 2, 3, 0);
1769   return (vector bool long long)__builtin_shufflevector(__wordcmp, __wordcmp, 0,
1770                                                         0, 2, 2);
1771 #endif
1772 }
1773
1774 static __inline__ vector bool long long __ATTRS_o_ai
1775 vec_cmpeq(vector unsigned long long __a, vector unsigned long long __b) {
1776   return vec_cmpeq((vector signed long long)__a, (vector signed long long)__b);
1777 }
1778
1779 static __inline__ vector bool long long __ATTRS_o_ai
1780 vec_cmpeq(vector bool long long __a, vector bool long long __b) {
1781   return vec_cmpeq((vector signed long long)__a, (vector signed long long)__b);
1782 }
1783 #endif
1784
1785 static __inline__ vector bool int __ATTRS_o_ai vec_cmpeq(vector float __a,
1786                                                          vector float __b) {
1787 #ifdef __VSX__
1788   return (vector bool int)__builtin_vsx_xvcmpeqsp(__a, __b);
1789 #else
1790   return (vector bool int)__builtin_altivec_vcmpeqfp(__a, __b);
1791 #endif
1792 }
1793
1794 #ifdef __VSX__
1795 static __inline__ vector bool long long __ATTRS_o_ai
1796 vec_cmpeq(vector double __a, vector double __b) {
1797   return (vector bool long long)__builtin_vsx_xvcmpeqdp(__a, __b);
1798 }
1799 #endif
1800
1801 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
1802 static __inline__ vector bool __int128 __ATTRS_o_ai
1803 vec_cmpeq(vector signed __int128 __a, vector signed __int128 __b) {
1804   return (vector bool __int128)__builtin_altivec_vcmpequq(
1805       (vector bool __int128)__a, (vector bool __int128)__b);
1806 }
1807
1808 static __inline__ vector bool __int128 __ATTRS_o_ai
1809 vec_cmpeq(vector unsigned __int128 __a, vector unsigned __int128 __b) {
1810   return (vector bool __int128)__builtin_altivec_vcmpequq(
1811       (vector bool __int128)__a, (vector bool __int128)__b);
1812 }
1813 #endif
1814
1815 #ifdef __POWER9_VECTOR__
1816 /* vec_cmpne */
1817
1818 static __inline__ vector bool char __ATTRS_o_ai
1819 vec_cmpne(vector bool char __a, vector bool char __b) {
1820   return (vector bool char)__builtin_altivec_vcmpneb((vector char)__a,
1821                                                      (vector char)__b);
1822 }
1823
1824 static __inline__ vector bool char __ATTRS_o_ai
1825 vec_cmpne(vector signed char __a, vector signed char __b) {
1826   return (vector bool char)__builtin_altivec_vcmpneb((vector char)__a,
1827                                                      (vector char)__b);
1828 }
1829
1830 static __inline__ vector bool char __ATTRS_o_ai
1831 vec_cmpne(vector unsigned char __a, vector unsigned char __b) {
1832   return (vector bool char)__builtin_altivec_vcmpneb((vector char)__a,
1833                                                      (vector char)__b);
1834 }
1835
1836 static __inline__ vector bool short __ATTRS_o_ai
1837 vec_cmpne(vector bool short __a, vector bool short __b) {
1838   return (vector bool short)__builtin_altivec_vcmpneh((vector short)__a,
1839                                                       (vector short)__b);
1840 }
1841
1842 static __inline__ vector bool short __ATTRS_o_ai
1843 vec_cmpne(vector signed short __a, vector signed short __b) {
1844   return (vector bool short)__builtin_altivec_vcmpneh((vector short)__a,
1845                                                       (vector short)__b);
1846 }
1847
1848 static __inline__ vector bool short __ATTRS_o_ai
1849 vec_cmpne(vector unsigned short __a, vector unsigned short __b) {
1850   return (vector bool short)__builtin_altivec_vcmpneh((vector short)__a,
1851                                                       (vector short)__b);
1852 }
1853
1854 static __inline__ vector bool int __ATTRS_o_ai
1855 vec_cmpne(vector bool int __a, vector bool int __b) {
1856   return (vector bool int)__builtin_altivec_vcmpnew((vector int)__a,
1857                                                     (vector int)__b);
1858 }
1859
1860 static __inline__ vector bool int __ATTRS_o_ai
1861 vec_cmpne(vector signed int __a, vector signed int __b) {
1862   return (vector bool int)__builtin_altivec_vcmpnew((vector int)__a,
1863                                                     (vector int)__b);
1864 }
1865
1866 static __inline__ vector bool int __ATTRS_o_ai
1867 vec_cmpne(vector unsigned int __a, vector unsigned int __b) {
1868   return (vector bool int)__builtin_altivec_vcmpnew((vector int)__a,
1869                                                     (vector int)__b);
1870 }
1871
1872 static __inline__ vector bool int __ATTRS_o_ai
1873 vec_cmpne(vector float __a, vector float __b) {
1874   return (vector bool int)__builtin_altivec_vcmpnew((vector int)__a,
1875                                                     (vector int)__b);
1876 }
1877
1878 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
1879 static __inline__ vector bool __int128 __ATTRS_o_ai
1880 vec_cmpne(vector unsigned __int128 __a, vector unsigned __int128 __b) {
1881   return (vector bool __int128) ~(__builtin_altivec_vcmpequq(
1882       (vector bool __int128)__a, (vector bool __int128)__b));
1883 }
1884
1885 static __inline__ vector bool __int128 __ATTRS_o_ai
1886 vec_cmpne(vector signed __int128 __a, vector signed __int128 __b) {
1887   return (vector bool __int128) ~(__builtin_altivec_vcmpequq(
1888       (vector bool __int128)__a, (vector bool __int128)__b));
1889 }
1890 #endif
1891
1892 /* vec_cmpnez */
1893
1894 static __inline__ vector bool char __ATTRS_o_ai
1895 vec_cmpnez(vector signed char __a, vector signed char __b) {
1896   return (vector bool char)__builtin_altivec_vcmpnezb((vector char)__a,
1897                                                       (vector char)__b);
1898 }
1899
1900 static __inline__ vector bool char __ATTRS_o_ai
1901 vec_cmpnez(vector unsigned char __a, vector unsigned char __b) {
1902   return (vector bool char)__builtin_altivec_vcmpnezb((vector char)__a,
1903                                                       (vector char)__b);
1904 }
1905
1906 static __inline__ vector bool short __ATTRS_o_ai
1907 vec_cmpnez(vector signed short __a, vector signed short __b) {
1908   return (vector bool short)__builtin_altivec_vcmpnezh((vector short)__a,
1909                                                        (vector short)__b);
1910 }
1911
1912 static __inline__ vector bool short __ATTRS_o_ai
1913 vec_cmpnez(vector unsigned short __a, vector unsigned short __b) {
1914   return (vector bool short)__builtin_altivec_vcmpnezh((vector short)__a,
1915                                                        (vector short)__b);
1916 }
1917
1918 static __inline__ vector bool int __ATTRS_o_ai
1919 vec_cmpnez(vector signed int __a, vector signed int __b) {
1920   return (vector bool int)__builtin_altivec_vcmpnezw((vector int)__a,
1921                                                      (vector int)__b);
1922 }
1923
1924 static __inline__ vector bool int __ATTRS_o_ai
1925 vec_cmpnez(vector unsigned int __a, vector unsigned int __b) {
1926   return (vector bool int)__builtin_altivec_vcmpnezw((vector int)__a,
1927                                                      (vector int)__b);
1928 }
1929
1930 static __inline__ signed int __ATTRS_o_ai
1931 vec_cntlz_lsbb(vector signed char __a) {
1932 #ifdef __LITTLE_ENDIAN__
1933   return __builtin_altivec_vctzlsbb(__a);
1934 #else
1935   return __builtin_altivec_vclzlsbb(__a);
1936 #endif
1937 }
1938
1939 static __inline__ signed int __ATTRS_o_ai
1940 vec_cntlz_lsbb(vector unsigned char __a) {
1941 #ifdef __LITTLE_ENDIAN__
1942   return __builtin_altivec_vctzlsbb(__a);
1943 #else
1944   return __builtin_altivec_vclzlsbb(__a);
1945 #endif
1946 }
1947
1948 static __inline__ signed int __ATTRS_o_ai
1949 vec_cnttz_lsbb(vector signed char __a) {
1950 #ifdef __LITTLE_ENDIAN__
1951   return __builtin_altivec_vclzlsbb(__a);
1952 #else
1953   return __builtin_altivec_vctzlsbb(__a);
1954 #endif
1955 }
1956
1957 static __inline__ signed int __ATTRS_o_ai
1958 vec_cnttz_lsbb(vector unsigned char __a) {
1959 #ifdef __LITTLE_ENDIAN__
1960   return __builtin_altivec_vclzlsbb(__a);
1961 #else
1962   return __builtin_altivec_vctzlsbb(__a);
1963 #endif
1964 }
1965
1966 static __inline__ vector unsigned int __ATTRS_o_ai
1967 vec_parity_lsbb(vector unsigned int __a) {
1968   return __builtin_altivec_vprtybw(__a);
1969 }
1970
1971 static __inline__ vector unsigned int __ATTRS_o_ai
1972 vec_parity_lsbb(vector signed int __a) {
1973   return __builtin_altivec_vprtybw(__a);
1974 }
1975
1976 #ifdef __SIZEOF_INT128__
1977 static __inline__ vector unsigned __int128 __ATTRS_o_ai
1978 vec_parity_lsbb(vector unsigned __int128 __a) {
1979   return __builtin_altivec_vprtybq(__a);
1980 }
1981
1982 static __inline__ vector unsigned __int128 __ATTRS_o_ai
1983 vec_parity_lsbb(vector signed __int128 __a) {
1984   return __builtin_altivec_vprtybq(__a);
1985 }
1986 #endif
1987
1988 static __inline__ vector unsigned long long __ATTRS_o_ai
1989 vec_parity_lsbb(vector unsigned long long __a) {
1990   return __builtin_altivec_vprtybd(__a);
1991 }
1992
1993 static __inline__ vector unsigned long long __ATTRS_o_ai
1994 vec_parity_lsbb(vector signed long long __a) {
1995   return __builtin_altivec_vprtybd(__a);
1996 }
1997
1998 #else
1999 /* vec_cmpne */
2000
2001 static __inline__ vector bool char __ATTRS_o_ai
2002 vec_cmpne(vector bool char __a, vector bool char __b) {
2003   return ~(vec_cmpeq(__a, __b));
2004 }
2005
2006 static __inline__ vector bool char __ATTRS_o_ai
2007 vec_cmpne(vector signed char __a, vector signed char __b) {
2008   return ~(vec_cmpeq(__a, __b));
2009 }
2010
2011 static __inline__ vector bool char __ATTRS_o_ai
2012 vec_cmpne(vector unsigned char __a, vector unsigned char __b) {
2013   return ~(vec_cmpeq(__a, __b));
2014 }
2015
2016 static __inline__ vector bool short __ATTRS_o_ai
2017 vec_cmpne(vector bool short __a, vector bool short __b) {
2018   return ~(vec_cmpeq(__a, __b));
2019 }
2020
2021 static __inline__ vector bool short __ATTRS_o_ai
2022 vec_cmpne(vector signed short __a, vector signed short __b) {
2023   return ~(vec_cmpeq(__a, __b));
2024 }
2025
2026 static __inline__ vector bool short __ATTRS_o_ai
2027 vec_cmpne(vector unsigned short __a, vector unsigned short __b) {
2028   return ~(vec_cmpeq(__a, __b));
2029 }
2030
2031 static __inline__ vector bool int __ATTRS_o_ai
2032 vec_cmpne(vector bool int __a, vector bool int __b) {
2033   return ~(vec_cmpeq(__a, __b));
2034 }
2035
2036 static __inline__ vector bool int __ATTRS_o_ai
2037 vec_cmpne(vector signed int __a, vector signed int __b) {
2038   return ~(vec_cmpeq(__a, __b));
2039 }
2040
2041 static __inline__ vector bool int __ATTRS_o_ai
2042 vec_cmpne(vector unsigned int __a, vector unsigned int __b) {
2043   return ~(vec_cmpeq(__a, __b));
2044 }
2045
2046 static __inline__ vector bool int __ATTRS_o_ai
2047 vec_cmpne(vector float __a, vector float __b) {
2048   return ~(vec_cmpeq(__a, __b));
2049 }
2050 #endif
2051
2052 #ifdef __POWER8_VECTOR__
2053 static __inline__ vector bool long long __ATTRS_o_ai
2054 vec_cmpne(vector bool long long __a, vector bool long long __b) {
2055   return (vector bool long long)
2056     ~(__builtin_altivec_vcmpequd((vector long long)__a, (vector long long)__b));
2057 }
2058
2059 static __inline__ vector bool long long __ATTRS_o_ai
2060 vec_cmpne(vector signed long long __a, vector signed long long __b) {
2061   return (vector bool long long)
2062     ~(__builtin_altivec_vcmpequd((vector long long)__a, (vector long long)__b));
2063 }
2064
2065 static __inline__ vector bool long long __ATTRS_o_ai
2066 vec_cmpne(vector unsigned long long __a, vector unsigned long long __b) {
2067   return (vector bool long long)
2068     ~(__builtin_altivec_vcmpequd((vector long long)__a, (vector long long)__b));
2069 }
2070 #elif defined(__VSX__)
2071 static __inline__ vector bool long long __ATTRS_o_ai
2072 vec_cmpne(vector bool long long __a, vector bool long long __b) {
2073   return (vector bool long long)~(
2074       vec_cmpeq((vector signed long long)__a, (vector signed long long)__b));
2075 }
2076
2077 static __inline__ vector bool long long __ATTRS_o_ai
2078 vec_cmpne(vector signed long long __a, vector signed long long __b) {
2079   return (vector bool long long)~(
2080       vec_cmpeq((vector signed long long)__a, (vector signed long long)__b));
2081 }
2082
2083 static __inline__ vector bool long long __ATTRS_o_ai
2084 vec_cmpne(vector unsigned long long __a, vector unsigned long long __b) {
2085   return (vector bool long long)~(
2086       vec_cmpeq((vector signed long long)__a, (vector signed long long)__b));
2087 }
2088 #endif
2089
2090 #ifdef __VSX__
2091 static __inline__ vector bool long long __ATTRS_o_ai
2092 vec_cmpne(vector double __a, vector double __b) {
2093   return (vector bool long long)
2094     ~(__builtin_altivec_vcmpequd((vector long long)__a, (vector long long)__b));
2095 }
2096 #endif
2097
2098 /* vec_cmpgt */
2099
2100 static __inline__ vector bool char __ATTRS_o_ai
2101 vec_cmpgt(vector signed char __a, vector signed char __b) {
2102   return (vector bool char)__builtin_altivec_vcmpgtsb(__a, __b);
2103 }
2104
2105 static __inline__ vector bool char __ATTRS_o_ai
2106 vec_cmpgt(vector unsigned char __a, vector unsigned char __b) {
2107   return (vector bool char)__builtin_altivec_vcmpgtub(__a, __b);
2108 }
2109
2110 static __inline__ vector bool short __ATTRS_o_ai vec_cmpgt(vector short __a,
2111                                                            vector short __b) {
2112   return (vector bool short)__builtin_altivec_vcmpgtsh(__a, __b);
2113 }
2114
2115 static __inline__ vector bool short __ATTRS_o_ai
2116 vec_cmpgt(vector unsigned short __a, vector unsigned short __b) {
2117   return (vector bool short)__builtin_altivec_vcmpgtuh(__a, __b);
2118 }
2119
2120 static __inline__ vector bool int __ATTRS_o_ai vec_cmpgt(vector int __a,
2121                                                          vector int __b) {
2122   return (vector bool int)__builtin_altivec_vcmpgtsw(__a, __b);
2123 }
2124
2125 static __inline__ vector bool int __ATTRS_o_ai
2126 vec_cmpgt(vector unsigned int __a, vector unsigned int __b) {
2127   return (vector bool int)__builtin_altivec_vcmpgtuw(__a, __b);
2128 }
2129
2130 #ifdef __POWER8_VECTOR__
2131 static __inline__ vector bool long long __ATTRS_o_ai
2132 vec_cmpgt(vector signed long long __a, vector signed long long __b) {
2133   return (vector bool long long)__builtin_altivec_vcmpgtsd(__a, __b);
2134 }
2135
2136 static __inline__ vector bool long long __ATTRS_o_ai
2137 vec_cmpgt(vector unsigned long long __a, vector unsigned long long __b) {
2138   return (vector bool long long)__builtin_altivec_vcmpgtud(__a, __b);
2139 }
2140 #elif defined(__VSX__)
2141 static __inline__ vector bool long long __ATTRS_o_ai
2142 vec_cmpgt(vector signed long long __a, vector signed long long __b) {
2143   vector signed int __sgtw = (vector signed int)vec_cmpgt(
2144       (vector signed int)__a, (vector signed int)__b);
2145   vector unsigned int __ugtw = (vector unsigned int)vec_cmpgt(
2146       (vector unsigned int)__a, (vector unsigned int)__b);
2147   vector unsigned int __eqw = (vector unsigned int)vec_cmpeq(
2148       (vector signed int)__a, (vector signed int)__b);
2149 #ifdef __LITTLE_ENDIAN__
2150   __ugtw = __builtin_shufflevector(__ugtw, __ugtw, 3, 0, 1, 2) & __eqw;
2151   __sgtw |= (vector signed int)__ugtw;
2152   return (vector bool long long)__builtin_shufflevector(__sgtw, __sgtw, 1, 1, 3,
2153                                                         3);
2154 #else
2155   __ugtw = __builtin_shufflevector(__ugtw, __ugtw, 1, 2, 3, 0) & __eqw;
2156   __sgtw |= (vector signed int)__ugtw;
2157   return (vector bool long long)__builtin_shufflevector(__sgtw, __sgtw, 0, 0, 2,
2158                                                         2);
2159 #endif
2160 }
2161
2162 static __inline__ vector bool long long __ATTRS_o_ai
2163 vec_cmpgt(vector unsigned long long __a, vector unsigned long long __b) {
2164   vector unsigned int __ugtw = (vector unsigned int)vec_cmpgt(
2165       (vector unsigned int)__a, (vector unsigned int)__b);
2166   vector unsigned int __eqw = (vector unsigned int)vec_cmpeq(
2167       (vector signed int)__a, (vector signed int)__b);
2168 #ifdef __LITTLE_ENDIAN__
2169   __eqw = __builtin_shufflevector(__ugtw, __ugtw, 3, 0, 1, 2) & __eqw;
2170   __ugtw |= __eqw;
2171   return (vector bool long long)__builtin_shufflevector(__ugtw, __ugtw, 1, 1, 3,
2172                                                         3);
2173 #else
2174   __eqw = __builtin_shufflevector(__ugtw, __ugtw, 1, 2, 3, 0) & __eqw;
2175   __ugtw |= __eqw;
2176   return (vector bool long long)__builtin_shufflevector(__ugtw, __ugtw, 0, 0, 2,
2177                                                         2);
2178 #endif
2179 }
2180 #endif
2181
2182 static __inline__ vector bool int __ATTRS_o_ai vec_cmpgt(vector float __a,
2183                                                          vector float __b) {
2184 #ifdef __VSX__
2185   return (vector bool int)__builtin_vsx_xvcmpgtsp(__a, __b);
2186 #else
2187   return (vector bool int)__builtin_altivec_vcmpgtfp(__a, __b);
2188 #endif
2189 }
2190
2191 #ifdef __VSX__
2192 static __inline__ vector bool long long __ATTRS_o_ai
2193 vec_cmpgt(vector double __a, vector double __b) {
2194   return (vector bool long long)__builtin_vsx_xvcmpgtdp(__a, __b);
2195 }
2196 #endif
2197
2198 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
2199 static __inline__ vector bool __int128 __ATTRS_o_ai
2200 vec_cmpgt(vector signed __int128 __a, vector signed __int128 __b) {
2201   return (vector bool __int128)__builtin_altivec_vcmpgtsq(
2202       (vector bool __int128)__a, (vector bool __int128)__b);
2203 }
2204
2205 static __inline__ vector bool __int128 __ATTRS_o_ai
2206 vec_cmpgt(vector unsigned __int128 __a, vector unsigned __int128 __b) {
2207   return (vector bool __int128)__builtin_altivec_vcmpgtuq(
2208       (vector bool __int128)__a, (vector bool __int128)__b);
2209 }
2210 #endif
2211
2212 /* vec_cmpge */
2213
2214 static __inline__ vector bool char __ATTRS_o_ai
2215 vec_cmpge(vector signed char __a, vector signed char __b) {
2216   return ~(vec_cmpgt(__b, __a));
2217 }
2218
2219 static __inline__ vector bool char __ATTRS_o_ai
2220 vec_cmpge(vector unsigned char __a, vector unsigned char __b) {
2221   return ~(vec_cmpgt(__b, __a));
2222 }
2223
2224 static __inline__ vector bool short __ATTRS_o_ai
2225 vec_cmpge(vector signed short __a, vector signed short __b) {
2226   return ~(vec_cmpgt(__b, __a));
2227 }
2228
2229 static __inline__ vector bool short __ATTRS_o_ai
2230 vec_cmpge(vector unsigned short __a, vector unsigned short __b) {
2231   return ~(vec_cmpgt(__b, __a));
2232 }
2233
2234 static __inline__ vector bool int __ATTRS_o_ai
2235 vec_cmpge(vector signed int __a, vector signed int __b) {
2236   return ~(vec_cmpgt(__b, __a));
2237 }
2238
2239 static __inline__ vector bool int __ATTRS_o_ai
2240 vec_cmpge(vector unsigned int __a, vector unsigned int __b) {
2241   return ~(vec_cmpgt(__b, __a));
2242 }
2243
2244 static __inline__ vector bool int __ATTRS_o_ai vec_cmpge(vector float __a,
2245                                                          vector float __b) {
2246 #ifdef __VSX__
2247   return (vector bool int)__builtin_vsx_xvcmpgesp(__a, __b);
2248 #else
2249   return (vector bool int)__builtin_altivec_vcmpgefp(__a, __b);
2250 #endif
2251 }
2252
2253 #ifdef __VSX__
2254 static __inline__ vector bool long long __ATTRS_o_ai
2255 vec_cmpge(vector double __a, vector double __b) {
2256   return (vector bool long long)__builtin_vsx_xvcmpgedp(__a, __b);
2257 }
2258
2259 static __inline__ vector bool long long __ATTRS_o_ai
2260 vec_cmpge(vector signed long long __a, vector signed long long __b) {
2261   return ~(vec_cmpgt(__b, __a));
2262 }
2263
2264 static __inline__ vector bool long long __ATTRS_o_ai
2265 vec_cmpge(vector unsigned long long __a, vector unsigned long long __b) {
2266   return ~(vec_cmpgt(__b, __a));
2267 }
2268 #endif
2269
2270 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
2271 static __inline__ vector bool __int128 __ATTRS_o_ai
2272 vec_cmpge(vector signed __int128 __a, vector signed __int128 __b) {
2273   return ~(vec_cmpgt(__b, __a));
2274 }
2275
2276 static __inline__ vector bool __int128 __ATTRS_o_ai
2277 vec_cmpge(vector unsigned __int128 __a, vector unsigned __int128 __b) {
2278   return ~(vec_cmpgt(__b, __a));
2279 }
2280 #endif
2281
2282 /* vec_vcmpgefp */
2283
2284 static __inline__ vector bool int __attribute__((__always_inline__))
2285 vec_vcmpgefp(vector float __a, vector float __b) {
2286   return (vector bool int)__builtin_altivec_vcmpgefp(__a, __b);
2287 }
2288
2289 /* vec_vcmpgtsb */
2290
2291 static __inline__ vector bool char __attribute__((__always_inline__))
2292 vec_vcmpgtsb(vector signed char __a, vector signed char __b) {
2293   return (vector bool char)__builtin_altivec_vcmpgtsb(__a, __b);
2294 }
2295
2296 /* vec_vcmpgtub */
2297
2298 static __inline__ vector bool char __attribute__((__always_inline__))
2299 vec_vcmpgtub(vector unsigned char __a, vector unsigned char __b) {
2300   return (vector bool char)__builtin_altivec_vcmpgtub(__a, __b);
2301 }
2302
2303 /* vec_vcmpgtsh */
2304
2305 static __inline__ vector bool short __attribute__((__always_inline__))
2306 vec_vcmpgtsh(vector short __a, vector short __b) {
2307   return (vector bool short)__builtin_altivec_vcmpgtsh(__a, __b);
2308 }
2309
2310 /* vec_vcmpgtuh */
2311
2312 static __inline__ vector bool short __attribute__((__always_inline__))
2313 vec_vcmpgtuh(vector unsigned short __a, vector unsigned short __b) {
2314   return (vector bool short)__builtin_altivec_vcmpgtuh(__a, __b);
2315 }
2316
2317 /* vec_vcmpgtsw */
2318
2319 static __inline__ vector bool int __attribute__((__always_inline__))
2320 vec_vcmpgtsw(vector int __a, vector int __b) {
2321   return (vector bool int)__builtin_altivec_vcmpgtsw(__a, __b);
2322 }
2323
2324 /* vec_vcmpgtuw */
2325
2326 static __inline__ vector bool int __attribute__((__always_inline__))
2327 vec_vcmpgtuw(vector unsigned int __a, vector unsigned int __b) {
2328   return (vector bool int)__builtin_altivec_vcmpgtuw(__a, __b);
2329 }
2330
2331 /* vec_vcmpgtfp */
2332
2333 static __inline__ vector bool int __attribute__((__always_inline__))
2334 vec_vcmpgtfp(vector float __a, vector float __b) {
2335   return (vector bool int)__builtin_altivec_vcmpgtfp(__a, __b);
2336 }
2337
2338 /* vec_cmple */
2339
2340 static __inline__ vector bool char __ATTRS_o_ai
2341 vec_cmple(vector signed char __a, vector signed char __b) {
2342   return vec_cmpge(__b, __a);
2343 }
2344
2345 static __inline__ vector bool char __ATTRS_o_ai
2346 vec_cmple(vector unsigned char __a, vector unsigned char __b) {
2347   return vec_cmpge(__b, __a);
2348 }
2349
2350 static __inline__ vector bool short __ATTRS_o_ai
2351 vec_cmple(vector signed short __a, vector signed short __b) {
2352   return vec_cmpge(__b, __a);
2353 }
2354
2355 static __inline__ vector bool short __ATTRS_o_ai
2356 vec_cmple(vector unsigned short __a, vector unsigned short __b) {
2357   return vec_cmpge(__b, __a);
2358 }
2359
2360 static __inline__ vector bool int __ATTRS_o_ai
2361 vec_cmple(vector signed int __a, vector signed int __b) {
2362   return vec_cmpge(__b, __a);
2363 }
2364
2365 static __inline__ vector bool int __ATTRS_o_ai
2366 vec_cmple(vector unsigned int __a, vector unsigned int __b) {
2367   return vec_cmpge(__b, __a);
2368 }
2369
2370 static __inline__ vector bool int __ATTRS_o_ai vec_cmple(vector float __a,
2371                                                          vector float __b) {
2372   return vec_cmpge(__b, __a);
2373 }
2374
2375 #ifdef __VSX__
2376 static __inline__ vector bool long long __ATTRS_o_ai
2377 vec_cmple(vector double __a, vector double __b) {
2378   return vec_cmpge(__b, __a);
2379 }
2380
2381 static __inline__ vector bool long long __ATTRS_o_ai
2382 vec_cmple(vector signed long long __a, vector signed long long __b) {
2383   return vec_cmpge(__b, __a);
2384 }
2385
2386 static __inline__ vector bool long long __ATTRS_o_ai
2387 vec_cmple(vector unsigned long long __a, vector unsigned long long __b) {
2388   return vec_cmpge(__b, __a);
2389 }
2390 #endif
2391
2392 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
2393 static __inline__ vector bool __int128 __ATTRS_o_ai
2394 vec_cmple(vector signed __int128 __a, vector signed __int128 __b) {
2395   return vec_cmpge(__b, __a);
2396 }
2397
2398 static __inline__ vector bool __int128 __ATTRS_o_ai
2399 vec_cmple(vector unsigned __int128 __a, vector unsigned __int128 __b) {
2400   return vec_cmpge(__b, __a);
2401 }
2402 #endif
2403
2404 /* vec_cmplt */
2405
2406 static __inline__ vector bool char __ATTRS_o_ai
2407 vec_cmplt(vector signed char __a, vector signed char __b) {
2408   return vec_cmpgt(__b, __a);
2409 }
2410
2411 static __inline__ vector bool char __ATTRS_o_ai
2412 vec_cmplt(vector unsigned char __a, vector unsigned char __b) {
2413   return vec_cmpgt(__b, __a);
2414 }
2415
2416 static __inline__ vector bool short __ATTRS_o_ai vec_cmplt(vector short __a,
2417                                                            vector short __b) {
2418   return vec_cmpgt(__b, __a);
2419 }
2420
2421 static __inline__ vector bool short __ATTRS_o_ai
2422 vec_cmplt(vector unsigned short __a, vector unsigned short __b) {
2423   return vec_cmpgt(__b, __a);
2424 }
2425
2426 static __inline__ vector bool int __ATTRS_o_ai vec_cmplt(vector int __a,
2427                                                          vector int __b) {
2428   return vec_cmpgt(__b, __a);
2429 }
2430
2431 static __inline__ vector bool int __ATTRS_o_ai
2432 vec_cmplt(vector unsigned int __a, vector unsigned int __b) {
2433   return vec_cmpgt(__b, __a);
2434 }
2435
2436 static __inline__ vector bool int __ATTRS_o_ai vec_cmplt(vector float __a,
2437                                                          vector float __b) {
2438   return vec_cmpgt(__b, __a);
2439 }
2440
2441 #ifdef __VSX__
2442 static __inline__ vector bool long long __ATTRS_o_ai
2443 vec_cmplt(vector double __a, vector double __b) {
2444   return vec_cmpgt(__b, __a);
2445 }
2446 #endif
2447
2448 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
2449 static __inline__ vector bool __int128 __ATTRS_o_ai
2450 vec_cmplt(vector signed __int128 __a, vector signed __int128 __b) {
2451   return vec_cmpgt(__b, __a);
2452 }
2453
2454 static __inline__ vector bool __int128 __ATTRS_o_ai
2455 vec_cmplt(vector unsigned __int128 __a, vector unsigned __int128 __b) {
2456   return vec_cmpgt(__b, __a);
2457 }
2458 #endif
2459
2460 #ifdef __VSX__
2461 static __inline__ vector bool long long __ATTRS_o_ai
2462 vec_cmplt(vector signed long long __a, vector signed long long __b) {
2463   return vec_cmpgt(__b, __a);
2464 }
2465
2466 static __inline__ vector bool long long __ATTRS_o_ai
2467 vec_cmplt(vector unsigned long long __a, vector unsigned long long __b) {
2468   return vec_cmpgt(__b, __a);
2469 }
2470 #endif
2471
2472 #ifdef __POWER8_VECTOR__
2473 /* vec_popcnt */
2474
2475 static __inline__ vector signed char __ATTRS_o_ai
2476 vec_popcnt(vector signed char __a) {
2477   return __builtin_altivec_vpopcntb(__a);
2478 }
2479 static __inline__ vector unsigned char __ATTRS_o_ai
2480 vec_popcnt(vector unsigned char __a) {
2481   return __builtin_altivec_vpopcntb(__a);
2482 }
2483 static __inline__ vector signed short __ATTRS_o_ai
2484 vec_popcnt(vector signed short __a) {
2485   return __builtin_altivec_vpopcnth(__a);
2486 }
2487 static __inline__ vector unsigned short __ATTRS_o_ai
2488 vec_popcnt(vector unsigned short __a) {
2489   return __builtin_altivec_vpopcnth(__a);
2490 }
2491 static __inline__ vector signed int __ATTRS_o_ai
2492 vec_popcnt(vector signed int __a) {
2493   return __builtin_altivec_vpopcntw(__a);
2494 }
2495 static __inline__ vector unsigned int __ATTRS_o_ai
2496 vec_popcnt(vector unsigned int __a) {
2497   return __builtin_altivec_vpopcntw(__a);
2498 }
2499 static __inline__ vector signed long long __ATTRS_o_ai
2500 vec_popcnt(vector signed long long __a) {
2501   return __builtin_altivec_vpopcntd(__a);
2502 }
2503 static __inline__ vector unsigned long long __ATTRS_o_ai
2504 vec_popcnt(vector unsigned long long __a) {
2505   return __builtin_altivec_vpopcntd(__a);
2506 }
2507
2508 #define vec_vclz vec_cntlz
2509 /* vec_cntlz */
2510
2511 static __inline__ vector signed char __ATTRS_o_ai
2512 vec_cntlz(vector signed char __a) {
2513   return __builtin_altivec_vclzb(__a);
2514 }
2515 static __inline__ vector unsigned char __ATTRS_o_ai
2516 vec_cntlz(vector unsigned char __a) {
2517   return __builtin_altivec_vclzb(__a);
2518 }
2519 static __inline__ vector signed short __ATTRS_o_ai
2520 vec_cntlz(vector signed short __a) {
2521   return __builtin_altivec_vclzh(__a);
2522 }
2523 static __inline__ vector unsigned short __ATTRS_o_ai
2524 vec_cntlz(vector unsigned short __a) {
2525   return __builtin_altivec_vclzh(__a);
2526 }
2527 static __inline__ vector signed int __ATTRS_o_ai
2528 vec_cntlz(vector signed int __a) {
2529   return __builtin_altivec_vclzw(__a);
2530 }
2531 static __inline__ vector unsigned int __ATTRS_o_ai
2532 vec_cntlz(vector unsigned int __a) {
2533   return __builtin_altivec_vclzw(__a);
2534 }
2535 static __inline__ vector signed long long __ATTRS_o_ai
2536 vec_cntlz(vector signed long long __a) {
2537   return __builtin_altivec_vclzd(__a);
2538 }
2539 static __inline__ vector unsigned long long __ATTRS_o_ai
2540 vec_cntlz(vector unsigned long long __a) {
2541   return __builtin_altivec_vclzd(__a);
2542 }
2543 #endif
2544
2545 #ifdef __POWER9_VECTOR__
2546
2547 /* vec_cnttz */
2548
2549 static __inline__ vector signed char __ATTRS_o_ai
2550 vec_cnttz(vector signed char __a) {
2551   return __builtin_altivec_vctzb(__a);
2552 }
2553 static __inline__ vector unsigned char __ATTRS_o_ai
2554 vec_cnttz(vector unsigned char __a) {
2555   return __builtin_altivec_vctzb(__a);
2556 }
2557 static __inline__ vector signed short __ATTRS_o_ai
2558 vec_cnttz(vector signed short __a) {
2559   return __builtin_altivec_vctzh(__a);
2560 }
2561 static __inline__ vector unsigned short __ATTRS_o_ai
2562 vec_cnttz(vector unsigned short __a) {
2563   return __builtin_altivec_vctzh(__a);
2564 }
2565 static __inline__ vector signed int __ATTRS_o_ai
2566 vec_cnttz(vector signed int __a) {
2567   return __builtin_altivec_vctzw(__a);
2568 }
2569 static __inline__ vector unsigned int __ATTRS_o_ai
2570 vec_cnttz(vector unsigned int __a) {
2571   return __builtin_altivec_vctzw(__a);
2572 }
2573 static __inline__ vector signed long long __ATTRS_o_ai
2574 vec_cnttz(vector signed long long __a) {
2575   return __builtin_altivec_vctzd(__a);
2576 }
2577 static __inline__ vector unsigned long long __ATTRS_o_ai
2578 vec_cnttz(vector unsigned long long __a) {
2579   return __builtin_altivec_vctzd(__a);
2580 }
2581
2582 /* vec_first_match_index */
2583
2584 static __inline__ unsigned __ATTRS_o_ai
2585 vec_first_match_index(vector signed char __a, vector signed char __b) {
2586   vector unsigned long long __res =
2587 #ifdef __LITTLE_ENDIAN__
2588     vec_cnttz((vector unsigned long long)vec_cmpeq(__a, __b));
2589 #else
2590     vec_cntlz((vector unsigned long long)vec_cmpeq(__a, __b));
2591 #endif
2592   if (__res[0] == 64) {
2593     return (__res[1] + 64) >> 3;
2594   }
2595   return __res[0] >> 3;
2596 }
2597
2598 static __inline__ unsigned __ATTRS_o_ai
2599 vec_first_match_index(vector unsigned char __a, vector unsigned char __b) {
2600   vector unsigned long long __res =
2601 #ifdef __LITTLE_ENDIAN__
2602     vec_cnttz((vector unsigned long long)vec_cmpeq(__a, __b));
2603 #else
2604     vec_cntlz((vector unsigned long long)vec_cmpeq(__a, __b));
2605 #endif
2606   if (__res[0] == 64) {
2607     return (__res[1] + 64) >> 3;
2608   }
2609   return __res[0] >> 3;
2610 }
2611
2612 static __inline__ unsigned __ATTRS_o_ai
2613 vec_first_match_index(vector signed short __a, vector signed short __b) {
2614   vector unsigned long long __res =
2615 #ifdef __LITTLE_ENDIAN__
2616     vec_cnttz((vector unsigned long long)vec_cmpeq(__a, __b));
2617 #else
2618     vec_cntlz((vector unsigned long long)vec_cmpeq(__a, __b));
2619 #endif
2620   if (__res[0] == 64) {
2621     return (__res[1] + 64) >> 4;
2622   }
2623   return __res[0] >> 4;
2624 }
2625
2626 static __inline__ unsigned __ATTRS_o_ai
2627 vec_first_match_index(vector unsigned short __a, vector unsigned short __b) {
2628   vector unsigned long long __res =
2629 #ifdef __LITTLE_ENDIAN__
2630     vec_cnttz((vector unsigned long long)vec_cmpeq(__a, __b));
2631 #else
2632     vec_cntlz((vector unsigned long long)vec_cmpeq(__a, __b));
2633 #endif
2634   if (__res[0] == 64) {
2635     return (__res[1] + 64) >> 4;
2636   }
2637   return __res[0] >> 4;
2638 }
2639
2640 static __inline__ unsigned __ATTRS_o_ai
2641 vec_first_match_index(vector signed int __a, vector signed int __b) {
2642   vector unsigned long long __res =
2643 #ifdef __LITTLE_ENDIAN__
2644     vec_cnttz((vector unsigned long long)vec_cmpeq(__a, __b));
2645 #else
2646     vec_cntlz((vector unsigned long long)vec_cmpeq(__a, __b));
2647 #endif
2648   if (__res[0] == 64) {
2649     return (__res[1] + 64) >> 5;
2650   }
2651   return __res[0] >> 5;
2652 }
2653
2654 static __inline__ unsigned __ATTRS_o_ai
2655 vec_first_match_index(vector unsigned int __a, vector unsigned int __b) {
2656   vector unsigned long long __res =
2657 #ifdef __LITTLE_ENDIAN__
2658     vec_cnttz((vector unsigned long long)vec_cmpeq(__a, __b));
2659 #else
2660     vec_cntlz((vector unsigned long long)vec_cmpeq(__a, __b));
2661 #endif
2662   if (__res[0] == 64) {
2663     return (__res[1] + 64) >> 5;
2664   }
2665   return __res[0] >> 5;
2666 }
2667
2668 /* vec_first_match_or_eos_index */
2669
2670 static __inline__ unsigned __ATTRS_o_ai
2671 vec_first_match_or_eos_index(vector signed char __a, vector signed char __b) {
2672   /* Compare the result of the comparison of two vectors with either and OR the
2673      result. Either the elements are equal or one will equal the comparison
2674      result if either is zero.
2675   */
2676   vector bool char __tmp1 = vec_cmpeq(__a, __b);
2677   vector bool char __tmp2 = __tmp1 |
2678                             vec_cmpeq((vector signed char)__tmp1, __a) |
2679                             vec_cmpeq((vector signed char)__tmp1, __b);
2680
2681   vector unsigned long long __res =
2682 #ifdef __LITTLE_ENDIAN__
2683       vec_cnttz((vector unsigned long long)__tmp2);
2684 #else
2685       vec_cntlz((vector unsigned long long)__tmp2);
2686 #endif
2687   if (__res[0] == 64) {
2688     return (__res[1] + 64) >> 3;
2689   }
2690   return __res[0] >> 3;
2691 }
2692
2693 static __inline__ unsigned __ATTRS_o_ai
2694 vec_first_match_or_eos_index(vector unsigned char __a,
2695                              vector unsigned char __b) {
2696   vector bool char __tmp1 = vec_cmpeq(__a, __b);
2697   vector bool char __tmp2 = __tmp1 |
2698                             vec_cmpeq((vector unsigned char)__tmp1, __a) |
2699                             vec_cmpeq((vector unsigned char)__tmp1, __b);
2700
2701   vector unsigned long long __res =
2702 #ifdef __LITTLE_ENDIAN__
2703       vec_cnttz((vector unsigned long long)__tmp2);
2704 #else
2705       vec_cntlz((vector unsigned long long)__tmp2);
2706 #endif
2707   if (__res[0] == 64) {
2708     return (__res[1] + 64) >> 3;
2709   }
2710   return __res[0] >> 3;
2711 }
2712
2713 static __inline__ unsigned __ATTRS_o_ai
2714 vec_first_match_or_eos_index(vector signed short __a, vector signed short __b) {
2715   vector bool short __tmp1 = vec_cmpeq(__a, __b);
2716   vector bool short __tmp2 = __tmp1 |
2717                              vec_cmpeq((vector signed short)__tmp1, __a) |
2718                              vec_cmpeq((vector signed short)__tmp1, __b);
2719
2720   vector unsigned long long __res =
2721 #ifdef __LITTLE_ENDIAN__
2722       vec_cnttz((vector unsigned long long)__tmp2);
2723 #else
2724       vec_cntlz((vector unsigned long long)__tmp2);
2725 #endif
2726   if (__res[0] == 64) {
2727     return (__res[1] + 64) >> 4;
2728   }
2729   return __res[0] >> 4;
2730 }
2731
2732 static __inline__ unsigned __ATTRS_o_ai
2733 vec_first_match_or_eos_index(vector unsigned short __a,
2734                              vector unsigned short __b) {
2735   vector bool short __tmp1 = vec_cmpeq(__a, __b);
2736   vector bool short __tmp2 = __tmp1 |
2737                              vec_cmpeq((vector unsigned short)__tmp1, __a) |
2738                              vec_cmpeq((vector unsigned short)__tmp1, __b);
2739
2740   vector unsigned long long __res =
2741 #ifdef __LITTLE_ENDIAN__
2742       vec_cnttz((vector unsigned long long)__tmp2);
2743 #else
2744       vec_cntlz((vector unsigned long long)__tmp2);
2745 #endif
2746   if (__res[0] == 64) {
2747     return (__res[1] + 64) >> 4;
2748   }
2749   return __res[0] >> 4;
2750 }
2751
2752 static __inline__ unsigned __ATTRS_o_ai
2753 vec_first_match_or_eos_index(vector signed int __a, vector signed int __b) {
2754   vector bool int __tmp1 = vec_cmpeq(__a, __b);
2755   vector bool int __tmp2 = __tmp1 | vec_cmpeq((vector signed int)__tmp1, __a) |
2756                            vec_cmpeq((vector signed int)__tmp1, __b);
2757
2758   vector unsigned long long __res =
2759 #ifdef __LITTLE_ENDIAN__
2760       vec_cnttz((vector unsigned long long)__tmp2);
2761 #else
2762       vec_cntlz((vector unsigned long long)__tmp2);
2763 #endif
2764   if (__res[0] == 64) {
2765     return (__res[1] + 64) >> 5;
2766   }
2767   return __res[0] >> 5;
2768 }
2769
2770 static __inline__ unsigned __ATTRS_o_ai
2771 vec_first_match_or_eos_index(vector unsigned int __a, vector unsigned int __b) {
2772   vector bool int __tmp1 = vec_cmpeq(__a, __b);
2773   vector bool int __tmp2 = __tmp1 |
2774                            vec_cmpeq((vector unsigned int)__tmp1, __a) |
2775                            vec_cmpeq((vector unsigned int)__tmp1, __b);
2776
2777   vector unsigned long long __res =
2778 #ifdef __LITTLE_ENDIAN__
2779     vec_cnttz((vector unsigned long long)__tmp2);
2780 #else
2781     vec_cntlz((vector unsigned long long)__tmp2);
2782 #endif
2783   if (__res[0] == 64) {
2784     return (__res[1] + 64) >> 5;
2785   }
2786   return __res[0] >> 5;
2787 }
2788
2789 /* vec_first_mismatch_index */
2790
2791 static __inline__ unsigned __ATTRS_o_ai
2792 vec_first_mismatch_index(vector signed char __a, vector signed char __b) {
2793   vector unsigned long long __res =
2794 #ifdef __LITTLE_ENDIAN__
2795     vec_cnttz((vector unsigned long long)vec_cmpne(__a, __b));
2796 #else
2797     vec_cntlz((vector unsigned long long)vec_cmpne(__a, __b));
2798 #endif
2799   if (__res[0] == 64) {
2800     return (__res[1] + 64) >> 3;
2801   }
2802   return __res[0] >> 3;
2803 }
2804
2805 static __inline__ unsigned __ATTRS_o_ai
2806 vec_first_mismatch_index(vector unsigned char __a, vector unsigned char __b) {
2807   vector unsigned long long __res =
2808 #ifdef __LITTLE_ENDIAN__
2809     vec_cnttz((vector unsigned long long)vec_cmpne(__a, __b));
2810 #else
2811     vec_cntlz((vector unsigned long long)vec_cmpne(__a, __b));
2812 #endif
2813   if (__res[0] == 64) {
2814     return (__res[1] + 64) >> 3;
2815   }
2816   return __res[0] >> 3;
2817 }
2818
2819 static __inline__ unsigned __ATTRS_o_ai
2820 vec_first_mismatch_index(vector signed short __a, vector signed short __b) {
2821   vector unsigned long long __res =
2822 #ifdef __LITTLE_ENDIAN__
2823     vec_cnttz((vector unsigned long long)vec_cmpne(__a, __b));
2824 #else
2825     vec_cntlz((vector unsigned long long)vec_cmpne(__a, __b));
2826 #endif
2827   if (__res[0] == 64) {
2828     return (__res[1] + 64) >> 4;
2829   }
2830   return __res[0] >> 4;
2831 }
2832
2833 static __inline__ unsigned __ATTRS_o_ai
2834 vec_first_mismatch_index(vector unsigned short __a, vector unsigned short __b) {
2835   vector unsigned long long __res =
2836 #ifdef __LITTLE_ENDIAN__
2837     vec_cnttz((vector unsigned long long)vec_cmpne(__a, __b));
2838 #else
2839     vec_cntlz((vector unsigned long long)vec_cmpne(__a, __b));
2840 #endif
2841   if (__res[0] == 64) {
2842     return (__res[1] + 64) >> 4;
2843   }
2844   return __res[0] >> 4;
2845 }
2846
2847 static __inline__ unsigned __ATTRS_o_ai
2848 vec_first_mismatch_index(vector signed int __a, vector signed int __b) {
2849   vector unsigned long long __res =
2850 #ifdef __LITTLE_ENDIAN__
2851     vec_cnttz((vector unsigned long long)vec_cmpne(__a, __b));
2852 #else
2853     vec_cntlz((vector unsigned long long)vec_cmpne(__a, __b));
2854 #endif
2855   if (__res[0] == 64) {
2856     return (__res[1] + 64) >> 5;
2857   }
2858   return __res[0] >> 5;
2859 }
2860
2861 static __inline__ unsigned __ATTRS_o_ai
2862 vec_first_mismatch_index(vector unsigned int __a, vector unsigned int __b) {
2863   vector unsigned long long __res =
2864 #ifdef __LITTLE_ENDIAN__
2865     vec_cnttz((vector unsigned long long)vec_cmpne(__a, __b));
2866 #else
2867     vec_cntlz((vector unsigned long long)vec_cmpne(__a, __b));
2868 #endif
2869   if (__res[0] == 64) {
2870     return (__res[1] + 64) >> 5;
2871   }
2872   return __res[0] >> 5;
2873 }
2874
2875 /* vec_first_mismatch_or_eos_index */
2876
2877 static __inline__ unsigned __ATTRS_o_ai
2878 vec_first_mismatch_or_eos_index(vector signed char __a,
2879                                 vector signed char __b) {
2880   vector unsigned long long __res =
2881 #ifdef __LITTLE_ENDIAN__
2882     vec_cnttz((vector unsigned long long)vec_cmpnez(__a, __b));
2883 #else
2884     vec_cntlz((vector unsigned long long)vec_cmpnez(__a, __b));
2885 #endif
2886   if (__res[0] == 64) {
2887     return (__res[1] + 64) >> 3;
2888   }
2889   return __res[0] >> 3;
2890 }
2891
2892 static __inline__ unsigned __ATTRS_o_ai
2893 vec_first_mismatch_or_eos_index(vector unsigned char __a,
2894                                 vector unsigned char __b) {
2895   vector unsigned long long __res =
2896 #ifdef __LITTLE_ENDIAN__
2897     vec_cnttz((vector unsigned long long)vec_cmpnez(__a, __b));
2898 #else
2899     vec_cntlz((vector unsigned long long)vec_cmpnez(__a, __b));
2900 #endif
2901   if (__res[0] == 64) {
2902     return (__res[1] + 64) >> 3;
2903   }
2904   return __res[0] >> 3;
2905 }
2906
2907 static __inline__ unsigned __ATTRS_o_ai
2908 vec_first_mismatch_or_eos_index(vector signed short __a,
2909                                 vector signed short __b) {
2910   vector unsigned long long __res =
2911 #ifdef __LITTLE_ENDIAN__
2912     vec_cnttz((vector unsigned long long)vec_cmpnez(__a, __b));
2913 #else
2914     vec_cntlz((vector unsigned long long)vec_cmpnez(__a, __b));
2915 #endif
2916   if (__res[0] == 64) {
2917     return (__res[1] + 64) >> 4;
2918   }
2919   return __res[0] >> 4;
2920 }
2921
2922 static __inline__ unsigned __ATTRS_o_ai
2923 vec_first_mismatch_or_eos_index(vector unsigned short __a,
2924                                 vector unsigned short __b) {
2925   vector unsigned long long __res =
2926 #ifdef __LITTLE_ENDIAN__
2927     vec_cnttz((vector unsigned long long)vec_cmpnez(__a, __b));
2928 #else
2929     vec_cntlz((vector unsigned long long)vec_cmpnez(__a, __b));
2930 #endif
2931   if (__res[0] == 64) {
2932     return (__res[1] + 64) >> 4;
2933   }
2934   return __res[0] >> 4;
2935 }
2936
2937 static __inline__ unsigned __ATTRS_o_ai
2938 vec_first_mismatch_or_eos_index(vector signed int __a, vector signed int __b) {
2939   vector unsigned long long __res =
2940 #ifdef __LITTLE_ENDIAN__
2941     vec_cnttz((vector unsigned long long)vec_cmpnez(__a, __b));
2942 #else
2943     vec_cntlz((vector unsigned long long)vec_cmpnez(__a, __b));
2944 #endif
2945   if (__res[0] == 64) {
2946     return (__res[1] + 64) >> 5;
2947   }
2948   return __res[0] >> 5;
2949 }
2950
2951 static __inline__ unsigned __ATTRS_o_ai
2952 vec_first_mismatch_or_eos_index(vector unsigned int __a,
2953                                 vector unsigned int __b) {
2954   vector unsigned long long __res =
2955 #ifdef __LITTLE_ENDIAN__
2956     vec_cnttz((vector unsigned long long)vec_cmpnez(__a, __b));
2957 #else
2958     vec_cntlz((vector unsigned long long)vec_cmpnez(__a, __b));
2959 #endif
2960   if (__res[0] == 64) {
2961     return (__res[1] + 64) >> 5;
2962   }
2963   return __res[0] >> 5;
2964 }
2965
2966 static __inline__ vector double  __ATTRS_o_ai
2967 vec_insert_exp(vector double __a, vector unsigned long long __b) {
2968   return __builtin_vsx_xviexpdp((vector unsigned long long)__a,__b);
2969 }
2970
2971 static __inline__ vector double  __ATTRS_o_ai
2972 vec_insert_exp(vector unsigned long long __a, vector unsigned long long __b) {
2973   return __builtin_vsx_xviexpdp(__a,__b);
2974 }
2975
2976 static __inline__ vector float  __ATTRS_o_ai
2977 vec_insert_exp(vector float __a, vector unsigned int __b) {
2978   return __builtin_vsx_xviexpsp((vector unsigned int)__a,__b);
2979 }
2980
2981 static __inline__ vector float  __ATTRS_o_ai
2982 vec_insert_exp(vector unsigned int __a, vector unsigned int __b) {
2983   return __builtin_vsx_xviexpsp(__a,__b);
2984 }
2985
2986 #if defined(__powerpc64__)
2987 static __inline__ vector signed char __ATTRS_o_ai vec_xl_len(const signed char *__a,
2988                                                              size_t __b) {
2989   return (vector signed char)__builtin_vsx_lxvl(__a, (__b << 56));
2990 }
2991
2992 static __inline__ vector unsigned char __ATTRS_o_ai
2993 vec_xl_len(const unsigned char *__a, size_t __b) {
2994   return (vector unsigned char)__builtin_vsx_lxvl(__a, (__b << 56));
2995 }
2996
2997 static __inline__ vector signed short __ATTRS_o_ai vec_xl_len(const signed short *__a,
2998                                                               size_t __b) {
2999   return (vector signed short)__builtin_vsx_lxvl(__a, (__b << 56));
3000 }
3001
3002 static __inline__ vector unsigned short __ATTRS_o_ai
3003 vec_xl_len(const unsigned short *__a, size_t __b) {
3004   return (vector unsigned short)__builtin_vsx_lxvl(__a, (__b << 56));
3005 }
3006
3007 static __inline__ vector signed int __ATTRS_o_ai vec_xl_len(const signed int *__a,
3008                                                             size_t __b) {
3009   return (vector signed int)__builtin_vsx_lxvl(__a, (__b << 56));
3010 }
3011
3012 static __inline__ vector unsigned int __ATTRS_o_ai vec_xl_len(const unsigned int *__a,
3013                                                               size_t __b) {
3014   return (vector unsigned int)__builtin_vsx_lxvl(__a, (__b << 56));
3015 }
3016
3017 static __inline__ vector float __ATTRS_o_ai vec_xl_len(const float *__a, size_t __b) {
3018   return (vector float)__builtin_vsx_lxvl(__a, (__b << 56));
3019 }
3020
3021 #ifdef __SIZEOF_INT128__
3022 static __inline__ vector signed __int128 __ATTRS_o_ai
3023 vec_xl_len(const signed __int128 *__a, size_t __b) {
3024   return (vector signed __int128)__builtin_vsx_lxvl(__a, (__b << 56));
3025 }
3026
3027 static __inline__ vector unsigned __int128 __ATTRS_o_ai
3028 vec_xl_len(const unsigned __int128 *__a, size_t __b) {
3029   return (vector unsigned __int128)__builtin_vsx_lxvl(__a, (__b << 56));
3030 }
3031 #endif
3032
3033 static __inline__ vector signed long long __ATTRS_o_ai
3034 vec_xl_len(const signed long long *__a, size_t __b) {
3035   return (vector signed long long)__builtin_vsx_lxvl(__a, (__b << 56));
3036 }
3037
3038 static __inline__ vector unsigned long long __ATTRS_o_ai
3039 vec_xl_len(const unsigned long long *__a, size_t __b) {
3040   return (vector unsigned long long)__builtin_vsx_lxvl(__a, (__b << 56));
3041 }
3042
3043 static __inline__ vector double __ATTRS_o_ai vec_xl_len(const double *__a,
3044                                                         size_t __b) {
3045   return (vector double)__builtin_vsx_lxvl(__a, (__b << 56));
3046 }
3047
3048 static __inline__ vector unsigned char __ATTRS_o_ai
3049 vec_xl_len_r(const unsigned char *__a, size_t __b) {
3050   vector unsigned char __res =
3051       (vector unsigned char)__builtin_vsx_lxvll(__a, (__b << 56));
3052 #ifdef __LITTLE_ENDIAN__
3053   vector unsigned char __mask =
3054       (vector unsigned char)__builtin_altivec_lvsr(16 - __b, (int *)NULL);
3055   __res = (vector unsigned char)__builtin_altivec_vperm_4si(
3056       (vector int)__res, (vector int)__res, __mask);
3057 #endif
3058   return __res;
3059 }
3060
3061 // vec_xst_len
3062 static __inline__ void __ATTRS_o_ai vec_xst_len(vector unsigned char __a,
3063                                                 unsigned char *__b,
3064                                                 size_t __c) {
3065   return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
3066 }
3067
3068 static __inline__ void __ATTRS_o_ai vec_xst_len(vector signed char __a,
3069                                                 signed char *__b, size_t __c) {
3070   return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
3071 }
3072
3073 static __inline__ void __ATTRS_o_ai vec_xst_len(vector signed short __a,
3074                                                 signed short *__b, size_t __c) {
3075   return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
3076 }
3077
3078 static __inline__ void __ATTRS_o_ai vec_xst_len(vector unsigned short __a,
3079                                                 unsigned short *__b,
3080                                                 size_t __c) {
3081   return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
3082 }
3083
3084 static __inline__ void __ATTRS_o_ai vec_xst_len(vector signed int __a,
3085                                                 signed int *__b, size_t __c) {
3086   return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
3087 }
3088
3089 static __inline__ void __ATTRS_o_ai vec_xst_len(vector unsigned int __a,
3090                                                 unsigned int *__b, size_t __c) {
3091   return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
3092 }
3093
3094 static __inline__ void __ATTRS_o_ai vec_xst_len(vector float __a, float *__b,
3095                                                 size_t __c) {
3096   return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
3097 }
3098
3099 #ifdef __SIZEOF_INT128__
3100 static __inline__ void __ATTRS_o_ai vec_xst_len(vector signed __int128 __a,
3101                                                 signed __int128 *__b,
3102                                                 size_t __c) {
3103   return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
3104 }
3105
3106 static __inline__ void __ATTRS_o_ai vec_xst_len(vector unsigned __int128 __a,
3107                                                 unsigned __int128 *__b,
3108                                                 size_t __c) {
3109   return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
3110 }
3111 #endif
3112
3113 static __inline__ void __ATTRS_o_ai vec_xst_len(vector signed long long __a,
3114                                                 signed long long *__b,
3115                                                 size_t __c) {
3116   return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
3117 }
3118
3119 static __inline__ void __ATTRS_o_ai vec_xst_len(vector unsigned long long __a,
3120                                                 unsigned long long *__b,
3121                                                 size_t __c) {
3122   return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
3123 }
3124
3125 static __inline__ void __ATTRS_o_ai vec_xst_len(vector double __a, double *__b,
3126                                                 size_t __c) {
3127   return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
3128 }
3129
3130 static __inline__ void __ATTRS_o_ai vec_xst_len_r(vector unsigned char __a,
3131                                                   unsigned char *__b,
3132                                                   size_t __c) {
3133 #ifdef __LITTLE_ENDIAN__
3134   vector unsigned char __mask =
3135       (vector unsigned char)__builtin_altivec_lvsl(16 - __c, (int *)NULL);
3136   vector unsigned char __res =
3137       __builtin_altivec_vperm_4si((vector int)__a, (vector int)__a, __mask);
3138   return __builtin_vsx_stxvll((vector int)__res, __b, (__c << 56));
3139 #else
3140   return __builtin_vsx_stxvll((vector int)__a, __b, (__c << 56));
3141 #endif
3142 }
3143 #endif
3144 #endif
3145
3146 #if defined(__POWER9_VECTOR__) && defined(__powerpc64__)
3147 #define __vec_ldrmb(PTR, CNT) vec_xl_len_r((const unsigned char *)(PTR), (CNT))
3148 #define __vec_strmb(PTR, CNT, VAL)                                             \
3149   vec_xst_len_r((VAL), (unsigned char *)(PTR), (CNT))
3150 #else
3151 #define __vec_ldrmb __builtin_vsx_ldrmb
3152 #define __vec_strmb __builtin_vsx_strmb
3153 #endif
3154
3155 /* vec_cpsgn */
3156
3157 #ifdef __VSX__
3158 static __inline__ vector float __ATTRS_o_ai vec_cpsgn(vector float __a,
3159                                                       vector float __b) {
3160   return __builtin_vsx_xvcpsgnsp(__b, __a);
3161 }
3162
3163 static __inline__ vector double __ATTRS_o_ai vec_cpsgn(vector double __a,
3164                                                        vector double __b) {
3165   return __builtin_vsx_xvcpsgndp(__b, __a);
3166 }
3167 #endif
3168
3169 /* vec_ctf */
3170
3171 #ifdef __VSX__
3172 // There are some functions that have different signatures with the XL compiler
3173 // from those in Clang/GCC and documented in the PVIPR. This macro ensures that
3174 // the XL-compatible signatures are used for those functions.
3175 #ifdef __XL_COMPAT_ALTIVEC__
3176 #define vec_ctf(__a, __b)                                                      \
3177   _Generic((__a), vector int                                                   \
3178            : (vector float)__builtin_altivec_vcfsx((vector int)(__a), (__b)),  \
3179              vector unsigned int                                               \
3180            : (vector float)__builtin_altivec_vcfux((vector unsigned int)(__a), \
3181                                                    (__b)),                     \
3182              vector unsigned long long                                         \
3183            : (__builtin_vsx_xvcvuxdsp((vector unsigned long long)(__a)) *      \
3184               (vector float)(vector unsigned)((0x7f - (__b)) << 23)),          \
3185              vector signed long long                                           \
3186            : (__builtin_vsx_xvcvsxdsp((vector signed long long)(__a)) *        \
3187               (vector float)(vector unsigned)((0x7f - (__b)) << 23)))
3188 #else // __XL_COMPAT_ALTIVEC__
3189 #define vec_ctf(__a, __b)                                                      \
3190   _Generic((__a), vector int                                                   \
3191            : (vector float)__builtin_altivec_vcfsx((vector int)(__a), (__b)),  \
3192              vector unsigned int                                               \
3193            : (vector float)__builtin_altivec_vcfux((vector unsigned int)(__a), \
3194                                                    (__b)),                     \
3195              vector unsigned long long                                         \
3196            : (__builtin_convertvector((vector unsigned long long)(__a),        \
3197                                       vector double) *                         \
3198               (vector double)(vector unsigned long long)((0x3ffULL - (__b))    \
3199                                                          << 52)),              \
3200              vector signed long long                                           \
3201            : (__builtin_convertvector((vector signed long long)(__a),          \
3202                                       vector double) *                         \
3203               (vector double)(vector unsigned long long)((0x3ffULL - (__b))    \
3204                                                          << 52)))
3205 #endif // __XL_COMPAT_ALTIVEC__
3206 #else
3207 #define vec_ctf(__a, __b)                                                      \
3208   _Generic((__a), vector int                                                   \
3209            : (vector float)__builtin_altivec_vcfsx((vector int)(__a), (__b)),  \
3210              vector unsigned int                                               \
3211            : (vector float)__builtin_altivec_vcfux((vector unsigned int)(__a), \
3212                                                    (__b)))
3213 #endif
3214
3215 /* vec_ctd */
3216 #ifdef __VSX__
3217 #define vec_ctd(__a, __b)                                                      \
3218   _Generic((__a), vector signed int                                            \
3219            : (vec_doublee((vector signed int)(__a)) *                          \
3220               (vector double)(vector unsigned long long)((0x3ffULL - (__b))    \
3221                                                          << 52)),              \
3222              vector unsigned int                                               \
3223            : (vec_doublee((vector unsigned int)(__a)) *                        \
3224               (vector double)(vector unsigned long long)((0x3ffULL - (__b))    \
3225                                                          << 52)),              \
3226              vector unsigned long long                                         \
3227            : (__builtin_convertvector((vector unsigned long long)(__a),        \
3228                                       vector double) *                         \
3229               (vector double)(vector unsigned long long)((0x3ffULL - (__b))    \
3230                                                          << 52)),              \
3231              vector signed long long                                           \
3232            : (__builtin_convertvector((vector signed long long)(__a),          \
3233                                       vector double) *                         \
3234               (vector double)(vector unsigned long long)((0x3ffULL - (__b))    \
3235                                                          << 52)))
3236 #endif // __VSX__
3237
3238 /* vec_vcfsx */
3239
3240 #define vec_vcfux __builtin_altivec_vcfux
3241 /* vec_vcfux */
3242
3243 #define vec_vcfsx(__a, __b) __builtin_altivec_vcfsx((vector int)(__a), (__b))
3244
3245 /* vec_cts */
3246
3247 #ifdef __VSX__
3248 #ifdef __XL_COMPAT_ALTIVEC__
3249 #define vec_cts(__a, __b)                                                      \
3250   _Generic((__a), vector float                                                 \
3251            : __builtin_altivec_vctsxs((vector float)(__a), (__b)),             \
3252              vector double                                                     \
3253            : __extension__({                                                   \
3254              vector double __ret =                                             \
3255                  (vector double)(__a) *                                        \
3256                  (vector double)(vector unsigned long long)((0x3ffULL + (__b)) \
3257                                                             << 52);            \
3258              __builtin_vsx_xvcvdpsxws(__ret);                                  \
3259            }))
3260 #else // __XL_COMPAT_ALTIVEC__
3261 #define vec_cts(__a, __b)                                                      \
3262   _Generic((__a), vector float                                                 \
3263            : __builtin_altivec_vctsxs((vector float)(__a), (__b)),             \
3264              vector double                                                     \
3265            : __extension__({                                                   \
3266              vector double __ret =                                             \
3267                  (vector double)(__a) *                                        \
3268                  (vector double)(vector unsigned long long)((0x3ffULL + (__b)) \
3269                                                             << 52);            \
3270              __builtin_convertvector(__ret, vector signed long long);          \
3271            }))
3272 #endif // __XL_COMPAT_ALTIVEC__
3273 #else
3274 #define vec_cts __builtin_altivec_vctsxs
3275 #endif
3276
3277 /* vec_vctsxs */
3278
3279 #define vec_vctsxs __builtin_altivec_vctsxs
3280
3281 /* vec_ctu */
3282
3283 #ifdef __VSX__
3284 #ifdef __XL_COMPAT_ALTIVEC__
3285 #define vec_ctu(__a, __b)                                                      \
3286   _Generic((__a), vector float                                                 \
3287            : __builtin_altivec_vctuxs((vector float)(__a), (__b)),             \
3288              vector double                                                     \
3289            : __extension__({                                                   \
3290              vector double __ret =                                             \
3291                  (vector double)(__a) *                                        \
3292                  (vector double)(vector unsigned long long)((0x3ffULL + __b)   \
3293                                                             << 52);            \
3294              __builtin_vsx_xvcvdpuxws(__ret);                                  \
3295            }))
3296 #else // __XL_COMPAT_ALTIVEC__
3297 #define vec_ctu(__a, __b)                                                      \
3298   _Generic((__a), vector float                                                 \
3299            : __builtin_altivec_vctuxs((vector float)(__a), (__b)),             \
3300              vector double                                                     \
3301            : __extension__({                                                   \
3302              vector double __ret =                                             \
3303                  (vector double)(__a) *                                        \
3304                  (vector double)(vector unsigned long long)((0x3ffULL + __b)   \
3305                                                             << 52);            \
3306              __builtin_convertvector(__ret, vector unsigned long long);        \
3307            }))
3308 #endif // __XL_COMPAT_ALTIVEC__
3309 #else
3310 #define vec_ctu __builtin_altivec_vctuxs
3311 #endif
3312
3313 #ifdef __LITTLE_ENDIAN__
3314 /* vec_ctsl */
3315
3316 #ifdef __VSX__
3317 #define vec_ctsl(__a, __b)                                                     \
3318   _Generic((__a), vector float                                                 \
3319            : __extension__({                                                   \
3320                vector float __ret =                                            \
3321                    (vector float)(__a) *                                       \
3322                    (vector float)(vector unsigned)((0x7f + (__b)) << 23);      \
3323                __builtin_vsx_xvcvspsxds(                                       \
3324                    __builtin_vsx_xxsldwi(__ret, __ret, 1));                    \
3325              }),                                                               \
3326              vector double                                                     \
3327            : __extension__({                                                   \
3328              vector double __ret =                                             \
3329                  (vector double)(__a) *                                        \
3330                  (vector double)(vector unsigned long long)((0x3ffULL + __b)   \
3331                                                             << 52);            \
3332              __builtin_convertvector(__ret, vector signed long long);          \
3333            }))
3334
3335 /* vec_ctul */
3336
3337 #define vec_ctul(__a, __b)                                                     \
3338   _Generic((__a), vector float                                                 \
3339            : __extension__({                                                   \
3340                vector float __ret =                                            \
3341                    (vector float)(__a) *                                       \
3342                    (vector float)(vector unsigned)((0x7f + (__b)) << 23);      \
3343                __builtin_vsx_xvcvspuxds(                                       \
3344                    __builtin_vsx_xxsldwi(__ret, __ret, 1));                    \
3345              }),                                                               \
3346              vector double                                                     \
3347            : __extension__({                                                   \
3348              vector double __ret =                                             \
3349                  (vector double)(__a) *                                        \
3350                  (vector double)(vector unsigned long long)((0x3ffULL + __b)   \
3351                                                             << 52);            \
3352              __builtin_convertvector(__ret, vector unsigned long long);        \
3353            }))
3354 #endif
3355 #else // __LITTLE_ENDIAN__
3356 /* vec_ctsl */
3357
3358 #ifdef __VSX__
3359 #define vec_ctsl(__a, __b)                                                     \
3360   _Generic((__a), vector float                                                 \
3361            : __extension__({                                                   \
3362                vector float __ret =                                            \
3363                    (vector float)(__a) *                                       \
3364                    (vector float)(vector unsigned)((0x7f + (__b)) << 23);      \
3365                __builtin_vsx_xvcvspsxds(__ret);                                \
3366              }),                                                               \
3367              vector double                                                     \
3368            : __extension__({                                                   \
3369              vector double __ret =                                             \
3370                  (vector double)(__a) *                                        \
3371                  (vector double)(vector unsigned long long)((0x3ffULL + __b)   \
3372                                                             << 52);            \
3373              __builtin_convertvector(__ret, vector signed long long);          \
3374            }))
3375
3376 /* vec_ctul */
3377
3378 #define vec_ctul(__a, __b)                                                     \
3379   _Generic((__a), vector float                                                 \
3380            : __extension__({                                                   \
3381                vector float __ret =                                            \
3382                    (vector float)(__a) *                                       \
3383                    (vector float)(vector unsigned)((0x7f + (__b)) << 23);      \
3384                __builtin_vsx_xvcvspuxds(__ret);                                \
3385              }),                                                               \
3386              vector double                                                     \
3387            : __extension__({                                                   \
3388              vector double __ret =                                             \
3389                  (vector double)(__a) *                                        \
3390                  (vector double)(vector unsigned long long)((0x3ffULL + __b)   \
3391                                                             << 52);            \
3392              __builtin_convertvector(__ret, vector unsigned long long);        \
3393            }))
3394 #endif
3395 #endif // __LITTLE_ENDIAN__
3396
3397 /* vec_vctuxs */
3398
3399 #define vec_vctuxs __builtin_altivec_vctuxs
3400
3401 /* vec_signext */
3402
3403 #ifdef __POWER9_VECTOR__
3404 static __inline__ vector signed int __ATTRS_o_ai
3405 vec_signexti(vector signed char __a) {
3406   return __builtin_altivec_vextsb2w(__a);
3407 }
3408
3409 static __inline__ vector signed int __ATTRS_o_ai
3410 vec_signexti(vector signed short __a) {
3411   return __builtin_altivec_vextsh2w(__a);
3412 }
3413
3414 static __inline__ vector signed long long __ATTRS_o_ai
3415 vec_signextll(vector signed char __a) {
3416   return __builtin_altivec_vextsb2d(__a);
3417 }
3418
3419 static __inline__ vector signed long long __ATTRS_o_ai
3420 vec_signextll(vector signed short __a) {
3421   return __builtin_altivec_vextsh2d(__a);
3422 }
3423
3424 static __inline__ vector signed long long __ATTRS_o_ai
3425 vec_signextll(vector signed int __a) {
3426   return __builtin_altivec_vextsw2d(__a);
3427 }
3428 #endif
3429
3430 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
3431 static __inline__ vector signed __int128 __ATTRS_o_ai
3432 vec_signextq(vector signed long long __a) {
3433   return __builtin_altivec_vextsd2q(__a);
3434 }
3435 #endif
3436
3437 /* vec_signed */
3438
3439 static __inline__ vector signed int __ATTRS_o_ai
3440 vec_sld(vector signed int, vector signed int, unsigned const int __c);
3441
3442 static __inline__ vector signed int __ATTRS_o_ai
3443 vec_signed(vector float __a) {
3444   return __builtin_convertvector(__a, vector signed int);
3445 }
3446
3447 #ifdef __VSX__
3448 static __inline__ vector signed long long __ATTRS_o_ai
3449 vec_signed(vector double __a) {
3450   return __builtin_convertvector(__a, vector signed long long);
3451 }
3452
3453 static __inline__ vector signed int __attribute__((__always_inline__))
3454 vec_signed2(vector double __a, vector double __b) {
3455   return (vector signed int) { __a[0], __a[1], __b[0], __b[1] };
3456 }
3457
3458 static __inline__ vector signed int __ATTRS_o_ai
3459 vec_signede(vector double __a) {
3460 #ifdef __LITTLE_ENDIAN__
3461   vector signed int __ret = __builtin_vsx_xvcvdpsxws(__a);
3462   return vec_sld(__ret, __ret, 12);
3463 #else
3464   return __builtin_vsx_xvcvdpsxws(__a);
3465 #endif
3466 }
3467
3468 static __inline__ vector signed int __ATTRS_o_ai
3469 vec_signedo(vector double __a) {
3470 #ifdef __LITTLE_ENDIAN__
3471   return __builtin_vsx_xvcvdpsxws(__a);
3472 #else
3473   vector signed int __ret = __builtin_vsx_xvcvdpsxws(__a);
3474   return vec_sld(__ret, __ret, 12);
3475 #endif
3476 }
3477 #endif
3478
3479 /* vec_unsigned */
3480
3481 static __inline__ vector unsigned int __ATTRS_o_ai
3482 vec_sld(vector unsigned int, vector unsigned int, unsigned const int __c);
3483
3484 static __inline__ vector unsigned int __ATTRS_o_ai
3485 vec_unsigned(vector float __a) {
3486   return __builtin_convertvector(__a, vector unsigned int);
3487 }
3488
3489 #ifdef __VSX__
3490 static __inline__ vector unsigned long long __ATTRS_o_ai
3491 vec_unsigned(vector double __a) {
3492   return __builtin_convertvector(__a, vector unsigned long long);
3493 }
3494
3495 static __inline__ vector unsigned int __attribute__((__always_inline__))
3496 vec_unsigned2(vector double __a, vector double __b) {
3497   return (vector unsigned int) { __a[0], __a[1], __b[0], __b[1] };
3498 }
3499
3500 static __inline__ vector unsigned int __ATTRS_o_ai
3501 vec_unsignede(vector double __a) {
3502 #ifdef __LITTLE_ENDIAN__
3503   vector unsigned int __ret = __builtin_vsx_xvcvdpuxws(__a);
3504   return vec_sld(__ret, __ret, 12);
3505 #else
3506   return __builtin_vsx_xvcvdpuxws(__a);
3507 #endif
3508 }
3509
3510 static __inline__ vector unsigned int __ATTRS_o_ai
3511 vec_unsignedo(vector double __a) {
3512 #ifdef __LITTLE_ENDIAN__
3513   return __builtin_vsx_xvcvdpuxws(__a);
3514 #else
3515   vector unsigned int __ret = __builtin_vsx_xvcvdpuxws(__a);
3516   return vec_sld(__ret, __ret, 12);
3517 #endif
3518 }
3519 #endif
3520
3521 /* vec_float */
3522
3523 static __inline__ vector float __ATTRS_o_ai
3524 vec_sld(vector float, vector float, unsigned const int __c);
3525
3526 static __inline__ vector float __ATTRS_o_ai
3527 vec_float(vector signed int __a) {
3528   return __builtin_convertvector(__a, vector float);
3529 }
3530
3531 static __inline__ vector float __ATTRS_o_ai
3532 vec_float(vector unsigned int __a) {
3533   return __builtin_convertvector(__a, vector float);
3534 }
3535
3536 #ifdef __VSX__
3537 static __inline__ vector float __ATTRS_o_ai
3538 vec_float2(vector signed long long __a, vector signed long long __b) {
3539   return (vector float) { __a[0], __a[1], __b[0], __b[1] };
3540 }
3541
3542 static __inline__ vector float __ATTRS_o_ai
3543 vec_float2(vector unsigned long long __a, vector unsigned long long __b) {
3544   return (vector float) { __a[0], __a[1], __b[0], __b[1] };
3545 }
3546
3547 static __inline__ vector float __ATTRS_o_ai
3548 vec_float2(vector double __a, vector double __b) {
3549   return (vector float) { __a[0], __a[1], __b[0], __b[1] };
3550 }
3551
3552 static __inline__ vector float __ATTRS_o_ai
3553 vec_floate(vector signed long long __a) {
3554 #ifdef __LITTLE_ENDIAN__
3555   vector float __ret = __builtin_vsx_xvcvsxdsp(__a);
3556   return vec_sld(__ret, __ret, 12);
3557 #else
3558   return __builtin_vsx_xvcvsxdsp(__a);
3559 #endif
3560 }
3561
3562 static __inline__ vector float __ATTRS_o_ai
3563 vec_floate(vector unsigned long long __a) {
3564 #ifdef __LITTLE_ENDIAN__
3565   vector float __ret = __builtin_vsx_xvcvuxdsp(__a);
3566   return vec_sld(__ret, __ret, 12);
3567 #else
3568   return __builtin_vsx_xvcvuxdsp(__a);
3569 #endif
3570 }
3571
3572 static __inline__ vector float __ATTRS_o_ai
3573 vec_floate(vector double __a) {
3574 #ifdef __LITTLE_ENDIAN__
3575   vector float __ret = __builtin_vsx_xvcvdpsp(__a);
3576   return vec_sld(__ret, __ret, 12);
3577 #else
3578   return __builtin_vsx_xvcvdpsp(__a);
3579 #endif
3580 }
3581
3582 static __inline__ vector float __ATTRS_o_ai
3583 vec_floato(vector signed long long __a) {
3584 #ifdef __LITTLE_ENDIAN__
3585   return __builtin_vsx_xvcvsxdsp(__a);
3586 #else
3587   vector float __ret = __builtin_vsx_xvcvsxdsp(__a);
3588   return vec_sld(__ret, __ret, 12);
3589 #endif
3590 }
3591
3592 static __inline__ vector float __ATTRS_o_ai
3593 vec_floato(vector unsigned long long __a) {
3594 #ifdef __LITTLE_ENDIAN__
3595   return __builtin_vsx_xvcvuxdsp(__a);
3596 #else
3597   vector float __ret = __builtin_vsx_xvcvuxdsp(__a);
3598   return vec_sld(__ret, __ret, 12);
3599 #endif
3600 }
3601
3602 static __inline__ vector float __ATTRS_o_ai
3603 vec_floato(vector double __a) {
3604 #ifdef __LITTLE_ENDIAN__
3605   return __builtin_vsx_xvcvdpsp(__a);
3606 #else
3607   vector float __ret = __builtin_vsx_xvcvdpsp(__a);
3608   return vec_sld(__ret, __ret, 12);
3609 #endif
3610 }
3611 #endif
3612
3613 /* vec_double */
3614
3615 #ifdef __VSX__
3616 static __inline__ vector double __ATTRS_o_ai
3617 vec_double(vector signed long long __a) {
3618   return __builtin_convertvector(__a, vector double);
3619 }
3620
3621 static __inline__ vector double __ATTRS_o_ai
3622 vec_double(vector unsigned long long __a) {
3623   return __builtin_convertvector(__a, vector double);
3624 }
3625
3626 static __inline__ vector double __ATTRS_o_ai
3627 vec_doublee(vector signed int __a) {
3628 #ifdef __LITTLE_ENDIAN__
3629   return __builtin_vsx_xvcvsxwdp(vec_sld(__a, __a, 4));
3630 #else
3631   return __builtin_vsx_xvcvsxwdp(__a);
3632 #endif
3633 }
3634
3635 static __inline__ vector double __ATTRS_o_ai
3636 vec_doublee(vector unsigned int __a) {
3637 #ifdef __LITTLE_ENDIAN__
3638   return __builtin_vsx_xvcvuxwdp(vec_sld(__a, __a, 4));
3639 #else
3640   return __builtin_vsx_xvcvuxwdp(__a);
3641 #endif
3642 }
3643
3644 static __inline__ vector double __ATTRS_o_ai
3645 vec_doublee(vector float __a) {
3646 #ifdef __LITTLE_ENDIAN__
3647   return __builtin_vsx_xvcvspdp(vec_sld(__a, __a, 4));
3648 #else
3649   return __builtin_vsx_xvcvspdp(__a);
3650 #endif
3651 }
3652
3653 static __inline__ vector double __ATTRS_o_ai
3654 vec_doubleh(vector signed int __a) {
3655   vector double __ret = {__a[0], __a[1]};
3656   return __ret;
3657 }
3658
3659 static __inline__ vector double __ATTRS_o_ai
3660 vec_doubleh(vector unsigned int __a) {
3661   vector double __ret = {__a[0], __a[1]};
3662   return __ret;
3663 }
3664
3665 static __inline__ vector double __ATTRS_o_ai
3666 vec_doubleh(vector float __a) {
3667   vector double __ret = {__a[0], __a[1]};
3668   return __ret;
3669 }
3670
3671 static __inline__ vector double __ATTRS_o_ai
3672 vec_doublel(vector signed int __a) {
3673   vector double __ret = {__a[2], __a[3]};
3674   return __ret;
3675 }
3676
3677 static __inline__ vector double __ATTRS_o_ai
3678 vec_doublel(vector unsigned int __a) {
3679   vector double __ret = {__a[2], __a[3]};
3680   return __ret;
3681 }
3682
3683 static __inline__ vector double __ATTRS_o_ai
3684 vec_doublel(vector float __a) {
3685   vector double __ret = {__a[2], __a[3]};
3686   return __ret;
3687 }
3688
3689 static __inline__ vector double __ATTRS_o_ai
3690 vec_doubleo(vector signed int __a) {
3691 #ifdef __LITTLE_ENDIAN__
3692   return __builtin_vsx_xvcvsxwdp(__a);
3693 #else
3694   return __builtin_vsx_xvcvsxwdp(vec_sld(__a, __a, 4));
3695 #endif
3696 }
3697
3698 static __inline__ vector double __ATTRS_o_ai
3699 vec_doubleo(vector unsigned int __a) {
3700 #ifdef __LITTLE_ENDIAN__
3701   return __builtin_vsx_xvcvuxwdp(__a);
3702 #else
3703   return __builtin_vsx_xvcvuxwdp(vec_sld(__a, __a, 4));
3704 #endif
3705 }
3706
3707 static __inline__ vector double __ATTRS_o_ai
3708 vec_doubleo(vector float __a) {
3709 #ifdef __LITTLE_ENDIAN__
3710   return __builtin_vsx_xvcvspdp(__a);
3711 #else
3712   return __builtin_vsx_xvcvspdp(vec_sld(__a, __a, 4));
3713 #endif
3714 }
3715
3716 /* vec_cvf */
3717 static __inline__ vector double __ATTRS_o_ai vec_cvf(vector float __a) {
3718   return vec_doublee(__a);
3719 }
3720
3721 static __inline__ vector float __ATTRS_o_ai vec_cvf(vector double __a) {
3722   return vec_floate(__a);
3723 }
3724 #endif
3725
3726 /* vec_div */
3727
3728 /* Integer vector divides (vectors are scalarized, elements divided
3729    and the vectors reassembled).
3730 */
3731 static __inline__ vector signed char __ATTRS_o_ai
3732 vec_div(vector signed char __a, vector signed char __b) {
3733   return __a / __b;
3734 }
3735
3736 static __inline__ vector unsigned char __ATTRS_o_ai
3737 vec_div(vector unsigned char __a, vector unsigned char __b) {
3738   return __a / __b;
3739 }
3740
3741 static __inline__ vector signed short __ATTRS_o_ai
3742 vec_div(vector signed short __a, vector signed short __b) {
3743   return __a / __b;
3744 }
3745
3746 static __inline__ vector unsigned short __ATTRS_o_ai
3747 vec_div(vector unsigned short __a, vector unsigned short __b) {
3748   return __a / __b;
3749 }
3750
3751 static __inline__ vector signed int __ATTRS_o_ai
3752 vec_div(vector signed int __a, vector signed int __b) {
3753   return __a / __b;
3754 }
3755
3756 static __inline__ vector unsigned int __ATTRS_o_ai
3757 vec_div(vector unsigned int __a, vector unsigned int __b) {
3758   return __a / __b;
3759 }
3760
3761 #ifdef __VSX__
3762 static __inline__ vector signed long long __ATTRS_o_ai
3763 vec_div(vector signed long long __a, vector signed long long __b) {
3764   return __a / __b;
3765 }
3766
3767 static __inline__ vector unsigned long long __ATTRS_o_ai
3768 vec_div(vector unsigned long long __a, vector unsigned long long __b) {
3769   return __a / __b;
3770 }
3771
3772 static __inline__ vector float __ATTRS_o_ai vec_div(vector float __a,
3773                                                     vector float __b) {
3774   return __a / __b;
3775 }
3776
3777 static __inline__ vector double __ATTRS_o_ai vec_div(vector double __a,
3778                                                      vector double __b) {
3779   return __a / __b;
3780 }
3781 #endif
3782
3783 /* vec_dive */
3784
3785 #ifdef __POWER10_VECTOR__
3786 static __inline__ vector signed int __ATTRS_o_ai
3787 vec_dive(vector signed int __a, vector signed int __b) {
3788   return __builtin_altivec_vdivesw(__a, __b);
3789 }
3790
3791 static __inline__ vector unsigned int __ATTRS_o_ai
3792 vec_dive(vector unsigned int __a, vector unsigned int __b) {
3793   return __builtin_altivec_vdiveuw(__a, __b);
3794 }
3795
3796 static __inline__ vector signed long long __ATTRS_o_ai
3797 vec_dive(vector signed long long __a, vector signed long long __b) {
3798   return __builtin_altivec_vdivesd(__a, __b);
3799 }
3800
3801 static __inline__ vector unsigned long long __ATTRS_o_ai
3802 vec_dive(vector unsigned long long __a, vector unsigned long long __b) {
3803   return __builtin_altivec_vdiveud(__a, __b);
3804 }
3805
3806 #ifdef __SIZEOF_INT128__
3807 static __inline__ vector unsigned __int128 __ATTRS_o_ai
3808 vec_dive(vector unsigned __int128 __a, vector unsigned __int128 __b) {
3809   return __builtin_altivec_vdiveuq(__a, __b);
3810 }
3811
3812 static __inline__ vector signed __int128 __ATTRS_o_ai
3813 vec_dive(vector signed __int128 __a, vector signed __int128 __b) {
3814   return __builtin_altivec_vdivesq(__a, __b);
3815 }
3816 #endif
3817 #endif
3818
3819 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
3820 static __inline__ vector unsigned __int128 __ATTRS_o_ai
3821 vec_div(vector unsigned __int128 __a, vector unsigned __int128 __b) {
3822   return __a / __b;
3823 }
3824
3825 static __inline__ vector signed __int128 __ATTRS_o_ai
3826 vec_div(vector signed __int128 __a, vector signed __int128 __b) {
3827   return __a / __b;
3828 }
3829 #endif /* __POWER10_VECTOR__ */
3830
3831 /* vec_xvtdiv */
3832
3833 #ifdef __VSX__
3834 static __inline__ int __ATTRS_o_ai vec_test_swdiv(vector double __a,
3835                                                   vector double __b) {
3836   return __builtin_vsx_xvtdivdp(__a, __b);
3837 }
3838
3839 static __inline__ int __ATTRS_o_ai vec_test_swdivs(vector float __a,
3840                                                    vector float __b) {
3841   return __builtin_vsx_xvtdivsp(__a, __b);
3842 }
3843 #endif
3844
3845 /* vec_dss */
3846
3847 #define vec_dss __builtin_altivec_dss
3848
3849 /* vec_dssall */
3850
3851 static __inline__ void __attribute__((__always_inline__)) vec_dssall(void) {
3852   __builtin_altivec_dssall();
3853 }
3854
3855 /* vec_dst */
3856 #define vec_dst(__PTR, __CW, __STR) \
3857   __builtin_altivec_dst((const void *)(__PTR), (__CW), (__STR))
3858
3859 /* vec_dstst */
3860 #define vec_dstst(__PTR, __CW, __STR) \
3861   __builtin_altivec_dstst((const void *)(__PTR), (__CW), (__STR))
3862
3863 /* vec_dststt */
3864 #define vec_dststt(__PTR, __CW, __STR) \
3865   __builtin_altivec_dststt((const void *)(__PTR), (__CW), (__STR))
3866
3867 /* vec_dstt */
3868 #define vec_dstt(__PTR, __CW, __STR) \
3869   __builtin_altivec_dstt((const void *)(__PTR), (__CW), (__STR))
3870
3871 /* vec_eqv */
3872
3873 #ifdef __POWER8_VECTOR__
3874 static __inline__ vector signed char __ATTRS_o_ai
3875 vec_eqv(vector signed char __a, vector signed char __b) {
3876   return (vector signed char)__builtin_vsx_xxleqv((vector unsigned int)__a,
3877                                                   (vector unsigned int)__b);
3878 }
3879
3880 static __inline__ vector unsigned char __ATTRS_o_ai
3881 vec_eqv(vector unsigned char __a, vector unsigned char __b) {
3882   return (vector unsigned char)__builtin_vsx_xxleqv((vector unsigned int)__a,
3883                                                     (vector unsigned int)__b);
3884 }
3885
3886 static __inline__ vector bool char __ATTRS_o_ai vec_eqv(vector bool char __a,
3887                                                         vector bool char __b) {
3888   return (vector bool char)__builtin_vsx_xxleqv((vector unsigned int)__a,
3889                                                 (vector unsigned int)__b);
3890 }
3891
3892 static __inline__ vector signed short __ATTRS_o_ai
3893 vec_eqv(vector signed short __a, vector signed short __b) {
3894   return (vector signed short)__builtin_vsx_xxleqv((vector unsigned int)__a,
3895                                                    (vector unsigned int)__b);
3896 }
3897
3898 static __inline__ vector unsigned short __ATTRS_o_ai
3899 vec_eqv(vector unsigned short __a, vector unsigned short __b) {
3900   return (vector unsigned short)__builtin_vsx_xxleqv((vector unsigned int)__a,
3901                                                      (vector unsigned int)__b);
3902 }
3903
3904 static __inline__ vector bool short __ATTRS_o_ai
3905 vec_eqv(vector bool short __a, vector bool short __b) {
3906   return (vector bool short)__builtin_vsx_xxleqv((vector unsigned int)__a,
3907                                                  (vector unsigned int)__b);
3908 }
3909
3910 static __inline__ vector signed int __ATTRS_o_ai
3911 vec_eqv(vector signed int __a, vector signed int __b) {
3912   return (vector signed int)__builtin_vsx_xxleqv((vector unsigned int)__a,
3913                                                  (vector unsigned int)__b);
3914 }
3915
3916 static __inline__ vector unsigned int __ATTRS_o_ai
3917 vec_eqv(vector unsigned int __a, vector unsigned int __b) {
3918   return __builtin_vsx_xxleqv(__a, __b);
3919 }
3920
3921 static __inline__ vector bool int __ATTRS_o_ai vec_eqv(vector bool int __a,
3922                                                        vector bool int __b) {
3923   return (vector bool int)__builtin_vsx_xxleqv((vector unsigned int)__a,
3924                                                (vector unsigned int)__b);
3925 }
3926
3927 static __inline__ vector signed long long __ATTRS_o_ai
3928 vec_eqv(vector signed long long __a, vector signed long long __b) {
3929   return (vector signed long long)__builtin_vsx_xxleqv(
3930       (vector unsigned int)__a, (vector unsigned int)__b);
3931 }
3932
3933 static __inline__ vector unsigned long long __ATTRS_o_ai
3934 vec_eqv(vector unsigned long long __a, vector unsigned long long __b) {
3935   return (vector unsigned long long)__builtin_vsx_xxleqv(
3936       (vector unsigned int)__a, (vector unsigned int)__b);
3937 }
3938
3939 static __inline__ vector bool long long __ATTRS_o_ai
3940 vec_eqv(vector bool long long __a, vector bool long long __b) {
3941   return (vector bool long long)__builtin_vsx_xxleqv((vector unsigned int)__a,
3942                                                      (vector unsigned int)__b);
3943 }
3944
3945 static __inline__ vector float __ATTRS_o_ai vec_eqv(vector float __a,
3946                                                     vector float __b) {
3947   return (vector float)__builtin_vsx_xxleqv((vector unsigned int)__a,
3948                                             (vector unsigned int)__b);
3949 }
3950
3951 static __inline__ vector double __ATTRS_o_ai vec_eqv(vector double __a,
3952                                                      vector double __b) {
3953   return (vector double)__builtin_vsx_xxleqv((vector unsigned int)__a,
3954                                              (vector unsigned int)__b);
3955 }
3956 #endif
3957
3958 /* vec_expte */
3959
3960 static __inline__ vector float __attribute__((__always_inline__))
3961 vec_expte(vector float __a) {
3962   return __builtin_altivec_vexptefp(__a);
3963 }
3964
3965 /* vec_vexptefp */
3966
3967 static __inline__ vector float __attribute__((__always_inline__))
3968 vec_vexptefp(vector float __a) {
3969   return __builtin_altivec_vexptefp(__a);
3970 }
3971
3972 /* vec_floor */
3973
3974 static __inline__ vector float __ATTRS_o_ai vec_floor(vector float __a) {
3975 #ifdef __VSX__
3976   return __builtin_vsx_xvrspim(__a);
3977 #else
3978   return __builtin_altivec_vrfim(__a);
3979 #endif
3980 }
3981
3982 #ifdef __VSX__
3983 static __inline__ vector double __ATTRS_o_ai vec_floor(vector double __a) {
3984   return __builtin_vsx_xvrdpim(__a);
3985 }
3986 #endif
3987
3988 /* vec_roundm */
3989 static __inline__ vector float __ATTRS_o_ai vec_roundm(vector float __a) {
3990   return vec_floor(__a);
3991 }
3992
3993 #ifdef __VSX__
3994 static __inline__ vector double __ATTRS_o_ai vec_roundm(vector double __a) {
3995   return vec_floor(__a);
3996 }
3997 #endif
3998
3999 /* vec_vrfim */
4000
4001 static __inline__ vector float __attribute__((__always_inline__))
4002 vec_vrfim(vector float __a) {
4003   return __builtin_altivec_vrfim(__a);
4004 }
4005
4006 /* vec_ld */
4007
4008 static __inline__ vector signed char __ATTRS_o_ai
4009 vec_ld(long __a, const vector signed char *__b) {
4010   return (vector signed char)__builtin_altivec_lvx(__a, __b);
4011 }
4012
4013 static __inline__ vector signed char __ATTRS_o_ai
4014 vec_ld(long __a, const signed char *__b) {
4015   return (vector signed char)__builtin_altivec_lvx(__a, __b);
4016 }
4017
4018 static __inline__ vector unsigned char __ATTRS_o_ai
4019 vec_ld(long __a, const vector unsigned char *__b) {
4020   return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
4021 }
4022
4023 static __inline__ vector unsigned char __ATTRS_o_ai
4024 vec_ld(long __a, const unsigned char *__b) {
4025   return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
4026 }
4027
4028 static __inline__ vector bool char __ATTRS_o_ai
4029 vec_ld(long __a, const vector bool char *__b) {
4030   return (vector bool char)__builtin_altivec_lvx(__a, __b);
4031 }
4032
4033 static __inline__ vector short __ATTRS_o_ai vec_ld(long __a,
4034                                                    const vector short *__b) {
4035   return (vector short)__builtin_altivec_lvx(__a, __b);
4036 }
4037
4038 static __inline__ vector short __ATTRS_o_ai vec_ld(long __a, const short *__b) {
4039   return (vector short)__builtin_altivec_lvx(__a, __b);
4040 }
4041
4042 static __inline__ vector unsigned short __ATTRS_o_ai
4043 vec_ld(long __a, const vector unsigned short *__b) {
4044   return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
4045 }
4046
4047 static __inline__ vector unsigned short __ATTRS_o_ai
4048 vec_ld(long __a, const unsigned short *__b) {
4049   return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
4050 }
4051
4052 static __inline__ vector bool short __ATTRS_o_ai
4053 vec_ld(long __a, const vector bool short *__b) {
4054   return (vector bool short)__builtin_altivec_lvx(__a, __b);
4055 }
4056
4057 static __inline__ vector pixel __ATTRS_o_ai vec_ld(long __a,
4058                                                    const vector pixel *__b) {
4059   return (vector pixel)__builtin_altivec_lvx(__a, __b);
4060 }
4061
4062 static __inline__ vector int __ATTRS_o_ai vec_ld(long __a,
4063                                                  const vector int *__b) {
4064   return (vector int)__builtin_altivec_lvx(__a, __b);
4065 }
4066
4067 static __inline__ vector int __ATTRS_o_ai vec_ld(long __a, const int *__b) {
4068   return (vector int)__builtin_altivec_lvx(__a, __b);
4069 }
4070
4071 static __inline__ vector unsigned int __ATTRS_o_ai
4072 vec_ld(long __a, const vector unsigned int *__b) {
4073   return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
4074 }
4075
4076 static __inline__ vector unsigned int __ATTRS_o_ai
4077 vec_ld(long __a, const unsigned int *__b) {
4078   return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
4079 }
4080
4081 static __inline__ vector bool int __ATTRS_o_ai
4082 vec_ld(long __a, const vector bool int *__b) {
4083   return (vector bool int)__builtin_altivec_lvx(__a, __b);
4084 }
4085
4086 static __inline__ vector float __ATTRS_o_ai vec_ld(long __a,
4087                                                    const vector float *__b) {
4088   return (vector float)__builtin_altivec_lvx(__a, __b);
4089 }
4090
4091 static __inline__ vector float __ATTRS_o_ai vec_ld(long __a, const float *__b) {
4092   return (vector float)__builtin_altivec_lvx(__a, __b);
4093 }
4094
4095 /* vec_lvx */
4096
4097 static __inline__ vector signed char __ATTRS_o_ai
4098 vec_lvx(long __a, const vector signed char *__b) {
4099   return (vector signed char)__builtin_altivec_lvx(__a, __b);
4100 }
4101
4102 static __inline__ vector signed char __ATTRS_o_ai
4103 vec_lvx(long __a, const signed char *__b) {
4104   return (vector signed char)__builtin_altivec_lvx(__a, __b);
4105 }
4106
4107 static __inline__ vector unsigned char __ATTRS_o_ai
4108 vec_lvx(long __a, const vector unsigned char *__b) {
4109   return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
4110 }
4111
4112 static __inline__ vector unsigned char __ATTRS_o_ai
4113 vec_lvx(long __a, const unsigned char *__b) {
4114   return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
4115 }
4116
4117 static __inline__ vector bool char __ATTRS_o_ai
4118 vec_lvx(long __a, const vector bool char *__b) {
4119   return (vector bool char)__builtin_altivec_lvx(__a, __b);
4120 }
4121
4122 static __inline__ vector short __ATTRS_o_ai vec_lvx(long __a,
4123                                                     const vector short *__b) {
4124   return (vector short)__builtin_altivec_lvx(__a, __b);
4125 }
4126
4127 static __inline__ vector short __ATTRS_o_ai vec_lvx(long __a, const short *__b) {
4128   return (vector short)__builtin_altivec_lvx(__a, __b);
4129 }
4130
4131 static __inline__ vector unsigned short __ATTRS_o_ai
4132 vec_lvx(long __a, const vector unsigned short *__b) {
4133   return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
4134 }
4135
4136 static __inline__ vector unsigned short __ATTRS_o_ai
4137 vec_lvx(long __a, const unsigned short *__b) {
4138   return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
4139 }
4140
4141 static __inline__ vector bool short __ATTRS_o_ai
4142 vec_lvx(long __a, const vector bool short *__b) {
4143   return (vector bool short)__builtin_altivec_lvx(__a, __b);
4144 }
4145
4146 static __inline__ vector pixel __ATTRS_o_ai vec_lvx(long __a,
4147                                                     const vector pixel *__b) {
4148   return (vector pixel)__builtin_altivec_lvx(__a, __b);
4149 }
4150
4151 static __inline__ vector int __ATTRS_o_ai vec_lvx(long __a,
4152                                                   const vector int *__b) {
4153   return (vector int)__builtin_altivec_lvx(__a, __b);
4154 }
4155
4156 static __inline__ vector int __ATTRS_o_ai vec_lvx(long __a, const int *__b) {
4157   return (vector int)__builtin_altivec_lvx(__a, __b);
4158 }
4159
4160 static __inline__ vector unsigned int __ATTRS_o_ai
4161 vec_lvx(long __a, const vector unsigned int *__b) {
4162   return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
4163 }
4164
4165 static __inline__ vector unsigned int __ATTRS_o_ai
4166 vec_lvx(long __a, const unsigned int *__b) {
4167   return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
4168 }
4169
4170 static __inline__ vector bool int __ATTRS_o_ai
4171 vec_lvx(long __a, const vector bool int *__b) {
4172   return (vector bool int)__builtin_altivec_lvx(__a, __b);
4173 }
4174
4175 static __inline__ vector float __ATTRS_o_ai vec_lvx(long __a,
4176                                                     const vector float *__b) {
4177   return (vector float)__builtin_altivec_lvx(__a, __b);
4178 }
4179
4180 static __inline__ vector float __ATTRS_o_ai vec_lvx(long __a, const float *__b) {
4181   return (vector float)__builtin_altivec_lvx(__a, __b);
4182 }
4183
4184 /* vec_lde */
4185
4186 static __inline__ vector signed char __ATTRS_o_ai
4187 vec_lde(long __a, const signed char *__b) {
4188   return (vector signed char)__builtin_altivec_lvebx(__a, __b);
4189 }
4190
4191 static __inline__ vector unsigned char __ATTRS_o_ai
4192 vec_lde(long __a, const unsigned char *__b) {
4193   return (vector unsigned char)__builtin_altivec_lvebx(__a, __b);
4194 }
4195
4196 static __inline__ vector short __ATTRS_o_ai vec_lde(long __a, const short *__b) {
4197   return (vector short)__builtin_altivec_lvehx(__a, __b);
4198 }
4199
4200 static __inline__ vector unsigned short __ATTRS_o_ai
4201 vec_lde(long __a, const unsigned short *__b) {
4202   return (vector unsigned short)__builtin_altivec_lvehx(__a, __b);
4203 }
4204
4205 static __inline__ vector int __ATTRS_o_ai vec_lde(long __a, const int *__b) {
4206   return (vector int)__builtin_altivec_lvewx(__a, __b);
4207 }
4208
4209 static __inline__ vector unsigned int __ATTRS_o_ai
4210 vec_lde(long __a, const unsigned int *__b) {
4211   return (vector unsigned int)__builtin_altivec_lvewx(__a, __b);
4212 }
4213
4214 static __inline__ vector float __ATTRS_o_ai vec_lde(long __a, const float *__b) {
4215   return (vector float)__builtin_altivec_lvewx(__a, __b);
4216 }
4217
4218 /* vec_lvebx */
4219
4220 static __inline__ vector signed char __ATTRS_o_ai
4221 vec_lvebx(long __a, const signed char *__b) {
4222   return (vector signed char)__builtin_altivec_lvebx(__a, __b);
4223 }
4224
4225 static __inline__ vector unsigned char __ATTRS_o_ai
4226 vec_lvebx(long __a, const unsigned char *__b) {
4227   return (vector unsigned char)__builtin_altivec_lvebx(__a, __b);
4228 }
4229
4230 /* vec_lvehx */
4231
4232 static __inline__ vector short __ATTRS_o_ai vec_lvehx(long __a,
4233                                                       const short *__b) {
4234   return (vector short)__builtin_altivec_lvehx(__a, __b);
4235 }
4236
4237 static __inline__ vector unsigned short __ATTRS_o_ai
4238 vec_lvehx(long __a, const unsigned short *__b) {
4239   return (vector unsigned short)__builtin_altivec_lvehx(__a, __b);
4240 }
4241
4242 /* vec_lvewx */
4243
4244 static __inline__ vector int __ATTRS_o_ai vec_lvewx(long __a, const int *__b) {
4245   return (vector int)__builtin_altivec_lvewx(__a, __b);
4246 }
4247
4248 static __inline__ vector unsigned int __ATTRS_o_ai
4249 vec_lvewx(long __a, const unsigned int *__b) {
4250   return (vector unsigned int)__builtin_altivec_lvewx(__a, __b);
4251 }
4252
4253 static __inline__ vector float __ATTRS_o_ai vec_lvewx(long __a,
4254                                                       const float *__b) {
4255   return (vector float)__builtin_altivec_lvewx(__a, __b);
4256 }
4257
4258 /* vec_ldl */
4259
4260 static __inline__ vector signed char __ATTRS_o_ai
4261 vec_ldl(long __a, const vector signed char *__b) {
4262   return (vector signed char)__builtin_altivec_lvxl(__a, __b);
4263 }
4264
4265 static __inline__ vector signed char __ATTRS_o_ai
4266 vec_ldl(long __a, const signed char *__b) {
4267   return (vector signed char)__builtin_altivec_lvxl(__a, __b);
4268 }
4269
4270 static __inline__ vector unsigned char __ATTRS_o_ai
4271 vec_ldl(long __a, const vector unsigned char *__b) {
4272   return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
4273 }
4274
4275 static __inline__ vector unsigned char __ATTRS_o_ai
4276 vec_ldl(long __a, const unsigned char *__b) {
4277   return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
4278 }
4279
4280 static __inline__ vector bool char __ATTRS_o_ai
4281 vec_ldl(long __a, const vector bool char *__b) {
4282   return (vector bool char)__builtin_altivec_lvxl(__a, __b);
4283 }
4284
4285 static __inline__ vector short __ATTRS_o_ai vec_ldl(long __a,
4286                                                     const vector short *__b) {
4287   return (vector short)__builtin_altivec_lvxl(__a, __b);
4288 }
4289
4290 static __inline__ vector short __ATTRS_o_ai vec_ldl(long __a, const short *__b) {
4291   return (vector short)__builtin_altivec_lvxl(__a, __b);
4292 }
4293
4294 static __inline__ vector unsigned short __ATTRS_o_ai
4295 vec_ldl(long __a, const vector unsigned short *__b) {
4296   return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
4297 }
4298
4299 static __inline__ vector unsigned short __ATTRS_o_ai
4300 vec_ldl(long __a, const unsigned short *__b) {
4301   return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
4302 }
4303
4304 static __inline__ vector bool short __ATTRS_o_ai
4305 vec_ldl(long __a, const vector bool short *__b) {
4306   return (vector bool short)__builtin_altivec_lvxl(__a, __b);
4307 }
4308
4309 static __inline__ vector pixel __ATTRS_o_ai vec_ldl(long __a,
4310                                                     const vector pixel *__b) {
4311   return (vector pixel short)__builtin_altivec_lvxl(__a, __b);
4312 }
4313
4314 static __inline__ vector int __ATTRS_o_ai vec_ldl(long __a,
4315                                                   const vector int *__b) {
4316   return (vector int)__builtin_altivec_lvxl(__a, __b);
4317 }
4318
4319 static __inline__ vector int __ATTRS_o_ai vec_ldl(long __a, const int *__b) {
4320   return (vector int)__builtin_altivec_lvxl(__a, __b);
4321 }
4322
4323 static __inline__ vector unsigned int __ATTRS_o_ai
4324 vec_ldl(long __a, const vector unsigned int *__b) {
4325   return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
4326 }
4327
4328 static __inline__ vector unsigned int __ATTRS_o_ai
4329 vec_ldl(long __a, const unsigned int *__b) {
4330   return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
4331 }
4332
4333 static __inline__ vector bool int __ATTRS_o_ai
4334 vec_ldl(long __a, const vector bool int *__b) {
4335   return (vector bool int)__builtin_altivec_lvxl(__a, __b);
4336 }
4337
4338 static __inline__ vector float __ATTRS_o_ai vec_ldl(long __a,
4339                                                     const vector float *__b) {
4340   return (vector float)__builtin_altivec_lvxl(__a, __b);
4341 }
4342
4343 static __inline__ vector float __ATTRS_o_ai vec_ldl(long __a, const float *__b) {
4344   return (vector float)__builtin_altivec_lvxl(__a, __b);
4345 }
4346
4347 /* vec_lvxl */
4348
4349 static __inline__ vector signed char __ATTRS_o_ai
4350 vec_lvxl(long __a, const vector signed char *__b) {
4351   return (vector signed char)__builtin_altivec_lvxl(__a, __b);
4352 }
4353
4354 static __inline__ vector signed char __ATTRS_o_ai
4355 vec_lvxl(long __a, const signed char *__b) {
4356   return (vector signed char)__builtin_altivec_lvxl(__a, __b);
4357 }
4358
4359 static __inline__ vector unsigned char __ATTRS_o_ai
4360 vec_lvxl(long __a, const vector unsigned char *__b) {
4361   return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
4362 }
4363
4364 static __inline__ vector unsigned char __ATTRS_o_ai
4365 vec_lvxl(long __a, const unsigned char *__b) {
4366   return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
4367 }
4368
4369 static __inline__ vector bool char __ATTRS_o_ai
4370 vec_lvxl(long __a, const vector bool char *__b) {
4371   return (vector bool char)__builtin_altivec_lvxl(__a, __b);
4372 }
4373
4374 static __inline__ vector short __ATTRS_o_ai vec_lvxl(long __a,
4375                                                      const vector short *__b) {
4376   return (vector short)__builtin_altivec_lvxl(__a, __b);
4377 }
4378
4379 static __inline__ vector short __ATTRS_o_ai vec_lvxl(long __a,
4380                                                      const short *__b) {
4381   return (vector short)__builtin_altivec_lvxl(__a, __b);
4382 }
4383
4384 static __inline__ vector unsigned short __ATTRS_o_ai
4385 vec_lvxl(long __a, const vector unsigned short *__b) {
4386   return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
4387 }
4388
4389 static __inline__ vector unsigned short __ATTRS_o_ai
4390 vec_lvxl(long __a, const unsigned short *__b) {
4391   return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
4392 }
4393
4394 static __inline__ vector bool short __ATTRS_o_ai
4395 vec_lvxl(long __a, const vector bool short *__b) {
4396   return (vector bool short)__builtin_altivec_lvxl(__a, __b);
4397 }
4398
4399 static __inline__ vector pixel __ATTRS_o_ai vec_lvxl(long __a,
4400                                                      const vector pixel *__b) {
4401   return (vector pixel)__builtin_altivec_lvxl(__a, __b);
4402 }
4403
4404 static __inline__ vector int __ATTRS_o_ai vec_lvxl(long __a,
4405                                                    const vector int *__b) {
4406   return (vector int)__builtin_altivec_lvxl(__a, __b);
4407 }
4408
4409 static __inline__ vector int __ATTRS_o_ai vec_lvxl(long __a, const int *__b) {
4410   return (vector int)__builtin_altivec_lvxl(__a, __b);
4411 }
4412
4413 static __inline__ vector unsigned int __ATTRS_o_ai
4414 vec_lvxl(long __a, const vector unsigned int *__b) {
4415   return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
4416 }
4417
4418 static __inline__ vector unsigned int __ATTRS_o_ai
4419 vec_lvxl(long __a, const unsigned int *__b) {
4420   return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
4421 }
4422
4423 static __inline__ vector bool int __ATTRS_o_ai
4424 vec_lvxl(long __a, const vector bool int *__b) {
4425   return (vector bool int)__builtin_altivec_lvxl(__a, __b);
4426 }
4427
4428 static __inline__ vector float __ATTRS_o_ai vec_lvxl(long __a,
4429                                                      const vector float *__b) {
4430   return (vector float)__builtin_altivec_lvxl(__a, __b);
4431 }
4432
4433 static __inline__ vector float __ATTRS_o_ai vec_lvxl(long __a,
4434                                                      const float *__b) {
4435   return (vector float)__builtin_altivec_lvxl(__a, __b);
4436 }
4437
4438 /* vec_loge */
4439
4440 static __inline__ vector float __attribute__((__always_inline__))
4441 vec_loge(vector float __a) {
4442   return __builtin_altivec_vlogefp(__a);
4443 }
4444
4445 /* vec_vlogefp */
4446
4447 static __inline__ vector float __attribute__((__always_inline__))
4448 vec_vlogefp(vector float __a) {
4449   return __builtin_altivec_vlogefp(__a);
4450 }
4451
4452 /* vec_lvsl */
4453
4454 #ifdef __LITTLE_ENDIAN__
4455 static __inline__ vector unsigned char __ATTRS_o_ai
4456     __attribute__((__deprecated__("use assignment for unaligned little endian \
4457 loads/stores"))) vec_lvsl(int __a, const signed char *__b) {
4458   vector unsigned char mask =
4459       (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4460   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4461                                   7,  6,  5,  4,  3,  2,  1, 0};
4462   return vec_perm(mask, mask, reverse);
4463 }
4464 #else
4465 static __inline__ vector unsigned char __ATTRS_o_ai
4466 vec_lvsl(int __a, const signed char *__b) {
4467   return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4468 }
4469 #endif
4470
4471 #ifdef __LITTLE_ENDIAN__
4472 static __inline__ vector unsigned char __ATTRS_o_ai
4473     __attribute__((__deprecated__("use assignment for unaligned little endian \
4474 loads/stores"))) vec_lvsl(int __a, const unsigned char *__b) {
4475   vector unsigned char mask =
4476       (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4477   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4478                                   7,  6,  5,  4,  3,  2,  1, 0};
4479   return vec_perm(mask, mask, reverse);
4480 }
4481 #else
4482 static __inline__ vector unsigned char __ATTRS_o_ai
4483 vec_lvsl(int __a, const unsigned char *__b) {
4484   return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4485 }
4486 #endif
4487
4488 #ifdef __LITTLE_ENDIAN__
4489 static __inline__ vector unsigned char __ATTRS_o_ai
4490     __attribute__((__deprecated__("use assignment for unaligned little endian \
4491 loads/stores"))) vec_lvsl(int __a, const short *__b) {
4492   vector unsigned char mask =
4493       (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4494   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4495                                   7,  6,  5,  4,  3,  2,  1, 0};
4496   return vec_perm(mask, mask, reverse);
4497 }
4498 #else
4499 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsl(int __a,
4500                                                              const short *__b) {
4501   return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4502 }
4503 #endif
4504
4505 #ifdef __LITTLE_ENDIAN__
4506 static __inline__ vector unsigned char __ATTRS_o_ai
4507     __attribute__((__deprecated__("use assignment for unaligned little endian \
4508 loads/stores"))) vec_lvsl(int __a, const unsigned short *__b) {
4509   vector unsigned char mask =
4510       (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4511   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4512                                   7,  6,  5,  4,  3,  2,  1, 0};
4513   return vec_perm(mask, mask, reverse);
4514 }
4515 #else
4516 static __inline__ vector unsigned char __ATTRS_o_ai
4517 vec_lvsl(int __a, const unsigned short *__b) {
4518   return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4519 }
4520 #endif
4521
4522 #ifdef __LITTLE_ENDIAN__
4523 static __inline__ vector unsigned char __ATTRS_o_ai
4524     __attribute__((__deprecated__("use assignment for unaligned little endian \
4525 loads/stores"))) vec_lvsl(int __a, const int *__b) {
4526   vector unsigned char mask =
4527       (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4528   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4529                                   7,  6,  5,  4,  3,  2,  1, 0};
4530   return vec_perm(mask, mask, reverse);
4531 }
4532 #else
4533 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsl(int __a,
4534                                                              const int *__b) {
4535   return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4536 }
4537 #endif
4538
4539 #ifdef __LITTLE_ENDIAN__
4540 static __inline__ vector unsigned char __ATTRS_o_ai
4541     __attribute__((__deprecated__("use assignment for unaligned little endian \
4542 loads/stores"))) vec_lvsl(int __a, const unsigned int *__b) {
4543   vector unsigned char mask =
4544       (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4545   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4546                                   7,  6,  5,  4,  3,  2,  1, 0};
4547   return vec_perm(mask, mask, reverse);
4548 }
4549 #else
4550 static __inline__ vector unsigned char __ATTRS_o_ai
4551 vec_lvsl(int __a, const unsigned int *__b) {
4552   return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4553 }
4554 #endif
4555
4556 #ifdef __LITTLE_ENDIAN__
4557 static __inline__ vector unsigned char __ATTRS_o_ai
4558     __attribute__((__deprecated__("use assignment for unaligned little endian \
4559 loads/stores"))) vec_lvsl(int __a, const float *__b) {
4560   vector unsigned char mask =
4561       (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4562   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4563                                   7,  6,  5,  4,  3,  2,  1, 0};
4564   return vec_perm(mask, mask, reverse);
4565 }
4566 #else
4567 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsl(int __a,
4568                                                              const float *__b) {
4569   return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4570 }
4571 #endif
4572
4573 /* vec_lvsr */
4574
4575 #ifdef __LITTLE_ENDIAN__
4576 static __inline__ vector unsigned char __ATTRS_o_ai
4577     __attribute__((__deprecated__("use assignment for unaligned little endian \
4578 loads/stores"))) vec_lvsr(int __a, const signed char *__b) {
4579   vector unsigned char mask =
4580       (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4581   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4582                                   7,  6,  5,  4,  3,  2,  1, 0};
4583   return vec_perm(mask, mask, reverse);
4584 }
4585 #else
4586 static __inline__ vector unsigned char __ATTRS_o_ai
4587 vec_lvsr(int __a, const signed char *__b) {
4588   return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4589 }
4590 #endif
4591
4592 #ifdef __LITTLE_ENDIAN__
4593 static __inline__ vector unsigned char __ATTRS_o_ai
4594     __attribute__((__deprecated__("use assignment for unaligned little endian \
4595 loads/stores"))) vec_lvsr(int __a, const unsigned char *__b) {
4596   vector unsigned char mask =
4597       (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4598   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4599                                   7,  6,  5,  4,  3,  2,  1, 0};
4600   return vec_perm(mask, mask, reverse);
4601 }
4602 #else
4603 static __inline__ vector unsigned char __ATTRS_o_ai
4604 vec_lvsr(int __a, const unsigned char *__b) {
4605   return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4606 }
4607 #endif
4608
4609 #ifdef __LITTLE_ENDIAN__
4610 static __inline__ vector unsigned char __ATTRS_o_ai
4611     __attribute__((__deprecated__("use assignment for unaligned little endian \
4612 loads/stores"))) vec_lvsr(int __a, const short *__b) {
4613   vector unsigned char mask =
4614       (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4615   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4616                                   7,  6,  5,  4,  3,  2,  1, 0};
4617   return vec_perm(mask, mask, reverse);
4618 }
4619 #else
4620 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsr(int __a,
4621                                                              const short *__b) {
4622   return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4623 }
4624 #endif
4625
4626 #ifdef __LITTLE_ENDIAN__
4627 static __inline__ vector unsigned char __ATTRS_o_ai
4628     __attribute__((__deprecated__("use assignment for unaligned little endian \
4629 loads/stores"))) vec_lvsr(int __a, const unsigned short *__b) {
4630   vector unsigned char mask =
4631       (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4632   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4633                                   7,  6,  5,  4,  3,  2,  1, 0};
4634   return vec_perm(mask, mask, reverse);
4635 }
4636 #else
4637 static __inline__ vector unsigned char __ATTRS_o_ai
4638 vec_lvsr(int __a, const unsigned short *__b) {
4639   return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4640 }
4641 #endif
4642
4643 #ifdef __LITTLE_ENDIAN__
4644 static __inline__ vector unsigned char __ATTRS_o_ai
4645     __attribute__((__deprecated__("use assignment for unaligned little endian \
4646 loads/stores"))) vec_lvsr(int __a, const int *__b) {
4647   vector unsigned char mask =
4648       (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4649   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4650                                   7,  6,  5,  4,  3,  2,  1, 0};
4651   return vec_perm(mask, mask, reverse);
4652 }
4653 #else
4654 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsr(int __a,
4655                                                              const int *__b) {
4656   return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4657 }
4658 #endif
4659
4660 #ifdef __LITTLE_ENDIAN__
4661 static __inline__ vector unsigned char __ATTRS_o_ai
4662     __attribute__((__deprecated__("use assignment for unaligned little endian \
4663 loads/stores"))) vec_lvsr(int __a, const unsigned int *__b) {
4664   vector unsigned char mask =
4665       (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4666   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4667                                   7,  6,  5,  4,  3,  2,  1, 0};
4668   return vec_perm(mask, mask, reverse);
4669 }
4670 #else
4671 static __inline__ vector unsigned char __ATTRS_o_ai
4672 vec_lvsr(int __a, const unsigned int *__b) {
4673   return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4674 }
4675 #endif
4676
4677 #ifdef __LITTLE_ENDIAN__
4678 static __inline__ vector unsigned char __ATTRS_o_ai
4679     __attribute__((__deprecated__("use assignment for unaligned little endian \
4680 loads/stores"))) vec_lvsr(int __a, const float *__b) {
4681   vector unsigned char mask =
4682       (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4683   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4684                                   7,  6,  5,  4,  3,  2,  1, 0};
4685   return vec_perm(mask, mask, reverse);
4686 }
4687 #else
4688 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsr(int __a,
4689                                                              const float *__b) {
4690   return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4691 }
4692 #endif
4693
4694 /* vec_madd */
4695 static __inline__ vector signed short __ATTRS_o_ai
4696 vec_mladd(vector signed short, vector signed short, vector signed short);
4697 static __inline__ vector signed short __ATTRS_o_ai
4698 vec_mladd(vector signed short, vector unsigned short, vector unsigned short);
4699 static __inline__ vector signed short __ATTRS_o_ai
4700 vec_mladd(vector unsigned short, vector signed short, vector signed short);
4701 static __inline__ vector unsigned short __ATTRS_o_ai
4702 vec_mladd(vector unsigned short, vector unsigned short, vector unsigned short);
4703
4704 static __inline__ vector signed short __ATTRS_o_ai vec_madd(
4705     vector signed short __a, vector signed short __b, vector signed short __c) {
4706   return vec_mladd(__a, __b, __c);
4707 }
4708
4709 static __inline__ vector signed short __ATTRS_o_ai
4710 vec_madd(vector signed short __a, vector unsigned short __b,
4711          vector unsigned short __c) {
4712   return vec_mladd(__a, __b, __c);
4713 }
4714
4715 static __inline__ vector signed short __ATTRS_o_ai
4716 vec_madd(vector unsigned short __a, vector signed short __b,
4717          vector signed short __c) {
4718   return vec_mladd(__a, __b, __c);
4719 }
4720
4721 static __inline__ vector unsigned short __ATTRS_o_ai
4722 vec_madd(vector unsigned short __a, vector unsigned short __b,
4723          vector unsigned short __c) {
4724   return vec_mladd(__a, __b, __c);
4725 }
4726
4727 static __inline__ vector float __ATTRS_o_ai vec_madd(vector float __a,
4728                                                      vector float __b,
4729                                                      vector float __c) {
4730 #ifdef __VSX__
4731   return __builtin_vsx_xvmaddasp(__a, __b, __c);
4732 #else
4733   return __builtin_altivec_vmaddfp(__a, __b, __c);
4734 #endif
4735 }
4736
4737 #ifdef __VSX__
4738 static __inline__ vector double __ATTRS_o_ai vec_madd(vector double __a,
4739                                                       vector double __b,
4740                                                       vector double __c) {
4741   return __builtin_vsx_xvmaddadp(__a, __b, __c);
4742 }
4743 #endif
4744
4745 /* vec_vmaddfp */
4746
4747 static __inline__ vector float __attribute__((__always_inline__))
4748 vec_vmaddfp(vector float __a, vector float __b, vector float __c) {
4749   return __builtin_altivec_vmaddfp(__a, __b, __c);
4750 }
4751
4752 /* vec_madds */
4753
4754 static __inline__ vector signed short __attribute__((__always_inline__))
4755 vec_madds(vector signed short __a, vector signed short __b,
4756           vector signed short __c) {
4757   return __builtin_altivec_vmhaddshs(__a, __b, __c);
4758 }
4759
4760 /* vec_vmhaddshs */
4761 static __inline__ vector signed short __attribute__((__always_inline__))
4762 vec_vmhaddshs(vector signed short __a, vector signed short __b,
4763               vector signed short __c) {
4764   return __builtin_altivec_vmhaddshs(__a, __b, __c);
4765 }
4766
4767 /* vec_msub */
4768
4769 #ifdef __VSX__
4770 static __inline__ vector float __ATTRS_o_ai vec_msub(vector float __a,
4771                                                      vector float __b,
4772                                                      vector float __c) {
4773   return __builtin_vsx_xvmsubasp(__a, __b, __c);
4774 }
4775
4776 static __inline__ vector double __ATTRS_o_ai vec_msub(vector double __a,
4777                                                       vector double __b,
4778                                                       vector double __c) {
4779   return __builtin_vsx_xvmsubadp(__a, __b, __c);
4780 }
4781 #endif
4782
4783 /* vec_max */
4784
4785 static __inline__ vector signed char __ATTRS_o_ai
4786 vec_max(vector signed char __a, vector signed char __b) {
4787   return __builtin_altivec_vmaxsb(__a, __b);
4788 }
4789
4790 static __inline__ vector signed char __ATTRS_o_ai
4791 vec_max(vector bool char __a, vector signed char __b) {
4792   return __builtin_altivec_vmaxsb((vector signed char)__a, __b);
4793 }
4794
4795 static __inline__ vector signed char __ATTRS_o_ai
4796 vec_max(vector signed char __a, vector bool char __b) {
4797   return __builtin_altivec_vmaxsb(__a, (vector signed char)__b);
4798 }
4799
4800 static __inline__ vector unsigned char __ATTRS_o_ai
4801 vec_max(vector unsigned char __a, vector unsigned char __b) {
4802   return __builtin_altivec_vmaxub(__a, __b);
4803 }
4804
4805 static __inline__ vector unsigned char __ATTRS_o_ai
4806 vec_max(vector bool char __a, vector unsigned char __b) {
4807   return __builtin_altivec_vmaxub((vector unsigned char)__a, __b);
4808 }
4809
4810 static __inline__ vector unsigned char __ATTRS_o_ai
4811 vec_max(vector unsigned char __a, vector bool char __b) {
4812   return __builtin_altivec_vmaxub(__a, (vector unsigned char)__b);
4813 }
4814
4815 static __inline__ vector short __ATTRS_o_ai vec_max(vector short __a,
4816                                                     vector short __b) {
4817   return __builtin_altivec_vmaxsh(__a, __b);
4818 }
4819
4820 static __inline__ vector short __ATTRS_o_ai vec_max(vector bool short __a,
4821                                                     vector short __b) {
4822   return __builtin_altivec_vmaxsh((vector short)__a, __b);
4823 }
4824
4825 static __inline__ vector short __ATTRS_o_ai vec_max(vector short __a,
4826                                                     vector bool short __b) {
4827   return __builtin_altivec_vmaxsh(__a, (vector short)__b);
4828 }
4829
4830 static __inline__ vector unsigned short __ATTRS_o_ai
4831 vec_max(vector unsigned short __a, vector unsigned short __b) {
4832   return __builtin_altivec_vmaxuh(__a, __b);
4833 }
4834
4835 static __inline__ vector unsigned short __ATTRS_o_ai
4836 vec_max(vector bool short __a, vector unsigned short __b) {
4837   return __builtin_altivec_vmaxuh((vector unsigned short)__a, __b);
4838 }
4839
4840 static __inline__ vector unsigned short __ATTRS_o_ai
4841 vec_max(vector unsigned short __a, vector bool short __b) {
4842   return __builtin_altivec_vmaxuh(__a, (vector unsigned short)__b);
4843 }
4844
4845 static __inline__ vector int __ATTRS_o_ai vec_max(vector int __a,
4846                                                   vector int __b) {
4847   return __builtin_altivec_vmaxsw(__a, __b);
4848 }
4849
4850 static __inline__ vector int __ATTRS_o_ai vec_max(vector bool int __a,
4851                                                   vector int __b) {
4852   return __builtin_altivec_vmaxsw((vector int)__a, __b);
4853 }
4854
4855 static __inline__ vector int __ATTRS_o_ai vec_max(vector int __a,
4856                                                   vector bool int __b) {
4857   return __builtin_altivec_vmaxsw(__a, (vector int)__b);
4858 }
4859
4860 static __inline__ vector unsigned int __ATTRS_o_ai
4861 vec_max(vector unsigned int __a, vector unsigned int __b) {
4862   return __builtin_altivec_vmaxuw(__a, __b);
4863 }
4864
4865 static __inline__ vector unsigned int __ATTRS_o_ai
4866 vec_max(vector bool int __a, vector unsigned int __b) {
4867   return __builtin_altivec_vmaxuw((vector unsigned int)__a, __b);
4868 }
4869
4870 static __inline__ vector unsigned int __ATTRS_o_ai
4871 vec_max(vector unsigned int __a, vector bool int __b) {
4872   return __builtin_altivec_vmaxuw(__a, (vector unsigned int)__b);
4873 }
4874
4875 #ifdef __POWER8_VECTOR__
4876 static __inline__ vector signed long long __ATTRS_o_ai
4877 vec_max(vector signed long long __a, vector signed long long __b) {
4878   return __builtin_altivec_vmaxsd(__a, __b);
4879 }
4880
4881 static __inline__ vector signed long long __ATTRS_o_ai
4882 vec_max(vector bool long long __a, vector signed long long __b) {
4883   return __builtin_altivec_vmaxsd((vector signed long long)__a, __b);
4884 }
4885
4886 static __inline__ vector signed long long __ATTRS_o_ai
4887 vec_max(vector signed long long __a, vector bool long long __b) {
4888   return __builtin_altivec_vmaxsd(__a, (vector signed long long)__b);
4889 }
4890
4891 static __inline__ vector unsigned long long __ATTRS_o_ai
4892 vec_max(vector unsigned long long __a, vector unsigned long long __b) {
4893   return __builtin_altivec_vmaxud(__a, __b);
4894 }
4895
4896 static __inline__ vector unsigned long long __ATTRS_o_ai
4897 vec_max(vector bool long long __a, vector unsigned long long __b) {
4898   return __builtin_altivec_vmaxud((vector unsigned long long)__a, __b);
4899 }
4900
4901 static __inline__ vector unsigned long long __ATTRS_o_ai
4902 vec_max(vector unsigned long long __a, vector bool long long __b) {
4903   return __builtin_altivec_vmaxud(__a, (vector unsigned long long)__b);
4904 }
4905 #endif
4906
4907 static __inline__ vector float __ATTRS_o_ai vec_max(vector float __a,
4908                                                     vector float __b) {
4909 #ifdef __VSX__
4910   return __builtin_vsx_xvmaxsp(__a, __b);
4911 #else
4912   return __builtin_altivec_vmaxfp(__a, __b);
4913 #endif
4914 }
4915
4916 #ifdef __VSX__
4917 static __inline__ vector double __ATTRS_o_ai vec_max(vector double __a,
4918                                                      vector double __b) {
4919   return __builtin_vsx_xvmaxdp(__a, __b);
4920 }
4921 #endif
4922
4923 /* vec_vmaxsb */
4924
4925 static __inline__ vector signed char __ATTRS_o_ai
4926 vec_vmaxsb(vector signed char __a, vector signed char __b) {
4927   return __builtin_altivec_vmaxsb(__a, __b);
4928 }
4929
4930 static __inline__ vector signed char __ATTRS_o_ai
4931 vec_vmaxsb(vector bool char __a, vector signed char __b) {
4932   return __builtin_altivec_vmaxsb((vector signed char)__a, __b);
4933 }
4934
4935 static __inline__ vector signed char __ATTRS_o_ai
4936 vec_vmaxsb(vector signed char __a, vector bool char __b) {
4937   return __builtin_altivec_vmaxsb(__a, (vector signed char)__b);
4938 }
4939
4940 /* vec_vmaxub */
4941
4942 static __inline__ vector unsigned char __ATTRS_o_ai
4943 vec_vmaxub(vector unsigned char __a, vector unsigned char __b) {
4944   return __builtin_altivec_vmaxub(__a, __b);
4945 }
4946
4947 static __inline__ vector unsigned char __ATTRS_o_ai
4948 vec_vmaxub(vector bool char __a, vector unsigned char __b) {
4949   return __builtin_altivec_vmaxub((vector unsigned char)__a, __b);
4950 }
4951
4952 static __inline__ vector unsigned char __ATTRS_o_ai
4953 vec_vmaxub(vector unsigned char __a, vector bool char __b) {
4954   return __builtin_altivec_vmaxub(__a, (vector unsigned char)__b);
4955 }
4956
4957 /* vec_vmaxsh */
4958
4959 static __inline__ vector short __ATTRS_o_ai vec_vmaxsh(vector short __a,
4960                                                        vector short __b) {
4961   return __builtin_altivec_vmaxsh(__a, __b);
4962 }
4963
4964 static __inline__ vector short __ATTRS_o_ai vec_vmaxsh(vector bool short __a,
4965                                                        vector short __b) {
4966   return __builtin_altivec_vmaxsh((vector short)__a, __b);
4967 }
4968
4969 static __inline__ vector short __ATTRS_o_ai vec_vmaxsh(vector short __a,
4970                                                        vector bool short __b) {
4971   return __builtin_altivec_vmaxsh(__a, (vector short)__b);
4972 }
4973
4974 /* vec_vmaxuh */
4975
4976 static __inline__ vector unsigned short __ATTRS_o_ai
4977 vec_vmaxuh(vector unsigned short __a, vector unsigned short __b) {
4978   return __builtin_altivec_vmaxuh(__a, __b);
4979 }
4980
4981 static __inline__ vector unsigned short __ATTRS_o_ai
4982 vec_vmaxuh(vector bool short __a, vector unsigned short __b) {
4983   return __builtin_altivec_vmaxuh((vector unsigned short)__a, __b);
4984 }
4985
4986 static __inline__ vector unsigned short __ATTRS_o_ai
4987 vec_vmaxuh(vector unsigned short __a, vector bool short __b) {
4988   return __builtin_altivec_vmaxuh(__a, (vector unsigned short)__b);
4989 }
4990
4991 /* vec_vmaxsw */
4992
4993 static __inline__ vector int __ATTRS_o_ai vec_vmaxsw(vector int __a,
4994                                                      vector int __b) {
4995   return __builtin_altivec_vmaxsw(__a, __b);
4996 }
4997
4998 static __inline__ vector int __ATTRS_o_ai vec_vmaxsw(vector bool int __a,
4999                                                      vector int __b) {
5000   return __builtin_altivec_vmaxsw((vector int)__a, __b);
5001 }
5002
5003 static __inline__ vector int __ATTRS_o_ai vec_vmaxsw(vector int __a,
5004                                                      vector bool int __b) {
5005   return __builtin_altivec_vmaxsw(__a, (vector int)__b);
5006 }
5007
5008 /* vec_vmaxuw */
5009
5010 static __inline__ vector unsigned int __ATTRS_o_ai
5011 vec_vmaxuw(vector unsigned int __a, vector unsigned int __b) {
5012   return __builtin_altivec_vmaxuw(__a, __b);
5013 }
5014
5015 static __inline__ vector unsigned int __ATTRS_o_ai
5016 vec_vmaxuw(vector bool int __a, vector unsigned int __b) {
5017   return __builtin_altivec_vmaxuw((vector unsigned int)__a, __b);
5018 }
5019
5020 static __inline__ vector unsigned int __ATTRS_o_ai
5021 vec_vmaxuw(vector unsigned int __a, vector bool int __b) {
5022   return __builtin_altivec_vmaxuw(__a, (vector unsigned int)__b);
5023 }
5024
5025 /* vec_vmaxfp */
5026
5027 static __inline__ vector float __attribute__((__always_inline__))
5028 vec_vmaxfp(vector float __a, vector float __b) {
5029 #ifdef __VSX__
5030   return __builtin_vsx_xvmaxsp(__a, __b);
5031 #else
5032   return __builtin_altivec_vmaxfp(__a, __b);
5033 #endif
5034 }
5035
5036 /* vec_mergeh */
5037
5038 static __inline__ vector signed char __ATTRS_o_ai
5039 vec_mergeh(vector signed char __a, vector signed char __b) {
5040   return vec_perm(__a, __b,
5041                   (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
5042                                          0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
5043                                          0x06, 0x16, 0x07, 0x17));
5044 }
5045
5046 static __inline__ vector unsigned char __ATTRS_o_ai
5047 vec_mergeh(vector unsigned char __a, vector unsigned char __b) {
5048   return vec_perm(__a, __b,
5049                   (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
5050                                          0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
5051                                          0x06, 0x16, 0x07, 0x17));
5052 }
5053
5054 static __inline__ vector bool char __ATTRS_o_ai
5055 vec_mergeh(vector bool char __a, vector bool char __b) {
5056   return vec_perm(__a, __b,
5057                   (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
5058                                          0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
5059                                          0x06, 0x16, 0x07, 0x17));
5060 }
5061
5062 static __inline__ vector short __ATTRS_o_ai vec_mergeh(vector short __a,
5063                                                        vector short __b) {
5064   return vec_perm(__a, __b,
5065                   (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
5066                                          0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
5067                                          0x06, 0x07, 0x16, 0x17));
5068 }
5069
5070 static __inline__ vector unsigned short __ATTRS_o_ai
5071 vec_mergeh(vector unsigned short __a, vector unsigned short __b) {
5072   return vec_perm(__a, __b,
5073                   (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
5074                                          0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
5075                                          0x06, 0x07, 0x16, 0x17));
5076 }
5077
5078 static __inline__ vector bool short __ATTRS_o_ai
5079 vec_mergeh(vector bool short __a, vector bool short __b) {
5080   return vec_perm(__a, __b,
5081                   (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
5082                                          0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
5083                                          0x06, 0x07, 0x16, 0x17));
5084 }
5085
5086 static __inline__ vector pixel __ATTRS_o_ai vec_mergeh(vector pixel __a,
5087                                                        vector pixel __b) {
5088   return vec_perm(__a, __b,
5089                   (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
5090                                          0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
5091                                          0x06, 0x07, 0x16, 0x17));
5092 }
5093
5094 static __inline__ vector int __ATTRS_o_ai vec_mergeh(vector int __a,
5095                                                      vector int __b) {
5096   return vec_perm(__a, __b,
5097                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5098                                          0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
5099                                          0x14, 0x15, 0x16, 0x17));
5100 }
5101
5102 static __inline__ vector unsigned int __ATTRS_o_ai
5103 vec_mergeh(vector unsigned int __a, vector unsigned int __b) {
5104   return vec_perm(__a, __b,
5105                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5106                                          0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
5107                                          0x14, 0x15, 0x16, 0x17));
5108 }
5109
5110 static __inline__ vector bool int __ATTRS_o_ai vec_mergeh(vector bool int __a,
5111                                                           vector bool int __b) {
5112   return vec_perm(__a, __b,
5113                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5114                                          0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
5115                                          0x14, 0x15, 0x16, 0x17));
5116 }
5117
5118 static __inline__ vector float __ATTRS_o_ai vec_mergeh(vector float __a,
5119                                                        vector float __b) {
5120   return vec_perm(__a, __b,
5121                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5122                                          0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
5123                                          0x14, 0x15, 0x16, 0x17));
5124 }
5125
5126 #ifdef __VSX__
5127 static __inline__ vector signed long long __ATTRS_o_ai
5128 vec_mergeh(vector signed long long __a, vector signed long long __b) {
5129   return vec_perm(__a, __b,
5130                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
5131                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
5132                                          0x14, 0x15, 0x16, 0x17));
5133 }
5134
5135 static __inline__ vector signed long long __ATTRS_o_ai
5136 vec_mergeh(vector signed long long __a, vector bool long long __b) {
5137   return vec_perm(__a, (vector signed long long)__b,
5138                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
5139                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
5140                                          0x14, 0x15, 0x16, 0x17));
5141 }
5142
5143 static __inline__ vector signed long long __ATTRS_o_ai
5144 vec_mergeh(vector bool long long __a, vector signed long long __b) {
5145   return vec_perm((vector signed long long)__a, __b,
5146                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
5147                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
5148                                          0x14, 0x15, 0x16, 0x17));
5149 }
5150
5151 static __inline__ vector unsigned long long __ATTRS_o_ai
5152 vec_mergeh(vector unsigned long long __a, vector unsigned long long __b) {
5153   return vec_perm(__a, __b,
5154                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
5155                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
5156                                          0x14, 0x15, 0x16, 0x17));
5157 }
5158
5159 static __inline__ vector unsigned long long __ATTRS_o_ai
5160 vec_mergeh(vector unsigned long long __a, vector bool long long __b) {
5161   return vec_perm(__a, (vector unsigned long long)__b,
5162                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
5163                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
5164                                          0x14, 0x15, 0x16, 0x17));
5165 }
5166
5167 static __inline__ vector unsigned long long __ATTRS_o_ai
5168 vec_mergeh(vector bool long long __a, vector unsigned long long __b) {
5169   return vec_perm((vector unsigned long long)__a, __b,
5170                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
5171                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
5172                                          0x14, 0x15, 0x16, 0x17));
5173 }
5174
5175 static __inline__ vector bool long long __ATTRS_o_ai
5176 vec_mergeh(vector bool long long __a, vector bool long long __b) {
5177   return vec_perm(__a, __b,
5178                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
5179                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
5180                                          0x14, 0x15, 0x16, 0x17));
5181 }
5182
5183 static __inline__ vector double __ATTRS_o_ai vec_mergeh(vector double __a,
5184                                                         vector double __b) {
5185   return vec_perm(__a, __b,
5186                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
5187                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
5188                                          0x14, 0x15, 0x16, 0x17));
5189 }
5190 static __inline__ vector double __ATTRS_o_ai
5191 vec_mergeh(vector double __a, vector bool long long __b) {
5192   return vec_perm(__a, (vector double)__b,
5193                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
5194                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
5195                                          0x14, 0x15, 0x16, 0x17));
5196 }
5197 static __inline__ vector double __ATTRS_o_ai
5198 vec_mergeh(vector bool long long __a, vector double __b) {
5199   return vec_perm((vector double)__a, __b,
5200                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
5201                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
5202                                          0x14, 0x15, 0x16, 0x17));
5203 }
5204 #endif
5205
5206 /* vec_vmrghb */
5207
5208 #define __builtin_altivec_vmrghb vec_vmrghb
5209
5210 static __inline__ vector signed char __ATTRS_o_ai
5211 vec_vmrghb(vector signed char __a, vector signed char __b) {
5212   return vec_perm(__a, __b,
5213                   (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
5214                                          0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
5215                                          0x06, 0x16, 0x07, 0x17));
5216 }
5217
5218 static __inline__ vector unsigned char __ATTRS_o_ai
5219 vec_vmrghb(vector unsigned char __a, vector unsigned char __b) {
5220   return vec_perm(__a, __b,
5221                   (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
5222                                          0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
5223                                          0x06, 0x16, 0x07, 0x17));
5224 }
5225
5226 static __inline__ vector bool char __ATTRS_o_ai
5227 vec_vmrghb(vector bool char __a, vector bool char __b) {
5228   return vec_perm(__a, __b,
5229                   (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
5230                                          0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
5231                                          0x06, 0x16, 0x07, 0x17));
5232 }
5233
5234 /* vec_vmrghh */
5235
5236 #define __builtin_altivec_vmrghh vec_vmrghh
5237
5238 static __inline__ vector short __ATTRS_o_ai vec_vmrghh(vector short __a,
5239                                                        vector short __b) {
5240   return vec_perm(__a, __b,
5241                   (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
5242                                          0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
5243                                          0x06, 0x07, 0x16, 0x17));
5244 }
5245
5246 static __inline__ vector unsigned short __ATTRS_o_ai
5247 vec_vmrghh(vector unsigned short __a, vector unsigned short __b) {
5248   return vec_perm(__a, __b,
5249                   (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
5250                                          0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
5251                                          0x06, 0x07, 0x16, 0x17));
5252 }
5253
5254 static __inline__ vector bool short __ATTRS_o_ai
5255 vec_vmrghh(vector bool short __a, vector bool short __b) {
5256   return vec_perm(__a, __b,
5257                   (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
5258                                          0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
5259                                          0x06, 0x07, 0x16, 0x17));
5260 }
5261
5262 static __inline__ vector pixel __ATTRS_o_ai vec_vmrghh(vector pixel __a,
5263                                                        vector pixel __b) {
5264   return vec_perm(__a, __b,
5265                   (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
5266                                          0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
5267                                          0x06, 0x07, 0x16, 0x17));
5268 }
5269
5270 /* vec_vmrghw */
5271
5272 #define __builtin_altivec_vmrghw vec_vmrghw
5273
5274 static __inline__ vector int __ATTRS_o_ai vec_vmrghw(vector int __a,
5275                                                      vector int __b) {
5276   return vec_perm(__a, __b,
5277                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5278                                          0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
5279                                          0x14, 0x15, 0x16, 0x17));
5280 }
5281
5282 static __inline__ vector unsigned int __ATTRS_o_ai
5283 vec_vmrghw(vector unsigned int __a, vector unsigned int __b) {
5284   return vec_perm(__a, __b,
5285                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5286                                          0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
5287                                          0x14, 0x15, 0x16, 0x17));
5288 }
5289
5290 static __inline__ vector bool int __ATTRS_o_ai vec_vmrghw(vector bool int __a,
5291                                                           vector bool int __b) {
5292   return vec_perm(__a, __b,
5293                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5294                                          0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
5295                                          0x14, 0x15, 0x16, 0x17));
5296 }
5297
5298 static __inline__ vector float __ATTRS_o_ai vec_vmrghw(vector float __a,
5299                                                        vector float __b) {
5300   return vec_perm(__a, __b,
5301                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5302                                          0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
5303                                          0x14, 0x15, 0x16, 0x17));
5304 }
5305
5306 /* vec_mergel */
5307
5308 static __inline__ vector signed char __ATTRS_o_ai
5309 vec_mergel(vector signed char __a, vector signed char __b) {
5310   return vec_perm(__a, __b,
5311                   (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
5312                                          0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
5313                                          0x0E, 0x1E, 0x0F, 0x1F));
5314 }
5315
5316 static __inline__ vector unsigned char __ATTRS_o_ai
5317 vec_mergel(vector unsigned char __a, vector unsigned char __b) {
5318   return vec_perm(__a, __b,
5319                   (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
5320                                          0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
5321                                          0x0E, 0x1E, 0x0F, 0x1F));
5322 }
5323
5324 static __inline__ vector bool char __ATTRS_o_ai
5325 vec_mergel(vector bool char __a, vector bool char __b) {
5326   return vec_perm(__a, __b,
5327                   (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
5328                                          0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
5329                                          0x0E, 0x1E, 0x0F, 0x1F));
5330 }
5331
5332 static __inline__ vector short __ATTRS_o_ai vec_mergel(vector short __a,
5333                                                        vector short __b) {
5334   return vec_perm(__a, __b,
5335                   (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
5336                                          0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
5337                                          0x0E, 0x0F, 0x1E, 0x1F));
5338 }
5339
5340 static __inline__ vector unsigned short __ATTRS_o_ai
5341 vec_mergel(vector unsigned short __a, vector unsigned short __b) {
5342   return vec_perm(__a, __b,
5343                   (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
5344                                          0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
5345                                          0x0E, 0x0F, 0x1E, 0x1F));
5346 }
5347
5348 static __inline__ vector bool short __ATTRS_o_ai
5349 vec_mergel(vector bool short __a, vector bool short __b) {
5350   return vec_perm(__a, __b,
5351                   (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
5352                                          0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
5353                                          0x0E, 0x0F, 0x1E, 0x1F));
5354 }
5355
5356 static __inline__ vector pixel __ATTRS_o_ai vec_mergel(vector pixel __a,
5357                                                        vector pixel __b) {
5358   return vec_perm(__a, __b,
5359                   (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
5360                                          0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
5361                                          0x0E, 0x0F, 0x1E, 0x1F));
5362 }
5363
5364 static __inline__ vector int __ATTRS_o_ai vec_mergel(vector int __a,
5365                                                      vector int __b) {
5366   return vec_perm(__a, __b,
5367                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
5368                                          0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
5369                                          0x1C, 0x1D, 0x1E, 0x1F));
5370 }
5371
5372 static __inline__ vector unsigned int __ATTRS_o_ai
5373 vec_mergel(vector unsigned int __a, vector unsigned int __b) {
5374   return vec_perm(__a, __b,
5375                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
5376                                          0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
5377                                          0x1C, 0x1D, 0x1E, 0x1F));
5378 }
5379
5380 static __inline__ vector bool int __ATTRS_o_ai vec_mergel(vector bool int __a,
5381                                                           vector bool int __b) {
5382   return vec_perm(__a, __b,
5383                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
5384                                          0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
5385                                          0x1C, 0x1D, 0x1E, 0x1F));
5386 }
5387
5388 static __inline__ vector float __ATTRS_o_ai vec_mergel(vector float __a,
5389                                                        vector float __b) {
5390   return vec_perm(__a, __b,
5391                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
5392                                          0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
5393                                          0x1C, 0x1D, 0x1E, 0x1F));
5394 }
5395
5396 #ifdef __VSX__
5397 static __inline__ vector signed long long __ATTRS_o_ai
5398 vec_mergel(vector signed long long __a, vector signed long long __b) {
5399   return vec_perm(__a, __b,
5400                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
5401                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
5402                                          0x1C, 0x1D, 0x1E, 0x1F));
5403 }
5404 static __inline__ vector signed long long __ATTRS_o_ai
5405 vec_mergel(vector signed long long __a, vector bool long long __b) {
5406   return vec_perm(__a, (vector signed long long)__b,
5407                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
5408                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
5409                                          0x1C, 0x1D, 0x1E, 0x1F));
5410 }
5411 static __inline__ vector signed long long __ATTRS_o_ai
5412 vec_mergel(vector bool long long __a, vector signed long long __b) {
5413   return vec_perm((vector signed long long)__a, __b,
5414                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
5415                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
5416                                          0x1C, 0x1D, 0x1E, 0x1F));
5417 }
5418 static __inline__ vector unsigned long long __ATTRS_o_ai
5419 vec_mergel(vector unsigned long long __a, vector unsigned long long __b) {
5420   return vec_perm(__a, __b,
5421                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
5422                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
5423                                          0x1C, 0x1D, 0x1E, 0x1F));
5424 }
5425 static __inline__ vector unsigned long long __ATTRS_o_ai
5426 vec_mergel(vector unsigned long long __a, vector bool long long __b) {
5427   return vec_perm(__a, (vector unsigned long long)__b,
5428                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
5429                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
5430                                          0x1C, 0x1D, 0x1E, 0x1F));
5431 }
5432 static __inline__ vector unsigned long long __ATTRS_o_ai
5433 vec_mergel(vector bool long long __a, vector unsigned long long __b) {
5434   return vec_perm((vector unsigned long long)__a, __b,
5435                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
5436                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
5437                                          0x1C, 0x1D, 0x1E, 0x1F));
5438 }
5439 static __inline__ vector bool long long __ATTRS_o_ai
5440 vec_mergel(vector bool long long __a, vector bool long long __b) {
5441   return vec_perm(__a, __b,
5442                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
5443                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
5444                                          0x1C, 0x1D, 0x1E, 0x1F));
5445 }
5446 static __inline__ vector double __ATTRS_o_ai vec_mergel(vector double __a,
5447                                                         vector double __b) {
5448   return vec_perm(__a, __b,
5449                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
5450                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
5451                                          0x1C, 0x1D, 0x1E, 0x1F));
5452 }
5453 static __inline__ vector double __ATTRS_o_ai
5454 vec_mergel(vector double __a, vector bool long long __b) {
5455   return vec_perm(__a, (vector double)__b,
5456                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
5457                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
5458                                          0x1C, 0x1D, 0x1E, 0x1F));
5459 }
5460 static __inline__ vector double __ATTRS_o_ai
5461 vec_mergel(vector bool long long __a, vector double __b) {
5462   return vec_perm((vector double)__a, __b,
5463                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
5464                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
5465                                          0x1C, 0x1D, 0x1E, 0x1F));
5466 }
5467 #endif
5468
5469 /* vec_vmrglb */
5470
5471 #define __builtin_altivec_vmrglb vec_vmrglb
5472
5473 static __inline__ vector signed char __ATTRS_o_ai
5474 vec_vmrglb(vector signed char __a, vector signed char __b) {
5475   return vec_perm(__a, __b,
5476                   (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
5477                                          0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
5478                                          0x0E, 0x1E, 0x0F, 0x1F));
5479 }
5480
5481 static __inline__ vector unsigned char __ATTRS_o_ai
5482 vec_vmrglb(vector unsigned char __a, vector unsigned char __b) {
5483   return vec_perm(__a, __b,
5484                   (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
5485                                          0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
5486                                          0x0E, 0x1E, 0x0F, 0x1F));
5487 }
5488
5489 static __inline__ vector bool char __ATTRS_o_ai
5490 vec_vmrglb(vector bool char __a, vector bool char __b) {
5491   return vec_perm(__a, __b,
5492                   (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
5493                                          0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
5494                                          0x0E, 0x1E, 0x0F, 0x1F));
5495 }
5496
5497 /* vec_vmrglh */
5498
5499 #define __builtin_altivec_vmrglh vec_vmrglh
5500
5501 static __inline__ vector short __ATTRS_o_ai vec_vmrglh(vector short __a,
5502                                                        vector short __b) {
5503   return vec_perm(__a, __b,
5504                   (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
5505                                          0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
5506                                          0x0E, 0x0F, 0x1E, 0x1F));
5507 }
5508
5509 static __inline__ vector unsigned short __ATTRS_o_ai
5510 vec_vmrglh(vector unsigned short __a, vector unsigned short __b) {
5511   return vec_perm(__a, __b,
5512                   (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
5513                                          0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
5514                                          0x0E, 0x0F, 0x1E, 0x1F));
5515 }
5516
5517 static __inline__ vector bool short __ATTRS_o_ai
5518 vec_vmrglh(vector bool short __a, vector bool short __b) {
5519   return vec_perm(__a, __b,
5520                   (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
5521                                          0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
5522                                          0x0E, 0x0F, 0x1E, 0x1F));
5523 }
5524
5525 static __inline__ vector pixel __ATTRS_o_ai vec_vmrglh(vector pixel __a,
5526                                                        vector pixel __b) {
5527   return vec_perm(__a, __b,
5528                   (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
5529                                          0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
5530                                          0x0E, 0x0F, 0x1E, 0x1F));
5531 }
5532
5533 /* vec_vmrglw */
5534
5535 #define __builtin_altivec_vmrglw vec_vmrglw
5536
5537 static __inline__ vector int __ATTRS_o_ai vec_vmrglw(vector int __a,
5538                                                      vector int __b) {
5539   return vec_perm(__a, __b,
5540                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
5541                                          0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
5542                                          0x1C, 0x1D, 0x1E, 0x1F));
5543 }
5544
5545 static __inline__ vector unsigned int __ATTRS_o_ai
5546 vec_vmrglw(vector unsigned int __a, vector unsigned int __b) {
5547   return vec_perm(__a, __b,
5548                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
5549                                          0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
5550                                          0x1C, 0x1D, 0x1E, 0x1F));
5551 }
5552
5553 static __inline__ vector bool int __ATTRS_o_ai vec_vmrglw(vector bool int __a,
5554                                                           vector bool int __b) {
5555   return vec_perm(__a, __b,
5556                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
5557                                          0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
5558                                          0x1C, 0x1D, 0x1E, 0x1F));
5559 }
5560
5561 static __inline__ vector float __ATTRS_o_ai vec_vmrglw(vector float __a,
5562                                                        vector float __b) {
5563   return vec_perm(__a, __b,
5564                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
5565                                          0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
5566                                          0x1C, 0x1D, 0x1E, 0x1F));
5567 }
5568
5569 #ifdef __POWER8_VECTOR__
5570 /* vec_mergee */
5571
5572 static __inline__ vector bool int __ATTRS_o_ai vec_mergee(vector bool int __a,
5573                                                           vector bool int __b) {
5574   return vec_perm(__a, __b,
5575                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5576                                          0x12, 0x13, 0x08, 0x09, 0x0A, 0x0B,
5577                                          0x18, 0x19, 0x1A, 0x1B));
5578 }
5579
5580 static __inline__ vector signed int __ATTRS_o_ai
5581 vec_mergee(vector signed int __a, vector signed int __b) {
5582   return vec_perm(__a, __b,
5583                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5584                                          0x12, 0x13, 0x08, 0x09, 0x0A, 0x0B,
5585                                          0x18, 0x19, 0x1A, 0x1B));
5586 }
5587
5588 static __inline__ vector unsigned int __ATTRS_o_ai
5589 vec_mergee(vector unsigned int __a, vector unsigned int __b) {
5590   return vec_perm(__a, __b,
5591                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5592                                          0x12, 0x13, 0x08, 0x09, 0x0A, 0x0B,
5593                                          0x18, 0x19, 0x1A, 0x1B));
5594 }
5595
5596 static __inline__ vector bool long long __ATTRS_o_ai
5597 vec_mergee(vector bool long long __a, vector bool long long __b) {
5598   return vec_mergeh(__a, __b);
5599 }
5600
5601 static __inline__ vector signed long long __ATTRS_o_ai
5602 vec_mergee(vector signed long long __a, vector signed long long __b) {
5603   return vec_mergeh(__a, __b);
5604 }
5605
5606 static __inline__ vector unsigned long long __ATTRS_o_ai
5607 vec_mergee(vector unsigned long long __a, vector unsigned long long __b) {
5608   return vec_mergeh(__a, __b);
5609 }
5610
5611 static __inline__ vector float __ATTRS_o_ai
5612 vec_mergee(vector float __a, vector float __b) {
5613   return vec_perm(__a, __b,
5614                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5615                                          0x12, 0x13, 0x08, 0x09, 0x0A, 0x0B,
5616                                          0x18, 0x19, 0x1A, 0x1B));
5617 }
5618
5619 static __inline__ vector double __ATTRS_o_ai
5620 vec_mergee(vector double __a, vector double __b) {
5621   return vec_mergeh(__a, __b);
5622 }
5623
5624 /* vec_mergeo */
5625
5626 static __inline__ vector bool int __ATTRS_o_ai vec_mergeo(vector bool int __a,
5627                                                           vector bool int __b) {
5628   return vec_perm(__a, __b,
5629                   (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x14, 0x15,
5630                                          0x16, 0x17, 0x0C, 0x0D, 0x0E, 0x0F,
5631                                          0x1C, 0x1D, 0x1E, 0x1F));
5632 }
5633
5634 static __inline__ vector signed int __ATTRS_o_ai
5635 vec_mergeo(vector signed int __a, vector signed int __b) {
5636   return vec_perm(__a, __b,
5637                   (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x14, 0x15,
5638                                          0x16, 0x17, 0x0C, 0x0D, 0x0E, 0x0F,
5639                                          0x1C, 0x1D, 0x1E, 0x1F));
5640 }
5641
5642 static __inline__ vector unsigned int __ATTRS_o_ai
5643 vec_mergeo(vector unsigned int __a, vector unsigned int __b) {
5644   return vec_perm(__a, __b,
5645                   (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x14, 0x15,
5646                                          0x16, 0x17, 0x0C, 0x0D, 0x0E, 0x0F,
5647                                          0x1C, 0x1D, 0x1E, 0x1F));
5648 }
5649
5650 static __inline__ vector bool long long __ATTRS_o_ai
5651 vec_mergeo(vector bool long long __a, vector bool long long __b) {
5652   return vec_mergel(__a, __b);
5653 }
5654
5655 static __inline__ vector signed long long __ATTRS_o_ai
5656 vec_mergeo(vector signed long long __a, vector signed long long __b) {
5657   return vec_mergel(__a, __b);
5658 }
5659
5660 static __inline__ vector unsigned long long __ATTRS_o_ai
5661 vec_mergeo(vector unsigned long long __a, vector unsigned long long __b) {
5662   return vec_mergel(__a, __b);
5663 }
5664
5665 static __inline__ vector float __ATTRS_o_ai
5666 vec_mergeo(vector float __a, vector float __b) {
5667   return vec_perm(__a, __b,
5668                   (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x14, 0x15,
5669                                          0x16, 0x17, 0x0C, 0x0D, 0x0E, 0x0F,
5670                                          0x1C, 0x1D, 0x1E, 0x1F));
5671 }
5672
5673 static __inline__ vector double __ATTRS_o_ai
5674 vec_mergeo(vector double __a, vector double __b) {
5675   return vec_mergel(__a, __b);
5676 }
5677
5678 #endif
5679
5680 /* vec_mfvscr */
5681
5682 static __inline__ vector unsigned short __attribute__((__always_inline__))
5683 vec_mfvscr(void) {
5684   return __builtin_altivec_mfvscr();
5685 }
5686
5687 /* vec_min */
5688
5689 static __inline__ vector signed char __ATTRS_o_ai
5690 vec_min(vector signed char __a, vector signed char __b) {
5691   return __builtin_altivec_vminsb(__a, __b);
5692 }
5693
5694 static __inline__ vector signed char __ATTRS_o_ai
5695 vec_min(vector bool char __a, vector signed char __b) {
5696   return __builtin_altivec_vminsb((vector signed char)__a, __b);
5697 }
5698
5699 static __inline__ vector signed char __ATTRS_o_ai
5700 vec_min(vector signed char __a, vector bool char __b) {
5701   return __builtin_altivec_vminsb(__a, (vector signed char)__b);
5702 }
5703
5704 static __inline__ vector unsigned char __ATTRS_o_ai
5705 vec_min(vector unsigned char __a, vector unsigned char __b) {
5706   return __builtin_altivec_vminub(__a, __b);
5707 }
5708
5709 static __inline__ vector unsigned char __ATTRS_o_ai
5710 vec_min(vector bool char __a, vector unsigned char __b) {
5711   return __builtin_altivec_vminub((vector unsigned char)__a, __b);
5712 }
5713
5714 static __inline__ vector unsigned char __ATTRS_o_ai
5715 vec_min(vector unsigned char __a, vector bool char __b) {
5716   return __builtin_altivec_vminub(__a, (vector unsigned char)__b);
5717 }
5718
5719 static __inline__ vector short __ATTRS_o_ai vec_min(vector short __a,
5720                                                     vector short __b) {
5721   return __builtin_altivec_vminsh(__a, __b);
5722 }
5723
5724 static __inline__ vector short __ATTRS_o_ai vec_min(vector bool short __a,
5725                                                     vector short __b) {
5726   return __builtin_altivec_vminsh((vector short)__a, __b);
5727 }
5728
5729 static __inline__ vector short __ATTRS_o_ai vec_min(vector short __a,
5730                                                     vector bool short __b) {
5731   return __builtin_altivec_vminsh(__a, (vector short)__b);
5732 }
5733
5734 static __inline__ vector unsigned short __ATTRS_o_ai
5735 vec_min(vector unsigned short __a, vector unsigned short __b) {
5736   return __builtin_altivec_vminuh(__a, __b);
5737 }
5738
5739 static __inline__ vector unsigned short __ATTRS_o_ai
5740 vec_min(vector bool short __a, vector unsigned short __b) {
5741   return __builtin_altivec_vminuh((vector unsigned short)__a, __b);
5742 }
5743
5744 static __inline__ vector unsigned short __ATTRS_o_ai
5745 vec_min(vector unsigned short __a, vector bool short __b) {
5746   return __builtin_altivec_vminuh(__a, (vector unsigned short)__b);
5747 }
5748
5749 static __inline__ vector int __ATTRS_o_ai vec_min(vector int __a,
5750                                                   vector int __b) {
5751   return __builtin_altivec_vminsw(__a, __b);
5752 }
5753
5754 static __inline__ vector int __ATTRS_o_ai vec_min(vector bool int __a,
5755                                                   vector int __b) {
5756   return __builtin_altivec_vminsw((vector int)__a, __b);
5757 }
5758
5759 static __inline__ vector int __ATTRS_o_ai vec_min(vector int __a,
5760                                                   vector bool int __b) {
5761   return __builtin_altivec_vminsw(__a, (vector int)__b);
5762 }
5763
5764 static __inline__ vector unsigned int __ATTRS_o_ai
5765 vec_min(vector unsigned int __a, vector unsigned int __b) {
5766   return __builtin_altivec_vminuw(__a, __b);
5767 }
5768
5769 static __inline__ vector unsigned int __ATTRS_o_ai
5770 vec_min(vector bool int __a, vector unsigned int __b) {
5771   return __builtin_altivec_vminuw((vector unsigned int)__a, __b);
5772 }
5773
5774 static __inline__ vector unsigned int __ATTRS_o_ai
5775 vec_min(vector unsigned int __a, vector bool int __b) {
5776   return __builtin_altivec_vminuw(__a, (vector unsigned int)__b);
5777 }
5778
5779 #ifdef __POWER8_VECTOR__
5780 static __inline__ vector signed long long __ATTRS_o_ai
5781 vec_min(vector signed long long __a, vector signed long long __b) {
5782   return __builtin_altivec_vminsd(__a, __b);
5783 }
5784
5785 static __inline__ vector signed long long __ATTRS_o_ai
5786 vec_min(vector bool long long __a, vector signed long long __b) {
5787   return __builtin_altivec_vminsd((vector signed long long)__a, __b);
5788 }
5789
5790 static __inline__ vector signed long long __ATTRS_o_ai
5791 vec_min(vector signed long long __a, vector bool long long __b) {
5792   return __builtin_altivec_vminsd(__a, (vector signed long long)__b);
5793 }
5794
5795 static __inline__ vector unsigned long long __ATTRS_o_ai
5796 vec_min(vector unsigned long long __a, vector unsigned long long __b) {
5797   return __builtin_altivec_vminud(__a, __b);
5798 }
5799
5800 static __inline__ vector unsigned long long __ATTRS_o_ai
5801 vec_min(vector bool long long __a, vector unsigned long long __b) {
5802   return __builtin_altivec_vminud((vector unsigned long long)__a, __b);
5803 }
5804
5805 static __inline__ vector unsigned long long __ATTRS_o_ai
5806 vec_min(vector unsigned long long __a, vector bool long long __b) {
5807   return __builtin_altivec_vminud(__a, (vector unsigned long long)__b);
5808 }
5809 #endif
5810
5811 static __inline__ vector float __ATTRS_o_ai vec_min(vector float __a,
5812                                                     vector float __b) {
5813 #ifdef __VSX__
5814   return __builtin_vsx_xvminsp(__a, __b);
5815 #else
5816   return __builtin_altivec_vminfp(__a, __b);
5817 #endif
5818 }
5819
5820 #ifdef __VSX__
5821 static __inline__ vector double __ATTRS_o_ai vec_min(vector double __a,
5822                                                      vector double __b) {
5823   return __builtin_vsx_xvmindp(__a, __b);
5824 }
5825 #endif
5826
5827 /* vec_vminsb */
5828
5829 static __inline__ vector signed char __ATTRS_o_ai
5830 vec_vminsb(vector signed char __a, vector signed char __b) {
5831   return __builtin_altivec_vminsb(__a, __b);
5832 }
5833
5834 static __inline__ vector signed char __ATTRS_o_ai
5835 vec_vminsb(vector bool char __a, vector signed char __b) {
5836   return __builtin_altivec_vminsb((vector signed char)__a, __b);
5837 }
5838
5839 static __inline__ vector signed char __ATTRS_o_ai
5840 vec_vminsb(vector signed char __a, vector bool char __b) {
5841   return __builtin_altivec_vminsb(__a, (vector signed char)__b);
5842 }
5843
5844 /* vec_vminub */
5845
5846 static __inline__ vector unsigned char __ATTRS_o_ai
5847 vec_vminub(vector unsigned char __a, vector unsigned char __b) {
5848   return __builtin_altivec_vminub(__a, __b);
5849 }
5850
5851 static __inline__ vector unsigned char __ATTRS_o_ai
5852 vec_vminub(vector bool char __a, vector unsigned char __b) {
5853   return __builtin_altivec_vminub((vector unsigned char)__a, __b);
5854 }
5855
5856 static __inline__ vector unsigned char __ATTRS_o_ai
5857 vec_vminub(vector unsigned char __a, vector bool char __b) {
5858   return __builtin_altivec_vminub(__a, (vector unsigned char)__b);
5859 }
5860
5861 /* vec_vminsh */
5862
5863 static __inline__ vector short __ATTRS_o_ai vec_vminsh(vector short __a,
5864                                                        vector short __b) {
5865   return __builtin_altivec_vminsh(__a, __b);
5866 }
5867
5868 static __inline__ vector short __ATTRS_o_ai vec_vminsh(vector bool short __a,
5869                                                        vector short __b) {
5870   return __builtin_altivec_vminsh((vector short)__a, __b);
5871 }
5872
5873 static __inline__ vector short __ATTRS_o_ai vec_vminsh(vector short __a,
5874                                                        vector bool short __b) {
5875   return __builtin_altivec_vminsh(__a, (vector short)__b);
5876 }
5877
5878 /* vec_vminuh */
5879
5880 static __inline__ vector unsigned short __ATTRS_o_ai
5881 vec_vminuh(vector unsigned short __a, vector unsigned short __b) {
5882   return __builtin_altivec_vminuh(__a, __b);
5883 }
5884
5885 static __inline__ vector unsigned short __ATTRS_o_ai
5886 vec_vminuh(vector bool short __a, vector unsigned short __b) {
5887   return __builtin_altivec_vminuh((vector unsigned short)__a, __b);
5888 }
5889
5890 static __inline__ vector unsigned short __ATTRS_o_ai
5891 vec_vminuh(vector unsigned short __a, vector bool short __b) {
5892   return __builtin_altivec_vminuh(__a, (vector unsigned short)__b);
5893 }
5894
5895 /* vec_vminsw */
5896
5897 static __inline__ vector int __ATTRS_o_ai vec_vminsw(vector int __a,
5898                                                      vector int __b) {
5899   return __builtin_altivec_vminsw(__a, __b);
5900 }
5901
5902 static __inline__ vector int __ATTRS_o_ai vec_vminsw(vector bool int __a,
5903                                                      vector int __b) {
5904   return __builtin_altivec_vminsw((vector int)__a, __b);
5905 }
5906
5907 static __inline__ vector int __ATTRS_o_ai vec_vminsw(vector int __a,
5908                                                      vector bool int __b) {
5909   return __builtin_altivec_vminsw(__a, (vector int)__b);
5910 }
5911
5912 /* vec_vminuw */
5913
5914 static __inline__ vector unsigned int __ATTRS_o_ai
5915 vec_vminuw(vector unsigned int __a, vector unsigned int __b) {
5916   return __builtin_altivec_vminuw(__a, __b);
5917 }
5918
5919 static __inline__ vector unsigned int __ATTRS_o_ai
5920 vec_vminuw(vector bool int __a, vector unsigned int __b) {
5921   return __builtin_altivec_vminuw((vector unsigned int)__a, __b);
5922 }
5923
5924 static __inline__ vector unsigned int __ATTRS_o_ai
5925 vec_vminuw(vector unsigned int __a, vector bool int __b) {
5926   return __builtin_altivec_vminuw(__a, (vector unsigned int)__b);
5927 }
5928
5929 /* vec_vminfp */
5930
5931 static __inline__ vector float __attribute__((__always_inline__))
5932 vec_vminfp(vector float __a, vector float __b) {
5933 #ifdef __VSX__
5934   return __builtin_vsx_xvminsp(__a, __b);
5935 #else
5936   return __builtin_altivec_vminfp(__a, __b);
5937 #endif
5938 }
5939
5940 /* vec_mladd */
5941
5942 #define __builtin_altivec_vmladduhm vec_mladd
5943
5944 static __inline__ vector short __ATTRS_o_ai vec_mladd(vector short __a,
5945                                                       vector short __b,
5946                                                       vector short __c) {
5947   return __a * __b + __c;
5948 }
5949
5950 static __inline__ vector short __ATTRS_o_ai vec_mladd(
5951     vector short __a, vector unsigned short __b, vector unsigned short __c) {
5952   return __a * (vector short)__b + (vector short)__c;
5953 }
5954
5955 static __inline__ vector short __ATTRS_o_ai vec_mladd(vector unsigned short __a,
5956                                                       vector short __b,
5957                                                       vector short __c) {
5958   return (vector short)__a * __b + __c;
5959 }
5960
5961 static __inline__ vector unsigned short __ATTRS_o_ai
5962 vec_mladd(vector unsigned short __a, vector unsigned short __b,
5963           vector unsigned short __c) {
5964   return __a * __b + __c;
5965 }
5966
5967 /* vec_vmladduhm */
5968
5969 static __inline__ vector short __ATTRS_o_ai vec_vmladduhm(vector short __a,
5970                                                           vector short __b,
5971                                                           vector short __c) {
5972   return __a * __b + __c;
5973 }
5974
5975 static __inline__ vector short __ATTRS_o_ai vec_vmladduhm(
5976     vector short __a, vector unsigned short __b, vector unsigned short __c) {
5977   return __a * (vector short)__b + (vector short)__c;
5978 }
5979
5980 static __inline__ vector short __ATTRS_o_ai
5981 vec_vmladduhm(vector unsigned short __a, vector short __b, vector short __c) {
5982   return (vector short)__a * __b + __c;
5983 }
5984
5985 static __inline__ vector unsigned short __ATTRS_o_ai
5986 vec_vmladduhm(vector unsigned short __a, vector unsigned short __b,
5987               vector unsigned short __c) {
5988   return __a * __b + __c;
5989 }
5990
5991 /* vec_mradds */
5992
5993 static __inline__ vector short __attribute__((__always_inline__))
5994 vec_mradds(vector short __a, vector short __b, vector short __c) {
5995   return __builtin_altivec_vmhraddshs(__a, __b, __c);
5996 }
5997
5998 /* vec_vmhraddshs */
5999
6000 static __inline__ vector short __attribute__((__always_inline__))
6001 vec_vmhraddshs(vector short __a, vector short __b, vector short __c) {
6002   return __builtin_altivec_vmhraddshs(__a, __b, __c);
6003 }
6004
6005 /* vec_msum */
6006
6007 static __inline__ vector int __ATTRS_o_ai vec_msum(vector signed char __a,
6008                                                    vector unsigned char __b,
6009                                                    vector int __c) {
6010   return __builtin_altivec_vmsummbm(__a, __b, __c);
6011 }
6012
6013 static __inline__ vector unsigned int __ATTRS_o_ai
6014 vec_msum(vector unsigned char __a, vector unsigned char __b,
6015          vector unsigned int __c) {
6016   return __builtin_altivec_vmsumubm(__a, __b, __c);
6017 }
6018
6019 static __inline__ vector int __ATTRS_o_ai vec_msum(vector short __a,
6020                                                    vector short __b,
6021                                                    vector int __c) {
6022   return __builtin_altivec_vmsumshm(__a, __b, __c);
6023 }
6024
6025 static __inline__ vector unsigned int __ATTRS_o_ai
6026 vec_msum(vector unsigned short __a, vector unsigned short __b,
6027          vector unsigned int __c) {
6028   return __builtin_altivec_vmsumuhm(__a, __b, __c);
6029 }
6030
6031 /* vec_msumc */
6032
6033 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
6034 static __inline__ vector unsigned __int128 __ATTRS_o_ai
6035 vec_msumc(vector unsigned long long __a, vector unsigned long long __b,
6036           vector unsigned __int128 __c) {
6037   return __builtin_altivec_vmsumcud(__a, __b, __c);
6038 }
6039 #endif
6040
6041 /* vec_vmsummbm */
6042
6043 static __inline__ vector int __attribute__((__always_inline__))
6044 vec_vmsummbm(vector signed char __a, vector unsigned char __b, vector int __c) {
6045   return __builtin_altivec_vmsummbm(__a, __b, __c);
6046 }
6047
6048 /* vec_vmsumubm */
6049
6050 static __inline__ vector unsigned int __attribute__((__always_inline__))
6051 vec_vmsumubm(vector unsigned char __a, vector unsigned char __b,
6052              vector unsigned int __c) {
6053   return __builtin_altivec_vmsumubm(__a, __b, __c);
6054 }
6055
6056 /* vec_vmsumshm */
6057
6058 static __inline__ vector int __attribute__((__always_inline__))
6059 vec_vmsumshm(vector short __a, vector short __b, vector int __c) {
6060   return __builtin_altivec_vmsumshm(__a, __b, __c);
6061 }
6062
6063 /* vec_vmsumuhm */
6064
6065 static __inline__ vector unsigned int __attribute__((__always_inline__))
6066 vec_vmsumuhm(vector unsigned short __a, vector unsigned short __b,
6067              vector unsigned int __c) {
6068   return __builtin_altivec_vmsumuhm(__a, __b, __c);
6069 }
6070
6071 /* vec_msums */
6072
6073 static __inline__ vector int __ATTRS_o_ai vec_msums(vector short __a,
6074                                                     vector short __b,
6075                                                     vector int __c) {
6076   return __builtin_altivec_vmsumshs(__a, __b, __c);
6077 }
6078
6079 static __inline__ vector unsigned int __ATTRS_o_ai
6080 vec_msums(vector unsigned short __a, vector unsigned short __b,
6081           vector unsigned int __c) {
6082   return __builtin_altivec_vmsumuhs(__a, __b, __c);
6083 }
6084
6085 /* vec_vmsumshs */
6086
6087 static __inline__ vector int __attribute__((__always_inline__))
6088 vec_vmsumshs(vector short __a, vector short __b, vector int __c) {
6089   return __builtin_altivec_vmsumshs(__a, __b, __c);
6090 }
6091
6092 /* vec_vmsumuhs */
6093
6094 static __inline__ vector unsigned int __attribute__((__always_inline__))
6095 vec_vmsumuhs(vector unsigned short __a, vector unsigned short __b,
6096              vector unsigned int __c) {
6097   return __builtin_altivec_vmsumuhs(__a, __b, __c);
6098 }
6099
6100 /* vec_mtvscr */
6101
6102 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector signed char __a) {
6103   __builtin_altivec_mtvscr((vector int)__a);
6104 }
6105
6106 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector unsigned char __a) {
6107   __builtin_altivec_mtvscr((vector int)__a);
6108 }
6109
6110 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector bool char __a) {
6111   __builtin_altivec_mtvscr((vector int)__a);
6112 }
6113
6114 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector short __a) {
6115   __builtin_altivec_mtvscr((vector int)__a);
6116 }
6117
6118 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector unsigned short __a) {
6119   __builtin_altivec_mtvscr((vector int)__a);
6120 }
6121
6122 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector bool short __a) {
6123   __builtin_altivec_mtvscr((vector int)__a);
6124 }
6125
6126 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector pixel __a) {
6127   __builtin_altivec_mtvscr((vector int)__a);
6128 }
6129
6130 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector int __a) {
6131   __builtin_altivec_mtvscr((vector int)__a);
6132 }
6133
6134 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector unsigned int __a) {
6135   __builtin_altivec_mtvscr((vector int)__a);
6136 }
6137
6138 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector bool int __a) {
6139   __builtin_altivec_mtvscr((vector int)__a);
6140 }
6141
6142 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector float __a) {
6143   __builtin_altivec_mtvscr((vector int)__a);
6144 }
6145
6146 /* vec_mul */
6147
6148 /* Integer vector multiplication will involve multiplication of the odd/even
6149    elements separately, then truncating the results and moving to the
6150    result vector.
6151 */
6152 static __inline__ vector signed char __ATTRS_o_ai
6153 vec_mul(vector signed char __a, vector signed char __b) {
6154   return __a * __b;
6155 }
6156
6157 static __inline__ vector unsigned char __ATTRS_o_ai
6158 vec_mul(vector unsigned char __a, vector unsigned char __b) {
6159   return __a * __b;
6160 }
6161
6162 static __inline__ vector signed short __ATTRS_o_ai
6163 vec_mul(vector signed short __a, vector signed short __b) {
6164   return __a * __b;
6165 }
6166
6167 static __inline__ vector unsigned short __ATTRS_o_ai
6168 vec_mul(vector unsigned short __a, vector unsigned short __b) {
6169   return __a * __b;
6170 }
6171
6172 static __inline__ vector signed int __ATTRS_o_ai
6173 vec_mul(vector signed int __a, vector signed int __b) {
6174   return __a * __b;
6175 }
6176
6177 static __inline__ vector unsigned int __ATTRS_o_ai
6178 vec_mul(vector unsigned int __a, vector unsigned int __b) {
6179   return __a * __b;
6180 }
6181
6182 #ifdef __VSX__
6183 static __inline__ vector signed long long __ATTRS_o_ai
6184 vec_mul(vector signed long long __a, vector signed long long __b) {
6185   return __a * __b;
6186 }
6187
6188 static __inline__ vector unsigned long long __ATTRS_o_ai
6189 vec_mul(vector unsigned long long __a, vector unsigned long long __b) {
6190   return __a * __b;
6191 }
6192 #endif
6193
6194 static __inline__ vector float __ATTRS_o_ai vec_mul(vector float __a,
6195                                                     vector float __b) {
6196   return __a * __b;
6197 }
6198
6199 #ifdef __VSX__
6200 static __inline__ vector double __ATTRS_o_ai vec_mul(vector double __a,
6201                                                      vector double __b) {
6202   return __a * __b;
6203 }
6204 #endif
6205
6206 /* The vmulos* and vmules* instructions have a big endian bias, so
6207    we must reverse the meaning of "even" and "odd" for little endian.  */
6208
6209 /* vec_mule */
6210
6211 static __inline__ vector short __ATTRS_o_ai vec_mule(vector signed char __a,
6212                                                      vector signed char __b) {
6213 #ifdef __LITTLE_ENDIAN__
6214   return __builtin_altivec_vmulosb(__a, __b);
6215 #else
6216   return __builtin_altivec_vmulesb(__a, __b);
6217 #endif
6218 }
6219
6220 static __inline__ vector unsigned short __ATTRS_o_ai
6221 vec_mule(vector unsigned char __a, vector unsigned char __b) {
6222 #ifdef __LITTLE_ENDIAN__
6223   return __builtin_altivec_vmuloub(__a, __b);
6224 #else
6225   return __builtin_altivec_vmuleub(__a, __b);
6226 #endif
6227 }
6228
6229 static __inline__ vector int __ATTRS_o_ai vec_mule(vector short __a,
6230                                                    vector short __b) {
6231 #ifdef __LITTLE_ENDIAN__
6232   return __builtin_altivec_vmulosh(__a, __b);
6233 #else
6234   return __builtin_altivec_vmulesh(__a, __b);
6235 #endif
6236 }
6237
6238 static __inline__ vector unsigned int __ATTRS_o_ai
6239 vec_mule(vector unsigned short __a, vector unsigned short __b) {
6240 #ifdef __LITTLE_ENDIAN__
6241   return __builtin_altivec_vmulouh(__a, __b);
6242 #else
6243   return __builtin_altivec_vmuleuh(__a, __b);
6244 #endif
6245 }
6246
6247 #ifdef __POWER8_VECTOR__
6248 static __inline__ vector signed long long __ATTRS_o_ai
6249 vec_mule(vector signed int __a, vector signed int __b) {
6250 #ifdef __LITTLE_ENDIAN__
6251   return __builtin_altivec_vmulosw(__a, __b);
6252 #else
6253   return __builtin_altivec_vmulesw(__a, __b);
6254 #endif
6255 }
6256
6257 static __inline__ vector unsigned long long __ATTRS_o_ai
6258 vec_mule(vector unsigned int __a, vector unsigned int __b) {
6259 #ifdef __LITTLE_ENDIAN__
6260   return __builtin_altivec_vmulouw(__a, __b);
6261 #else
6262   return __builtin_altivec_vmuleuw(__a, __b);
6263 #endif
6264 }
6265 #endif
6266
6267 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
6268 static __inline__ vector signed __int128 __ATTRS_o_ai
6269 vec_mule(vector signed long long __a, vector signed long long __b) {
6270 #ifdef __LITTLE_ENDIAN__
6271   return __builtin_altivec_vmulosd(__a, __b);
6272 #else
6273   return __builtin_altivec_vmulesd(__a, __b);
6274 #endif
6275 }
6276
6277 static __inline__ vector unsigned __int128 __ATTRS_o_ai
6278 vec_mule(vector unsigned long long __a, vector unsigned long long __b) {
6279 #ifdef __LITTLE_ENDIAN__
6280   return __builtin_altivec_vmuloud(__a, __b);
6281 #else
6282   return __builtin_altivec_vmuleud(__a, __b);
6283 #endif
6284 }
6285 #endif
6286
6287 /* vec_vmulesb */
6288
6289 static __inline__ vector short __attribute__((__always_inline__))
6290 vec_vmulesb(vector signed char __a, vector signed char __b) {
6291 #ifdef __LITTLE_ENDIAN__
6292   return __builtin_altivec_vmulosb(__a, __b);
6293 #else
6294   return __builtin_altivec_vmulesb(__a, __b);
6295 #endif
6296 }
6297
6298 /* vec_vmuleub */
6299
6300 static __inline__ vector unsigned short __attribute__((__always_inline__))
6301 vec_vmuleub(vector unsigned char __a, vector unsigned char __b) {
6302 #ifdef __LITTLE_ENDIAN__
6303   return __builtin_altivec_vmuloub(__a, __b);
6304 #else
6305   return __builtin_altivec_vmuleub(__a, __b);
6306 #endif
6307 }
6308
6309 /* vec_vmulesh */
6310
6311 static __inline__ vector int __attribute__((__always_inline__))
6312 vec_vmulesh(vector short __a, vector short __b) {
6313 #ifdef __LITTLE_ENDIAN__
6314   return __builtin_altivec_vmulosh(__a, __b);
6315 #else
6316   return __builtin_altivec_vmulesh(__a, __b);
6317 #endif
6318 }
6319
6320 /* vec_vmuleuh */
6321
6322 static __inline__ vector unsigned int __attribute__((__always_inline__))
6323 vec_vmuleuh(vector unsigned short __a, vector unsigned short __b) {
6324 #ifdef __LITTLE_ENDIAN__
6325   return __builtin_altivec_vmulouh(__a, __b);
6326 #else
6327   return __builtin_altivec_vmuleuh(__a, __b);
6328 #endif
6329 }
6330
6331 /* vec_mulh */
6332
6333 #ifdef __POWER10_VECTOR__
6334 static __inline__ vector signed int __ATTRS_o_ai
6335 vec_mulh(vector signed int __a, vector signed int __b) {
6336   return __builtin_altivec_vmulhsw(__a, __b);
6337 }
6338
6339 static __inline__ vector unsigned int __ATTRS_o_ai
6340 vec_mulh(vector unsigned int __a, vector unsigned int __b) {
6341   return __builtin_altivec_vmulhuw(__a, __b);
6342 }
6343
6344 static __inline__ vector signed long long __ATTRS_o_ai
6345 vec_mulh(vector signed long long __a, vector signed long long __b) {
6346   return __builtin_altivec_vmulhsd(__a, __b);
6347 }
6348
6349 static __inline__ vector unsigned long long __ATTRS_o_ai
6350 vec_mulh(vector unsigned long long __a, vector unsigned long long __b) {
6351   return __builtin_altivec_vmulhud(__a, __b);
6352 }
6353 #endif
6354
6355 /* vec_mulo */
6356
6357 static __inline__ vector short __ATTRS_o_ai vec_mulo(vector signed char __a,
6358                                                      vector signed char __b) {
6359 #ifdef __LITTLE_ENDIAN__
6360   return __builtin_altivec_vmulesb(__a, __b);
6361 #else
6362   return __builtin_altivec_vmulosb(__a, __b);
6363 #endif
6364 }
6365
6366 static __inline__ vector unsigned short __ATTRS_o_ai
6367 vec_mulo(vector unsigned char __a, vector unsigned char __b) {
6368 #ifdef __LITTLE_ENDIAN__
6369   return __builtin_altivec_vmuleub(__a, __b);
6370 #else
6371   return __builtin_altivec_vmuloub(__a, __b);
6372 #endif
6373 }
6374
6375 static __inline__ vector int __ATTRS_o_ai vec_mulo(vector short __a,
6376                                                    vector short __b) {
6377 #ifdef __LITTLE_ENDIAN__
6378   return __builtin_altivec_vmulesh(__a, __b);
6379 #else
6380   return __builtin_altivec_vmulosh(__a, __b);
6381 #endif
6382 }
6383
6384 static __inline__ vector unsigned int __ATTRS_o_ai
6385 vec_mulo(vector unsigned short __a, vector unsigned short __b) {
6386 #ifdef __LITTLE_ENDIAN__
6387   return __builtin_altivec_vmuleuh(__a, __b);
6388 #else
6389   return __builtin_altivec_vmulouh(__a, __b);
6390 #endif
6391 }
6392
6393 #ifdef __POWER8_VECTOR__
6394 static __inline__ vector signed long long __ATTRS_o_ai
6395 vec_mulo(vector signed int __a, vector signed int __b) {
6396 #ifdef __LITTLE_ENDIAN__
6397   return __builtin_altivec_vmulesw(__a, __b);
6398 #else
6399   return __builtin_altivec_vmulosw(__a, __b);
6400 #endif
6401 }
6402
6403 static __inline__ vector unsigned long long __ATTRS_o_ai
6404 vec_mulo(vector unsigned int __a, vector unsigned int __b) {
6405 #ifdef __LITTLE_ENDIAN__
6406   return __builtin_altivec_vmuleuw(__a, __b);
6407 #else
6408   return __builtin_altivec_vmulouw(__a, __b);
6409 #endif
6410 }
6411 #endif
6412
6413 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
6414 static __inline__ vector signed __int128 __ATTRS_o_ai
6415 vec_mulo(vector signed long long __a, vector signed long long __b) {
6416 #ifdef __LITTLE_ENDIAN__
6417   return __builtin_altivec_vmulesd(__a, __b);
6418 #else
6419   return __builtin_altivec_vmulosd(__a, __b);
6420 #endif
6421 }
6422
6423 static __inline__ vector unsigned __int128 __ATTRS_o_ai
6424 vec_mulo(vector unsigned long long __a, vector unsigned long long __b) {
6425 #ifdef __LITTLE_ENDIAN__
6426   return __builtin_altivec_vmuleud(__a, __b);
6427 #else
6428   return __builtin_altivec_vmuloud(__a, __b);
6429 #endif
6430 }
6431 #endif
6432
6433 /* vec_vmulosb */
6434
6435 static __inline__ vector short __attribute__((__always_inline__))
6436 vec_vmulosb(vector signed char __a, vector signed char __b) {
6437 #ifdef __LITTLE_ENDIAN__
6438   return __builtin_altivec_vmulesb(__a, __b);
6439 #else
6440   return __builtin_altivec_vmulosb(__a, __b);
6441 #endif
6442 }
6443
6444 /* vec_vmuloub */
6445
6446 static __inline__ vector unsigned short __attribute__((__always_inline__))
6447 vec_vmuloub(vector unsigned char __a, vector unsigned char __b) {
6448 #ifdef __LITTLE_ENDIAN__
6449   return __builtin_altivec_vmuleub(__a, __b);
6450 #else
6451   return __builtin_altivec_vmuloub(__a, __b);
6452 #endif
6453 }
6454
6455 /* vec_vmulosh */
6456
6457 static __inline__ vector int __attribute__((__always_inline__))
6458 vec_vmulosh(vector short __a, vector short __b) {
6459 #ifdef __LITTLE_ENDIAN__
6460   return __builtin_altivec_vmulesh(__a, __b);
6461 #else
6462   return __builtin_altivec_vmulosh(__a, __b);
6463 #endif
6464 }
6465
6466 /* vec_vmulouh */
6467
6468 static __inline__ vector unsigned int __attribute__((__always_inline__))
6469 vec_vmulouh(vector unsigned short __a, vector unsigned short __b) {
6470 #ifdef __LITTLE_ENDIAN__
6471   return __builtin_altivec_vmuleuh(__a, __b);
6472 #else
6473   return __builtin_altivec_vmulouh(__a, __b);
6474 #endif
6475 }
6476
6477 /*  vec_nand */
6478
6479 #ifdef __POWER8_VECTOR__
6480 static __inline__ vector signed char __ATTRS_o_ai
6481 vec_nand(vector signed char __a, vector signed char __b) {
6482   return ~(__a & __b);
6483 }
6484
6485 static __inline__ vector signed char __ATTRS_o_ai
6486 vec_nand(vector signed char __a, vector bool char __b) {
6487   return ~(__a & __b);
6488 }
6489
6490 static __inline__ vector signed char __ATTRS_o_ai
6491 vec_nand(vector bool char __a, vector signed char __b) {
6492   return ~(__a & __b);
6493 }
6494
6495 static __inline__ vector unsigned char __ATTRS_o_ai
6496 vec_nand(vector unsigned char __a, vector unsigned char __b) {
6497   return ~(__a & __b);
6498 }
6499
6500 static __inline__ vector unsigned char __ATTRS_o_ai
6501 vec_nand(vector unsigned char __a, vector bool char __b) {
6502   return ~(__a & __b);
6503 }
6504
6505 static __inline__ vector unsigned char __ATTRS_o_ai
6506 vec_nand(vector bool char __a, vector unsigned char __b) {
6507   return ~(__a & __b);
6508 }
6509
6510 static __inline__ vector bool char __ATTRS_o_ai vec_nand(vector bool char __a,
6511                                                          vector bool char __b) {
6512   return ~(__a & __b);
6513 }
6514
6515 static __inline__ vector signed short __ATTRS_o_ai
6516 vec_nand(vector signed short __a, vector signed short __b) {
6517   return ~(__a & __b);
6518 }
6519
6520 static __inline__ vector signed short __ATTRS_o_ai
6521 vec_nand(vector signed short __a, vector bool short __b) {
6522   return ~(__a & __b);
6523 }
6524
6525 static __inline__ vector signed short __ATTRS_o_ai
6526 vec_nand(vector bool short __a, vector signed short __b) {
6527   return ~(__a & __b);
6528 }
6529
6530 static __inline__ vector unsigned short __ATTRS_o_ai
6531 vec_nand(vector unsigned short __a, vector unsigned short __b) {
6532   return ~(__a & __b);
6533 }
6534
6535 static __inline__ vector unsigned short __ATTRS_o_ai
6536 vec_nand(vector unsigned short __a, vector bool short __b) {
6537   return ~(__a & __b);
6538 }
6539
6540 static __inline__ vector bool short __ATTRS_o_ai
6541 vec_nand(vector bool short __a, vector bool short __b) {
6542   return ~(__a & __b);
6543 }
6544
6545 static __inline__ vector signed int __ATTRS_o_ai
6546 vec_nand(vector signed int __a, vector signed int __b) {
6547   return ~(__a & __b);
6548 }
6549
6550 static __inline__ vector signed int __ATTRS_o_ai vec_nand(vector signed int __a,
6551                                                           vector bool int __b) {
6552   return ~(__a & __b);
6553 }
6554
6555 static __inline__ vector signed int __ATTRS_o_ai
6556 vec_nand(vector bool int __a, vector signed int __b) {
6557   return ~(__a & __b);
6558 }
6559
6560 static __inline__ vector unsigned int __ATTRS_o_ai
6561 vec_nand(vector unsigned int __a, vector unsigned int __b) {
6562   return ~(__a & __b);
6563 }
6564
6565 static __inline__ vector unsigned int __ATTRS_o_ai
6566 vec_nand(vector unsigned int __a, vector bool int __b) {
6567   return ~(__a & __b);
6568 }
6569
6570 static __inline__ vector unsigned int __ATTRS_o_ai
6571 vec_nand(vector bool int __a, vector unsigned int __b) {
6572   return ~(__a & __b);
6573 }
6574
6575 static __inline__ vector bool int __ATTRS_o_ai vec_nand(vector bool int __a,
6576                                                         vector bool int __b) {
6577   return ~(__a & __b);
6578 }
6579
6580 static __inline__ vector float __ATTRS_o_ai
6581 vec_nand(vector float __a, vector float __b) {
6582   return (vector float)(~((vector unsigned int)__a &
6583                           (vector unsigned int)__b));
6584 }
6585
6586 static __inline__ vector signed long long __ATTRS_o_ai
6587 vec_nand(vector signed long long __a, vector signed long long __b) {
6588   return ~(__a & __b);
6589 }
6590
6591 static __inline__ vector signed long long __ATTRS_o_ai
6592 vec_nand(vector signed long long __a, vector bool long long __b) {
6593   return ~(__a & __b);
6594 }
6595
6596 static __inline__ vector signed long long __ATTRS_o_ai
6597 vec_nand(vector bool long long __a, vector signed long long __b) {
6598   return ~(__a & __b);
6599 }
6600
6601 static __inline__ vector unsigned long long __ATTRS_o_ai
6602 vec_nand(vector unsigned long long __a, vector unsigned long long __b) {
6603   return ~(__a & __b);
6604 }
6605
6606 static __inline__ vector unsigned long long __ATTRS_o_ai
6607 vec_nand(vector unsigned long long __a, vector bool long long __b) {
6608   return ~(__a & __b);
6609 }
6610
6611 static __inline__ vector unsigned long long __ATTRS_o_ai
6612 vec_nand(vector bool long long __a, vector unsigned long long __b) {
6613   return ~(__a & __b);
6614 }
6615
6616 static __inline__ vector bool long long __ATTRS_o_ai
6617 vec_nand(vector bool long long __a, vector bool long long __b) {
6618   return ~(__a & __b);
6619 }
6620
6621 static __inline__ vector double __ATTRS_o_ai
6622 vec_nand(vector double __a, vector double __b) {
6623   return (vector double)(~((vector unsigned long long)__a &
6624                            (vector unsigned long long)__b));
6625 }
6626
6627 #endif
6628
6629 /* vec_nmadd */
6630
6631 #ifdef __VSX__
6632 static __inline__ vector float __ATTRS_o_ai vec_nmadd(vector float __a,
6633                                                       vector float __b,
6634                                                       vector float __c) {
6635   return __builtin_vsx_xvnmaddasp(__a, __b, __c);
6636 }
6637
6638 static __inline__ vector double __ATTRS_o_ai vec_nmadd(vector double __a,
6639                                                        vector double __b,
6640                                                        vector double __c) {
6641   return __builtin_vsx_xvnmaddadp(__a, __b, __c);
6642 }
6643 #endif
6644
6645 /* vec_nmsub */
6646
6647 static __inline__ vector float __ATTRS_o_ai vec_nmsub(vector float __a,
6648                                                       vector float __b,
6649                                                       vector float __c) {
6650 #ifdef __VSX__
6651   return __builtin_vsx_xvnmsubasp(__a, __b, __c);
6652 #else
6653   return __builtin_altivec_vnmsubfp(__a, __b, __c);
6654 #endif
6655 }
6656
6657 #ifdef __VSX__
6658 static __inline__ vector double __ATTRS_o_ai vec_nmsub(vector double __a,
6659                                                        vector double __b,
6660                                                        vector double __c) {
6661   return __builtin_vsx_xvnmsubadp(__a, __b, __c);
6662 }
6663 #endif
6664
6665 /* vec_vnmsubfp */
6666
6667 static __inline__ vector float __attribute__((__always_inline__))
6668 vec_vnmsubfp(vector float __a, vector float __b, vector float __c) {
6669   return __builtin_altivec_vnmsubfp(__a, __b, __c);
6670 }
6671
6672 /* vec_nor */
6673
6674 #define __builtin_altivec_vnor vec_nor
6675
6676 static __inline__ vector signed char __ATTRS_o_ai
6677 vec_nor(vector signed char __a, vector signed char __b) {
6678   return ~(__a | __b);
6679 }
6680
6681 static __inline__ vector unsigned char __ATTRS_o_ai
6682 vec_nor(vector unsigned char __a, vector unsigned char __b) {
6683   return ~(__a | __b);
6684 }
6685
6686 static __inline__ vector bool char __ATTRS_o_ai vec_nor(vector bool char __a,
6687                                                         vector bool char __b) {
6688   return ~(__a | __b);
6689 }
6690
6691 static __inline__ vector short __ATTRS_o_ai vec_nor(vector short __a,
6692                                                     vector short __b) {
6693   return ~(__a | __b);
6694 }
6695
6696 static __inline__ vector unsigned short __ATTRS_o_ai
6697 vec_nor(vector unsigned short __a, vector unsigned short __b) {
6698   return ~(__a | __b);
6699 }
6700
6701 static __inline__ vector bool short __ATTRS_o_ai
6702 vec_nor(vector bool short __a, vector bool short __b) {
6703   return ~(__a | __b);
6704 }
6705
6706 static __inline__ vector int __ATTRS_o_ai vec_nor(vector int __a,
6707                                                   vector int __b) {
6708   return ~(__a | __b);
6709 }
6710
6711 static __inline__ vector unsigned int __ATTRS_o_ai
6712 vec_nor(vector unsigned int __a, vector unsigned int __b) {
6713   return ~(__a | __b);
6714 }
6715
6716 static __inline__ vector bool int __ATTRS_o_ai vec_nor(vector bool int __a,
6717                                                        vector bool int __b) {
6718   return ~(__a | __b);
6719 }
6720
6721 static __inline__ vector float __ATTRS_o_ai vec_nor(vector float __a,
6722                                                     vector float __b) {
6723   vector unsigned int __res =
6724       ~((vector unsigned int)__a | (vector unsigned int)__b);
6725   return (vector float)__res;
6726 }
6727
6728 #ifdef __VSX__
6729 static __inline__ vector double __ATTRS_o_ai vec_nor(vector double __a,
6730                                                      vector double __b) {
6731   vector unsigned long long __res =
6732       ~((vector unsigned long long)__a | (vector unsigned long long)__b);
6733   return (vector double)__res;
6734 }
6735 #endif
6736
6737 /* vec_vnor */
6738
6739 static __inline__ vector signed char __ATTRS_o_ai
6740 vec_vnor(vector signed char __a, vector signed char __b) {
6741   return ~(__a | __b);
6742 }
6743
6744 static __inline__ vector unsigned char __ATTRS_o_ai
6745 vec_vnor(vector unsigned char __a, vector unsigned char __b) {
6746   return ~(__a | __b);
6747 }
6748
6749 static __inline__ vector bool char __ATTRS_o_ai vec_vnor(vector bool char __a,
6750                                                          vector bool char __b) {
6751   return ~(__a | __b);
6752 }
6753
6754 static __inline__ vector short __ATTRS_o_ai vec_vnor(vector short __a,
6755                                                      vector short __b) {
6756   return ~(__a | __b);
6757 }
6758
6759 static __inline__ vector unsigned short __ATTRS_o_ai
6760 vec_vnor(vector unsigned short __a, vector unsigned short __b) {
6761   return ~(__a | __b);
6762 }
6763
6764 static __inline__ vector bool short __ATTRS_o_ai
6765 vec_vnor(vector bool short __a, vector bool short __b) {
6766   return ~(__a | __b);
6767 }
6768
6769 static __inline__ vector int __ATTRS_o_ai vec_vnor(vector int __a,
6770                                                    vector int __b) {
6771   return ~(__a | __b);
6772 }
6773
6774 static __inline__ vector unsigned int __ATTRS_o_ai
6775 vec_vnor(vector unsigned int __a, vector unsigned int __b) {
6776   return ~(__a | __b);
6777 }
6778
6779 static __inline__ vector bool int __ATTRS_o_ai vec_vnor(vector bool int __a,
6780                                                         vector bool int __b) {
6781   return ~(__a | __b);
6782 }
6783
6784 static __inline__ vector float __ATTRS_o_ai vec_vnor(vector float __a,
6785                                                      vector float __b) {
6786   vector unsigned int __res =
6787       ~((vector unsigned int)__a | (vector unsigned int)__b);
6788   return (vector float)__res;
6789 }
6790
6791 #ifdef __VSX__
6792 static __inline__ vector signed long long __ATTRS_o_ai
6793 vec_nor(vector signed long long __a, vector signed long long __b) {
6794   return ~(__a | __b);
6795 }
6796
6797 static __inline__ vector unsigned long long __ATTRS_o_ai
6798 vec_nor(vector unsigned long long __a, vector unsigned long long __b) {
6799   return ~(__a | __b);
6800 }
6801
6802 static __inline__ vector bool long long __ATTRS_o_ai
6803 vec_nor(vector bool long long __a, vector bool long long __b) {
6804   return ~(__a | __b);
6805 }
6806 #endif
6807
6808 /* vec_or */
6809
6810 #define __builtin_altivec_vor vec_or
6811
6812 static __inline__ vector signed char __ATTRS_o_ai
6813 vec_or(vector signed char __a, vector signed char __b) {
6814   return __a | __b;
6815 }
6816
6817 static __inline__ vector signed char __ATTRS_o_ai
6818 vec_or(vector bool char __a, vector signed char __b) {
6819   return (vector signed char)__a | __b;
6820 }
6821
6822 static __inline__ vector signed char __ATTRS_o_ai vec_or(vector signed char __a,
6823                                                          vector bool char __b) {
6824   return __a | (vector signed char)__b;
6825 }
6826
6827 static __inline__ vector unsigned char __ATTRS_o_ai
6828 vec_or(vector unsigned char __a, vector unsigned char __b) {
6829   return __a | __b;
6830 }
6831
6832 static __inline__ vector unsigned char __ATTRS_o_ai
6833 vec_or(vector bool char __a, vector unsigned char __b) {
6834   return (vector unsigned char)__a | __b;
6835 }
6836
6837 static __inline__ vector unsigned char __ATTRS_o_ai
6838 vec_or(vector unsigned char __a, vector bool char __b) {
6839   return __a | (vector unsigned char)__b;
6840 }
6841
6842 static __inline__ vector bool char __ATTRS_o_ai vec_or(vector bool char __a,
6843                                                        vector bool char __b) {
6844   return __a | __b;
6845 }
6846
6847 static __inline__ vector short __ATTRS_o_ai vec_or(vector short __a,
6848                                                    vector short __b) {
6849   return __a | __b;
6850 }
6851
6852 static __inline__ vector short __ATTRS_o_ai vec_or(vector bool short __a,
6853                                                    vector short __b) {
6854   return (vector short)__a | __b;
6855 }
6856
6857 static __inline__ vector short __ATTRS_o_ai vec_or(vector short __a,
6858                                                    vector bool short __b) {
6859   return __a | (vector short)__b;
6860 }
6861
6862 static __inline__ vector unsigned short __ATTRS_o_ai
6863 vec_or(vector unsigned short __a, vector unsigned short __b) {
6864   return __a | __b;
6865 }
6866
6867 static __inline__ vector unsigned short __ATTRS_o_ai
6868 vec_or(vector bool short __a, vector unsigned short __b) {
6869   return (vector unsigned short)__a | __b;
6870 }
6871
6872 static __inline__ vector unsigned short __ATTRS_o_ai
6873 vec_or(vector unsigned short __a, vector bool short __b) {
6874   return __a | (vector unsigned short)__b;
6875 }
6876
6877 static __inline__ vector bool short __ATTRS_o_ai vec_or(vector bool short __a,
6878                                                         vector bool short __b) {
6879   return __a | __b;
6880 }
6881
6882 static __inline__ vector int __ATTRS_o_ai vec_or(vector int __a,
6883                                                  vector int __b) {
6884   return __a | __b;
6885 }
6886
6887 static __inline__ vector int __ATTRS_o_ai vec_or(vector bool int __a,
6888                                                  vector int __b) {
6889   return (vector int)__a | __b;
6890 }
6891
6892 static __inline__ vector int __ATTRS_o_ai vec_or(vector int __a,
6893                                                  vector bool int __b) {
6894   return __a | (vector int)__b;
6895 }
6896
6897 static __inline__ vector unsigned int __ATTRS_o_ai
6898 vec_or(vector unsigned int __a, vector unsigned int __b) {
6899   return __a | __b;
6900 }
6901
6902 static __inline__ vector unsigned int __ATTRS_o_ai
6903 vec_or(vector bool int __a, vector unsigned int __b) {
6904   return (vector unsigned int)__a | __b;
6905 }
6906
6907 static __inline__ vector unsigned int __ATTRS_o_ai
6908 vec_or(vector unsigned int __a, vector bool int __b) {
6909   return __a | (vector unsigned int)__b;
6910 }
6911
6912 static __inline__ vector bool int __ATTRS_o_ai vec_or(vector bool int __a,
6913                                                       vector bool int __b) {
6914   return __a | __b;
6915 }
6916
6917 static __inline__ vector float __ATTRS_o_ai vec_or(vector float __a,
6918                                                    vector float __b) {
6919   vector unsigned int __res =
6920       (vector unsigned int)__a | (vector unsigned int)__b;
6921   return (vector float)__res;
6922 }
6923
6924 static __inline__ vector float __ATTRS_o_ai vec_or(vector bool int __a,
6925                                                    vector float __b) {
6926   vector unsigned int __res =
6927       (vector unsigned int)__a | (vector unsigned int)__b;
6928   return (vector float)__res;
6929 }
6930
6931 static __inline__ vector float __ATTRS_o_ai vec_or(vector float __a,
6932                                                    vector bool int __b) {
6933   vector unsigned int __res =
6934       (vector unsigned int)__a | (vector unsigned int)__b;
6935   return (vector float)__res;
6936 }
6937
6938 #ifdef __VSX__
6939 static __inline__ vector double __ATTRS_o_ai vec_or(vector bool long long __a,
6940                                                     vector double __b) {
6941   return (vector double)((vector unsigned long long)__a |
6942                          (vector unsigned long long)__b);
6943 }
6944
6945 static __inline__ vector double __ATTRS_o_ai vec_or(vector double __a,
6946                                                     vector bool long long __b) {
6947   return (vector double)((vector unsigned long long)__a |
6948                          (vector unsigned long long)__b);
6949 }
6950
6951 static __inline__ vector double __ATTRS_o_ai vec_or(vector double __a,
6952                                                     vector double __b) {
6953   return (vector double)((vector unsigned long long)__a |
6954                          (vector unsigned long long)__b);
6955 }
6956
6957 static __inline__ vector signed long long __ATTRS_o_ai
6958 vec_or(vector signed long long __a, vector signed long long __b) {
6959   return __a | __b;
6960 }
6961
6962 static __inline__ vector signed long long __ATTRS_o_ai
6963 vec_or(vector bool long long __a, vector signed long long __b) {
6964   return (vector signed long long)__a | __b;
6965 }
6966
6967 static __inline__ vector signed long long __ATTRS_o_ai
6968 vec_or(vector signed long long __a, vector bool long long __b) {
6969   return __a | (vector signed long long)__b;
6970 }
6971
6972 static __inline__ vector unsigned long long __ATTRS_o_ai
6973 vec_or(vector unsigned long long __a, vector unsigned long long __b) {
6974   return __a | __b;
6975 }
6976
6977 static __inline__ vector unsigned long long __ATTRS_o_ai
6978 vec_or(vector bool long long __a, vector unsigned long long __b) {
6979   return (vector unsigned long long)__a | __b;
6980 }
6981
6982 static __inline__ vector unsigned long long __ATTRS_o_ai
6983 vec_or(vector unsigned long long __a, vector bool long long __b) {
6984   return __a | (vector unsigned long long)__b;
6985 }
6986
6987 static __inline__ vector bool long long __ATTRS_o_ai
6988 vec_or(vector bool long long __a, vector bool long long __b) {
6989   return __a | __b;
6990 }
6991 #endif
6992
6993 #ifdef __POWER8_VECTOR__
6994 static __inline__ vector signed char __ATTRS_o_ai
6995 vec_orc(vector signed char __a, vector signed char __b) {
6996   return __a | ~__b;
6997 }
6998
6999 static __inline__ vector signed char __ATTRS_o_ai
7000 vec_orc(vector signed char __a, vector bool char __b) {
7001   return __a | ~__b;
7002 }
7003
7004 static __inline__ vector signed char __ATTRS_o_ai
7005 vec_orc(vector bool char __a, vector signed char __b) {
7006   return __a | ~__b;
7007 }
7008
7009 static __inline__ vector unsigned char __ATTRS_o_ai
7010 vec_orc(vector unsigned char __a, vector unsigned char __b) {
7011   return __a | ~__b;
7012 }
7013
7014 static __inline__ vector unsigned char __ATTRS_o_ai
7015 vec_orc(vector unsigned char __a, vector bool char __b) {
7016   return __a | ~__b;
7017 }
7018
7019 static __inline__ vector unsigned char __ATTRS_o_ai
7020 vec_orc(vector bool char __a, vector unsigned char __b) {
7021   return __a | ~__b;
7022 }
7023
7024 static __inline__ vector bool char __ATTRS_o_ai vec_orc(vector bool char __a,
7025                                                         vector bool char __b) {
7026   return __a | ~__b;
7027 }
7028
7029 static __inline__ vector signed short __ATTRS_o_ai
7030 vec_orc(vector signed short __a, vector signed short __b) {
7031   return __a | ~__b;
7032 }
7033
7034 static __inline__ vector signed short __ATTRS_o_ai
7035 vec_orc(vector signed short __a, vector bool short __b) {
7036   return __a | ~__b;
7037 }
7038
7039 static __inline__ vector signed short __ATTRS_o_ai
7040 vec_orc(vector bool short __a, vector signed short __b) {
7041   return __a | ~__b;
7042 }
7043
7044 static __inline__ vector unsigned short __ATTRS_o_ai
7045 vec_orc(vector unsigned short __a, vector unsigned short __b) {
7046   return __a | ~__b;
7047 }
7048
7049 static __inline__ vector unsigned short __ATTRS_o_ai
7050 vec_orc(vector unsigned short __a, vector bool short __b) {
7051   return __a | ~__b;
7052 }
7053
7054 static __inline__ vector unsigned short __ATTRS_o_ai
7055 vec_orc(vector bool short __a, vector unsigned short __b) {
7056   return __a | ~__b;
7057 }
7058
7059 static __inline__ vector bool short __ATTRS_o_ai
7060 vec_orc(vector bool short __a, vector bool short __b) {
7061   return __a | ~__b;
7062 }
7063
7064 static __inline__ vector signed int __ATTRS_o_ai
7065 vec_orc(vector signed int __a, vector signed int __b) {
7066   return __a | ~__b;
7067 }
7068
7069 static __inline__ vector signed int __ATTRS_o_ai vec_orc(vector signed int __a,
7070                                                          vector bool int __b) {
7071   return __a | ~__b;
7072 }
7073
7074 static __inline__ vector signed int __ATTRS_o_ai
7075 vec_orc(vector bool int __a, vector signed int __b) {
7076   return __a | ~__b;
7077 }
7078
7079 static __inline__ vector unsigned int __ATTRS_o_ai
7080 vec_orc(vector unsigned int __a, vector unsigned int __b) {
7081   return __a | ~__b;
7082 }
7083
7084 static __inline__ vector unsigned int __ATTRS_o_ai
7085 vec_orc(vector unsigned int __a, vector bool int __b) {
7086   return __a | ~__b;
7087 }
7088
7089 static __inline__ vector unsigned int __ATTRS_o_ai
7090 vec_orc(vector bool int __a, vector unsigned int __b) {
7091   return __a | ~__b;
7092 }
7093
7094 static __inline__ vector bool int __ATTRS_o_ai vec_orc(vector bool int __a,
7095                                                        vector bool int __b) {
7096   return __a | ~__b;
7097 }
7098
7099 static __inline__ vector float __ATTRS_o_ai
7100 vec_orc(vector bool int __a, vector float __b) {
7101  return (vector float)(__a | ~(vector unsigned int)__b);
7102 }
7103
7104 static __inline__ vector float __ATTRS_o_ai
7105 vec_orc(vector float __a, vector bool int __b) {
7106   return (vector float)((vector unsigned int)__a | ~__b);
7107 }
7108
7109 static __inline__ vector signed long long __ATTRS_o_ai
7110 vec_orc(vector signed long long __a, vector signed long long __b) {
7111   return __a | ~__b;
7112 }
7113
7114 static __inline__ vector signed long long __ATTRS_o_ai
7115 vec_orc(vector signed long long __a, vector bool long long __b) {
7116   return __a | ~__b;
7117 }
7118
7119 static __inline__ vector signed long long __ATTRS_o_ai
7120 vec_orc(vector bool long long __a, vector signed long long __b) {
7121   return __a | ~__b;
7122 }
7123
7124 static __inline__ vector unsigned long long __ATTRS_o_ai
7125 vec_orc(vector unsigned long long __a, vector unsigned long long __b) {
7126   return __a | ~__b;
7127 }
7128
7129 static __inline__ vector unsigned long long __ATTRS_o_ai
7130 vec_orc(vector unsigned long long __a, vector bool long long __b) {
7131   return __a | ~__b;
7132 }
7133
7134 static __inline__ vector unsigned long long __ATTRS_o_ai
7135 vec_orc(vector bool long long __a, vector unsigned long long __b) {
7136   return __a | ~__b;
7137 }
7138
7139 static __inline__ vector bool long long __ATTRS_o_ai
7140 vec_orc(vector bool long long __a, vector bool long long __b) {
7141   return __a | ~__b;
7142 }
7143
7144 static __inline__ vector double __ATTRS_o_ai
7145 vec_orc(vector double __a, vector bool long long __b) {
7146   return (vector double)((vector unsigned long long)__a | ~__b);
7147 }
7148
7149 static __inline__ vector double __ATTRS_o_ai
7150 vec_orc(vector bool long long __a, vector double __b) {
7151   return (vector double)(__a | ~(vector unsigned long long)__b);
7152 }
7153 #endif
7154
7155 /* vec_vor */
7156
7157 static __inline__ vector signed char __ATTRS_o_ai
7158 vec_vor(vector signed char __a, vector signed char __b) {
7159   return __a | __b;
7160 }
7161
7162 static __inline__ vector signed char __ATTRS_o_ai
7163 vec_vor(vector bool char __a, vector signed char __b) {
7164   return (vector signed char)__a | __b;
7165 }
7166
7167 static __inline__ vector signed char __ATTRS_o_ai
7168 vec_vor(vector signed char __a, vector bool char __b) {
7169   return __a | (vector signed char)__b;
7170 }
7171
7172 static __inline__ vector unsigned char __ATTRS_o_ai
7173 vec_vor(vector unsigned char __a, vector unsigned char __b) {
7174   return __a | __b;
7175 }
7176
7177 static __inline__ vector unsigned char __ATTRS_o_ai
7178 vec_vor(vector bool char __a, vector unsigned char __b) {
7179   return (vector unsigned char)__a | __b;
7180 }
7181
7182 static __inline__ vector unsigned char __ATTRS_o_ai
7183 vec_vor(vector unsigned char __a, vector bool char __b) {
7184   return __a | (vector unsigned char)__b;
7185 }
7186
7187 static __inline__ vector bool char __ATTRS_o_ai vec_vor(vector bool char __a,
7188                                                         vector bool char __b) {
7189   return __a | __b;
7190 }
7191
7192 static __inline__ vector short __ATTRS_o_ai vec_vor(vector short __a,
7193                                                     vector short __b) {
7194   return __a | __b;
7195 }
7196
7197 static __inline__ vector short __ATTRS_o_ai vec_vor(vector bool short __a,
7198                                                     vector short __b) {
7199   return (vector short)__a | __b;
7200 }
7201
7202 static __inline__ vector short __ATTRS_o_ai vec_vor(vector short __a,
7203                                                     vector bool short __b) {
7204   return __a | (vector short)__b;
7205 }
7206
7207 static __inline__ vector unsigned short __ATTRS_o_ai
7208 vec_vor(vector unsigned short __a, vector unsigned short __b) {
7209   return __a | __b;
7210 }
7211
7212 static __inline__ vector unsigned short __ATTRS_o_ai
7213 vec_vor(vector bool short __a, vector unsigned short __b) {
7214   return (vector unsigned short)__a | __b;
7215 }
7216
7217 static __inline__ vector unsigned short __ATTRS_o_ai
7218 vec_vor(vector unsigned short __a, vector bool short __b) {
7219   return __a | (vector unsigned short)__b;
7220 }
7221
7222 static __inline__ vector bool short __ATTRS_o_ai
7223 vec_vor(vector bool short __a, vector bool short __b) {
7224   return __a | __b;
7225 }
7226
7227 static __inline__ vector int __ATTRS_o_ai vec_vor(vector int __a,
7228                                                   vector int __b) {
7229   return __a | __b;
7230 }
7231
7232 static __inline__ vector int __ATTRS_o_ai vec_vor(vector bool int __a,
7233                                                   vector int __b) {
7234   return (vector int)__a | __b;
7235 }
7236
7237 static __inline__ vector int __ATTRS_o_ai vec_vor(vector int __a,
7238                                                   vector bool int __b) {
7239   return __a | (vector int)__b;
7240 }
7241
7242 static __inline__ vector unsigned int __ATTRS_o_ai
7243 vec_vor(vector unsigned int __a, vector unsigned int __b) {
7244   return __a | __b;
7245 }
7246
7247 static __inline__ vector unsigned int __ATTRS_o_ai
7248 vec_vor(vector bool int __a, vector unsigned int __b) {
7249   return (vector unsigned int)__a | __b;
7250 }
7251
7252 static __inline__ vector unsigned int __ATTRS_o_ai
7253 vec_vor(vector unsigned int __a, vector bool int __b) {
7254   return __a | (vector unsigned int)__b;
7255 }
7256
7257 static __inline__ vector bool int __ATTRS_o_ai vec_vor(vector bool int __a,
7258                                                        vector bool int __b) {
7259   return __a | __b;
7260 }
7261
7262 static __inline__ vector float __ATTRS_o_ai vec_vor(vector float __a,
7263                                                     vector float __b) {
7264   vector unsigned int __res =
7265       (vector unsigned int)__a | (vector unsigned int)__b;
7266   return (vector float)__res;
7267 }
7268
7269 static __inline__ vector float __ATTRS_o_ai vec_vor(vector bool int __a,
7270                                                     vector float __b) {
7271   vector unsigned int __res =
7272       (vector unsigned int)__a | (vector unsigned int)__b;
7273   return (vector float)__res;
7274 }
7275
7276 static __inline__ vector float __ATTRS_o_ai vec_vor(vector float __a,
7277                                                     vector bool int __b) {
7278   vector unsigned int __res =
7279       (vector unsigned int)__a | (vector unsigned int)__b;
7280   return (vector float)__res;
7281 }
7282
7283 #ifdef __VSX__
7284 static __inline__ vector signed long long __ATTRS_o_ai
7285 vec_vor(vector signed long long __a, vector signed long long __b) {
7286   return __a | __b;
7287 }
7288
7289 static __inline__ vector signed long long __ATTRS_o_ai
7290 vec_vor(vector bool long long __a, vector signed long long __b) {
7291   return (vector signed long long)__a | __b;
7292 }
7293
7294 static __inline__ vector signed long long __ATTRS_o_ai
7295 vec_vor(vector signed long long __a, vector bool long long __b) {
7296   return __a | (vector signed long long)__b;
7297 }
7298
7299 static __inline__ vector unsigned long long __ATTRS_o_ai
7300 vec_vor(vector unsigned long long __a, vector unsigned long long __b) {
7301   return __a | __b;
7302 }
7303
7304 static __inline__ vector unsigned long long __ATTRS_o_ai
7305 vec_vor(vector bool long long __a, vector unsigned long long __b) {
7306   return (vector unsigned long long)__a | __b;
7307 }
7308
7309 static __inline__ vector unsigned long long __ATTRS_o_ai
7310 vec_vor(vector unsigned long long __a, vector bool long long __b) {
7311   return __a | (vector unsigned long long)__b;
7312 }
7313
7314 static __inline__ vector bool long long __ATTRS_o_ai
7315 vec_vor(vector bool long long __a, vector bool long long __b) {
7316   return __a | __b;
7317 }
7318 #endif
7319
7320 /* vec_pack */
7321
7322 /* The various vector pack instructions have a big-endian bias, so for
7323    little endian we must handle reversed element numbering.  */
7324
7325 static __inline__ vector signed char __ATTRS_o_ai
7326 vec_pack(vector signed short __a, vector signed short __b) {
7327 #ifdef __LITTLE_ENDIAN__
7328   return (vector signed char)vec_perm(
7329       __a, __b,
7330       (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
7331                              0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
7332 #else
7333   return (vector signed char)vec_perm(
7334       __a, __b,
7335       (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
7336                              0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
7337 #endif
7338 }
7339
7340 static __inline__ vector unsigned char __ATTRS_o_ai
7341 vec_pack(vector unsigned short __a, vector unsigned short __b) {
7342 #ifdef __LITTLE_ENDIAN__
7343   return (vector unsigned char)vec_perm(
7344       __a, __b,
7345       (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
7346                              0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
7347 #else
7348   return (vector unsigned char)vec_perm(
7349       __a, __b,
7350       (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
7351                              0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
7352 #endif
7353 }
7354
7355 static __inline__ vector bool char __ATTRS_o_ai
7356 vec_pack(vector bool short __a, vector bool short __b) {
7357 #ifdef __LITTLE_ENDIAN__
7358   return (vector bool char)vec_perm(
7359       __a, __b,
7360       (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
7361                              0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
7362 #else
7363   return (vector bool char)vec_perm(
7364       __a, __b,
7365       (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
7366                              0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
7367 #endif
7368 }
7369
7370 static __inline__ vector short __ATTRS_o_ai vec_pack(vector int __a,
7371                                                      vector int __b) {
7372 #ifdef __LITTLE_ENDIAN__
7373   return (vector short)vec_perm(
7374       __a, __b,
7375       (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
7376                              0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
7377 #else
7378   return (vector short)vec_perm(
7379       __a, __b,
7380       (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
7381                              0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
7382 #endif
7383 }
7384
7385 static __inline__ vector unsigned short __ATTRS_o_ai
7386 vec_pack(vector unsigned int __a, vector unsigned int __b) {
7387 #ifdef __LITTLE_ENDIAN__
7388   return (vector unsigned short)vec_perm(
7389       __a, __b,
7390       (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
7391                              0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
7392 #else
7393   return (vector unsigned short)vec_perm(
7394       __a, __b,
7395       (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
7396                              0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
7397 #endif
7398 }
7399
7400 static __inline__ vector bool short __ATTRS_o_ai vec_pack(vector bool int __a,
7401                                                           vector bool int __b) {
7402 #ifdef __LITTLE_ENDIAN__
7403   return (vector bool short)vec_perm(
7404       __a, __b,
7405       (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
7406                              0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
7407 #else
7408   return (vector bool short)vec_perm(
7409       __a, __b,
7410       (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
7411                              0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
7412 #endif
7413 }
7414
7415 #ifdef __VSX__
7416 static __inline__ vector signed int __ATTRS_o_ai
7417 vec_pack(vector signed long long __a, vector signed long long __b) {
7418 #ifdef __LITTLE_ENDIAN__
7419   return (vector signed int)vec_perm(
7420       __a, __b,
7421       (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
7422                              0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
7423 #else
7424   return (vector signed int)vec_perm(
7425       __a, __b,
7426       (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
7427                              0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
7428 #endif
7429 }
7430 static __inline__ vector unsigned int __ATTRS_o_ai
7431 vec_pack(vector unsigned long long __a, vector unsigned long long __b) {
7432 #ifdef __LITTLE_ENDIAN__
7433   return (vector unsigned int)vec_perm(
7434       __a, __b,
7435       (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
7436                              0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
7437 #else
7438   return (vector unsigned int)vec_perm(
7439       __a, __b,
7440       (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
7441                              0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
7442 #endif
7443 }
7444
7445 static __inline__ vector bool int __ATTRS_o_ai
7446 vec_pack(vector bool long long __a, vector bool long long __b) {
7447 #ifdef __LITTLE_ENDIAN__
7448   return (vector bool int)vec_perm(
7449       __a, __b,
7450       (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
7451                              0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
7452 #else
7453   return (vector bool int)vec_perm(
7454       __a, __b,
7455       (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
7456                              0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
7457 #endif
7458 }
7459
7460 static __inline__ vector float __ATTRS_o_ai
7461 vec_pack(vector double __a, vector double __b) {
7462   return (vector float) (__a[0], __a[1], __b[0], __b[1]);
7463 }
7464 #endif
7465
7466 #ifdef __POWER9_VECTOR__
7467 static __inline__ vector unsigned short __ATTRS_o_ai
7468 vec_pack_to_short_fp32(vector float __a, vector float __b) {
7469   vector float __resa = __builtin_vsx_xvcvsphp(__a);
7470   vector float __resb = __builtin_vsx_xvcvsphp(__b);
7471 #ifdef __LITTLE_ENDIAN__
7472   return (vector unsigned short)vec_mergee(__resa, __resb);
7473 #else
7474   return (vector unsigned short)vec_mergeo(__resa, __resb);
7475 #endif
7476 }
7477
7478 #endif
7479 /* vec_vpkuhum */
7480
7481 #define __builtin_altivec_vpkuhum vec_vpkuhum
7482
7483 static __inline__ vector signed char __ATTRS_o_ai
7484 vec_vpkuhum(vector signed short __a, vector signed short __b) {
7485 #ifdef __LITTLE_ENDIAN__
7486   return (vector signed char)vec_perm(
7487       __a, __b,
7488       (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
7489                              0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
7490 #else
7491   return (vector signed char)vec_perm(
7492       __a, __b,
7493       (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
7494                              0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
7495 #endif
7496 }
7497
7498 static __inline__ vector unsigned char __ATTRS_o_ai
7499 vec_vpkuhum(vector unsigned short __a, vector unsigned short __b) {
7500 #ifdef __LITTLE_ENDIAN__
7501   return (vector unsigned char)vec_perm(
7502       __a, __b,
7503       (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
7504                              0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
7505 #else
7506   return (vector unsigned char)vec_perm(
7507       __a, __b,
7508       (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
7509                              0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
7510 #endif
7511 }
7512
7513 static __inline__ vector bool char __ATTRS_o_ai
7514 vec_vpkuhum(vector bool short __a, vector bool short __b) {
7515 #ifdef __LITTLE_ENDIAN__
7516   return (vector bool char)vec_perm(
7517       __a, __b,
7518       (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
7519                              0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
7520 #else
7521   return (vector bool char)vec_perm(
7522       __a, __b,
7523       (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
7524                              0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
7525 #endif
7526 }
7527
7528 /* vec_vpkuwum */
7529
7530 #define __builtin_altivec_vpkuwum vec_vpkuwum
7531
7532 static __inline__ vector short __ATTRS_o_ai vec_vpkuwum(vector int __a,
7533                                                         vector int __b) {
7534 #ifdef __LITTLE_ENDIAN__
7535   return (vector short)vec_perm(
7536       __a, __b,
7537       (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
7538                              0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
7539 #else
7540   return (vector short)vec_perm(
7541       __a, __b,
7542       (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
7543                              0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
7544 #endif
7545 }
7546
7547 static __inline__ vector unsigned short __ATTRS_o_ai
7548 vec_vpkuwum(vector unsigned int __a, vector unsigned int __b) {
7549 #ifdef __LITTLE_ENDIAN__
7550   return (vector unsigned short)vec_perm(
7551       __a, __b,
7552       (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
7553                              0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
7554 #else
7555   return (vector unsigned short)vec_perm(
7556       __a, __b,
7557       (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
7558                              0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
7559 #endif
7560 }
7561
7562 static __inline__ vector bool short __ATTRS_o_ai
7563 vec_vpkuwum(vector bool int __a, vector bool int __b) {
7564 #ifdef __LITTLE_ENDIAN__
7565   return (vector bool short)vec_perm(
7566       __a, __b,
7567       (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
7568                              0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
7569 #else
7570   return (vector bool short)vec_perm(
7571       __a, __b,
7572       (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
7573                              0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
7574 #endif
7575 }
7576
7577 /* vec_vpkudum */
7578
7579 #ifdef __POWER8_VECTOR__
7580 #define __builtin_altivec_vpkudum vec_vpkudum
7581
7582 static __inline__ vector int __ATTRS_o_ai vec_vpkudum(vector long long __a,
7583                                                       vector long long __b) {
7584 #ifdef __LITTLE_ENDIAN__
7585   return (vector int)vec_perm(
7586       __a, __b,
7587       (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
7588                              0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
7589 #else
7590   return (vector int)vec_perm(
7591       __a, __b,
7592       (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
7593                              0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
7594 #endif
7595 }
7596
7597 static __inline__ vector unsigned int __ATTRS_o_ai
7598 vec_vpkudum(vector unsigned long long __a, vector unsigned long long __b) {
7599 #ifdef __LITTLE_ENDIAN__
7600   return (vector unsigned int)vec_perm(
7601       __a, __b,
7602       (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
7603                              0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
7604 #else
7605   return (vector unsigned int)vec_perm(
7606       __a, __b,
7607       (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
7608                              0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
7609 #endif
7610 }
7611
7612 static __inline__ vector bool int __ATTRS_o_ai
7613 vec_vpkudum(vector bool long long __a, vector bool long long __b) {
7614 #ifdef __LITTLE_ENDIAN__
7615   return (vector bool int)vec_perm(
7616       (vector long long)__a, (vector long long)__b,
7617       (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
7618                              0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
7619 #else
7620   return (vector bool int)vec_perm(
7621       (vector long long)__a, (vector long long)__b,
7622       (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
7623                              0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
7624 #endif
7625 }
7626 #endif
7627
7628 /* vec_packpx */
7629
7630 static __inline__ vector pixel __attribute__((__always_inline__))
7631 vec_packpx(vector unsigned int __a, vector unsigned int __b) {
7632 #ifdef __LITTLE_ENDIAN__
7633   return (vector pixel)__builtin_altivec_vpkpx(__b, __a);
7634 #else
7635   return (vector pixel)__builtin_altivec_vpkpx(__a, __b);
7636 #endif
7637 }
7638
7639 /* vec_vpkpx */
7640
7641 static __inline__ vector pixel __attribute__((__always_inline__))
7642 vec_vpkpx(vector unsigned int __a, vector unsigned int __b) {
7643 #ifdef __LITTLE_ENDIAN__
7644   return (vector pixel)__builtin_altivec_vpkpx(__b, __a);
7645 #else
7646   return (vector pixel)__builtin_altivec_vpkpx(__a, __b);
7647 #endif
7648 }
7649
7650 /* vec_packs */
7651
7652 static __inline__ vector signed char __ATTRS_o_ai vec_packs(vector short __a,
7653                                                             vector short __b) {
7654 #ifdef __LITTLE_ENDIAN__
7655   return __builtin_altivec_vpkshss(__b, __a);
7656 #else
7657   return __builtin_altivec_vpkshss(__a, __b);
7658 #endif
7659 }
7660
7661 static __inline__ vector unsigned char __ATTRS_o_ai
7662 vec_packs(vector unsigned short __a, vector unsigned short __b) {
7663 #ifdef __LITTLE_ENDIAN__
7664   return __builtin_altivec_vpkuhus(__b, __a);
7665 #else
7666   return __builtin_altivec_vpkuhus(__a, __b);
7667 #endif
7668 }
7669
7670 static __inline__ vector signed short __ATTRS_o_ai vec_packs(vector int __a,
7671                                                              vector int __b) {
7672 #ifdef __LITTLE_ENDIAN__
7673   return __builtin_altivec_vpkswss(__b, __a);
7674 #else
7675   return __builtin_altivec_vpkswss(__a, __b);
7676 #endif
7677 }
7678
7679 static __inline__ vector unsigned short __ATTRS_o_ai
7680 vec_packs(vector unsigned int __a, vector unsigned int __b) {
7681 #ifdef __LITTLE_ENDIAN__
7682   return __builtin_altivec_vpkuwus(__b, __a);
7683 #else
7684   return __builtin_altivec_vpkuwus(__a, __b);
7685 #endif
7686 }
7687
7688 #ifdef __POWER8_VECTOR__
7689 static __inline__ vector int __ATTRS_o_ai vec_packs(vector long long __a,
7690                                                     vector long long __b) {
7691 #ifdef __LITTLE_ENDIAN__
7692   return __builtin_altivec_vpksdss(__b, __a);
7693 #else
7694   return __builtin_altivec_vpksdss(__a, __b);
7695 #endif
7696 }
7697
7698 static __inline__ vector unsigned int __ATTRS_o_ai
7699 vec_packs(vector unsigned long long __a, vector unsigned long long __b) {
7700 #ifdef __LITTLE_ENDIAN__
7701   return __builtin_altivec_vpkudus(__b, __a);
7702 #else
7703   return __builtin_altivec_vpkudus(__a, __b);
7704 #endif
7705 }
7706 #endif
7707
7708 /* vec_vpkshss */
7709
7710 static __inline__ vector signed char __attribute__((__always_inline__))
7711 vec_vpkshss(vector short __a, vector short __b) {
7712 #ifdef __LITTLE_ENDIAN__
7713   return __builtin_altivec_vpkshss(__b, __a);
7714 #else
7715   return __builtin_altivec_vpkshss(__a, __b);
7716 #endif
7717 }
7718
7719 /* vec_vpksdss */
7720
7721 #ifdef __POWER8_VECTOR__
7722 static __inline__ vector int __ATTRS_o_ai vec_vpksdss(vector long long __a,
7723                                                       vector long long __b) {
7724 #ifdef __LITTLE_ENDIAN__
7725   return __builtin_altivec_vpksdss(__b, __a);
7726 #else
7727   return __builtin_altivec_vpksdss(__a, __b);
7728 #endif
7729 }
7730 #endif
7731
7732 /* vec_vpkuhus */
7733
7734 static __inline__ vector unsigned char __attribute__((__always_inline__))
7735 vec_vpkuhus(vector unsigned short __a, vector unsigned short __b) {
7736 #ifdef __LITTLE_ENDIAN__
7737   return __builtin_altivec_vpkuhus(__b, __a);
7738 #else
7739   return __builtin_altivec_vpkuhus(__a, __b);
7740 #endif
7741 }
7742
7743 /* vec_vpkudus */
7744
7745 #ifdef __POWER8_VECTOR__
7746 static __inline__ vector unsigned int __attribute__((__always_inline__))
7747 vec_vpkudus(vector unsigned long long __a, vector unsigned long long __b) {
7748 #ifdef __LITTLE_ENDIAN__
7749   return __builtin_altivec_vpkudus(__b, __a);
7750 #else
7751   return __builtin_altivec_vpkudus(__a, __b);
7752 #endif
7753 }
7754 #endif
7755
7756 /* vec_vpkswss */
7757
7758 static __inline__ vector signed short __attribute__((__always_inline__))
7759 vec_vpkswss(vector int __a, vector int __b) {
7760 #ifdef __LITTLE_ENDIAN__
7761   return __builtin_altivec_vpkswss(__b, __a);
7762 #else
7763   return __builtin_altivec_vpkswss(__a, __b);
7764 #endif
7765 }
7766
7767 /* vec_vpkuwus */
7768
7769 static __inline__ vector unsigned short __attribute__((__always_inline__))
7770 vec_vpkuwus(vector unsigned int __a, vector unsigned int __b) {
7771 #ifdef __LITTLE_ENDIAN__
7772   return __builtin_altivec_vpkuwus(__b, __a);
7773 #else
7774   return __builtin_altivec_vpkuwus(__a, __b);
7775 #endif
7776 }
7777
7778 /* vec_packsu */
7779
7780 static __inline__ vector unsigned char __ATTRS_o_ai
7781 vec_packsu(vector short __a, vector short __b) {
7782 #ifdef __LITTLE_ENDIAN__
7783   return __builtin_altivec_vpkshus(__b, __a);
7784 #else
7785   return __builtin_altivec_vpkshus(__a, __b);
7786 #endif
7787 }
7788
7789 static __inline__ vector unsigned char __ATTRS_o_ai
7790 vec_packsu(vector unsigned short __a, vector unsigned short __b) {
7791 #ifdef __LITTLE_ENDIAN__
7792   return __builtin_altivec_vpkuhus(__b, __a);
7793 #else
7794   return __builtin_altivec_vpkuhus(__a, __b);
7795 #endif
7796 }
7797
7798 static __inline__ vector unsigned short __ATTRS_o_ai
7799 vec_packsu(vector int __a, vector int __b) {
7800 #ifdef __LITTLE_ENDIAN__
7801   return __builtin_altivec_vpkswus(__b, __a);
7802 #else
7803   return __builtin_altivec_vpkswus(__a, __b);
7804 #endif
7805 }
7806
7807 static __inline__ vector unsigned short __ATTRS_o_ai
7808 vec_packsu(vector unsigned int __a, vector unsigned int __b) {
7809 #ifdef __LITTLE_ENDIAN__
7810   return __builtin_altivec_vpkuwus(__b, __a);
7811 #else
7812   return __builtin_altivec_vpkuwus(__a, __b);
7813 #endif
7814 }
7815
7816 #ifdef __POWER8_VECTOR__
7817 static __inline__ vector unsigned int __ATTRS_o_ai
7818 vec_packsu(vector long long __a, vector long long __b) {
7819 #ifdef __LITTLE_ENDIAN__
7820   return __builtin_altivec_vpksdus(__b, __a);
7821 #else
7822   return __builtin_altivec_vpksdus(__a, __b);
7823 #endif
7824 }
7825
7826 static __inline__ vector unsigned int __ATTRS_o_ai
7827 vec_packsu(vector unsigned long long __a, vector unsigned long long __b) {
7828 #ifdef __LITTLE_ENDIAN__
7829   return __builtin_altivec_vpkudus(__b, __a);
7830 #else
7831   return __builtin_altivec_vpkudus(__a, __b);
7832 #endif
7833 }
7834 #endif
7835
7836 /* vec_vpkshus */
7837
7838 static __inline__ vector unsigned char __ATTRS_o_ai
7839 vec_vpkshus(vector short __a, vector short __b) {
7840 #ifdef __LITTLE_ENDIAN__
7841   return __builtin_altivec_vpkshus(__b, __a);
7842 #else
7843   return __builtin_altivec_vpkshus(__a, __b);
7844 #endif
7845 }
7846
7847 static __inline__ vector unsigned char __ATTRS_o_ai
7848 vec_vpkshus(vector unsigned short __a, vector unsigned short __b) {
7849 #ifdef __LITTLE_ENDIAN__
7850   return __builtin_altivec_vpkuhus(__b, __a);
7851 #else
7852   return __builtin_altivec_vpkuhus(__a, __b);
7853 #endif
7854 }
7855
7856 /* vec_vpkswus */
7857
7858 static __inline__ vector unsigned short __ATTRS_o_ai
7859 vec_vpkswus(vector int __a, vector int __b) {
7860 #ifdef __LITTLE_ENDIAN__
7861   return __builtin_altivec_vpkswus(__b, __a);
7862 #else
7863   return __builtin_altivec_vpkswus(__a, __b);
7864 #endif
7865 }
7866
7867 static __inline__ vector unsigned short __ATTRS_o_ai
7868 vec_vpkswus(vector unsigned int __a, vector unsigned int __b) {
7869 #ifdef __LITTLE_ENDIAN__
7870   return __builtin_altivec_vpkuwus(__b, __a);
7871 #else
7872   return __builtin_altivec_vpkuwus(__a, __b);
7873 #endif
7874 }
7875
7876 /* vec_vpksdus */
7877
7878 #ifdef __POWER8_VECTOR__
7879 static __inline__ vector unsigned int __ATTRS_o_ai
7880 vec_vpksdus(vector long long __a, vector long long __b) {
7881 #ifdef __LITTLE_ENDIAN__
7882   return __builtin_altivec_vpksdus(__b, __a);
7883 #else
7884   return __builtin_altivec_vpksdus(__a, __b);
7885 #endif
7886 }
7887 #endif
7888
7889 /* vec_perm */
7890
7891 // The vperm instruction is defined architecturally with a big-endian bias.
7892 // For little endian, we swap the input operands and invert the permute
7893 // control vector.  Only the rightmost 5 bits matter, so we could use
7894 // a vector of all 31s instead of all 255s to perform the inversion.
7895 // However, when the PCV is not a constant, using 255 has an advantage
7896 // in that the vec_xor can be recognized as a vec_nor (and for P8 and
7897 // later, possibly a vec_nand).
7898
7899 static __inline__ vector signed char __ATTRS_o_ai vec_perm(
7900     vector signed char __a, vector signed char __b, vector unsigned char __c) {
7901 #ifdef __LITTLE_ENDIAN__
7902   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7903                               255, 255, 255, 255, 255, 255, 255, 255};
7904   __d = vec_xor(__c, __d);
7905   return (vector signed char)__builtin_altivec_vperm_4si((vector int)__b,
7906                                                          (vector int)__a, __d);
7907 #else
7908   return (vector signed char)__builtin_altivec_vperm_4si((vector int)__a,
7909                                                          (vector int)__b, __c);
7910 #endif
7911 }
7912
7913 static __inline__ vector unsigned char __ATTRS_o_ai
7914 vec_perm(vector unsigned char __a, vector unsigned char __b,
7915          vector unsigned char __c) {
7916 #ifdef __LITTLE_ENDIAN__
7917   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7918                               255, 255, 255, 255, 255, 255, 255, 255};
7919   __d = vec_xor(__c, __d);
7920   return (vector unsigned char)__builtin_altivec_vperm_4si(
7921       (vector int)__b, (vector int)__a, __d);
7922 #else
7923   return (vector unsigned char)__builtin_altivec_vperm_4si(
7924       (vector int)__a, (vector int)__b, __c);
7925 #endif
7926 }
7927
7928 static __inline__ vector bool char __ATTRS_o_ai
7929 vec_perm(vector bool char __a, vector bool char __b, vector unsigned char __c) {
7930 #ifdef __LITTLE_ENDIAN__
7931   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7932                               255, 255, 255, 255, 255, 255, 255, 255};
7933   __d = vec_xor(__c, __d);
7934   return (vector bool char)__builtin_altivec_vperm_4si((vector int)__b,
7935                                                        (vector int)__a, __d);
7936 #else
7937   return (vector bool char)__builtin_altivec_vperm_4si((vector int)__a,
7938                                                        (vector int)__b, __c);
7939 #endif
7940 }
7941
7942 static __inline__ vector short __ATTRS_o_ai vec_perm(vector signed short __a,
7943                                                      vector signed short __b,
7944                                                      vector unsigned char __c) {
7945 #ifdef __LITTLE_ENDIAN__
7946   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7947                               255, 255, 255, 255, 255, 255, 255, 255};
7948   __d = vec_xor(__c, __d);
7949   return (vector signed short)__builtin_altivec_vperm_4si((vector int)__b,
7950                                                           (vector int)__a, __d);
7951 #else
7952   return (vector signed short)__builtin_altivec_vperm_4si((vector int)__a,
7953                                                           (vector int)__b, __c);
7954 #endif
7955 }
7956
7957 static __inline__ vector unsigned short __ATTRS_o_ai
7958 vec_perm(vector unsigned short __a, vector unsigned short __b,
7959          vector unsigned char __c) {
7960 #ifdef __LITTLE_ENDIAN__
7961   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7962                               255, 255, 255, 255, 255, 255, 255, 255};
7963   __d = vec_xor(__c, __d);
7964   return (vector unsigned short)__builtin_altivec_vperm_4si(
7965       (vector int)__b, (vector int)__a, __d);
7966 #else
7967   return (vector unsigned short)__builtin_altivec_vperm_4si(
7968       (vector int)__a, (vector int)__b, __c);
7969 #endif
7970 }
7971
7972 static __inline__ vector bool short __ATTRS_o_ai vec_perm(
7973     vector bool short __a, vector bool short __b, vector unsigned char __c) {
7974 #ifdef __LITTLE_ENDIAN__
7975   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7976                               255, 255, 255, 255, 255, 255, 255, 255};
7977   __d = vec_xor(__c, __d);
7978   return (vector bool short)__builtin_altivec_vperm_4si((vector int)__b,
7979                                                         (vector int)__a, __d);
7980 #else
7981   return (vector bool short)__builtin_altivec_vperm_4si((vector int)__a,
7982                                                         (vector int)__b, __c);
7983 #endif
7984 }
7985
7986 static __inline__ vector pixel __ATTRS_o_ai vec_perm(vector pixel __a,
7987                                                      vector pixel __b,
7988                                                      vector unsigned char __c) {
7989 #ifdef __LITTLE_ENDIAN__
7990   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7991                               255, 255, 255, 255, 255, 255, 255, 255};
7992   __d = vec_xor(__c, __d);
7993   return (vector pixel)__builtin_altivec_vperm_4si((vector int)__b,
7994                                                    (vector int)__a, __d);
7995 #else
7996   return (vector pixel)__builtin_altivec_vperm_4si((vector int)__a,
7997                                                    (vector int)__b, __c);
7998 #endif
7999 }
8000
8001 static __inline__ vector int __ATTRS_o_ai vec_perm(vector signed int __a,
8002                                                    vector signed int __b,
8003                                                    vector unsigned char __c) {
8004 #ifdef __LITTLE_ENDIAN__
8005   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
8006                               255, 255, 255, 255, 255, 255, 255, 255};
8007   __d = vec_xor(__c, __d);
8008   return (vector signed int)__builtin_altivec_vperm_4si(__b, __a, __d);
8009 #else
8010   return (vector signed int)__builtin_altivec_vperm_4si(__a, __b, __c);
8011 #endif
8012 }
8013
8014 static __inline__ vector unsigned int __ATTRS_o_ai
8015 vec_perm(vector unsigned int __a, vector unsigned int __b,
8016          vector unsigned char __c) {
8017 #ifdef __LITTLE_ENDIAN__
8018   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
8019                               255, 255, 255, 255, 255, 255, 255, 255};
8020   __d = vec_xor(__c, __d);
8021   return (vector unsigned int)__builtin_altivec_vperm_4si((vector int)__b,
8022                                                           (vector int)__a, __d);
8023 #else
8024   return (vector unsigned int)__builtin_altivec_vperm_4si((vector int)__a,
8025                                                           (vector int)__b, __c);
8026 #endif
8027 }
8028
8029 static __inline__ vector bool int __ATTRS_o_ai
8030 vec_perm(vector bool int __a, vector bool int __b, vector unsigned char __c) {
8031 #ifdef __LITTLE_ENDIAN__
8032   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
8033                               255, 255, 255, 255, 255, 255, 255, 255};
8034   __d = vec_xor(__c, __d);
8035   return (vector bool int)__builtin_altivec_vperm_4si((vector int)__b,
8036                                                       (vector int)__a, __d);
8037 #else
8038   return (vector bool int)__builtin_altivec_vperm_4si((vector int)__a,
8039                                                       (vector int)__b, __c);
8040 #endif
8041 }
8042
8043 static __inline__ vector float __ATTRS_o_ai vec_perm(vector float __a,
8044                                                      vector float __b,
8045                                                      vector unsigned char __c) {
8046 #ifdef __LITTLE_ENDIAN__
8047   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
8048                               255, 255, 255, 255, 255, 255, 255, 255};
8049   __d = vec_xor(__c, __d);
8050   return (vector float)__builtin_altivec_vperm_4si((vector int)__b,
8051                                                    (vector int)__a, __d);
8052 #else
8053   return (vector float)__builtin_altivec_vperm_4si((vector int)__a,
8054                                                    (vector int)__b, __c);
8055 #endif
8056 }
8057
8058 #ifdef __VSX__
8059 static __inline__ vector long long __ATTRS_o_ai
8060 vec_perm(vector signed long long __a, vector signed long long __b,
8061          vector unsigned char __c) {
8062 #ifdef __LITTLE_ENDIAN__
8063   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
8064                               255, 255, 255, 255, 255, 255, 255, 255};
8065   __d = vec_xor(__c, __d);
8066   return (vector signed long long)__builtin_altivec_vperm_4si(
8067       (vector int)__b, (vector int)__a, __d);
8068 #else
8069   return (vector signed long long)__builtin_altivec_vperm_4si(
8070       (vector int)__a, (vector int)__b, __c);
8071 #endif
8072 }
8073
8074 static __inline__ vector unsigned long long __ATTRS_o_ai
8075 vec_perm(vector unsigned long long __a, vector unsigned long long __b,
8076          vector unsigned char __c) {
8077 #ifdef __LITTLE_ENDIAN__
8078   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
8079                               255, 255, 255, 255, 255, 255, 255, 255};
8080   __d = vec_xor(__c, __d);
8081   return (vector unsigned long long)__builtin_altivec_vperm_4si(
8082       (vector int)__b, (vector int)__a, __d);
8083 #else
8084   return (vector unsigned long long)__builtin_altivec_vperm_4si(
8085       (vector int)__a, (vector int)__b, __c);
8086 #endif
8087 }
8088
8089 static __inline__ vector bool long long __ATTRS_o_ai
8090 vec_perm(vector bool long long __a, vector bool long long __b,
8091          vector unsigned char __c) {
8092 #ifdef __LITTLE_ENDIAN__
8093   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
8094                               255, 255, 255, 255, 255, 255, 255, 255};
8095   __d = vec_xor(__c, __d);
8096   return (vector bool long long)__builtin_altivec_vperm_4si(
8097       (vector int)__b, (vector int)__a, __d);
8098 #else
8099   return (vector bool long long)__builtin_altivec_vperm_4si(
8100       (vector int)__a, (vector int)__b, __c);
8101 #endif
8102 }
8103
8104 static __inline__ vector double __ATTRS_o_ai
8105 vec_perm(vector double __a, vector double __b, vector unsigned char __c) {
8106 #ifdef __LITTLE_ENDIAN__
8107   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
8108                               255, 255, 255, 255, 255, 255, 255, 255};
8109   __d = vec_xor(__c, __d);
8110   return (vector double)__builtin_altivec_vperm_4si((vector int)__b,
8111                                                     (vector int)__a, __d);
8112 #else
8113   return (vector double)__builtin_altivec_vperm_4si((vector int)__a,
8114                                                     (vector int)__b, __c);
8115 #endif
8116 }
8117 #endif
8118
8119 /* vec_vperm */
8120
8121 static __inline__ vector signed char __ATTRS_o_ai vec_vperm(
8122     vector signed char __a, vector signed char __b, vector unsigned char __c) {
8123   return vec_perm(__a, __b, __c);
8124 }
8125
8126 static __inline__ vector unsigned char __ATTRS_o_ai
8127 vec_vperm(vector unsigned char __a, vector unsigned char __b,
8128           vector unsigned char __c) {
8129   return vec_perm(__a, __b, __c);
8130 }
8131
8132 static __inline__ vector bool char __ATTRS_o_ai vec_vperm(
8133     vector bool char __a, vector bool char __b, vector unsigned char __c) {
8134   return vec_perm(__a, __b, __c);
8135 }
8136
8137 static __inline__ vector short __ATTRS_o_ai
8138 vec_vperm(vector short __a, vector short __b, vector unsigned char __c) {
8139   return vec_perm(__a, __b, __c);
8140 }
8141
8142 static __inline__ vector unsigned short __ATTRS_o_ai
8143 vec_vperm(vector unsigned short __a, vector unsigned short __b,
8144           vector unsigned char __c) {
8145   return vec_perm(__a, __b, __c);
8146 }
8147
8148 static __inline__ vector bool short __ATTRS_o_ai vec_vperm(
8149     vector bool short __a, vector bool short __b, vector unsigned char __c) {
8150   return vec_perm(__a, __b, __c);
8151 }
8152
8153 static __inline__ vector pixel __ATTRS_o_ai
8154 vec_vperm(vector pixel __a, vector pixel __b, vector unsigned char __c) {
8155   return vec_perm(__a, __b, __c);
8156 }
8157
8158 static __inline__ vector int __ATTRS_o_ai vec_vperm(vector int __a,
8159                                                     vector int __b,
8160                                                     vector unsigned char __c) {
8161   return vec_perm(__a, __b, __c);
8162 }
8163
8164 static __inline__ vector unsigned int __ATTRS_o_ai
8165 vec_vperm(vector unsigned int __a, vector unsigned int __b,
8166           vector unsigned char __c) {
8167   return vec_perm(__a, __b, __c);
8168 }
8169
8170 static __inline__ vector bool int __ATTRS_o_ai
8171 vec_vperm(vector bool int __a, vector bool int __b, vector unsigned char __c) {
8172   return vec_perm(__a, __b, __c);
8173 }
8174
8175 static __inline__ vector float __ATTRS_o_ai
8176 vec_vperm(vector float __a, vector float __b, vector unsigned char __c) {
8177   return vec_perm(__a, __b, __c);
8178 }
8179
8180 #ifdef __VSX__
8181 static __inline__ vector long long __ATTRS_o_ai vec_vperm(
8182     vector long long __a, vector long long __b, vector unsigned char __c) {
8183   return vec_perm(__a, __b, __c);
8184 }
8185
8186 static __inline__ vector unsigned long long __ATTRS_o_ai
8187 vec_vperm(vector unsigned long long __a, vector unsigned long long __b,
8188           vector unsigned char __c) {
8189   return vec_perm(__a, __b, __c);
8190 }
8191
8192 static __inline__ vector double __ATTRS_o_ai
8193 vec_vperm(vector double __a, vector double __b, vector unsigned char __c) {
8194   return vec_perm(__a, __b, __c);
8195 }
8196 #endif
8197
8198 /* vec_re */
8199
8200 static __inline__ vector float __ATTRS_o_ai vec_re(vector float __a) {
8201 #ifdef __VSX__
8202   return __builtin_vsx_xvresp(__a);
8203 #else
8204   return __builtin_altivec_vrefp(__a);
8205 #endif
8206 }
8207
8208 #ifdef __VSX__
8209 static __inline__ vector double __ATTRS_o_ai vec_re(vector double __a) {
8210   return __builtin_vsx_xvredp(__a);
8211 }
8212 #endif
8213
8214 /* vec_vrefp */
8215
8216 static __inline__ vector float __attribute__((__always_inline__))
8217 vec_vrefp(vector float __a) {
8218   return __builtin_altivec_vrefp(__a);
8219 }
8220
8221 /* vec_rl */
8222
8223 static __inline__ vector signed char __ATTRS_o_ai
8224 vec_rl(vector signed char __a, vector unsigned char __b) {
8225   return (vector signed char)__builtin_altivec_vrlb((vector char)__a, __b);
8226 }
8227
8228 static __inline__ vector unsigned char __ATTRS_o_ai
8229 vec_rl(vector unsigned char __a, vector unsigned char __b) {
8230   return (vector unsigned char)__builtin_altivec_vrlb((vector char)__a, __b);
8231 }
8232
8233 static __inline__ vector short __ATTRS_o_ai vec_rl(vector short __a,
8234                                                    vector unsigned short __b) {
8235   return __builtin_altivec_vrlh(__a, __b);
8236 }
8237
8238 static __inline__ vector unsigned short __ATTRS_o_ai
8239 vec_rl(vector unsigned short __a, vector unsigned short __b) {
8240   return (vector unsigned short)__builtin_altivec_vrlh((vector short)__a, __b);
8241 }
8242
8243 static __inline__ vector int __ATTRS_o_ai vec_rl(vector int __a,
8244                                                  vector unsigned int __b) {
8245   return __builtin_altivec_vrlw(__a, __b);
8246 }
8247
8248 static __inline__ vector unsigned int __ATTRS_o_ai
8249 vec_rl(vector unsigned int __a, vector unsigned int __b) {
8250   return (vector unsigned int)__builtin_altivec_vrlw((vector int)__a, __b);
8251 }
8252
8253 #ifdef __POWER8_VECTOR__
8254 static __inline__ vector signed long long __ATTRS_o_ai
8255 vec_rl(vector signed long long __a, vector unsigned long long __b) {
8256   return __builtin_altivec_vrld(__a, __b);
8257 }
8258
8259 static __inline__ vector unsigned long long __ATTRS_o_ai
8260 vec_rl(vector unsigned long long __a, vector unsigned long long __b) {
8261   return __builtin_altivec_vrld(__a, __b);
8262 }
8263 #endif
8264
8265 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
8266 static __inline__ vector signed __int128 __ATTRS_o_ai
8267 vec_rl(vector signed __int128 __a, vector unsigned __int128 __b) {
8268   return (__b << __a)|(__b >> ((__CHAR_BIT__ * sizeof(vector signed __int128)) - __a));
8269 }
8270
8271 static __inline__ vector unsigned __int128 __ATTRS_o_ai
8272 vec_rl(vector unsigned __int128 __a, vector unsigned __int128 __b) {
8273   return (__b << __a)|(__b >> ((__CHAR_BIT__ * sizeof(vector unsigned __int128)) - __a));
8274 }
8275 #endif
8276
8277 /* vec_rlmi */
8278 #ifdef __POWER9_VECTOR__
8279 static __inline__ vector unsigned int __ATTRS_o_ai
8280 vec_rlmi(vector unsigned int __a, vector unsigned int __b,
8281          vector unsigned int __c) {
8282   return __builtin_altivec_vrlwmi(__a, __c, __b);
8283 }
8284
8285 static __inline__ vector unsigned long long __ATTRS_o_ai
8286 vec_rlmi(vector unsigned long long __a, vector unsigned long long __b,
8287          vector unsigned long long __c) {
8288   return __builtin_altivec_vrldmi(__a, __c, __b);
8289 }
8290 #endif
8291
8292 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
8293 static __inline__ vector unsigned __int128 __ATTRS_o_ai
8294 vec_rlmi(vector unsigned __int128 __a, vector unsigned __int128 __b,
8295          vector unsigned __int128 __c) {
8296   return __builtin_altivec_vrlqmi(__a, __c, __b);
8297 }
8298
8299 static __inline__ vector signed __int128 __ATTRS_o_ai
8300 vec_rlmi(vector signed __int128 __a, vector signed __int128 __b,
8301          vector signed __int128 __c) {
8302   return __builtin_altivec_vrlqmi(__a, __c, __b);
8303 }
8304 #endif
8305
8306 /* vec_rlnm */
8307 #ifdef __POWER9_VECTOR__
8308 static __inline__ vector unsigned int __ATTRS_o_ai
8309 vec_rlnm(vector unsigned int __a, vector unsigned int __b,
8310          vector unsigned int __c) {
8311   vector unsigned int OneByte = { 0x8, 0x8, 0x8, 0x8 };
8312   return __builtin_altivec_vrlwnm(__a, ((__c << OneByte) | __b));
8313 }
8314
8315 static __inline__ vector unsigned long long __ATTRS_o_ai
8316 vec_rlnm(vector unsigned long long __a, vector unsigned long long __b,
8317          vector unsigned long long __c) {
8318   vector unsigned long long OneByte = { 0x8, 0x8 };
8319   return __builtin_altivec_vrldnm(__a, ((__c << OneByte) | __b));
8320 }
8321 #endif
8322
8323 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
8324 static __inline__ vector unsigned __int128 __ATTRS_o_ai
8325 vec_rlnm(vector unsigned __int128 __a, vector unsigned __int128 __b,
8326          vector unsigned __int128 __c) {
8327   // Merge __b and __c using an appropriate shuffle.
8328   vector unsigned char TmpB = (vector unsigned char)__b;
8329   vector unsigned char TmpC = (vector unsigned char)__c;
8330   vector unsigned char MaskAndShift =
8331 #ifdef __LITTLE_ENDIAN__
8332       __builtin_shufflevector(TmpB, TmpC, -1, -1, -1, -1, -1, -1, -1, -1, 16, 0,
8333                               1, -1, -1, -1, -1, -1);
8334 #else
8335       __builtin_shufflevector(TmpB, TmpC, -1, -1, -1, -1, -1, 31, 30, 15, -1,
8336                               -1, -1, -1, -1, -1, -1, -1);
8337 #endif
8338    return __builtin_altivec_vrlqnm(__a, (vector unsigned __int128) MaskAndShift);
8339 }
8340
8341 static __inline__ vector signed __int128 __ATTRS_o_ai
8342 vec_rlnm(vector signed __int128 __a, vector signed __int128 __b,
8343          vector signed __int128 __c) {
8344   // Merge __b and __c using an appropriate shuffle.
8345   vector unsigned char TmpB = (vector unsigned char)__b;
8346   vector unsigned char TmpC = (vector unsigned char)__c;
8347   vector unsigned char MaskAndShift =
8348 #ifdef __LITTLE_ENDIAN__
8349       __builtin_shufflevector(TmpB, TmpC, -1, -1, -1, -1, -1, -1, -1, -1, 16, 0,
8350                               1, -1, -1, -1, -1, -1);
8351 #else
8352       __builtin_shufflevector(TmpB, TmpC, -1, -1, -1, -1, -1, 31, 30, 15, -1,
8353                               -1, -1, -1, -1, -1, -1, -1);
8354 #endif
8355   return __builtin_altivec_vrlqnm(__a, (vector unsigned __int128) MaskAndShift);
8356 }
8357 #endif
8358
8359 /* vec_vrlb */
8360
8361 static __inline__ vector signed char __ATTRS_o_ai
8362 vec_vrlb(vector signed char __a, vector unsigned char __b) {
8363   return (vector signed char)__builtin_altivec_vrlb((vector char)__a, __b);
8364 }
8365
8366 static __inline__ vector unsigned char __ATTRS_o_ai
8367 vec_vrlb(vector unsigned char __a, vector unsigned char __b) {
8368   return (vector unsigned char)__builtin_altivec_vrlb((vector char)__a, __b);
8369 }
8370
8371 /* vec_vrlh */
8372
8373 static __inline__ vector short __ATTRS_o_ai
8374 vec_vrlh(vector short __a, vector unsigned short __b) {
8375   return __builtin_altivec_vrlh(__a, __b);
8376 }
8377
8378 static __inline__ vector unsigned short __ATTRS_o_ai
8379 vec_vrlh(vector unsigned short __a, vector unsigned short __b) {
8380   return (vector unsigned short)__builtin_altivec_vrlh((vector short)__a, __b);
8381 }
8382
8383 /* vec_vrlw */
8384
8385 static __inline__ vector int __ATTRS_o_ai vec_vrlw(vector int __a,
8386                                                    vector unsigned int __b) {
8387   return __builtin_altivec_vrlw(__a, __b);
8388 }
8389
8390 static __inline__ vector unsigned int __ATTRS_o_ai
8391 vec_vrlw(vector unsigned int __a, vector unsigned int __b) {
8392   return (vector unsigned int)__builtin_altivec_vrlw((vector int)__a, __b);
8393 }
8394
8395 /* vec_round */
8396
8397 static __inline__ vector float __ATTRS_o_ai vec_round(vector float __a) {
8398   return __builtin_altivec_vrfin(__a);
8399 }
8400
8401 #ifdef __VSX__
8402 static __inline__ vector double __ATTRS_o_ai vec_round(vector double __a) {
8403   return __builtin_vsx_xvrdpi(__a);
8404 }
8405
8406 /* vec_rint */
8407
8408 static __inline__ vector float __ATTRS_o_ai vec_rint(vector float __a) {
8409   return __builtin_vsx_xvrspic(__a);
8410 }
8411
8412 static __inline__ vector double __ATTRS_o_ai vec_rint(vector double __a) {
8413   return __builtin_vsx_xvrdpic(__a);
8414 }
8415
8416 /* vec_roundc */
8417
8418 static __inline__ vector float __ATTRS_o_ai vec_roundc(vector float __a) {
8419   return __builtin_vsx_xvrspic(__a);
8420 }
8421
8422 static __inline__ vector double __ATTRS_o_ai vec_roundc(vector double __a) {
8423   return __builtin_vsx_xvrdpic(__a);
8424 }
8425
8426 /* vec_nearbyint */
8427
8428 static __inline__ vector float __ATTRS_o_ai vec_nearbyint(vector float __a) {
8429   return __builtin_vsx_xvrspi(__a);
8430 }
8431
8432 static __inline__ vector double __ATTRS_o_ai vec_nearbyint(vector double __a) {
8433   return __builtin_vsx_xvrdpi(__a);
8434 }
8435 #endif
8436
8437 /* vec_vrfin */
8438
8439 static __inline__ vector float __attribute__((__always_inline__))
8440 vec_vrfin(vector float __a) {
8441   return __builtin_altivec_vrfin(__a);
8442 }
8443
8444 /* vec_sqrt */
8445
8446 #ifdef __VSX__
8447 static __inline__ vector float __ATTRS_o_ai vec_sqrt(vector float __a) {
8448   return __builtin_vsx_xvsqrtsp(__a);
8449 }
8450
8451 static __inline__ vector double __ATTRS_o_ai vec_sqrt(vector double __a) {
8452   return __builtin_vsx_xvsqrtdp(__a);
8453 }
8454 #endif
8455
8456 /* vec_rsqrte */
8457
8458 static __inline__ vector float __ATTRS_o_ai vec_rsqrte(vector float __a) {
8459 #ifdef __VSX__
8460   return __builtin_vsx_xvrsqrtesp(__a);
8461 #else
8462   return __builtin_altivec_vrsqrtefp(__a);
8463 #endif
8464 }
8465
8466 #ifdef __VSX__
8467 static __inline__ vector double __ATTRS_o_ai vec_rsqrte(vector double __a) {
8468   return __builtin_vsx_xvrsqrtedp(__a);
8469 }
8470 #endif
8471
8472 static vector float __ATTRS_o_ai vec_rsqrt(vector float __a) {
8473   return __builtin_ppc_rsqrtf(__a);
8474 }
8475
8476 #ifdef __VSX__
8477 static vector double __ATTRS_o_ai vec_rsqrt(vector double __a) {
8478   return __builtin_ppc_rsqrtd(__a);
8479 }
8480 #endif
8481
8482 /* vec_vrsqrtefp */
8483
8484 static __inline__ __vector float __attribute__((__always_inline__))
8485 vec_vrsqrtefp(vector float __a) {
8486   return __builtin_altivec_vrsqrtefp(__a);
8487 }
8488
8489 /* vec_xvtsqrt */
8490
8491 #ifdef __VSX__
8492 static __inline__ int __ATTRS_o_ai vec_test_swsqrt(vector double __a) {
8493   return __builtin_vsx_xvtsqrtdp(__a);
8494 }
8495
8496 static __inline__ int __ATTRS_o_ai vec_test_swsqrts(vector float __a) {
8497   return __builtin_vsx_xvtsqrtsp(__a);
8498 }
8499 #endif
8500
8501 /* vec_sel */
8502
8503 #define __builtin_altivec_vsel_4si vec_sel
8504
8505 static __inline__ vector signed char __ATTRS_o_ai vec_sel(
8506     vector signed char __a, vector signed char __b, vector unsigned char __c) {
8507   return (__a & ~(vector signed char)__c) | (__b & (vector signed char)__c);
8508 }
8509
8510 static __inline__ vector signed char __ATTRS_o_ai
8511 vec_sel(vector signed char __a, vector signed char __b, vector bool char __c) {
8512   return (__a & ~(vector signed char)__c) | (__b & (vector signed char)__c);
8513 }
8514
8515 static __inline__ vector unsigned char __ATTRS_o_ai
8516 vec_sel(vector unsigned char __a, vector unsigned char __b,
8517         vector unsigned char __c) {
8518   return (__a & ~__c) | (__b & __c);
8519 }
8520
8521 static __inline__ vector unsigned char __ATTRS_o_ai vec_sel(
8522     vector unsigned char __a, vector unsigned char __b, vector bool char __c) {
8523   return (__a & ~(vector unsigned char)__c) | (__b & (vector unsigned char)__c);
8524 }
8525
8526 static __inline__ vector bool char __ATTRS_o_ai
8527 vec_sel(vector bool char __a, vector bool char __b, vector unsigned char __c) {
8528   return (__a & ~(vector bool char)__c) | (__b & (vector bool char)__c);
8529 }
8530
8531 static __inline__ vector bool char __ATTRS_o_ai vec_sel(vector bool char __a,
8532                                                         vector bool char __b,
8533                                                         vector bool char __c) {
8534   return (__a & ~__c) | (__b & __c);
8535 }
8536
8537 static __inline__ vector short __ATTRS_o_ai vec_sel(vector short __a,
8538                                                     vector short __b,
8539                                                     vector unsigned short __c) {
8540   return (__a & ~(vector short)__c) | (__b & (vector short)__c);
8541 }
8542
8543 static __inline__ vector short __ATTRS_o_ai vec_sel(vector short __a,
8544                                                     vector short __b,
8545                                                     vector bool short __c) {
8546   return (__a & ~(vector short)__c) | (__b & (vector short)__c);
8547 }
8548
8549 static __inline__ vector unsigned short __ATTRS_o_ai
8550 vec_sel(vector unsigned short __a, vector unsigned short __b,
8551         vector unsigned short __c) {
8552   return (__a & ~__c) | (__b & __c);
8553 }
8554
8555 static __inline__ vector unsigned short __ATTRS_o_ai
8556 vec_sel(vector unsigned short __a, vector unsigned short __b,
8557         vector bool short __c) {
8558   return (__a & ~(vector unsigned short)__c) |
8559          (__b & (vector unsigned short)__c);
8560 }
8561
8562 static __inline__ vector bool short __ATTRS_o_ai vec_sel(
8563     vector bool short __a, vector bool short __b, vector unsigned short __c) {
8564   return (__a & ~(vector bool short)__c) | (__b & (vector bool short)__c);
8565 }
8566
8567 static __inline__ vector bool short __ATTRS_o_ai
8568 vec_sel(vector bool short __a, vector bool short __b, vector bool short __c) {
8569   return (__a & ~__c) | (__b & __c);
8570 }
8571
8572 static __inline__ vector int __ATTRS_o_ai vec_sel(vector int __a,
8573                                                   vector int __b,
8574                                                   vector unsigned int __c) {
8575   return (__a & ~(vector int)__c) | (__b & (vector int)__c);
8576 }
8577
8578 static __inline__ vector int __ATTRS_o_ai vec_sel(vector int __a,
8579                                                   vector int __b,
8580                                                   vector bool int __c) {
8581   return (__a & ~(vector int)__c) | (__b & (vector int)__c);
8582 }
8583
8584 static __inline__ vector unsigned int __ATTRS_o_ai vec_sel(
8585     vector unsigned int __a, vector unsigned int __b, vector unsigned int __c) {
8586   return (__a & ~__c) | (__b & __c);
8587 }
8588
8589 static __inline__ vector unsigned int __ATTRS_o_ai
8590 vec_sel(vector unsigned int __a, vector unsigned int __b, vector bool int __c) {
8591   return (__a & ~(vector unsigned int)__c) | (__b & (vector unsigned int)__c);
8592 }
8593
8594 static __inline__ vector bool int __ATTRS_o_ai
8595 vec_sel(vector bool int __a, vector bool int __b, vector unsigned int __c) {
8596   return (__a & ~(vector bool int)__c) | (__b & (vector bool int)__c);
8597 }
8598
8599 static __inline__ vector bool int __ATTRS_o_ai vec_sel(vector bool int __a,
8600                                                        vector bool int __b,
8601                                                        vector bool int __c) {
8602   return (__a & ~__c) | (__b & __c);
8603 }
8604
8605 static __inline__ vector float __ATTRS_o_ai vec_sel(vector float __a,
8606                                                     vector float __b,
8607                                                     vector unsigned int __c) {
8608   vector int __res = ((vector int)__a & ~(vector int)__c) |
8609                      ((vector int)__b & (vector int)__c);
8610   return (vector float)__res;
8611 }
8612
8613 static __inline__ vector float __ATTRS_o_ai vec_sel(vector float __a,
8614                                                     vector float __b,
8615                                                     vector bool int __c) {
8616   vector int __res = ((vector int)__a & ~(vector int)__c) |
8617                      ((vector int)__b & (vector int)__c);
8618   return (vector float)__res;
8619 }
8620
8621 #ifdef __VSX__
8622 static __inline__ vector double __ATTRS_o_ai
8623 vec_sel(vector double __a, vector double __b, vector bool long long __c) {
8624   vector long long __res = ((vector long long)__a & ~(vector long long)__c) |
8625                            ((vector long long)__b & (vector long long)__c);
8626   return (vector double)__res;
8627 }
8628
8629 static __inline__ vector double __ATTRS_o_ai
8630 vec_sel(vector double __a, vector double __b, vector unsigned long long __c) {
8631   vector long long __res = ((vector long long)__a & ~(vector long long)__c) |
8632                            ((vector long long)__b & (vector long long)__c);
8633   return (vector double)__res;
8634 }
8635
8636 static __inline__ vector bool long long __ATTRS_o_ai
8637 vec_sel(vector bool long long __a, vector bool long long __b,
8638         vector bool long long __c) {
8639   return (__a & ~__c) | (__b & __c);
8640 }
8641
8642 static __inline__ vector bool long long __ATTRS_o_ai
8643 vec_sel(vector bool long long __a, vector bool long long __b,
8644         vector unsigned long long __c) {
8645   return (__a & ~(vector bool long long)__c) |
8646          (__b & (vector bool long long)__c);
8647 }
8648
8649 static __inline__ vector signed long long __ATTRS_o_ai
8650 vec_sel(vector signed long long __a, vector signed long long __b,
8651         vector bool long long __c) {
8652   return (__a & ~(vector signed long long)__c) |
8653          (__b & (vector signed long long)__c);
8654 }
8655
8656 static __inline__ vector signed long long __ATTRS_o_ai
8657 vec_sel(vector signed long long __a, vector signed long long __b,
8658         vector unsigned long long __c) {
8659   return (__a & ~(vector signed long long)__c) |
8660          (__b & (vector signed long long)__c);
8661 }
8662
8663 static __inline__ vector unsigned long long __ATTRS_o_ai
8664 vec_sel(vector unsigned long long __a, vector unsigned long long __b,
8665         vector bool long long __c) {
8666   return (__a & ~(vector unsigned long long)__c) |
8667          (__b & (vector unsigned long long)__c);
8668 }
8669
8670 static __inline__ vector unsigned long long __ATTRS_o_ai
8671 vec_sel(vector unsigned long long __a, vector unsigned long long __b,
8672         vector unsigned long long __c) {
8673   return (__a & ~__c) | (__b & __c);
8674 }
8675 #endif
8676
8677 /* vec_vsel */
8678
8679 static __inline__ vector signed char __ATTRS_o_ai vec_vsel(
8680     vector signed char __a, vector signed char __b, vector unsigned char __c) {
8681   return (__a & ~(vector signed char)__c) | (__b & (vector signed char)__c);
8682 }
8683
8684 static __inline__ vector signed char __ATTRS_o_ai
8685 vec_vsel(vector signed char __a, vector signed char __b, vector bool char __c) {
8686   return (__a & ~(vector signed char)__c) | (__b & (vector signed char)__c);
8687 }
8688
8689 static __inline__ vector unsigned char __ATTRS_o_ai
8690 vec_vsel(vector unsigned char __a, vector unsigned char __b,
8691          vector unsigned char __c) {
8692   return (__a & ~__c) | (__b & __c);
8693 }
8694
8695 static __inline__ vector unsigned char __ATTRS_o_ai vec_vsel(
8696     vector unsigned char __a, vector unsigned char __b, vector bool char __c) {
8697   return (__a & ~(vector unsigned char)__c) | (__b & (vector unsigned char)__c);
8698 }
8699
8700 static __inline__ vector bool char __ATTRS_o_ai
8701 vec_vsel(vector bool char __a, vector bool char __b, vector unsigned char __c) {
8702   return (__a & ~(vector bool char)__c) | (__b & (vector bool char)__c);
8703 }
8704
8705 static __inline__ vector bool char __ATTRS_o_ai vec_vsel(vector bool char __a,
8706                                                          vector bool char __b,
8707                                                          vector bool char __c) {
8708   return (__a & ~__c) | (__b & __c);
8709 }
8710
8711 static __inline__ vector short __ATTRS_o_ai
8712 vec_vsel(vector short __a, vector short __b, vector unsigned short __c) {
8713   return (__a & ~(vector short)__c) | (__b & (vector short)__c);
8714 }
8715
8716 static __inline__ vector short __ATTRS_o_ai vec_vsel(vector short __a,
8717                                                      vector short __b,
8718                                                      vector bool short __c) {
8719   return (__a & ~(vector short)__c) | (__b & (vector short)__c);
8720 }
8721
8722 static __inline__ vector unsigned short __ATTRS_o_ai
8723 vec_vsel(vector unsigned short __a, vector unsigned short __b,
8724          vector unsigned short __c) {
8725   return (__a & ~__c) | (__b & __c);
8726 }
8727
8728 static __inline__ vector unsigned short __ATTRS_o_ai
8729 vec_vsel(vector unsigned short __a, vector unsigned short __b,
8730          vector bool short __c) {
8731   return (__a & ~(vector unsigned short)__c) |
8732          (__b & (vector unsigned short)__c);
8733 }
8734
8735 static __inline__ vector bool short __ATTRS_o_ai vec_vsel(
8736     vector bool short __a, vector bool short __b, vector unsigned short __c) {
8737   return (__a & ~(vector bool short)__c) | (__b & (vector bool short)__c);
8738 }
8739
8740 static __inline__ vector bool short __ATTRS_o_ai
8741 vec_vsel(vector bool short __a, vector bool short __b, vector bool short __c) {
8742   return (__a & ~__c) | (__b & __c);
8743 }
8744
8745 static __inline__ vector int __ATTRS_o_ai vec_vsel(vector int __a,
8746                                                    vector int __b,
8747                                                    vector unsigned int __c) {
8748   return (__a & ~(vector int)__c) | (__b & (vector int)__c);
8749 }
8750
8751 static __inline__ vector int __ATTRS_o_ai vec_vsel(vector int __a,
8752                                                    vector int __b,
8753                                                    vector bool int __c) {
8754   return (__a & ~(vector int)__c) | (__b & (vector int)__c);
8755 }
8756
8757 static __inline__ vector unsigned int __ATTRS_o_ai vec_vsel(
8758     vector unsigned int __a, vector unsigned int __b, vector unsigned int __c) {
8759   return (__a & ~__c) | (__b & __c);
8760 }
8761
8762 static __inline__ vector unsigned int __ATTRS_o_ai vec_vsel(
8763     vector unsigned int __a, vector unsigned int __b, vector bool int __c) {
8764   return (__a & ~(vector unsigned int)__c) | (__b & (vector unsigned int)__c);
8765 }
8766
8767 static __inline__ vector bool int __ATTRS_o_ai
8768 vec_vsel(vector bool int __a, vector bool int __b, vector unsigned int __c) {
8769   return (__a & ~(vector bool int)__c) | (__b & (vector bool int)__c);
8770 }
8771
8772 static __inline__ vector bool int __ATTRS_o_ai vec_vsel(vector bool int __a,
8773                                                         vector bool int __b,
8774                                                         vector bool int __c) {
8775   return (__a & ~__c) | (__b & __c);
8776 }
8777
8778 static __inline__ vector float __ATTRS_o_ai vec_vsel(vector float __a,
8779                                                      vector float __b,
8780                                                      vector unsigned int __c) {
8781   vector int __res = ((vector int)__a & ~(vector int)__c) |
8782                      ((vector int)__b & (vector int)__c);
8783   return (vector float)__res;
8784 }
8785
8786 static __inline__ vector float __ATTRS_o_ai vec_vsel(vector float __a,
8787                                                      vector float __b,
8788                                                      vector bool int __c) {
8789   vector int __res = ((vector int)__a & ~(vector int)__c) |
8790                      ((vector int)__b & (vector int)__c);
8791   return (vector float)__res;
8792 }
8793
8794 /* vec_sl */
8795
8796 // vec_sl does modulo arithmetic on __b first, so __b is allowed to be more
8797 // than the length of __a.
8798 static __inline__ vector unsigned char __ATTRS_o_ai
8799 vec_sl(vector unsigned char __a, vector unsigned char __b) {
8800   return __a << (__b %
8801                  (vector unsigned char)(sizeof(unsigned char) * __CHAR_BIT__));
8802 }
8803
8804 static __inline__ vector signed char __ATTRS_o_ai
8805 vec_sl(vector signed char __a, vector unsigned char __b) {
8806   return (vector signed char)vec_sl((vector unsigned char)__a, __b);
8807 }
8808
8809 static __inline__ vector unsigned short __ATTRS_o_ai
8810 vec_sl(vector unsigned short __a, vector unsigned short __b) {
8811   return __a << (__b % (vector unsigned short)(sizeof(unsigned short) *
8812                                                __CHAR_BIT__));
8813 }
8814
8815 static __inline__ vector short __ATTRS_o_ai vec_sl(vector short __a,
8816                                                    vector unsigned short __b) {
8817   return (vector short)vec_sl((vector unsigned short)__a, __b);
8818 }
8819
8820 static __inline__ vector unsigned int __ATTRS_o_ai
8821 vec_sl(vector unsigned int __a, vector unsigned int __b) {
8822   return __a << (__b %
8823                  (vector unsigned int)(sizeof(unsigned int) * __CHAR_BIT__));
8824 }
8825
8826 static __inline__ vector int __ATTRS_o_ai vec_sl(vector int __a,
8827                                                  vector unsigned int __b) {
8828   return (vector int)vec_sl((vector unsigned int)__a, __b);
8829 }
8830
8831 #ifdef __POWER8_VECTOR__
8832 static __inline__ vector unsigned long long __ATTRS_o_ai
8833 vec_sl(vector unsigned long long __a, vector unsigned long long __b) {
8834   return __a << (__b % (vector unsigned long long)(sizeof(unsigned long long) *
8835                                                    __CHAR_BIT__));
8836 }
8837
8838 static __inline__ vector long long __ATTRS_o_ai
8839 vec_sl(vector long long __a, vector unsigned long long __b) {
8840   return (vector long long)vec_sl((vector unsigned long long)__a, __b);
8841 }
8842 #else
8843 static __inline__ vector unsigned char __ATTRS_o_ai
8844 vec_vspltb(vector unsigned char __a, unsigned char __b);
8845 static __inline__ vector unsigned long long __ATTRS_o_ai
8846 vec_sl(vector unsigned long long __a, vector unsigned long long __b) {
8847   __b %= (vector unsigned long long)(sizeof(unsigned long long) * __CHAR_BIT__);
8848
8849   // Big endian element one (the right doubleword) can be left shifted as-is.
8850   // The other element needs to be swapped into the right doubleword and
8851   // shifted. Then the right doublewords of the two result vectors are merged.
8852   vector signed long long __rightelt =
8853       (vector signed long long)__builtin_altivec_vslo((vector signed int)__a,
8854                                                       (vector signed int)__b);
8855 #ifdef __LITTLE_ENDIAN__
8856   __rightelt = (vector signed long long)__builtin_altivec_vsl(
8857       (vector signed int)__rightelt,
8858       (vector signed int)vec_vspltb((vector unsigned char)__b, 0));
8859 #else
8860   __rightelt = (vector signed long long)__builtin_altivec_vsl(
8861       (vector signed int)__rightelt,
8862       (vector signed int)vec_vspltb((vector unsigned char)__b, 15));
8863 #endif
8864   __a = __builtin_shufflevector(__a, __a, 1, 0);
8865   __b = __builtin_shufflevector(__b, __b, 1, 0);
8866   vector signed long long __leftelt =
8867       (vector signed long long)__builtin_altivec_vslo((vector signed int)__a,
8868                                                       (vector signed int)__b);
8869 #ifdef __LITTLE_ENDIAN__
8870   __leftelt = (vector signed long long)__builtin_altivec_vsl(
8871       (vector signed int)__leftelt,
8872       (vector signed int)vec_vspltb((vector unsigned char)__b, 0));
8873   return (vector unsigned long long)__builtin_shufflevector(__rightelt,
8874                                                             __leftelt, 0, 2);
8875 #else
8876   __leftelt = (vector signed long long)__builtin_altivec_vsl(
8877       (vector signed int)__leftelt,
8878       (vector signed int)vec_vspltb((vector unsigned char)__b, 15));
8879   return (vector unsigned long long)__builtin_shufflevector(__leftelt,
8880                                                             __rightelt, 1, 3);
8881 #endif
8882 }
8883
8884 static __inline__ vector long long __ATTRS_o_ai
8885 vec_sl(vector long long __a, vector unsigned long long __b) {
8886   return (vector long long)vec_sl((vector unsigned long long)__a, __b);
8887 }
8888 #endif
8889
8890 /* vec_vslb */
8891
8892 #define __builtin_altivec_vslb vec_vslb
8893
8894 static __inline__ vector signed char __ATTRS_o_ai
8895 vec_vslb(vector signed char __a, vector unsigned char __b) {
8896   return vec_sl(__a, __b);
8897 }
8898
8899 static __inline__ vector unsigned char __ATTRS_o_ai
8900 vec_vslb(vector unsigned char __a, vector unsigned char __b) {
8901   return vec_sl(__a, __b);
8902 }
8903
8904 /* vec_vslh */
8905
8906 #define __builtin_altivec_vslh vec_vslh
8907
8908 static __inline__ vector short __ATTRS_o_ai
8909 vec_vslh(vector short __a, vector unsigned short __b) {
8910   return vec_sl(__a, __b);
8911 }
8912
8913 static __inline__ vector unsigned short __ATTRS_o_ai
8914 vec_vslh(vector unsigned short __a, vector unsigned short __b) {
8915   return vec_sl(__a, __b);
8916 }
8917
8918 /* vec_vslw */
8919
8920 #define __builtin_altivec_vslw vec_vslw
8921
8922 static __inline__ vector int __ATTRS_o_ai vec_vslw(vector int __a,
8923                                                    vector unsigned int __b) {
8924   return vec_sl(__a, __b);
8925 }
8926
8927 static __inline__ vector unsigned int __ATTRS_o_ai
8928 vec_vslw(vector unsigned int __a, vector unsigned int __b) {
8929   return vec_sl(__a, __b);
8930 }
8931
8932 /* vec_sld */
8933
8934 #define __builtin_altivec_vsldoi_4si vec_sld
8935
8936 static __inline__ vector signed char __ATTRS_o_ai vec_sld(
8937     vector signed char __a, vector signed char __b, unsigned const int __c) {
8938   unsigned char __d = __c & 0x0F;
8939 #ifdef __LITTLE_ENDIAN__
8940   return vec_perm(
8941       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8942                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
8943                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
8944                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
8945 #else
8946   return vec_perm(
8947       __a, __b,
8948       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8949                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8950                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8951 #endif
8952 }
8953
8954 static __inline__ vector unsigned char __ATTRS_o_ai
8955 vec_sld(vector unsigned char __a, vector unsigned char __b,
8956         unsigned const int __c) {
8957   unsigned char __d = __c & 0x0F;
8958 #ifdef __LITTLE_ENDIAN__
8959   return vec_perm(
8960       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8961                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
8962                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
8963                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
8964 #else
8965   return vec_perm(
8966       __a, __b,
8967       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8968                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8969                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8970 #endif
8971 }
8972
8973 static __inline__ vector bool char __ATTRS_o_ai
8974 vec_sld(vector bool char __a, vector bool char __b, unsigned const int __c) {
8975   unsigned char __d = __c & 0x0F;
8976 #ifdef __LITTLE_ENDIAN__
8977   return vec_perm(
8978       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8979                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
8980                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
8981                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
8982 #else
8983   return vec_perm(
8984       __a, __b,
8985       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8986                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8987                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8988 #endif
8989 }
8990
8991 static __inline__ vector signed short __ATTRS_o_ai vec_sld(
8992     vector signed short __a, vector signed short __b, unsigned const int __c) {
8993   unsigned char __d = __c & 0x0F;
8994 #ifdef __LITTLE_ENDIAN__
8995   return vec_perm(
8996       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8997                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
8998                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
8999                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9000 #else
9001   return vec_perm(
9002       __a, __b,
9003       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9004                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9005                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9006 #endif
9007 }
9008
9009 static __inline__ vector unsigned short __ATTRS_o_ai
9010 vec_sld(vector unsigned short __a, vector unsigned short __b,
9011         unsigned const int __c) {
9012   unsigned char __d = __c & 0x0F;
9013 #ifdef __LITTLE_ENDIAN__
9014   return vec_perm(
9015       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9016                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9017                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9018                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9019 #else
9020   return vec_perm(
9021       __a, __b,
9022       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9023                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9024                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9025 #endif
9026 }
9027
9028 static __inline__ vector bool short __ATTRS_o_ai
9029 vec_sld(vector bool short __a, vector bool short __b, unsigned const int __c) {
9030   unsigned char __d = __c & 0x0F;
9031 #ifdef __LITTLE_ENDIAN__
9032   return vec_perm(
9033       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9034                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9035                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9036                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9037 #else
9038   return vec_perm(
9039       __a, __b,
9040       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9041                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9042                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9043 #endif
9044 }
9045
9046 static __inline__ vector pixel __ATTRS_o_ai vec_sld(vector pixel __a,
9047                                                     vector pixel __b,
9048                                                     unsigned const int __c) {
9049   unsigned char __d = __c & 0x0F;
9050 #ifdef __LITTLE_ENDIAN__
9051   return vec_perm(
9052       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9053                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9054                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9055                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9056 #else
9057   return vec_perm(
9058       __a, __b,
9059       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9060                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9061                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9062 #endif
9063 }
9064
9065 static __inline__ vector signed int __ATTRS_o_ai
9066 vec_sld(vector signed int __a, vector signed int __b, unsigned const int __c) {
9067   unsigned char __d = __c & 0x0F;
9068 #ifdef __LITTLE_ENDIAN__
9069   return vec_perm(
9070       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9071                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9072                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9073                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9074 #else
9075   return vec_perm(
9076       __a, __b,
9077       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9078                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9079                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9080 #endif
9081 }
9082
9083 static __inline__ vector unsigned int __ATTRS_o_ai vec_sld(
9084     vector unsigned int __a, vector unsigned int __b, unsigned const int __c) {
9085   unsigned char __d = __c & 0x0F;
9086 #ifdef __LITTLE_ENDIAN__
9087   return vec_perm(
9088       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9089                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9090                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9091                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9092 #else
9093   return vec_perm(
9094       __a, __b,
9095       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9096                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9097                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9098 #endif
9099 }
9100
9101 static __inline__ vector bool int __ATTRS_o_ai vec_sld(vector bool int __a,
9102                                                        vector bool int __b,
9103                                                        unsigned const int __c) {
9104   unsigned char __d = __c & 0x0F;
9105 #ifdef __LITTLE_ENDIAN__
9106   return vec_perm(
9107       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9108                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9109                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9110                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9111 #else
9112   return vec_perm(
9113       __a, __b,
9114       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9115                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9116                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9117 #endif
9118 }
9119
9120 static __inline__ vector float __ATTRS_o_ai vec_sld(vector float __a,
9121                                                     vector float __b,
9122                                                     unsigned const int __c) {
9123   unsigned char __d = __c & 0x0F;
9124 #ifdef __LITTLE_ENDIAN__
9125   return vec_perm(
9126       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9127                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9128                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9129                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9130 #else
9131   return vec_perm(
9132       __a, __b,
9133       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9134                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9135                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9136 #endif
9137 }
9138
9139 #ifdef __VSX__
9140 static __inline__ vector bool long long __ATTRS_o_ai
9141 vec_sld(vector bool long long __a, vector bool long long __b,
9142         unsigned const int __c) {
9143   unsigned char __d = __c & 0x0F;
9144 #ifdef __LITTLE_ENDIAN__
9145   return vec_perm(
9146       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9147                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9148                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9149                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9150 #else
9151   return vec_perm(
9152       __a, __b,
9153       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9154                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9155                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9156 #endif
9157 }
9158
9159 static __inline__ vector signed long long __ATTRS_o_ai
9160 vec_sld(vector signed long long __a, vector signed long long __b,
9161         unsigned const int __c) {
9162   unsigned char __d = __c & 0x0F;
9163 #ifdef __LITTLE_ENDIAN__
9164   return vec_perm(
9165       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9166                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9167                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9168                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9169 #else
9170   return vec_perm(
9171       __a, __b,
9172       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9173                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9174                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9175 #endif
9176 }
9177
9178 static __inline__ vector unsigned long long __ATTRS_o_ai
9179 vec_sld(vector unsigned long long __a, vector unsigned long long __b,
9180         unsigned const int __c) {
9181   unsigned char __d = __c & 0x0F;
9182 #ifdef __LITTLE_ENDIAN__
9183   return vec_perm(
9184       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9185                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9186                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9187                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9188 #else
9189   return vec_perm(
9190       __a, __b,
9191       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9192                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9193                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9194 #endif
9195 }
9196
9197 static __inline__ vector double __ATTRS_o_ai vec_sld(vector double __a,
9198                                                      vector double __b,
9199                                                      unsigned const int __c) {
9200   unsigned char __d = __c & 0x0F;
9201 #ifdef __LITTLE_ENDIAN__
9202   return vec_perm(
9203       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9204                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9205                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9206                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9207 #else
9208   return vec_perm(
9209       __a, __b,
9210       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9211                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9212                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9213 #endif
9214 }
9215 #endif
9216
9217 /* vec_sldw */
9218 static __inline__ vector signed char __ATTRS_o_ai vec_sldw(
9219     vector signed char __a, vector signed char __b, unsigned const int __c) {
9220   return vec_sld(__a, __b, ((__c << 2) & 0x0F));
9221 }
9222
9223 static __inline__ vector unsigned char __ATTRS_o_ai
9224 vec_sldw(vector unsigned char __a, vector unsigned char __b,
9225          unsigned const int __c) {
9226   return vec_sld(__a, __b, ((__c << 2) & 0x0F));
9227 }
9228
9229 static __inline__ vector signed short __ATTRS_o_ai vec_sldw(
9230     vector signed short __a, vector signed short __b, unsigned const int __c) {
9231   return vec_sld(__a, __b, ((__c << 2) & 0x0F));
9232 }
9233
9234 static __inline__ vector unsigned short __ATTRS_o_ai
9235 vec_sldw(vector unsigned short __a, vector unsigned short __b,
9236          unsigned const int __c) {
9237   return vec_sld(__a, __b, ((__c << 2) & 0x0F));
9238 }
9239
9240 static __inline__ vector signed int __ATTRS_o_ai
9241 vec_sldw(vector signed int __a, vector signed int __b, unsigned const int __c) {
9242   return vec_sld(__a, __b, ((__c << 2) & 0x0F));
9243 }
9244
9245 static __inline__ vector unsigned int __ATTRS_o_ai vec_sldw(
9246     vector unsigned int __a, vector unsigned int __b, unsigned const int __c) {
9247   return vec_sld(__a, __b, ((__c << 2) & 0x0F));
9248 }
9249
9250 static __inline__ vector float __ATTRS_o_ai vec_sldw(
9251     vector float __a, vector float __b, unsigned const int __c) {
9252   return vec_sld(__a, __b, ((__c << 2) & 0x0F));
9253 }
9254
9255 #ifdef __VSX__
9256 static __inline__ vector signed long long __ATTRS_o_ai
9257 vec_sldw(vector signed long long __a, vector signed long long __b,
9258          unsigned const int __c) {
9259   return vec_sld(__a, __b, ((__c << 2) & 0x0F));
9260 }
9261
9262 static __inline__ vector unsigned long long __ATTRS_o_ai
9263 vec_sldw(vector unsigned long long __a, vector unsigned long long __b,
9264          unsigned const int __c) {
9265   return vec_sld(__a, __b, ((__c << 2) & 0x0F));
9266 }
9267
9268 static __inline__ vector double __ATTRS_o_ai vec_sldw(
9269     vector double __a, vector double __b, unsigned const int __c) {
9270   return vec_sld(__a, __b, ((__c << 2) & 0x0F));
9271 }
9272 #endif
9273
9274 #ifdef __POWER9_VECTOR__
9275 /* vec_slv */
9276 static __inline__ vector unsigned char __ATTRS_o_ai
9277 vec_slv(vector unsigned char __a, vector unsigned char __b) {
9278   return __builtin_altivec_vslv(__a, __b);
9279 }
9280
9281 /* vec_srv */
9282 static __inline__ vector unsigned char __ATTRS_o_ai
9283 vec_srv(vector unsigned char __a, vector unsigned char __b) {
9284   return __builtin_altivec_vsrv(__a, __b);
9285 }
9286 #endif
9287
9288 /* vec_vsldoi */
9289
9290 static __inline__ vector signed char __ATTRS_o_ai
9291 vec_vsldoi(vector signed char __a, vector signed char __b, unsigned char __c) {
9292   unsigned char __d = __c & 0x0F;
9293 #ifdef __LITTLE_ENDIAN__
9294   return vec_perm(
9295       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9296                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9297                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9298                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9299 #else
9300   return vec_perm(
9301       __a, __b,
9302       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9303                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9304                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9305 #endif
9306 }
9307
9308 static __inline__ vector unsigned char __ATTRS_o_ai vec_vsldoi(
9309     vector unsigned char __a, vector unsigned char __b, unsigned char __c) {
9310   unsigned char __d = __c & 0x0F;
9311 #ifdef __LITTLE_ENDIAN__
9312   return vec_perm(
9313       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9314                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9315                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9316                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9317 #else
9318   return vec_perm(
9319       __a, __b,
9320       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9321                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9322                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9323 #endif
9324 }
9325
9326 static __inline__ vector short __ATTRS_o_ai vec_vsldoi(vector short __a,
9327                                                        vector short __b,
9328                                                        unsigned char __c) {
9329   unsigned char __d = __c & 0x0F;
9330 #ifdef __LITTLE_ENDIAN__
9331   return vec_perm(
9332       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9333                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9334                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9335                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9336 #else
9337   return vec_perm(
9338       __a, __b,
9339       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9340                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9341                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9342 #endif
9343 }
9344
9345 static __inline__ vector unsigned short __ATTRS_o_ai vec_vsldoi(
9346     vector unsigned short __a, vector unsigned short __b, unsigned char __c) {
9347   unsigned char __d = __c & 0x0F;
9348 #ifdef __LITTLE_ENDIAN__
9349   return vec_perm(
9350       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9351                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9352                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9353                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9354 #else
9355   return vec_perm(
9356       __a, __b,
9357       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9358                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9359                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9360 #endif
9361 }
9362
9363 static __inline__ vector pixel __ATTRS_o_ai vec_vsldoi(vector pixel __a,
9364                                                        vector pixel __b,
9365                                                        unsigned char __c) {
9366   unsigned char __d = __c & 0x0F;
9367 #ifdef __LITTLE_ENDIAN__
9368   return vec_perm(
9369       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9370                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9371                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9372                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9373 #else
9374   return vec_perm(
9375       __a, __b,
9376       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9377                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9378                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9379 #endif
9380 }
9381
9382 static __inline__ vector int __ATTRS_o_ai vec_vsldoi(vector int __a,
9383                                                      vector int __b,
9384                                                      unsigned char __c) {
9385   unsigned char __d = __c & 0x0F;
9386 #ifdef __LITTLE_ENDIAN__
9387   return vec_perm(
9388       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9389                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9390                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9391                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9392 #else
9393   return vec_perm(
9394       __a, __b,
9395       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9396                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9397                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9398 #endif
9399 }
9400
9401 static __inline__ vector unsigned int __ATTRS_o_ai vec_vsldoi(
9402     vector unsigned int __a, vector unsigned int __b, unsigned char __c) {
9403   unsigned char __d = __c & 0x0F;
9404 #ifdef __LITTLE_ENDIAN__
9405   return vec_perm(
9406       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9407                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9408                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9409                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9410 #else
9411   return vec_perm(
9412       __a, __b,
9413       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9414                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9415                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9416 #endif
9417 }
9418
9419 static __inline__ vector float __ATTRS_o_ai vec_vsldoi(vector float __a,
9420                                                        vector float __b,
9421                                                        unsigned char __c) {
9422   unsigned char __d = __c & 0x0F;
9423 #ifdef __LITTLE_ENDIAN__
9424   return vec_perm(
9425       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9426                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9427                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9428                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9429 #else
9430   return vec_perm(
9431       __a, __b,
9432       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9433                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9434                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9435 #endif
9436 }
9437
9438 /* vec_sll */
9439
9440 static __inline__ vector signed char __ATTRS_o_ai
9441 vec_sll(vector signed char __a, vector unsigned char __b) {
9442   return (vector signed char)__builtin_altivec_vsl((vector int)__a,
9443                                                    (vector int)__b);
9444 }
9445
9446 static __inline__ vector signed char __ATTRS_o_ai
9447 vec_sll(vector signed char __a, vector unsigned short __b) {
9448   return (vector signed char)__builtin_altivec_vsl((vector int)__a,
9449                                                    (vector int)__b);
9450 }
9451
9452 static __inline__ vector signed char __ATTRS_o_ai
9453 vec_sll(vector signed char __a, vector unsigned int __b) {
9454   return (vector signed char)__builtin_altivec_vsl((vector int)__a,
9455                                                    (vector int)__b);
9456 }
9457
9458 static __inline__ vector unsigned char __ATTRS_o_ai
9459 vec_sll(vector unsigned char __a, vector unsigned char __b) {
9460   return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
9461                                                      (vector int)__b);
9462 }
9463
9464 static __inline__ vector unsigned char __ATTRS_o_ai
9465 vec_sll(vector unsigned char __a, vector unsigned short __b) {
9466   return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
9467                                                      (vector int)__b);
9468 }
9469
9470 static __inline__ vector unsigned char __ATTRS_o_ai
9471 vec_sll(vector unsigned char __a, vector unsigned int __b) {
9472   return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
9473                                                      (vector int)__b);
9474 }
9475
9476 static __inline__ vector bool char __ATTRS_o_ai
9477 vec_sll(vector bool char __a, vector unsigned char __b) {
9478   return (vector bool char)__builtin_altivec_vsl((vector int)__a,
9479                                                  (vector int)__b);
9480 }
9481
9482 static __inline__ vector bool char __ATTRS_o_ai
9483 vec_sll(vector bool char __a, vector unsigned short __b) {
9484   return (vector bool char)__builtin_altivec_vsl((vector int)__a,
9485                                                  (vector int)__b);
9486 }
9487
9488 static __inline__ vector bool char __ATTRS_o_ai
9489 vec_sll(vector bool char __a, vector unsigned int __b) {
9490   return (vector bool char)__builtin_altivec_vsl((vector int)__a,
9491                                                  (vector int)__b);
9492 }
9493
9494 static __inline__ vector short __ATTRS_o_ai vec_sll(vector short __a,
9495                                                     vector unsigned char __b) {
9496   return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
9497 }
9498
9499 static __inline__ vector short __ATTRS_o_ai vec_sll(vector short __a,
9500                                                     vector unsigned short __b) {
9501   return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
9502 }
9503
9504 static __inline__ vector short __ATTRS_o_ai vec_sll(vector short __a,
9505                                                     vector unsigned int __b) {
9506   return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
9507 }
9508
9509 static __inline__ vector unsigned short __ATTRS_o_ai
9510 vec_sll(vector unsigned short __a, vector unsigned char __b) {
9511   return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
9512                                                       (vector int)__b);
9513 }
9514
9515 static __inline__ vector unsigned short __ATTRS_o_ai
9516 vec_sll(vector unsigned short __a, vector unsigned short __b) {
9517   return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
9518                                                       (vector int)__b);
9519 }
9520
9521 static __inline__ vector unsigned short __ATTRS_o_ai
9522 vec_sll(vector unsigned short __a, vector unsigned int __b) {
9523   return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
9524                                                       (vector int)__b);
9525 }
9526
9527 static __inline__ vector bool short __ATTRS_o_ai
9528 vec_sll(vector bool short __a, vector unsigned char __b) {
9529   return (vector bool short)__builtin_altivec_vsl((vector int)__a,
9530                                                   (vector int)__b);
9531 }
9532
9533 static __inline__ vector bool short __ATTRS_o_ai
9534 vec_sll(vector bool short __a, vector unsigned short __b) {
9535   return (vector bool short)__builtin_altivec_vsl((vector int)__a,
9536                                                   (vector int)__b);
9537 }
9538
9539 static __inline__ vector bool short __ATTRS_o_ai
9540 vec_sll(vector bool short __a, vector unsigned int __b) {
9541   return (vector bool short)__builtin_altivec_vsl((vector int)__a,
9542                                                   (vector int)__b);
9543 }
9544
9545 static __inline__ vector pixel __ATTRS_o_ai vec_sll(vector pixel __a,
9546                                                     vector unsigned char __b) {
9547   return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
9548 }
9549
9550 static __inline__ vector pixel __ATTRS_o_ai vec_sll(vector pixel __a,
9551                                                     vector unsigned short __b) {
9552   return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
9553 }
9554
9555 static __inline__ vector pixel __ATTRS_o_ai vec_sll(vector pixel __a,
9556                                                     vector unsigned int __b) {
9557   return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
9558 }
9559
9560 static __inline__ vector int __ATTRS_o_ai vec_sll(vector int __a,
9561                                                   vector unsigned char __b) {
9562   return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
9563 }
9564
9565 static __inline__ vector int __ATTRS_o_ai vec_sll(vector int __a,
9566                                                   vector unsigned short __b) {
9567   return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
9568 }
9569
9570 static __inline__ vector int __ATTRS_o_ai vec_sll(vector int __a,
9571                                                   vector unsigned int __b) {
9572   return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
9573 }
9574
9575 static __inline__ vector unsigned int __ATTRS_o_ai
9576 vec_sll(vector unsigned int __a, vector unsigned char __b) {
9577   return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
9578                                                     (vector int)__b);
9579 }
9580
9581 static __inline__ vector unsigned int __ATTRS_o_ai
9582 vec_sll(vector unsigned int __a, vector unsigned short __b) {
9583   return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
9584                                                     (vector int)__b);
9585 }
9586
9587 static __inline__ vector unsigned int __ATTRS_o_ai
9588 vec_sll(vector unsigned int __a, vector unsigned int __b) {
9589   return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
9590                                                     (vector int)__b);
9591 }
9592
9593 static __inline__ vector bool int __ATTRS_o_ai
9594 vec_sll(vector bool int __a, vector unsigned char __b) {
9595   return (vector bool int)__builtin_altivec_vsl((vector int)__a,
9596                                                 (vector int)__b);
9597 }
9598
9599 static __inline__ vector bool int __ATTRS_o_ai
9600 vec_sll(vector bool int __a, vector unsigned short __b) {
9601   return (vector bool int)__builtin_altivec_vsl((vector int)__a,
9602                                                 (vector int)__b);
9603 }
9604
9605 static __inline__ vector bool int __ATTRS_o_ai
9606 vec_sll(vector bool int __a, vector unsigned int __b) {
9607   return (vector bool int)__builtin_altivec_vsl((vector int)__a,
9608                                                 (vector int)__b);
9609 }
9610
9611 #ifdef __VSX__
9612 static __inline__ vector signed long long __ATTRS_o_ai
9613 vec_sll(vector signed long long __a, vector unsigned char __b) {
9614   return (vector signed long long)__builtin_altivec_vsl((vector int)__a,
9615                                                         (vector int)__b);
9616 }
9617
9618 static __inline__ vector unsigned long long __ATTRS_o_ai
9619 vec_sll(vector unsigned long long __a, vector unsigned char __b) {
9620   return (vector unsigned long long)__builtin_altivec_vsl((vector int)__a,
9621                                                           (vector int)__b);
9622 }
9623 #endif
9624
9625 /* vec_vsl */
9626
9627 static __inline__ vector signed char __ATTRS_o_ai
9628 vec_vsl(vector signed char __a, vector unsigned char __b) {
9629   return (vector signed char)__builtin_altivec_vsl((vector int)__a,
9630                                                    (vector int)__b);
9631 }
9632
9633 static __inline__ vector signed char __ATTRS_o_ai
9634 vec_vsl(vector signed char __a, vector unsigned short __b) {
9635   return (vector signed char)__builtin_altivec_vsl((vector int)__a,
9636                                                    (vector int)__b);
9637 }
9638
9639 static __inline__ vector signed char __ATTRS_o_ai
9640 vec_vsl(vector signed char __a, vector unsigned int __b) {
9641   return (vector signed char)__builtin_altivec_vsl((vector int)__a,
9642                                                    (vector int)__b);
9643 }
9644
9645 static __inline__ vector unsigned char __ATTRS_o_ai
9646 vec_vsl(vector unsigned char __a, vector unsigned char __b) {
9647   return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
9648                                                      (vector int)__b);
9649 }
9650
9651 static __inline__ vector unsigned char __ATTRS_o_ai
9652 vec_vsl(vector unsigned char __a, vector unsigned short __b) {
9653   return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
9654                                                      (vector int)__b);
9655 }
9656
9657 static __inline__ vector unsigned char __ATTRS_o_ai
9658 vec_vsl(vector unsigned char __a, vector unsigned int __b) {
9659   return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
9660                                                      (vector int)__b);
9661 }
9662
9663 static __inline__ vector bool char __ATTRS_o_ai
9664 vec_vsl(vector bool char __a, vector unsigned char __b) {
9665   return (vector bool char)__builtin_altivec_vsl((vector int)__a,
9666                                                  (vector int)__b);
9667 }
9668
9669 static __inline__ vector bool char __ATTRS_o_ai
9670 vec_vsl(vector bool char __a, vector unsigned short __b) {
9671   return (vector bool char)__builtin_altivec_vsl((vector int)__a,
9672                                                  (vector int)__b);
9673 }
9674
9675 static __inline__ vector bool char __ATTRS_o_ai
9676 vec_vsl(vector bool char __a, vector unsigned int __b) {
9677   return (vector bool char)__builtin_altivec_vsl((vector int)__a,
9678                                                  (vector int)__b);
9679 }
9680
9681 static __inline__ vector short __ATTRS_o_ai vec_vsl(vector short __a,
9682                                                     vector unsigned char __b) {
9683   return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
9684 }
9685
9686 static __inline__ vector short __ATTRS_o_ai vec_vsl(vector short __a,
9687                                                     vector unsigned short __b) {
9688   return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
9689 }
9690
9691 static __inline__ vector short __ATTRS_o_ai vec_vsl(vector short __a,
9692                                                     vector unsigned int __b) {
9693   return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
9694 }
9695
9696 static __inline__ vector unsigned short __ATTRS_o_ai
9697 vec_vsl(vector unsigned short __a, vector unsigned char __b) {
9698   return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
9699                                                       (vector int)__b);
9700 }
9701
9702 static __inline__ vector unsigned short __ATTRS_o_ai
9703 vec_vsl(vector unsigned short __a, vector unsigned short __b) {
9704   return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
9705                                                       (vector int)__b);
9706 }
9707
9708 static __inline__ vector unsigned short __ATTRS_o_ai
9709 vec_vsl(vector unsigned short __a, vector unsigned int __b) {
9710   return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
9711                                                       (vector int)__b);
9712 }
9713
9714 static __inline__ vector bool short __ATTRS_o_ai
9715 vec_vsl(vector bool short __a, vector unsigned char __b) {
9716   return (vector bool short)__builtin_altivec_vsl((vector int)__a,
9717                                                   (vector int)__b);
9718 }
9719
9720 static __inline__ vector bool short __ATTRS_o_ai
9721 vec_vsl(vector bool short __a, vector unsigned short __b) {
9722   return (vector bool short)__builtin_altivec_vsl((vector int)__a,
9723                                                   (vector int)__b);
9724 }
9725
9726 static __inline__ vector bool short __ATTRS_o_ai
9727 vec_vsl(vector bool short __a, vector unsigned int __b) {
9728   return (vector bool short)__builtin_altivec_vsl((vector int)__a,
9729                                                   (vector int)__b);
9730 }
9731
9732 static __inline__ vector pixel __ATTRS_o_ai vec_vsl(vector pixel __a,
9733                                                     vector unsigned char __b) {
9734   return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
9735 }
9736
9737 static __inline__ vector pixel __ATTRS_o_ai vec_vsl(vector pixel __a,
9738                                                     vector unsigned short __b) {
9739   return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
9740 }
9741
9742 static __inline__ vector pixel __ATTRS_o_ai vec_vsl(vector pixel __a,
9743                                                     vector unsigned int __b) {
9744   return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
9745 }
9746
9747 static __inline__ vector int __ATTRS_o_ai vec_vsl(vector int __a,
9748                                                   vector unsigned char __b) {
9749   return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
9750 }
9751
9752 static __inline__ vector int __ATTRS_o_ai vec_vsl(vector int __a,
9753                                                   vector unsigned short __b) {
9754   return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
9755 }
9756
9757 static __inline__ vector int __ATTRS_o_ai vec_vsl(vector int __a,
9758                                                   vector unsigned int __b) {
9759   return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
9760 }
9761
9762 static __inline__ vector unsigned int __ATTRS_o_ai
9763 vec_vsl(vector unsigned int __a, vector unsigned char __b) {
9764   return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
9765                                                     (vector int)__b);
9766 }
9767
9768 static __inline__ vector unsigned int __ATTRS_o_ai
9769 vec_vsl(vector unsigned int __a, vector unsigned short __b) {
9770   return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
9771                                                     (vector int)__b);
9772 }
9773
9774 static __inline__ vector unsigned int __ATTRS_o_ai
9775 vec_vsl(vector unsigned int __a, vector unsigned int __b) {
9776   return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
9777                                                     (vector int)__b);
9778 }
9779
9780 static __inline__ vector bool int __ATTRS_o_ai
9781 vec_vsl(vector bool int __a, vector unsigned char __b) {
9782   return (vector bool int)__builtin_altivec_vsl((vector int)__a,
9783                                                 (vector int)__b);
9784 }
9785
9786 static __inline__ vector bool int __ATTRS_o_ai
9787 vec_vsl(vector bool int __a, vector unsigned short __b) {
9788   return (vector bool int)__builtin_altivec_vsl((vector int)__a,
9789                                                 (vector int)__b);
9790 }
9791
9792 static __inline__ vector bool int __ATTRS_o_ai
9793 vec_vsl(vector bool int __a, vector unsigned int __b) {
9794   return (vector bool int)__builtin_altivec_vsl((vector int)__a,
9795                                                 (vector int)__b);
9796 }
9797
9798 /* vec_slo */
9799
9800 static __inline__ vector signed char __ATTRS_o_ai
9801 vec_slo(vector signed char __a, vector signed char __b) {
9802   return (vector signed char)__builtin_altivec_vslo((vector int)__a,
9803                                                     (vector int)__b);
9804 }
9805
9806 static __inline__ vector signed char __ATTRS_o_ai
9807 vec_slo(vector signed char __a, vector unsigned char __b) {
9808   return (vector signed char)__builtin_altivec_vslo((vector int)__a,
9809                                                     (vector int)__b);
9810 }
9811
9812 static __inline__ vector unsigned char __ATTRS_o_ai
9813 vec_slo(vector unsigned char __a, vector signed char __b) {
9814   return (vector unsigned char)__builtin_altivec_vslo((vector int)__a,
9815                                                       (vector int)__b);
9816 }
9817
9818 static __inline__ vector unsigned char __ATTRS_o_ai
9819 vec_slo(vector unsigned char __a, vector unsigned char __b) {
9820   return (vector unsigned char)__builtin_altivec_vslo((vector int)__a,
9821                                                       (vector int)__b);
9822 }
9823
9824 static __inline__ vector short __ATTRS_o_ai vec_slo(vector short __a,
9825                                                     vector signed char __b) {
9826   return (vector short)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9827 }
9828
9829 static __inline__ vector short __ATTRS_o_ai vec_slo(vector short __a,
9830                                                     vector unsigned char __b) {
9831   return (vector short)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9832 }
9833
9834 static __inline__ vector unsigned short __ATTRS_o_ai
9835 vec_slo(vector unsigned short __a, vector signed char __b) {
9836   return (vector unsigned short)__builtin_altivec_vslo((vector int)__a,
9837                                                        (vector int)__b);
9838 }
9839
9840 static __inline__ vector unsigned short __ATTRS_o_ai
9841 vec_slo(vector unsigned short __a, vector unsigned char __b) {
9842   return (vector unsigned short)__builtin_altivec_vslo((vector int)__a,
9843                                                        (vector int)__b);
9844 }
9845
9846 static __inline__ vector pixel __ATTRS_o_ai vec_slo(vector pixel __a,
9847                                                     vector signed char __b) {
9848   return (vector pixel)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9849 }
9850
9851 static __inline__ vector pixel __ATTRS_o_ai vec_slo(vector pixel __a,
9852                                                     vector unsigned char __b) {
9853   return (vector pixel)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9854 }
9855
9856 static __inline__ vector int __ATTRS_o_ai vec_slo(vector int __a,
9857                                                   vector signed char __b) {
9858   return (vector int)__builtin_altivec_vslo(__a, (vector int)__b);
9859 }
9860
9861 static __inline__ vector int __ATTRS_o_ai vec_slo(vector int __a,
9862                                                   vector unsigned char __b) {
9863   return (vector int)__builtin_altivec_vslo(__a, (vector int)__b);
9864 }
9865
9866 static __inline__ vector unsigned int __ATTRS_o_ai
9867 vec_slo(vector unsigned int __a, vector signed char __b) {
9868   return (vector unsigned int)__builtin_altivec_vslo((vector int)__a,
9869                                                      (vector int)__b);
9870 }
9871
9872 static __inline__ vector unsigned int __ATTRS_o_ai
9873 vec_slo(vector unsigned int __a, vector unsigned char __b) {
9874   return (vector unsigned int)__builtin_altivec_vslo((vector int)__a,
9875                                                      (vector int)__b);
9876 }
9877
9878 static __inline__ vector float __ATTRS_o_ai vec_slo(vector float __a,
9879                                                     vector signed char __b) {
9880   return (vector float)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9881 }
9882
9883 static __inline__ vector float __ATTRS_o_ai vec_slo(vector float __a,
9884                                                     vector unsigned char __b) {
9885   return (vector float)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9886 }
9887
9888 #ifdef __VSX__
9889 static __inline__ vector signed long long __ATTRS_o_ai
9890 vec_slo(vector signed long long __a, vector signed char __b) {
9891   return (vector signed long long)__builtin_altivec_vslo((vector int)__a,
9892                                                          (vector int)__b);
9893 }
9894
9895 static __inline__ vector signed long long __ATTRS_o_ai
9896 vec_slo(vector signed long long __a, vector unsigned char __b) {
9897   return (vector signed long long)__builtin_altivec_vslo((vector int)__a,
9898                                                          (vector int)__b);
9899 }
9900
9901 static __inline__ vector unsigned long long __ATTRS_o_ai
9902 vec_slo(vector unsigned long long __a, vector signed char __b) {
9903   return (vector unsigned long long)__builtin_altivec_vslo((vector int)__a,
9904                                                            (vector int)__b);
9905 }
9906
9907 static __inline__ vector unsigned long long __ATTRS_o_ai
9908 vec_slo(vector unsigned long long __a, vector unsigned char __b) {
9909   return (vector unsigned long long)__builtin_altivec_vslo((vector int)__a,
9910                                                            (vector int)__b);
9911 }
9912 #endif
9913
9914 /* vec_vslo */
9915
9916 static __inline__ vector signed char __ATTRS_o_ai
9917 vec_vslo(vector signed char __a, vector signed char __b) {
9918   return (vector signed char)__builtin_altivec_vslo((vector int)__a,
9919                                                     (vector int)__b);
9920 }
9921
9922 static __inline__ vector signed char __ATTRS_o_ai
9923 vec_vslo(vector signed char __a, vector unsigned char __b) {
9924   return (vector signed char)__builtin_altivec_vslo((vector int)__a,
9925                                                     (vector int)__b);
9926 }
9927
9928 static __inline__ vector unsigned char __ATTRS_o_ai
9929 vec_vslo(vector unsigned char __a, vector signed char __b) {
9930   return (vector unsigned char)__builtin_altivec_vslo((vector int)__a,
9931                                                       (vector int)__b);
9932 }
9933
9934 static __inline__ vector unsigned char __ATTRS_o_ai
9935 vec_vslo(vector unsigned char __a, vector unsigned char __b) {
9936   return (vector unsigned char)__builtin_altivec_vslo((vector int)__a,
9937                                                       (vector int)__b);
9938 }
9939
9940 static __inline__ vector short __ATTRS_o_ai vec_vslo(vector short __a,
9941                                                      vector signed char __b) {
9942   return (vector short)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9943 }
9944
9945 static __inline__ vector short __ATTRS_o_ai vec_vslo(vector short __a,
9946                                                      vector unsigned char __b) {
9947   return (vector short)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9948 }
9949
9950 static __inline__ vector unsigned short __ATTRS_o_ai
9951 vec_vslo(vector unsigned short __a, vector signed char __b) {
9952   return (vector unsigned short)__builtin_altivec_vslo((vector int)__a,
9953                                                        (vector int)__b);
9954 }
9955
9956 static __inline__ vector unsigned short __ATTRS_o_ai
9957 vec_vslo(vector unsigned short __a, vector unsigned char __b) {
9958   return (vector unsigned short)__builtin_altivec_vslo((vector int)__a,
9959                                                        (vector int)__b);
9960 }
9961
9962 static __inline__ vector pixel __ATTRS_o_ai vec_vslo(vector pixel __a,
9963                                                      vector signed char __b) {
9964   return (vector pixel)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9965 }
9966
9967 static __inline__ vector pixel __ATTRS_o_ai vec_vslo(vector pixel __a,
9968                                                      vector unsigned char __b) {
9969   return (vector pixel)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9970 }
9971
9972 static __inline__ vector int __ATTRS_o_ai vec_vslo(vector int __a,
9973                                                    vector signed char __b) {
9974   return (vector int)__builtin_altivec_vslo(__a, (vector int)__b);
9975 }
9976
9977 static __inline__ vector int __ATTRS_o_ai vec_vslo(vector int __a,
9978                                                    vector unsigned char __b) {
9979   return (vector int)__builtin_altivec_vslo(__a, (vector int)__b);
9980 }
9981
9982 static __inline__ vector unsigned int __ATTRS_o_ai
9983 vec_vslo(vector unsigned int __a, vector signed char __b) {
9984   return (vector unsigned int)__builtin_altivec_vslo((vector int)__a,
9985                                                      (vector int)__b);
9986 }
9987
9988 static __inline__ vector unsigned int __ATTRS_o_ai
9989 vec_vslo(vector unsigned int __a, vector unsigned char __b) {
9990   return (vector unsigned int)__builtin_altivec_vslo((vector int)__a,
9991                                                      (vector int)__b);
9992 }
9993
9994 static __inline__ vector float __ATTRS_o_ai vec_vslo(vector float __a,
9995                                                      vector signed char __b) {
9996   return (vector float)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9997 }
9998
9999 static __inline__ vector float __ATTRS_o_ai vec_vslo(vector float __a,
10000                                                      vector unsigned char __b) {
10001   return (vector float)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
10002 }
10003
10004 /* vec_splat */
10005
10006 static __inline__ vector signed char __ATTRS_o_ai
10007 vec_splat(vector signed char __a, unsigned const int __b) {
10008   return vec_perm(__a, __a, (vector unsigned char)(__b & 0x0F));
10009 }
10010
10011 static __inline__ vector unsigned char __ATTRS_o_ai
10012 vec_splat(vector unsigned char __a, unsigned const int __b) {
10013   return vec_perm(__a, __a, (vector unsigned char)(__b & 0x0F));
10014 }
10015
10016 static __inline__ vector bool char __ATTRS_o_ai
10017 vec_splat(vector bool char __a, unsigned const int __b) {
10018   return vec_perm(__a, __a, (vector unsigned char)(__b & 0x0F));
10019 }
10020
10021 static __inline__ vector signed short __ATTRS_o_ai
10022 vec_splat(vector signed short __a, unsigned const int __b) {
10023   unsigned char b0 = (__b & 0x07) * 2;
10024   unsigned char b1 = b0 + 1;
10025   return vec_perm(__a, __a,
10026                   (vector unsigned char)(b0, b1, b0, b1, b0, b1, b0, b1, b0, b1,
10027                                          b0, b1, b0, b1, b0, b1));
10028 }
10029
10030 static __inline__ vector unsigned short __ATTRS_o_ai
10031 vec_splat(vector unsigned short __a, unsigned const int __b) {
10032   unsigned char b0 = (__b & 0x07) * 2;
10033   unsigned char b1 = b0 + 1;
10034   return vec_perm(__a, __a,
10035                   (vector unsigned char)(b0, b1, b0, b1, b0, b1, b0, b1, b0, b1,
10036                                          b0, b1, b0, b1, b0, b1));
10037 }
10038
10039 static __inline__ vector bool short __ATTRS_o_ai
10040 vec_splat(vector bool short __a, unsigned const int __b) {
10041   unsigned char b0 = (__b & 0x07) * 2;
10042   unsigned char b1 = b0 + 1;
10043   return vec_perm(__a, __a,
10044                   (vector unsigned char)(b0, b1, b0, b1, b0, b1, b0, b1, b0, b1,
10045                                          b0, b1, b0, b1, b0, b1));
10046 }
10047
10048 static __inline__ vector pixel __ATTRS_o_ai vec_splat(vector pixel __a,
10049                                                       unsigned const int __b) {
10050   unsigned char b0 = (__b & 0x07) * 2;
10051   unsigned char b1 = b0 + 1;
10052   return vec_perm(__a, __a,
10053                   (vector unsigned char)(b0, b1, b0, b1, b0, b1, b0, b1, b0, b1,
10054                                          b0, b1, b0, b1, b0, b1));
10055 }
10056
10057 static __inline__ vector signed int __ATTRS_o_ai
10058 vec_splat(vector signed int __a, unsigned const int __b) {
10059   unsigned char b0 = (__b & 0x03) * 4;
10060   unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3;
10061   return vec_perm(__a, __a,
10062                   (vector unsigned char)(b0, b1, b2, b3, b0, b1, b2, b3, b0, b1,
10063                                          b2, b3, b0, b1, b2, b3));
10064 }
10065
10066 static __inline__ vector unsigned int __ATTRS_o_ai
10067 vec_splat(vector unsigned int __a, unsigned const int __b) {
10068   unsigned char b0 = (__b & 0x03) * 4;
10069   unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3;
10070   return vec_perm(__a, __a,
10071                   (vector unsigned char)(b0, b1, b2, b3, b0, b1, b2, b3, b0, b1,
10072                                          b2, b3, b0, b1, b2, b3));
10073 }
10074
10075 static __inline__ vector bool int __ATTRS_o_ai
10076 vec_splat(vector bool int __a, unsigned const int __b) {
10077   unsigned char b0 = (__b & 0x03) * 4;
10078   unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3;
10079   return vec_perm(__a, __a,
10080                   (vector unsigned char)(b0, b1, b2, b3, b0, b1, b2, b3, b0, b1,
10081                                          b2, b3, b0, b1, b2, b3));
10082 }
10083
10084 static __inline__ vector float __ATTRS_o_ai vec_splat(vector float __a,
10085                                                       unsigned const int __b) {
10086   unsigned char b0 = (__b & 0x03) * 4;
10087   unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3;
10088   return vec_perm(__a, __a,
10089                   (vector unsigned char)(b0, b1, b2, b3, b0, b1, b2, b3, b0, b1,
10090                                          b2, b3, b0, b1, b2, b3));
10091 }
10092
10093 #ifdef __VSX__
10094 static __inline__ vector double __ATTRS_o_ai vec_splat(vector double __a,
10095                                                        unsigned const int __b) {
10096   unsigned char b0 = (__b & 0x01) * 8;
10097   unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3, b4 = b0 + 4, b5 = b0 + 5,
10098                 b6 = b0 + 6, b7 = b0 + 7;
10099   return vec_perm(__a, __a,
10100                   (vector unsigned char)(b0, b1, b2, b3, b4, b5, b6, b7, b0, b1,
10101                                          b2, b3, b4, b5, b6, b7));
10102 }
10103 static __inline__ vector bool long long __ATTRS_o_ai
10104 vec_splat(vector bool long long __a, unsigned const int __b) {
10105   unsigned char b0 = (__b & 0x01) * 8;
10106   unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3, b4 = b0 + 4, b5 = b0 + 5,
10107                 b6 = b0 + 6, b7 = b0 + 7;
10108   return vec_perm(__a, __a,
10109                   (vector unsigned char)(b0, b1, b2, b3, b4, b5, b6, b7, b0, b1,
10110                                          b2, b3, b4, b5, b6, b7));
10111 }
10112 static __inline__ vector signed long long __ATTRS_o_ai
10113 vec_splat(vector signed long long __a, unsigned const int __b) {
10114   unsigned char b0 = (__b & 0x01) * 8;
10115   unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3, b4 = b0 + 4, b5 = b0 + 5,
10116                 b6 = b0 + 6, b7 = b0 + 7;
10117   return vec_perm(__a, __a,
10118                   (vector unsigned char)(b0, b1, b2, b3, b4, b5, b6, b7, b0, b1,
10119                                          b2, b3, b4, b5, b6, b7));
10120 }
10121 static __inline__ vector unsigned long long __ATTRS_o_ai
10122 vec_splat(vector unsigned long long __a, unsigned const int __b) {
10123   unsigned char b0 = (__b & 0x01) * 8;
10124   unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3, b4 = b0 + 4, b5 = b0 + 5,
10125                 b6 = b0 + 6, b7 = b0 + 7;
10126   return vec_perm(__a, __a,
10127                   (vector unsigned char)(b0, b1, b2, b3, b4, b5, b6, b7, b0, b1,
10128                                          b2, b3, b4, b5, b6, b7));
10129 }
10130 #endif
10131
10132 /* vec_vspltb */
10133
10134 #define __builtin_altivec_vspltb vec_vspltb
10135
10136 static __inline__ vector signed char __ATTRS_o_ai
10137 vec_vspltb(vector signed char __a, unsigned char __b) {
10138   return vec_perm(__a, __a, (vector unsigned char)(__b));
10139 }
10140
10141 static __inline__ vector unsigned char __ATTRS_o_ai
10142 vec_vspltb(vector unsigned char __a, unsigned char __b) {
10143   return vec_perm(__a, __a, (vector unsigned char)(__b));
10144 }
10145
10146 static __inline__ vector bool char __ATTRS_o_ai vec_vspltb(vector bool char __a,
10147                                                            unsigned char __b) {
10148   return vec_perm(__a, __a, (vector unsigned char)(__b));
10149 }
10150
10151 /* vec_vsplth */
10152
10153 #define __builtin_altivec_vsplth vec_vsplth
10154
10155 static __inline__ vector short __ATTRS_o_ai vec_vsplth(vector short __a,
10156                                                        unsigned char __b) {
10157   __b *= 2;
10158   unsigned char b1 = __b + 1;
10159   return vec_perm(__a, __a,
10160                   (vector unsigned char)(__b, b1, __b, b1, __b, b1, __b, b1,
10161                                          __b, b1, __b, b1, __b, b1, __b, b1));
10162 }
10163
10164 static __inline__ vector unsigned short __ATTRS_o_ai
10165 vec_vsplth(vector unsigned short __a, unsigned char __b) {
10166   __b *= 2;
10167   unsigned char b1 = __b + 1;
10168   return vec_perm(__a, __a,
10169                   (vector unsigned char)(__b, b1, __b, b1, __b, b1, __b, b1,
10170                                          __b, b1, __b, b1, __b, b1, __b, b1));
10171 }
10172
10173 static __inline__ vector bool short __ATTRS_o_ai
10174 vec_vsplth(vector bool short __a, unsigned char __b) {
10175   __b *= 2;
10176   unsigned char b1 = __b + 1;
10177   return vec_perm(__a, __a,
10178                   (vector unsigned char)(__b, b1, __b, b1, __b, b1, __b, b1,
10179                                          __b, b1, __b, b1, __b, b1, __b, b1));
10180 }
10181
10182 static __inline__ vector pixel __ATTRS_o_ai vec_vsplth(vector pixel __a,
10183                                                        unsigned char __b) {
10184   __b *= 2;
10185   unsigned char b1 = __b + 1;
10186   return vec_perm(__a, __a,
10187                   (vector unsigned char)(__b, b1, __b, b1, __b, b1, __b, b1,
10188                                          __b, b1, __b, b1, __b, b1, __b, b1));
10189 }
10190
10191 /* vec_vspltw */
10192
10193 #define __builtin_altivec_vspltw vec_vspltw
10194
10195 static __inline__ vector int __ATTRS_o_ai vec_vspltw(vector int __a,
10196                                                      unsigned char __b) {
10197   __b *= 4;
10198   unsigned char b1 = __b + 1, b2 = __b + 2, b3 = __b + 3;
10199   return vec_perm(__a, __a,
10200                   (vector unsigned char)(__b, b1, b2, b3, __b, b1, b2, b3, __b,
10201                                          b1, b2, b3, __b, b1, b2, b3));
10202 }
10203
10204 static __inline__ vector unsigned int __ATTRS_o_ai
10205 vec_vspltw(vector unsigned int __a, unsigned char __b) {
10206   __b *= 4;
10207   unsigned char b1 = __b + 1, b2 = __b + 2, b3 = __b + 3;
10208   return vec_perm(__a, __a,
10209                   (vector unsigned char)(__b, b1, b2, b3, __b, b1, b2, b3, __b,
10210                                          b1, b2, b3, __b, b1, b2, b3));
10211 }
10212
10213 static __inline__ vector bool int __ATTRS_o_ai vec_vspltw(vector bool int __a,
10214                                                           unsigned char __b) {
10215   __b *= 4;
10216   unsigned char b1 = __b + 1, b2 = __b + 2, b3 = __b + 3;
10217   return vec_perm(__a, __a,
10218                   (vector unsigned char)(__b, b1, b2, b3, __b, b1, b2, b3, __b,
10219                                          b1, b2, b3, __b, b1, b2, b3));
10220 }
10221
10222 static __inline__ vector float __ATTRS_o_ai vec_vspltw(vector float __a,
10223                                                        unsigned char __b) {
10224   __b *= 4;
10225   unsigned char b1 = __b + 1, b2 = __b + 2, b3 = __b + 3;
10226   return vec_perm(__a, __a,
10227                   (vector unsigned char)(__b, b1, b2, b3, __b, b1, b2, b3, __b,
10228                                          b1, b2, b3, __b, b1, b2, b3));
10229 }
10230
10231 /* vec_splat_s8 */
10232
10233 #define __builtin_altivec_vspltisb vec_splat_s8
10234
10235 // FIXME: parameter should be treated as 5-bit signed literal
10236 static __inline__ vector signed char __ATTRS_o_ai
10237 vec_splat_s8(signed char __a) {
10238   return (vector signed char)(__a);
10239 }
10240
10241 /* vec_vspltisb */
10242
10243 // FIXME: parameter should be treated as 5-bit signed literal
10244 static __inline__ vector signed char __ATTRS_o_ai
10245 vec_vspltisb(signed char __a) {
10246   return (vector signed char)(__a);
10247 }
10248
10249 /* vec_splat_s16 */
10250
10251 #define __builtin_altivec_vspltish vec_splat_s16
10252
10253 // FIXME: parameter should be treated as 5-bit signed literal
10254 static __inline__ vector short __ATTRS_o_ai vec_splat_s16(signed char __a) {
10255   return (vector short)(__a);
10256 }
10257
10258 /* vec_vspltish */
10259
10260 // FIXME: parameter should be treated as 5-bit signed literal
10261 static __inline__ vector short __ATTRS_o_ai vec_vspltish(signed char __a) {
10262   return (vector short)(__a);
10263 }
10264
10265 /* vec_splat_s32 */
10266
10267 #define __builtin_altivec_vspltisw vec_splat_s32
10268
10269 // FIXME: parameter should be treated as 5-bit signed literal
10270 static __inline__ vector int __ATTRS_o_ai vec_splat_s32(signed char __a) {
10271   return (vector int)(__a);
10272 }
10273
10274 /* vec_vspltisw */
10275
10276 // FIXME: parameter should be treated as 5-bit signed literal
10277 static __inline__ vector int __ATTRS_o_ai vec_vspltisw(signed char __a) {
10278   return (vector int)(__a);
10279 }
10280
10281 /* vec_splat_u8 */
10282
10283 // FIXME: parameter should be treated as 5-bit signed literal
10284 static __inline__ vector unsigned char __ATTRS_o_ai
10285 vec_splat_u8(unsigned char __a) {
10286   return (vector unsigned char)(__a);
10287 }
10288
10289 /* vec_splat_u16 */
10290
10291 // FIXME: parameter should be treated as 5-bit signed literal
10292 static __inline__ vector unsigned short __ATTRS_o_ai
10293 vec_splat_u16(signed char __a) {
10294   return (vector unsigned short)(__a);
10295 }
10296
10297 /* vec_splat_u32 */
10298
10299 // FIXME: parameter should be treated as 5-bit signed literal
10300 static __inline__ vector unsigned int __ATTRS_o_ai
10301 vec_splat_u32(signed char __a) {
10302   return (vector unsigned int)(__a);
10303 }
10304
10305 /* vec_sr */
10306
10307 // vec_sr does modulo arithmetic on __b first, so __b is allowed to be more
10308 // than the length of __a.
10309 static __inline__ vector unsigned char __ATTRS_o_ai
10310 vec_sr(vector unsigned char __a, vector unsigned char __b) {
10311   return __a >>
10312          (__b % (vector unsigned char)(sizeof(unsigned char) * __CHAR_BIT__));
10313 }
10314
10315 static __inline__ vector signed char __ATTRS_o_ai
10316 vec_sr(vector signed char __a, vector unsigned char __b) {
10317   return (vector signed char)vec_sr((vector unsigned char)__a, __b);
10318 }
10319
10320 static __inline__ vector unsigned short __ATTRS_o_ai
10321 vec_sr(vector unsigned short __a, vector unsigned short __b) {
10322   return __a >>
10323          (__b % (vector unsigned short)(sizeof(unsigned short) * __CHAR_BIT__));
10324 }
10325
10326 static __inline__ vector short __ATTRS_o_ai vec_sr(vector short __a,
10327                                                    vector unsigned short __b) {
10328   return (vector short)vec_sr((vector unsigned short)__a, __b);
10329 }
10330
10331 static __inline__ vector unsigned int __ATTRS_o_ai
10332 vec_sr(vector unsigned int __a, vector unsigned int __b) {
10333   return __a >>
10334          (__b % (vector unsigned int)(sizeof(unsigned int) * __CHAR_BIT__));
10335 }
10336
10337 static __inline__ vector int __ATTRS_o_ai vec_sr(vector int __a,
10338                                                  vector unsigned int __b) {
10339   return (vector int)vec_sr((vector unsigned int)__a, __b);
10340 }
10341
10342 #ifdef __POWER8_VECTOR__
10343 static __inline__ vector unsigned long long __ATTRS_o_ai
10344 vec_sr(vector unsigned long long __a, vector unsigned long long __b) {
10345   return __a >> (__b % (vector unsigned long long)(sizeof(unsigned long long) *
10346                                                    __CHAR_BIT__));
10347 }
10348
10349 static __inline__ vector long long __ATTRS_o_ai
10350 vec_sr(vector long long __a, vector unsigned long long __b) {
10351   return (vector long long)vec_sr((vector unsigned long long)__a, __b);
10352 }
10353 #else
10354 static __inline__ vector unsigned long long __ATTRS_o_ai
10355 vec_sr(vector unsigned long long __a, vector unsigned long long __b) {
10356   __b %= (vector unsigned long long)(sizeof(unsigned long long) * __CHAR_BIT__);
10357
10358   // Big endian element zero (the left doubleword) can be right shifted as-is.
10359   // However the shift amount must be in the right doubleword.
10360   // The other element needs to be swapped into the left doubleword and
10361   // shifted. Then the left doublewords of the two result vectors are merged.
10362   vector unsigned long long __swapshift =
10363       __builtin_shufflevector(__b, __b, 1, 0);
10364   vector unsigned long long __leftelt =
10365       (vector unsigned long long)__builtin_altivec_vsro(
10366           (vector signed int)__a, (vector signed int)__swapshift);
10367 #ifdef __LITTLE_ENDIAN__
10368   __leftelt = (vector unsigned long long)__builtin_altivec_vsr(
10369       (vector signed int)__leftelt,
10370       (vector signed int)vec_vspltb((vector unsigned char)__swapshift, 0));
10371 #else
10372   __leftelt = (vector unsigned long long)__builtin_altivec_vsr(
10373       (vector signed int)__leftelt,
10374       (vector signed int)vec_vspltb((vector unsigned char)__swapshift, 15));
10375 #endif
10376   __a = __builtin_shufflevector(__a, __a, 1, 0);
10377   vector unsigned long long __rightelt =
10378       (vector unsigned long long)__builtin_altivec_vsro((vector signed int)__a,
10379                                                         (vector signed int)__b);
10380 #ifdef __LITTLE_ENDIAN__
10381   __rightelt = (vector unsigned long long)__builtin_altivec_vsr(
10382       (vector signed int)__rightelt,
10383       (vector signed int)vec_vspltb((vector unsigned char)__b, 0));
10384   return __builtin_shufflevector(__rightelt, __leftelt, 1, 3);
10385 #else
10386   __rightelt = (vector unsigned long long)__builtin_altivec_vsr(
10387       (vector signed int)__rightelt,
10388       (vector signed int)vec_vspltb((vector unsigned char)__b, 15));
10389   return __builtin_shufflevector(__leftelt, __rightelt, 0, 2);
10390 #endif
10391 }
10392
10393 static __inline__ vector long long __ATTRS_o_ai
10394 vec_sr(vector long long __a, vector unsigned long long __b) {
10395   return (vector long long)vec_sr((vector unsigned long long)__a, __b);
10396 }
10397 #endif
10398
10399 /* vec_vsrb */
10400
10401 #define __builtin_altivec_vsrb vec_vsrb
10402
10403 static __inline__ vector signed char __ATTRS_o_ai
10404 vec_vsrb(vector signed char __a, vector unsigned char __b) {
10405   return vec_sr(__a, __b);
10406 }
10407
10408 static __inline__ vector unsigned char __ATTRS_o_ai
10409 vec_vsrb(vector unsigned char __a, vector unsigned char __b) {
10410   return vec_sr(__a, __b);
10411 }
10412
10413 /* vec_vsrh */
10414
10415 #define __builtin_altivec_vsrh vec_vsrh
10416
10417 static __inline__ vector short __ATTRS_o_ai
10418 vec_vsrh(vector short __a, vector unsigned short __b) {
10419   return vec_sr(__a, __b);
10420 }
10421
10422 static __inline__ vector unsigned short __ATTRS_o_ai
10423 vec_vsrh(vector unsigned short __a, vector unsigned short __b) {
10424   return vec_sr(__a, __b);
10425 }
10426
10427 /* vec_vsrw */
10428
10429 #define __builtin_altivec_vsrw vec_vsrw
10430
10431 static __inline__ vector int __ATTRS_o_ai vec_vsrw(vector int __a,
10432                                                    vector unsigned int __b) {
10433   return vec_sr(__a, __b);
10434 }
10435
10436 static __inline__ vector unsigned int __ATTRS_o_ai
10437 vec_vsrw(vector unsigned int __a, vector unsigned int __b) {
10438   return vec_sr(__a, __b);
10439 }
10440
10441 /* vec_sra */
10442
10443 static __inline__ vector signed char __ATTRS_o_ai
10444 vec_sra(vector signed char __a, vector unsigned char __b) {
10445   return (vector signed char)__builtin_altivec_vsrab((vector char)__a, __b);
10446 }
10447
10448 static __inline__ vector unsigned char __ATTRS_o_ai
10449 vec_sra(vector unsigned char __a, vector unsigned char __b) {
10450   return (vector unsigned char)__builtin_altivec_vsrab((vector char)__a, __b);
10451 }
10452
10453 static __inline__ vector short __ATTRS_o_ai vec_sra(vector short __a,
10454                                                     vector unsigned short __b) {
10455   return __builtin_altivec_vsrah(__a, (vector unsigned short)__b);
10456 }
10457
10458 static __inline__ vector unsigned short __ATTRS_o_ai
10459 vec_sra(vector unsigned short __a, vector unsigned short __b) {
10460   return (vector unsigned short)__builtin_altivec_vsrah((vector short)__a, __b);
10461 }
10462
10463 static __inline__ vector int __ATTRS_o_ai vec_sra(vector int __a,
10464                                                   vector unsigned int __b) {
10465   return __builtin_altivec_vsraw(__a, __b);
10466 }
10467
10468 static __inline__ vector unsigned int __ATTRS_o_ai
10469 vec_sra(vector unsigned int __a, vector unsigned int __b) {
10470   return (vector unsigned int)__builtin_altivec_vsraw((vector int)__a, __b);
10471 }
10472
10473 #ifdef __POWER8_VECTOR__
10474 static __inline__ vector signed long long __ATTRS_o_ai
10475 vec_sra(vector signed long long __a, vector unsigned long long __b) {
10476   return __a >> __b;
10477 }
10478
10479 static __inline__ vector unsigned long long __ATTRS_o_ai
10480 vec_sra(vector unsigned long long __a, vector unsigned long long __b) {
10481   return (vector unsigned long long)((vector signed long long)__a >> __b);
10482 }
10483 #else
10484 static __inline__ vector signed long long __ATTRS_o_ai
10485 vec_sra(vector signed long long __a, vector unsigned long long __b) {
10486   __b %= (vector unsigned long long)(sizeof(unsigned long long) * __CHAR_BIT__);
10487   return __a >> __b;
10488 }
10489
10490 static __inline__ vector unsigned long long __ATTRS_o_ai
10491 vec_sra(vector unsigned long long __a, vector unsigned long long __b) {
10492   __b %= (vector unsigned long long)(sizeof(unsigned long long) * __CHAR_BIT__);
10493   return (vector unsigned long long)((vector signed long long)__a >> __b);
10494 }
10495 #endif
10496
10497 /* vec_vsrab */
10498
10499 static __inline__ vector signed char __ATTRS_o_ai
10500 vec_vsrab(vector signed char __a, vector unsigned char __b) {
10501   return (vector signed char)__builtin_altivec_vsrab((vector char)__a, __b);
10502 }
10503
10504 static __inline__ vector unsigned char __ATTRS_o_ai
10505 vec_vsrab(vector unsigned char __a, vector unsigned char __b) {
10506   return (vector unsigned char)__builtin_altivec_vsrab((vector char)__a, __b);
10507 }
10508
10509 /* vec_vsrah */
10510
10511 static __inline__ vector short __ATTRS_o_ai
10512 vec_vsrah(vector short __a, vector unsigned short __b) {
10513   return __builtin_altivec_vsrah(__a, (vector unsigned short)__b);
10514 }
10515
10516 static __inline__ vector unsigned short __ATTRS_o_ai
10517 vec_vsrah(vector unsigned short __a, vector unsigned short __b) {
10518   return (vector unsigned short)__builtin_altivec_vsrah((vector short)__a, __b);
10519 }
10520
10521 /* vec_vsraw */
10522
10523 static __inline__ vector int __ATTRS_o_ai vec_vsraw(vector int __a,
10524                                                     vector unsigned int __b) {
10525   return __builtin_altivec_vsraw(__a, __b);
10526 }
10527
10528 static __inline__ vector unsigned int __ATTRS_o_ai
10529 vec_vsraw(vector unsigned int __a, vector unsigned int __b) {
10530   return (vector unsigned int)__builtin_altivec_vsraw((vector int)__a, __b);
10531 }
10532
10533 /* vec_srl */
10534
10535 static __inline__ vector signed char __ATTRS_o_ai
10536 vec_srl(vector signed char __a, vector unsigned char __b) {
10537   return (vector signed char)__builtin_altivec_vsr((vector int)__a,
10538                                                    (vector int)__b);
10539 }
10540
10541 static __inline__ vector signed char __ATTRS_o_ai
10542 vec_srl(vector signed char __a, vector unsigned short __b) {
10543   return (vector signed char)__builtin_altivec_vsr((vector int)__a,
10544                                                    (vector int)__b);
10545 }
10546
10547 static __inline__ vector signed char __ATTRS_o_ai
10548 vec_srl(vector signed char __a, vector unsigned int __b) {
10549   return (vector signed char)__builtin_altivec_vsr((vector int)__a,
10550                                                    (vector int)__b);
10551 }
10552
10553 static __inline__ vector unsigned char __ATTRS_o_ai
10554 vec_srl(vector unsigned char __a, vector unsigned char __b) {
10555   return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
10556                                                      (vector int)__b);
10557 }
10558
10559 static __inline__ vector unsigned char __ATTRS_o_ai
10560 vec_srl(vector unsigned char __a, vector unsigned short __b) {
10561   return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
10562                                                      (vector int)__b);
10563 }
10564
10565 static __inline__ vector unsigned char __ATTRS_o_ai
10566 vec_srl(vector unsigned char __a, vector unsigned int __b) {
10567   return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
10568                                                      (vector int)__b);
10569 }
10570
10571 static __inline__ vector bool char __ATTRS_o_ai
10572 vec_srl(vector bool char __a, vector unsigned char __b) {
10573   return (vector bool char)__builtin_altivec_vsr((vector int)__a,
10574                                                  (vector int)__b);
10575 }
10576
10577 static __inline__ vector bool char __ATTRS_o_ai
10578 vec_srl(vector bool char __a, vector unsigned short __b) {
10579   return (vector bool char)__builtin_altivec_vsr((vector int)__a,
10580                                                  (vector int)__b);
10581 }
10582
10583 static __inline__ vector bool char __ATTRS_o_ai
10584 vec_srl(vector bool char __a, vector unsigned int __b) {
10585   return (vector bool char)__builtin_altivec_vsr((vector int)__a,
10586                                                  (vector int)__b);
10587 }
10588
10589 static __inline__ vector short __ATTRS_o_ai vec_srl(vector short __a,
10590                                                     vector unsigned char __b) {
10591   return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
10592 }
10593
10594 static __inline__ vector short __ATTRS_o_ai vec_srl(vector short __a,
10595                                                     vector unsigned short __b) {
10596   return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
10597 }
10598
10599 static __inline__ vector short __ATTRS_o_ai vec_srl(vector short __a,
10600                                                     vector unsigned int __b) {
10601   return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
10602 }
10603
10604 static __inline__ vector unsigned short __ATTRS_o_ai
10605 vec_srl(vector unsigned short __a, vector unsigned char __b) {
10606   return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
10607                                                       (vector int)__b);
10608 }
10609
10610 static __inline__ vector unsigned short __ATTRS_o_ai
10611 vec_srl(vector unsigned short __a, vector unsigned short __b) {
10612   return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
10613                                                       (vector int)__b);
10614 }
10615
10616 static __inline__ vector unsigned short __ATTRS_o_ai
10617 vec_srl(vector unsigned short __a, vector unsigned int __b) {
10618   return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
10619                                                       (vector int)__b);
10620 }
10621
10622 static __inline__ vector bool short __ATTRS_o_ai
10623 vec_srl(vector bool short __a, vector unsigned char __b) {
10624   return (vector bool short)__builtin_altivec_vsr((vector int)__a,
10625                                                   (vector int)__b);
10626 }
10627
10628 static __inline__ vector bool short __ATTRS_o_ai
10629 vec_srl(vector bool short __a, vector unsigned short __b) {
10630   return (vector bool short)__builtin_altivec_vsr((vector int)__a,
10631                                                   (vector int)__b);
10632 }
10633
10634 static __inline__ vector bool short __ATTRS_o_ai
10635 vec_srl(vector bool short __a, vector unsigned int __b) {
10636   return (vector bool short)__builtin_altivec_vsr((vector int)__a,
10637                                                   (vector int)__b);
10638 }
10639
10640 static __inline__ vector pixel __ATTRS_o_ai vec_srl(vector pixel __a,
10641                                                     vector unsigned char __b) {
10642   return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
10643 }
10644
10645 static __inline__ vector pixel __ATTRS_o_ai vec_srl(vector pixel __a,
10646                                                     vector unsigned short __b) {
10647   return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
10648 }
10649
10650 static __inline__ vector pixel __ATTRS_o_ai vec_srl(vector pixel __a,
10651                                                     vector unsigned int __b) {
10652   return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
10653 }
10654
10655 static __inline__ vector int __ATTRS_o_ai vec_srl(vector int __a,
10656                                                   vector unsigned char __b) {
10657   return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
10658 }
10659
10660 static __inline__ vector int __ATTRS_o_ai vec_srl(vector int __a,
10661                                                   vector unsigned short __b) {
10662   return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
10663 }
10664
10665 static __inline__ vector int __ATTRS_o_ai vec_srl(vector int __a,
10666                                                   vector unsigned int __b) {
10667   return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
10668 }
10669
10670 static __inline__ vector unsigned int __ATTRS_o_ai
10671 vec_srl(vector unsigned int __a, vector unsigned char __b) {
10672   return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
10673                                                     (vector int)__b);
10674 }
10675
10676 static __inline__ vector unsigned int __ATTRS_o_ai
10677 vec_srl(vector unsigned int __a, vector unsigned short __b) {
10678   return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
10679                                                     (vector int)__b);
10680 }
10681
10682 static __inline__ vector unsigned int __ATTRS_o_ai
10683 vec_srl(vector unsigned int __a, vector unsigned int __b) {
10684   return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
10685                                                     (vector int)__b);
10686 }
10687
10688 static __inline__ vector bool int __ATTRS_o_ai
10689 vec_srl(vector bool int __a, vector unsigned char __b) {
10690   return (vector bool int)__builtin_altivec_vsr((vector int)__a,
10691                                                 (vector int)__b);
10692 }
10693
10694 static __inline__ vector bool int __ATTRS_o_ai
10695 vec_srl(vector bool int __a, vector unsigned short __b) {
10696   return (vector bool int)__builtin_altivec_vsr((vector int)__a,
10697                                                 (vector int)__b);
10698 }
10699
10700 static __inline__ vector bool int __ATTRS_o_ai
10701 vec_srl(vector bool int __a, vector unsigned int __b) {
10702   return (vector bool int)__builtin_altivec_vsr((vector int)__a,
10703                                                 (vector int)__b);
10704 }
10705
10706 #ifdef __VSX__
10707 static __inline__ vector signed long long __ATTRS_o_ai
10708 vec_srl(vector signed long long __a, vector unsigned char __b) {
10709   return (vector signed long long)__builtin_altivec_vsr((vector int)__a,
10710                                                         (vector int)__b);
10711 }
10712
10713 static __inline__ vector unsigned long long __ATTRS_o_ai
10714 vec_srl(vector unsigned long long __a, vector unsigned char __b) {
10715   return (vector unsigned long long)__builtin_altivec_vsr((vector int)__a,
10716                                                           (vector int)__b);
10717 }
10718 #endif
10719
10720 /* vec_vsr */
10721
10722 static __inline__ vector signed char __ATTRS_o_ai
10723 vec_vsr(vector signed char __a, vector unsigned char __b) {
10724   return (vector signed char)__builtin_altivec_vsr((vector int)__a,
10725                                                    (vector int)__b);
10726 }
10727
10728 static __inline__ vector signed char __ATTRS_o_ai
10729 vec_vsr(vector signed char __a, vector unsigned short __b) {
10730   return (vector signed char)__builtin_altivec_vsr((vector int)__a,
10731                                                    (vector int)__b);
10732 }
10733
10734 static __inline__ vector signed char __ATTRS_o_ai
10735 vec_vsr(vector signed char __a, vector unsigned int __b) {
10736   return (vector signed char)__builtin_altivec_vsr((vector int)__a,
10737                                                    (vector int)__b);
10738 }
10739
10740 static __inline__ vector unsigned char __ATTRS_o_ai
10741 vec_vsr(vector unsigned char __a, vector unsigned char __b) {
10742   return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
10743                                                      (vector int)__b);
10744 }
10745
10746 static __inline__ vector unsigned char __ATTRS_o_ai
10747 vec_vsr(vector unsigned char __a, vector unsigned short __b) {
10748   return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
10749                                                      (vector int)__b);
10750 }
10751
10752 static __inline__ vector unsigned char __ATTRS_o_ai
10753 vec_vsr(vector unsigned char __a, vector unsigned int __b) {
10754   return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
10755                                                      (vector int)__b);
10756 }
10757
10758 static __inline__ vector bool char __ATTRS_o_ai
10759 vec_vsr(vector bool char __a, vector unsigned char __b) {
10760   return (vector bool char)__builtin_altivec_vsr((vector int)__a,
10761                                                  (vector int)__b);
10762 }
10763
10764 static __inline__ vector bool char __ATTRS_o_ai
10765 vec_vsr(vector bool char __a, vector unsigned short __b) {
10766   return (vector bool char)__builtin_altivec_vsr((vector int)__a,
10767                                                  (vector int)__b);
10768 }
10769
10770 static __inline__ vector bool char __ATTRS_o_ai
10771 vec_vsr(vector bool char __a, vector unsigned int __b) {
10772   return (vector bool char)__builtin_altivec_vsr((vector int)__a,
10773                                                  (vector int)__b);
10774 }
10775
10776 static __inline__ vector short __ATTRS_o_ai vec_vsr(vector short __a,
10777                                                     vector unsigned char __b) {
10778   return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
10779 }
10780
10781 static __inline__ vector short __ATTRS_o_ai vec_vsr(vector short __a,
10782                                                     vector unsigned short __b) {
10783   return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
10784 }
10785
10786 static __inline__ vector short __ATTRS_o_ai vec_vsr(vector short __a,
10787                                                     vector unsigned int __b) {
10788   return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
10789 }
10790
10791 static __inline__ vector unsigned short __ATTRS_o_ai
10792 vec_vsr(vector unsigned short __a, vector unsigned char __b) {
10793   return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
10794                                                       (vector int)__b);
10795 }
10796
10797 static __inline__ vector unsigned short __ATTRS_o_ai
10798 vec_vsr(vector unsigned short __a, vector unsigned short __b) {
10799   return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
10800                                                       (vector int)__b);
10801 }
10802
10803 static __inline__ vector unsigned short __ATTRS_o_ai
10804 vec_vsr(vector unsigned short __a, vector unsigned int __b) {
10805   return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
10806                                                       (vector int)__b);
10807 }
10808
10809 static __inline__ vector bool short __ATTRS_o_ai
10810 vec_vsr(vector bool short __a, vector unsigned char __b) {
10811   return (vector bool short)__builtin_altivec_vsr((vector int)__a,
10812                                                   (vector int)__b);
10813 }
10814
10815 static __inline__ vector bool short __ATTRS_o_ai
10816 vec_vsr(vector bool short __a, vector unsigned short __b) {
10817   return (vector bool short)__builtin_altivec_vsr((vector int)__a,
10818                                                   (vector int)__b);
10819 }
10820
10821 static __inline__ vector bool short __ATTRS_o_ai
10822 vec_vsr(vector bool short __a, vector unsigned int __b) {
10823   return (vector bool short)__builtin_altivec_vsr((vector int)__a,
10824                                                   (vector int)__b);
10825 }
10826
10827 static __inline__ vector pixel __ATTRS_o_ai vec_vsr(vector pixel __a,
10828                                                     vector unsigned char __b) {
10829   return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
10830 }
10831
10832 static __inline__ vector pixel __ATTRS_o_ai vec_vsr(vector pixel __a,
10833                                                     vector unsigned short __b) {
10834   return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
10835 }
10836
10837 static __inline__ vector pixel __ATTRS_o_ai vec_vsr(vector pixel __a,
10838                                                     vector unsigned int __b) {
10839   return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
10840 }
10841
10842 static __inline__ vector int __ATTRS_o_ai vec_vsr(vector int __a,
10843                                                   vector unsigned char __b) {
10844   return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
10845 }
10846
10847 static __inline__ vector int __ATTRS_o_ai vec_vsr(vector int __a,
10848                                                   vector unsigned short __b) {
10849   return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
10850 }
10851
10852 static __inline__ vector int __ATTRS_o_ai vec_vsr(vector int __a,
10853                                                   vector unsigned int __b) {
10854   return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
10855 }
10856
10857 static __inline__ vector unsigned int __ATTRS_o_ai
10858 vec_vsr(vector unsigned int __a, vector unsigned char __b) {
10859   return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
10860                                                     (vector int)__b);
10861 }
10862
10863 static __inline__ vector unsigned int __ATTRS_o_ai
10864 vec_vsr(vector unsigned int __a, vector unsigned short __b) {
10865   return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
10866                                                     (vector int)__b);
10867 }
10868
10869 static __inline__ vector unsigned int __ATTRS_o_ai
10870 vec_vsr(vector unsigned int __a, vector unsigned int __b) {
10871   return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
10872                                                     (vector int)__b);
10873 }
10874
10875 static __inline__ vector bool int __ATTRS_o_ai
10876 vec_vsr(vector bool int __a, vector unsigned char __b) {
10877   return (vector bool int)__builtin_altivec_vsr((vector int)__a,
10878                                                 (vector int)__b);
10879 }
10880
10881 static __inline__ vector bool int __ATTRS_o_ai
10882 vec_vsr(vector bool int __a, vector unsigned short __b) {
10883   return (vector bool int)__builtin_altivec_vsr((vector int)__a,
10884                                                 (vector int)__b);
10885 }
10886
10887 static __inline__ vector bool int __ATTRS_o_ai
10888 vec_vsr(vector bool int __a, vector unsigned int __b) {
10889   return (vector bool int)__builtin_altivec_vsr((vector int)__a,
10890                                                 (vector int)__b);
10891 }
10892
10893 /* vec_sro */
10894
10895 static __inline__ vector signed char __ATTRS_o_ai
10896 vec_sro(vector signed char __a, vector signed char __b) {
10897   return (vector signed char)__builtin_altivec_vsro((vector int)__a,
10898                                                     (vector int)__b);
10899 }
10900
10901 static __inline__ vector signed char __ATTRS_o_ai
10902 vec_sro(vector signed char __a, vector unsigned char __b) {
10903   return (vector signed char)__builtin_altivec_vsro((vector int)__a,
10904                                                     (vector int)__b);
10905 }
10906
10907 static __inline__ vector unsigned char __ATTRS_o_ai
10908 vec_sro(vector unsigned char __a, vector signed char __b) {
10909   return (vector unsigned char)__builtin_altivec_vsro((vector int)__a,
10910                                                       (vector int)__b);
10911 }
10912
10913 static __inline__ vector unsigned char __ATTRS_o_ai
10914 vec_sro(vector unsigned char __a, vector unsigned char __b) {
10915   return (vector unsigned char)__builtin_altivec_vsro((vector int)__a,
10916                                                       (vector int)__b);
10917 }
10918
10919 static __inline__ vector short __ATTRS_o_ai vec_sro(vector short __a,
10920                                                     vector signed char __b) {
10921   return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10922 }
10923
10924 static __inline__ vector short __ATTRS_o_ai vec_sro(vector short __a,
10925                                                     vector unsigned char __b) {
10926   return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10927 }
10928
10929 static __inline__ vector unsigned short __ATTRS_o_ai
10930 vec_sro(vector unsigned short __a, vector signed char __b) {
10931   return (vector unsigned short)__builtin_altivec_vsro((vector int)__a,
10932                                                        (vector int)__b);
10933 }
10934
10935 static __inline__ vector unsigned short __ATTRS_o_ai
10936 vec_sro(vector unsigned short __a, vector unsigned char __b) {
10937   return (vector unsigned short)__builtin_altivec_vsro((vector int)__a,
10938                                                        (vector int)__b);
10939 }
10940
10941 static __inline__ vector pixel __ATTRS_o_ai vec_sro(vector pixel __a,
10942                                                     vector signed char __b) {
10943   return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10944 }
10945
10946 static __inline__ vector pixel __ATTRS_o_ai vec_sro(vector pixel __a,
10947                                                     vector unsigned char __b) {
10948   return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10949 }
10950
10951 static __inline__ vector int __ATTRS_o_ai vec_sro(vector int __a,
10952                                                   vector signed char __b) {
10953   return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
10954 }
10955
10956 static __inline__ vector int __ATTRS_o_ai vec_sro(vector int __a,
10957                                                   vector unsigned char __b) {
10958   return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
10959 }
10960
10961 static __inline__ vector unsigned int __ATTRS_o_ai
10962 vec_sro(vector unsigned int __a, vector signed char __b) {
10963   return (vector unsigned int)__builtin_altivec_vsro((vector int)__a,
10964                                                      (vector int)__b);
10965 }
10966
10967 static __inline__ vector unsigned int __ATTRS_o_ai
10968 vec_sro(vector unsigned int __a, vector unsigned char __b) {
10969   return (vector unsigned int)__builtin_altivec_vsro((vector int)__a,
10970                                                      (vector int)__b);
10971 }
10972
10973 static __inline__ vector float __ATTRS_o_ai vec_sro(vector float __a,
10974                                                     vector signed char __b) {
10975   return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10976 }
10977
10978 static __inline__ vector float __ATTRS_o_ai vec_sro(vector float __a,
10979                                                     vector unsigned char __b) {
10980   return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10981 }
10982
10983 #ifdef __VSX__
10984 static __inline__ vector signed long long __ATTRS_o_ai
10985 vec_sro(vector signed long long __a, vector signed char __b) {
10986   return (vector signed long long)__builtin_altivec_vsro((vector int)__a,
10987                                                          (vector int)__b);
10988 }
10989
10990 static __inline__ vector signed long long __ATTRS_o_ai
10991 vec_sro(vector signed long long __a, vector unsigned char __b) {
10992   return (vector signed long long)__builtin_altivec_vsro((vector int)__a,
10993                                                          (vector int)__b);
10994 }
10995
10996 static __inline__ vector unsigned long long __ATTRS_o_ai
10997 vec_sro(vector unsigned long long __a, vector signed char __b) {
10998   return (vector unsigned long long)__builtin_altivec_vsro((vector int)__a,
10999                                                            (vector int)__b);
11000 }
11001
11002 static __inline__ vector unsigned long long __ATTRS_o_ai
11003 vec_sro(vector unsigned long long __a, vector unsigned char __b) {
11004   return (vector unsigned long long)__builtin_altivec_vsro((vector int)__a,
11005                                                            (vector int)__b);
11006 }
11007 #endif
11008
11009 /* vec_vsro */
11010
11011 static __inline__ vector signed char __ATTRS_o_ai
11012 vec_vsro(vector signed char __a, vector signed char __b) {
11013   return (vector signed char)__builtin_altivec_vsro((vector int)__a,
11014                                                     (vector int)__b);
11015 }
11016
11017 static __inline__ vector signed char __ATTRS_o_ai
11018 vec_vsro(vector signed char __a, vector unsigned char __b) {
11019   return (vector signed char)__builtin_altivec_vsro((vector int)__a,
11020                                                     (vector int)__b);
11021 }
11022
11023 static __inline__ vector unsigned char __ATTRS_o_ai
11024 vec_vsro(vector unsigned char __a, vector signed char __b) {
11025   return (vector unsigned char)__builtin_altivec_vsro((vector int)__a,
11026                                                       (vector int)__b);
11027 }
11028
11029 static __inline__ vector unsigned char __ATTRS_o_ai
11030 vec_vsro(vector unsigned char __a, vector unsigned char __b) {
11031   return (vector unsigned char)__builtin_altivec_vsro((vector int)__a,
11032                                                       (vector int)__b);
11033 }
11034
11035 static __inline__ vector short __ATTRS_o_ai vec_vsro(vector short __a,
11036                                                      vector signed char __b) {
11037   return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
11038 }
11039
11040 static __inline__ vector short __ATTRS_o_ai vec_vsro(vector short __a,
11041                                                      vector unsigned char __b) {
11042   return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
11043 }
11044
11045 static __inline__ vector unsigned short __ATTRS_o_ai
11046 vec_vsro(vector unsigned short __a, vector signed char __b) {
11047   return (vector unsigned short)__builtin_altivec_vsro((vector int)__a,
11048                                                        (vector int)__b);
11049 }
11050
11051 static __inline__ vector unsigned short __ATTRS_o_ai
11052 vec_vsro(vector unsigned short __a, vector unsigned char __b) {
11053   return (vector unsigned short)__builtin_altivec_vsro((vector int)__a,
11054                                                        (vector int)__b);
11055 }
11056
11057 static __inline__ vector pixel __ATTRS_o_ai vec_vsro(vector pixel __a,
11058                                                      vector signed char __b) {
11059   return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
11060 }
11061
11062 static __inline__ vector pixel __ATTRS_o_ai vec_vsro(vector pixel __a,
11063                                                      vector unsigned char __b) {
11064   return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
11065 }
11066
11067 static __inline__ vector int __ATTRS_o_ai vec_vsro(vector int __a,
11068                                                    vector signed char __b) {
11069   return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
11070 }
11071
11072 static __inline__ vector int __ATTRS_o_ai vec_vsro(vector int __a,
11073                                                    vector unsigned char __b) {
11074   return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
11075 }
11076
11077 static __inline__ vector unsigned int __ATTRS_o_ai
11078 vec_vsro(vector unsigned int __a, vector signed char __b) {
11079   return (vector unsigned int)__builtin_altivec_vsro((vector int)__a,
11080                                                      (vector int)__b);
11081 }
11082
11083 static __inline__ vector unsigned int __ATTRS_o_ai
11084 vec_vsro(vector unsigned int __a, vector unsigned char __b) {
11085   return (vector unsigned int)__builtin_altivec_vsro((vector int)__a,
11086                                                      (vector int)__b);
11087 }
11088
11089 static __inline__ vector float __ATTRS_o_ai vec_vsro(vector float __a,
11090                                                      vector signed char __b) {
11091   return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
11092 }
11093
11094 static __inline__ vector float __ATTRS_o_ai vec_vsro(vector float __a,
11095                                                      vector unsigned char __b) {
11096   return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
11097 }
11098
11099 /* vec_st */
11100
11101 static __inline__ void __ATTRS_o_ai vec_st(vector signed char __a, long __b,
11102                                            vector signed char *__c) {
11103   __builtin_altivec_stvx((vector int)__a, __b, __c);
11104 }
11105
11106 static __inline__ void __ATTRS_o_ai vec_st(vector signed char __a, long __b,
11107                                            signed char *__c) {
11108   __builtin_altivec_stvx((vector int)__a, __b, __c);
11109 }
11110
11111 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned char __a, long __b,
11112                                            vector unsigned char *__c) {
11113   __builtin_altivec_stvx((vector int)__a, __b, __c);
11114 }
11115
11116 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned char __a, long __b,
11117                                            unsigned char *__c) {
11118   __builtin_altivec_stvx((vector int)__a, __b, __c);
11119 }
11120
11121 static __inline__ void __ATTRS_o_ai vec_st(vector bool char __a, long __b,
11122                                            signed char *__c) {
11123   __builtin_altivec_stvx((vector int)__a, __b, __c);
11124 }
11125
11126 static __inline__ void __ATTRS_o_ai vec_st(vector bool char __a, long __b,
11127                                            unsigned char *__c) {
11128   __builtin_altivec_stvx((vector int)__a, __b, __c);
11129 }
11130
11131 static __inline__ void __ATTRS_o_ai vec_st(vector bool char __a, long __b,
11132                                            vector bool char *__c) {
11133   __builtin_altivec_stvx((vector int)__a, __b, __c);
11134 }
11135
11136 static __inline__ void __ATTRS_o_ai vec_st(vector short __a, long __b,
11137                                            vector short *__c) {
11138   __builtin_altivec_stvx((vector int)__a, __b, __c);
11139 }
11140
11141 static __inline__ void __ATTRS_o_ai vec_st(vector short __a, long __b,
11142                                            short *__c) {
11143   __builtin_altivec_stvx((vector int)__a, __b, __c);
11144 }
11145
11146 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned short __a, long __b,
11147                                            vector unsigned short *__c) {
11148   __builtin_altivec_stvx((vector int)__a, __b, __c);
11149 }
11150
11151 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned short __a, long __b,
11152                                            unsigned short *__c) {
11153   __builtin_altivec_stvx((vector int)__a, __b, __c);
11154 }
11155
11156 static __inline__ void __ATTRS_o_ai vec_st(vector bool short __a, long __b,
11157                                            short *__c) {
11158   __builtin_altivec_stvx((vector int)__a, __b, __c);
11159 }
11160
11161 static __inline__ void __ATTRS_o_ai vec_st(vector bool short __a, long __b,
11162                                            unsigned short *__c) {
11163   __builtin_altivec_stvx((vector int)__a, __b, __c);
11164 }
11165
11166 static __inline__ void __ATTRS_o_ai vec_st(vector bool short __a, long __b,
11167                                            vector bool short *__c) {
11168   __builtin_altivec_stvx((vector int)__a, __b, __c);
11169 }
11170
11171 static __inline__ void __ATTRS_o_ai vec_st(vector pixel __a, long __b,
11172                                            short *__c) {
11173   __builtin_altivec_stvx((vector int)__a, __b, __c);
11174 }
11175
11176 static __inline__ void __ATTRS_o_ai vec_st(vector pixel __a, long __b,
11177                                            unsigned short *__c) {
11178   __builtin_altivec_stvx((vector int)__a, __b, __c);
11179 }
11180
11181 static __inline__ void __ATTRS_o_ai vec_st(vector pixel __a, long __b,
11182                                            vector pixel *__c) {
11183   __builtin_altivec_stvx((vector int)__a, __b, __c);
11184 }
11185
11186 static __inline__ void __ATTRS_o_ai vec_st(vector int __a, long __b,
11187                                            vector int *__c) {
11188   __builtin_altivec_stvx(__a, __b, __c);
11189 }
11190
11191 static __inline__ void __ATTRS_o_ai vec_st(vector int __a, long __b, int *__c) {
11192   __builtin_altivec_stvx(__a, __b, __c);
11193 }
11194
11195 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned int __a, long __b,
11196                                            vector unsigned int *__c) {
11197   __builtin_altivec_stvx((vector int)__a, __b, __c);
11198 }
11199
11200 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned int __a, long __b,
11201                                            unsigned int *__c) {
11202   __builtin_altivec_stvx((vector int)__a, __b, __c);
11203 }
11204
11205 static __inline__ void __ATTRS_o_ai vec_st(vector bool int __a, long __b,
11206                                            int *__c) {
11207   __builtin_altivec_stvx((vector int)__a, __b, __c);
11208 }
11209
11210 static __inline__ void __ATTRS_o_ai vec_st(vector bool int __a, long __b,
11211                                            unsigned int *__c) {
11212   __builtin_altivec_stvx((vector int)__a, __b, __c);
11213 }
11214
11215 static __inline__ void __ATTRS_o_ai vec_st(vector bool int __a, long __b,
11216                                            vector bool int *__c) {
11217   __builtin_altivec_stvx((vector int)__a, __b, __c);
11218 }
11219
11220 static __inline__ void __ATTRS_o_ai vec_st(vector float __a, long __b,
11221                                            vector float *__c) {
11222   __builtin_altivec_stvx((vector int)__a, __b, __c);
11223 }
11224
11225 static __inline__ void __ATTRS_o_ai vec_st(vector float __a, long __b,
11226                                            float *__c) {
11227   __builtin_altivec_stvx((vector int)__a, __b, __c);
11228 }
11229
11230 /* vec_stvx */
11231
11232 static __inline__ void __ATTRS_o_ai vec_stvx(vector signed char __a, long __b,
11233                                              vector signed char *__c) {
11234   __builtin_altivec_stvx((vector int)__a, __b, __c);
11235 }
11236
11237 static __inline__ void __ATTRS_o_ai vec_stvx(vector signed char __a, long __b,
11238                                              signed char *__c) {
11239   __builtin_altivec_stvx((vector int)__a, __b, __c);
11240 }
11241
11242 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned char __a, long __b,
11243                                              vector unsigned char *__c) {
11244   __builtin_altivec_stvx((vector int)__a, __b, __c);
11245 }
11246
11247 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned char __a, long __b,
11248                                              unsigned char *__c) {
11249   __builtin_altivec_stvx((vector int)__a, __b, __c);
11250 }
11251
11252 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool char __a, long __b,
11253                                              signed char *__c) {
11254   __builtin_altivec_stvx((vector int)__a, __b, __c);
11255 }
11256
11257 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool char __a, long __b,
11258                                              unsigned char *__c) {
11259   __builtin_altivec_stvx((vector int)__a, __b, __c);
11260 }
11261
11262 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool char __a, long __b,
11263                                              vector bool char *__c) {
11264   __builtin_altivec_stvx((vector int)__a, __b, __c);
11265 }
11266
11267 static __inline__ void __ATTRS_o_ai vec_stvx(vector short __a, long __b,
11268                                              vector short *__c) {
11269   __builtin_altivec_stvx((vector int)__a, __b, __c);
11270 }
11271
11272 static __inline__ void __ATTRS_o_ai vec_stvx(vector short __a, long __b,
11273                                              short *__c) {
11274   __builtin_altivec_stvx((vector int)__a, __b, __c);
11275 }
11276
11277 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned short __a, long __b,
11278                                              vector unsigned short *__c) {
11279   __builtin_altivec_stvx((vector int)__a, __b, __c);
11280 }
11281
11282 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned short __a, long __b,
11283                                              unsigned short *__c) {
11284   __builtin_altivec_stvx((vector int)__a, __b, __c);
11285 }
11286
11287 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool short __a, long __b,
11288                                              short *__c) {
11289   __builtin_altivec_stvx((vector int)__a, __b, __c);
11290 }
11291
11292 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool short __a, long __b,
11293                                              unsigned short *__c) {
11294   __builtin_altivec_stvx((vector int)__a, __b, __c);
11295 }
11296
11297 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool short __a, long __b,
11298                                              vector bool short *__c) {
11299   __builtin_altivec_stvx((vector int)__a, __b, __c);
11300 }
11301
11302 static __inline__ void __ATTRS_o_ai vec_stvx(vector pixel __a, long __b,
11303                                              short *__c) {
11304   __builtin_altivec_stvx((vector int)__a, __b, __c);
11305 }
11306
11307 static __inline__ void __ATTRS_o_ai vec_stvx(vector pixel __a, long __b,
11308                                              unsigned short *__c) {
11309   __builtin_altivec_stvx((vector int)__a, __b, __c);
11310 }
11311
11312 static __inline__ void __ATTRS_o_ai vec_stvx(vector pixel __a, long __b,
11313                                              vector pixel *__c) {
11314   __builtin_altivec_stvx((vector int)__a, __b, __c);
11315 }
11316
11317 static __inline__ void __ATTRS_o_ai vec_stvx(vector int __a, long __b,
11318                                              vector int *__c) {
11319   __builtin_altivec_stvx(__a, __b, __c);
11320 }
11321
11322 static __inline__ void __ATTRS_o_ai vec_stvx(vector int __a, long __b,
11323                                              int *__c) {
11324   __builtin_altivec_stvx(__a, __b, __c);
11325 }
11326
11327 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned int __a, long __b,
11328                                              vector unsigned int *__c) {
11329   __builtin_altivec_stvx((vector int)__a, __b, __c);
11330 }
11331
11332 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned int __a, long __b,
11333                                              unsigned int *__c) {
11334   __builtin_altivec_stvx((vector int)__a, __b, __c);
11335 }
11336
11337 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool int __a, long __b,
11338                                              int *__c) {
11339   __builtin_altivec_stvx((vector int)__a, __b, __c);
11340 }
11341
11342 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool int __a, long __b,
11343                                              unsigned int *__c) {
11344   __builtin_altivec_stvx((vector int)__a, __b, __c);
11345 }
11346
11347 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool int __a, long __b,
11348                                              vector bool int *__c) {
11349   __builtin_altivec_stvx((vector int)__a, __b, __c);
11350 }
11351
11352 static __inline__ void __ATTRS_o_ai vec_stvx(vector float __a, long __b,
11353                                              vector float *__c) {
11354   __builtin_altivec_stvx((vector int)__a, __b, __c);
11355 }
11356
11357 static __inline__ void __ATTRS_o_ai vec_stvx(vector float __a, long __b,
11358                                              float *__c) {
11359   __builtin_altivec_stvx((vector int)__a, __b, __c);
11360 }
11361
11362 /* vec_ste */
11363
11364 static __inline__ void __ATTRS_o_ai vec_ste(vector signed char __a, long __b,
11365                                             signed char *__c) {
11366   __builtin_altivec_stvebx((vector char)__a, __b, __c);
11367 }
11368
11369 static __inline__ void __ATTRS_o_ai vec_ste(vector unsigned char __a, long __b,
11370                                             unsigned char *__c) {
11371   __builtin_altivec_stvebx((vector char)__a, __b, __c);
11372 }
11373
11374 static __inline__ void __ATTRS_o_ai vec_ste(vector bool char __a, long __b,
11375                                             signed char *__c) {
11376   __builtin_altivec_stvebx((vector char)__a, __b, __c);
11377 }
11378
11379 static __inline__ void __ATTRS_o_ai vec_ste(vector bool char __a, long __b,
11380                                             unsigned char *__c) {
11381   __builtin_altivec_stvebx((vector char)__a, __b, __c);
11382 }
11383
11384 static __inline__ void __ATTRS_o_ai vec_ste(vector short __a, long __b,
11385                                             short *__c) {
11386   __builtin_altivec_stvehx(__a, __b, __c);
11387 }
11388
11389 static __inline__ void __ATTRS_o_ai vec_ste(vector unsigned short __a, long __b,
11390                                             unsigned short *__c) {
11391   __builtin_altivec_stvehx((vector short)__a, __b, __c);
11392 }
11393
11394 static __inline__ void __ATTRS_o_ai vec_ste(vector bool short __a, long __b,
11395                                             short *__c) {
11396   __builtin_altivec_stvehx((vector short)__a, __b, __c);
11397 }
11398
11399 static __inline__ void __ATTRS_o_ai vec_ste(vector bool short __a, long __b,
11400                                             unsigned short *__c) {
11401   __builtin_altivec_stvehx((vector short)__a, __b, __c);
11402 }
11403
11404 static __inline__ void __ATTRS_o_ai vec_ste(vector pixel __a, long __b,
11405                                             short *__c) {
11406   __builtin_altivec_stvehx((vector short)__a, __b, __c);
11407 }
11408
11409 static __inline__ void __ATTRS_o_ai vec_ste(vector pixel __a, long __b,
11410                                             unsigned short *__c) {
11411   __builtin_altivec_stvehx((vector short)__a, __b, __c);
11412 }
11413
11414 static __inline__ void __ATTRS_o_ai vec_ste(vector int __a, long __b, int *__c) {
11415   __builtin_altivec_stvewx(__a, __b, __c);
11416 }
11417
11418 static __inline__ void __ATTRS_o_ai vec_ste(vector unsigned int __a, long __b,
11419                                             unsigned int *__c) {
11420   __builtin_altivec_stvewx((vector int)__a, __b, __c);
11421 }
11422
11423 static __inline__ void __ATTRS_o_ai vec_ste(vector bool int __a, long __b,
11424                                             int *__c) {
11425   __builtin_altivec_stvewx((vector int)__a, __b, __c);
11426 }
11427
11428 static __inline__ void __ATTRS_o_ai vec_ste(vector bool int __a, long __b,
11429                                             unsigned int *__c) {
11430   __builtin_altivec_stvewx((vector int)__a, __b, __c);
11431 }
11432
11433 static __inline__ void __ATTRS_o_ai vec_ste(vector float __a, long __b,
11434                                             float *__c) {
11435   __builtin_altivec_stvewx((vector int)__a, __b, __c);
11436 }
11437
11438 /* vec_stvebx */
11439
11440 static __inline__ void __ATTRS_o_ai vec_stvebx(vector signed char __a, long __b,
11441                                                signed char *__c) {
11442   __builtin_altivec_stvebx((vector char)__a, __b, __c);
11443 }
11444
11445 static __inline__ void __ATTRS_o_ai vec_stvebx(vector unsigned char __a,
11446                                                long __b, unsigned char *__c) {
11447   __builtin_altivec_stvebx((vector char)__a, __b, __c);
11448 }
11449
11450 static __inline__ void __ATTRS_o_ai vec_stvebx(vector bool char __a, long __b,
11451                                                signed char *__c) {
11452   __builtin_altivec_stvebx((vector char)__a, __b, __c);
11453 }
11454
11455 static __inline__ void __ATTRS_o_ai vec_stvebx(vector bool char __a, long __b,
11456                                                unsigned char *__c) {
11457   __builtin_altivec_stvebx((vector char)__a, __b, __c);
11458 }
11459
11460 /* vec_stvehx */
11461
11462 static __inline__ void __ATTRS_o_ai vec_stvehx(vector short __a, long __b,
11463                                                short *__c) {
11464   __builtin_altivec_stvehx(__a, __b, __c);
11465 }
11466
11467 static __inline__ void __ATTRS_o_ai vec_stvehx(vector unsigned short __a,
11468                                                long __b, unsigned short *__c) {
11469   __builtin_altivec_stvehx((vector short)__a, __b, __c);
11470 }
11471
11472 static __inline__ void __ATTRS_o_ai vec_stvehx(vector bool short __a, long __b,
11473                                                short *__c) {
11474   __builtin_altivec_stvehx((vector short)__a, __b, __c);
11475 }
11476
11477 static __inline__ void __ATTRS_o_ai vec_stvehx(vector bool short __a, long __b,
11478                                                unsigned short *__c) {
11479   __builtin_altivec_stvehx((vector short)__a, __b, __c);
11480 }
11481
11482 static __inline__ void __ATTRS_o_ai vec_stvehx(vector pixel __a, long __b,
11483                                                short *__c) {
11484   __builtin_altivec_stvehx((vector short)__a, __b, __c);
11485 }
11486
11487 static __inline__ void __ATTRS_o_ai vec_stvehx(vector pixel __a, long __b,
11488                                                unsigned short *__c) {
11489   __builtin_altivec_stvehx((vector short)__a, __b, __c);
11490 }
11491
11492 /* vec_stvewx */
11493
11494 static __inline__ void __ATTRS_o_ai vec_stvewx(vector int __a, long __b,
11495                                                int *__c) {
11496   __builtin_altivec_stvewx(__a, __b, __c);
11497 }
11498
11499 static __inline__ void __ATTRS_o_ai vec_stvewx(vector unsigned int __a, long __b,
11500                                                unsigned int *__c) {
11501   __builtin_altivec_stvewx((vector int)__a, __b, __c);
11502 }
11503
11504 static __inline__ void __ATTRS_o_ai vec_stvewx(vector bool int __a, long __b,
11505                                                int *__c) {
11506   __builtin_altivec_stvewx((vector int)__a, __b, __c);
11507 }
11508
11509 static __inline__ void __ATTRS_o_ai vec_stvewx(vector bool int __a, long __b,
11510                                                unsigned int *__c) {
11511   __builtin_altivec_stvewx((vector int)__a, __b, __c);
11512 }
11513
11514 static __inline__ void __ATTRS_o_ai vec_stvewx(vector float __a, long __b,
11515                                                float *__c) {
11516   __builtin_altivec_stvewx((vector int)__a, __b, __c);
11517 }
11518
11519 /* vec_stl */
11520
11521 static __inline__ void __ATTRS_o_ai vec_stl(vector signed char __a, int __b,
11522                                             vector signed char *__c) {
11523   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11524 }
11525
11526 static __inline__ void __ATTRS_o_ai vec_stl(vector signed char __a, int __b,
11527                                             signed char *__c) {
11528   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11529 }
11530
11531 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned char __a, int __b,
11532                                             vector unsigned char *__c) {
11533   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11534 }
11535
11536 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned char __a, int __b,
11537                                             unsigned char *__c) {
11538   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11539 }
11540
11541 static __inline__ void __ATTRS_o_ai vec_stl(vector bool char __a, int __b,
11542                                             signed char *__c) {
11543   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11544 }
11545
11546 static __inline__ void __ATTRS_o_ai vec_stl(vector bool char __a, int __b,
11547                                             unsigned char *__c) {
11548   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11549 }
11550
11551 static __inline__ void __ATTRS_o_ai vec_stl(vector bool char __a, int __b,
11552                                             vector bool char *__c) {
11553   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11554 }
11555
11556 static __inline__ void __ATTRS_o_ai vec_stl(vector short __a, int __b,
11557                                             vector short *__c) {
11558   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11559 }
11560
11561 static __inline__ void __ATTRS_o_ai vec_stl(vector short __a, int __b,
11562                                             short *__c) {
11563   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11564 }
11565
11566 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned short __a, int __b,
11567                                             vector unsigned short *__c) {
11568   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11569 }
11570
11571 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned short __a, int __b,
11572                                             unsigned short *__c) {
11573   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11574 }
11575
11576 static __inline__ void __ATTRS_o_ai vec_stl(vector bool short __a, int __b,
11577                                             short *__c) {
11578   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11579 }
11580
11581 static __inline__ void __ATTRS_o_ai vec_stl(vector bool short __a, int __b,
11582                                             unsigned short *__c) {
11583   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11584 }
11585
11586 static __inline__ void __ATTRS_o_ai vec_stl(vector bool short __a, int __b,
11587                                             vector bool short *__c) {
11588   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11589 }
11590
11591 static __inline__ void __ATTRS_o_ai vec_stl(vector pixel __a, int __b,
11592                                             short *__c) {
11593   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11594 }
11595
11596 static __inline__ void __ATTRS_o_ai vec_stl(vector pixel __a, int __b,
11597                                             unsigned short *__c) {
11598   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11599 }
11600
11601 static __inline__ void __ATTRS_o_ai vec_stl(vector pixel __a, int __b,
11602                                             vector pixel *__c) {
11603   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11604 }
11605
11606 static __inline__ void __ATTRS_o_ai vec_stl(vector int __a, int __b,
11607                                             vector int *__c) {
11608   __builtin_altivec_stvxl(__a, __b, __c);
11609 }
11610
11611 static __inline__ void __ATTRS_o_ai vec_stl(vector int __a, int __b, int *__c) {
11612   __builtin_altivec_stvxl(__a, __b, __c);
11613 }
11614
11615 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned int __a, int __b,
11616                                             vector unsigned int *__c) {
11617   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11618 }
11619
11620 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned int __a, int __b,
11621                                             unsigned int *__c) {
11622   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11623 }
11624
11625 static __inline__ void __ATTRS_o_ai vec_stl(vector bool int __a, int __b,
11626                                             int *__c) {
11627   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11628 }
11629
11630 static __inline__ void __ATTRS_o_ai vec_stl(vector bool int __a, int __b,
11631                                             unsigned int *__c) {
11632   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11633 }
11634
11635 static __inline__ void __ATTRS_o_ai vec_stl(vector bool int __a, int __b,
11636                                             vector bool int *__c) {
11637   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11638 }
11639
11640 static __inline__ void __ATTRS_o_ai vec_stl(vector float __a, int __b,
11641                                             vector float *__c) {
11642   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11643 }
11644
11645 static __inline__ void __ATTRS_o_ai vec_stl(vector float __a, int __b,
11646                                             float *__c) {
11647   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11648 }
11649
11650 /* vec_stvxl */
11651
11652 static __inline__ void __ATTRS_o_ai vec_stvxl(vector signed char __a, int __b,
11653                                               vector signed char *__c) {
11654   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11655 }
11656
11657 static __inline__ void __ATTRS_o_ai vec_stvxl(vector signed char __a, int __b,
11658                                               signed char *__c) {
11659   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11660 }
11661
11662 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned char __a, int __b,
11663                                               vector unsigned char *__c) {
11664   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11665 }
11666
11667 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned char __a, int __b,
11668                                               unsigned char *__c) {
11669   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11670 }
11671
11672 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool char __a, int __b,
11673                                               signed char *__c) {
11674   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11675 }
11676
11677 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool char __a, int __b,
11678                                               unsigned char *__c) {
11679   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11680 }
11681
11682 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool char __a, int __b,
11683                                               vector bool char *__c) {
11684   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11685 }
11686
11687 static __inline__ void __ATTRS_o_ai vec_stvxl(vector short __a, int __b,
11688                                               vector short *__c) {
11689   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11690 }
11691
11692 static __inline__ void __ATTRS_o_ai vec_stvxl(vector short __a, int __b,
11693                                               short *__c) {
11694   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11695 }
11696
11697 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned short __a,
11698                                               int __b,
11699                                               vector unsigned short *__c) {
11700   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11701 }
11702
11703 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned short __a,
11704                                               int __b, unsigned short *__c) {
11705   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11706 }
11707
11708 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool short __a, int __b,
11709                                               short *__c) {
11710   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11711 }
11712
11713 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool short __a, int __b,
11714                                               unsigned short *__c) {
11715   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11716 }
11717
11718 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool short __a, int __b,
11719                                               vector bool short *__c) {
11720   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11721 }
11722
11723 static __inline__ void __ATTRS_o_ai vec_stvxl(vector pixel __a, int __b,
11724                                               short *__c) {
11725   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11726 }
11727
11728 static __inline__ void __ATTRS_o_ai vec_stvxl(vector pixel __a, int __b,
11729                                               unsigned short *__c) {
11730   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11731 }
11732
11733 static __inline__ void __ATTRS_o_ai vec_stvxl(vector pixel __a, int __b,
11734                                               vector pixel *__c) {
11735   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11736 }
11737
11738 static __inline__ void __ATTRS_o_ai vec_stvxl(vector int __a, int __b,
11739                                               vector int *__c) {
11740   __builtin_altivec_stvxl(__a, __b, __c);
11741 }
11742
11743 static __inline__ void __ATTRS_o_ai vec_stvxl(vector int __a, int __b,
11744                                               int *__c) {
11745   __builtin_altivec_stvxl(__a, __b, __c);
11746 }
11747
11748 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned int __a, int __b,
11749                                               vector unsigned int *__c) {
11750   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11751 }
11752
11753 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned int __a, int __b,
11754                                               unsigned int *__c) {
11755   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11756 }
11757
11758 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool int __a, int __b,
11759                                               int *__c) {
11760   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11761 }
11762
11763 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool int __a, int __b,
11764                                               unsigned int *__c) {
11765   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11766 }
11767
11768 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool int __a, int __b,
11769                                               vector bool int *__c) {
11770   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11771 }
11772
11773 static __inline__ void __ATTRS_o_ai vec_stvxl(vector float __a, int __b,
11774                                               vector float *__c) {
11775   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11776 }
11777
11778 static __inline__ void __ATTRS_o_ai vec_stvxl(vector float __a, int __b,
11779                                               float *__c) {
11780   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11781 }
11782
11783 /* vec_sub */
11784
11785 static __inline__ vector signed char __ATTRS_o_ai
11786 vec_sub(vector signed char __a, vector signed char __b) {
11787   return __a - __b;
11788 }
11789
11790 static __inline__ vector signed char __ATTRS_o_ai
11791 vec_sub(vector bool char __a, vector signed char __b) {
11792   return (vector signed char)__a - __b;
11793 }
11794
11795 static __inline__ vector signed char __ATTRS_o_ai
11796 vec_sub(vector signed char __a, vector bool char __b) {
11797   return __a - (vector signed char)__b;
11798 }
11799
11800 static __inline__ vector unsigned char __ATTRS_o_ai
11801 vec_sub(vector unsigned char __a, vector unsigned char __b) {
11802   return __a - __b;
11803 }
11804
11805 static __inline__ vector unsigned char __ATTRS_o_ai
11806 vec_sub(vector bool char __a, vector unsigned char __b) {
11807   return (vector unsigned char)__a - __b;
11808 }
11809
11810 static __inline__ vector unsigned char __ATTRS_o_ai
11811 vec_sub(vector unsigned char __a, vector bool char __b) {
11812   return __a - (vector unsigned char)__b;
11813 }
11814
11815 static __inline__ vector short __ATTRS_o_ai vec_sub(vector short __a,
11816                                                     vector short __b) {
11817   return __a - __b;
11818 }
11819
11820 static __inline__ vector short __ATTRS_o_ai vec_sub(vector bool short __a,
11821                                                     vector short __b) {
11822   return (vector short)__a - __b;
11823 }
11824
11825 static __inline__ vector short __ATTRS_o_ai vec_sub(vector short __a,
11826                                                     vector bool short __b) {
11827   return __a - (vector short)__b;
11828 }
11829
11830 static __inline__ vector unsigned short __ATTRS_o_ai
11831 vec_sub(vector unsigned short __a, vector unsigned short __b) {
11832   return __a - __b;
11833 }
11834
11835 static __inline__ vector unsigned short __ATTRS_o_ai
11836 vec_sub(vector bool short __a, vector unsigned short __b) {
11837   return (vector unsigned short)__a - __b;
11838 }
11839
11840 static __inline__ vector unsigned short __ATTRS_o_ai
11841 vec_sub(vector unsigned short __a, vector bool short __b) {
11842   return __a - (vector unsigned short)__b;
11843 }
11844
11845 static __inline__ vector int __ATTRS_o_ai vec_sub(vector int __a,
11846                                                   vector int __b) {
11847   return __a - __b;
11848 }
11849
11850 static __inline__ vector int __ATTRS_o_ai vec_sub(vector bool int __a,
11851                                                   vector int __b) {
11852   return (vector int)__a - __b;
11853 }
11854
11855 static __inline__ vector int __ATTRS_o_ai vec_sub(vector int __a,
11856                                                   vector bool int __b) {
11857   return __a - (vector int)__b;
11858 }
11859
11860 static __inline__ vector unsigned int __ATTRS_o_ai
11861 vec_sub(vector unsigned int __a, vector unsigned int __b) {
11862   return __a - __b;
11863 }
11864
11865 static __inline__ vector unsigned int __ATTRS_o_ai
11866 vec_sub(vector bool int __a, vector unsigned int __b) {
11867   return (vector unsigned int)__a - __b;
11868 }
11869
11870 static __inline__ vector unsigned int __ATTRS_o_ai
11871 vec_sub(vector unsigned int __a, vector bool int __b) {
11872   return __a - (vector unsigned int)__b;
11873 }
11874
11875 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__) &&                    \
11876     defined(__SIZEOF_INT128__)
11877 static __inline__ vector signed __int128 __ATTRS_o_ai
11878 vec_sub(vector signed __int128 __a, vector signed __int128 __b) {
11879   return __a - __b;
11880 }
11881
11882 static __inline__ vector unsigned __int128 __ATTRS_o_ai
11883 vec_sub(vector unsigned __int128 __a, vector unsigned __int128 __b) {
11884   return __a - __b;
11885 }
11886 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__) &&
11887        // defined(__SIZEOF_INT128__)
11888
11889 #ifdef __VSX__
11890 static __inline__ vector signed long long __ATTRS_o_ai
11891 vec_sub(vector signed long long __a, vector signed long long __b) {
11892   return __a - __b;
11893 }
11894
11895 static __inline__ vector unsigned long long __ATTRS_o_ai
11896 vec_sub(vector unsigned long long __a, vector unsigned long long __b) {
11897   return __a - __b;
11898 }
11899
11900 static __inline__ vector double __ATTRS_o_ai vec_sub(vector double __a,
11901                                                      vector double __b) {
11902   return __a - __b;
11903 }
11904 #endif
11905
11906 static __inline__ vector float __ATTRS_o_ai vec_sub(vector float __a,
11907                                                     vector float __b) {
11908   return __a - __b;
11909 }
11910
11911 /* vec_vsububm */
11912
11913 #define __builtin_altivec_vsububm vec_vsububm
11914
11915 static __inline__ vector signed char __ATTRS_o_ai
11916 vec_vsububm(vector signed char __a, vector signed char __b) {
11917   return __a - __b;
11918 }
11919
11920 static __inline__ vector signed char __ATTRS_o_ai
11921 vec_vsububm(vector bool char __a, vector signed char __b) {
11922   return (vector signed char)__a - __b;
11923 }
11924
11925 static __inline__ vector signed char __ATTRS_o_ai
11926 vec_vsububm(vector signed char __a, vector bool char __b) {
11927   return __a - (vector signed char)__b;
11928 }
11929
11930 static __inline__ vector unsigned char __ATTRS_o_ai
11931 vec_vsububm(vector unsigned char __a, vector unsigned char __b) {
11932   return __a - __b;
11933 }
11934
11935 static __inline__ vector unsigned char __ATTRS_o_ai
11936 vec_vsububm(vector bool char __a, vector unsigned char __b) {
11937   return (vector unsigned char)__a - __b;
11938 }
11939
11940 static __inline__ vector unsigned char __ATTRS_o_ai
11941 vec_vsububm(vector unsigned char __a, vector bool char __b) {
11942   return __a - (vector unsigned char)__b;
11943 }
11944
11945 /* vec_vsubuhm */
11946
11947 #define __builtin_altivec_vsubuhm vec_vsubuhm
11948
11949 static __inline__ vector short __ATTRS_o_ai vec_vsubuhm(vector short __a,
11950                                                         vector short __b) {
11951   return __a - __b;
11952 }
11953
11954 static __inline__ vector short __ATTRS_o_ai vec_vsubuhm(vector bool short __a,
11955                                                         vector short __b) {
11956   return (vector short)__a - __b;
11957 }
11958
11959 static __inline__ vector short __ATTRS_o_ai vec_vsubuhm(vector short __a,
11960                                                         vector bool short __b) {
11961   return __a - (vector short)__b;
11962 }
11963
11964 static __inline__ vector unsigned short __ATTRS_o_ai
11965 vec_vsubuhm(vector unsigned short __a, vector unsigned short __b) {
11966   return __a - __b;
11967 }
11968
11969 static __inline__ vector unsigned short __ATTRS_o_ai
11970 vec_vsubuhm(vector bool short __a, vector unsigned short __b) {
11971   return (vector unsigned short)__a - __b;
11972 }
11973
11974 static __inline__ vector unsigned short __ATTRS_o_ai
11975 vec_vsubuhm(vector unsigned short __a, vector bool short __b) {
11976   return __a - (vector unsigned short)__b;
11977 }
11978
11979 /* vec_vsubuwm */
11980
11981 #define __builtin_altivec_vsubuwm vec_vsubuwm
11982
11983 static __inline__ vector int __ATTRS_o_ai vec_vsubuwm(vector int __a,
11984                                                       vector int __b) {
11985   return __a - __b;
11986 }
11987
11988 static __inline__ vector int __ATTRS_o_ai vec_vsubuwm(vector bool int __a,
11989                                                       vector int __b) {
11990   return (vector int)__a - __b;
11991 }
11992
11993 static __inline__ vector int __ATTRS_o_ai vec_vsubuwm(vector int __a,
11994                                                       vector bool int __b) {
11995   return __a - (vector int)__b;
11996 }
11997
11998 static __inline__ vector unsigned int __ATTRS_o_ai
11999 vec_vsubuwm(vector unsigned int __a, vector unsigned int __b) {
12000   return __a - __b;
12001 }
12002
12003 static __inline__ vector unsigned int __ATTRS_o_ai
12004 vec_vsubuwm(vector bool int __a, vector unsigned int __b) {
12005   return (vector unsigned int)__a - __b;
12006 }
12007
12008 static __inline__ vector unsigned int __ATTRS_o_ai
12009 vec_vsubuwm(vector unsigned int __a, vector bool int __b) {
12010   return __a - (vector unsigned int)__b;
12011 }
12012
12013 /* vec_vsubfp */
12014
12015 #define __builtin_altivec_vsubfp vec_vsubfp
12016
12017 static __inline__ vector float __attribute__((__always_inline__))
12018 vec_vsubfp(vector float __a, vector float __b) {
12019   return __a - __b;
12020 }
12021
12022 /* vec_subc */
12023
12024 static __inline__ vector signed int __ATTRS_o_ai
12025 vec_subc(vector signed int __a, vector signed int __b) {
12026   return (vector signed int)__builtin_altivec_vsubcuw((vector unsigned int)__a,
12027                                                       (vector unsigned int) __b);
12028 }
12029
12030 static __inline__ vector unsigned int __ATTRS_o_ai
12031 vec_subc(vector unsigned int __a, vector unsigned int __b) {
12032   return __builtin_altivec_vsubcuw(__a, __b);
12033 }
12034
12035 #ifdef __POWER8_VECTOR__
12036 #ifdef __SIZEOF_INT128__
12037 static __inline__ vector unsigned __int128 __ATTRS_o_ai
12038 vec_subc(vector unsigned __int128 __a, vector unsigned __int128 __b) {
12039   return __builtin_altivec_vsubcuq(__a, __b);
12040 }
12041
12042 static __inline__ vector signed __int128 __ATTRS_o_ai
12043 vec_subc(vector signed __int128 __a, vector signed __int128 __b) {
12044   return __builtin_altivec_vsubcuq(__a, __b);
12045 }
12046 #endif
12047
12048 static __inline__ vector unsigned char __attribute__((__always_inline__))
12049 vec_subc_u128(vector unsigned char __a, vector unsigned char __b) {
12050   return (vector unsigned char)__builtin_altivec_vsubcuq(__a, __b);
12051 }
12052 #endif // __POWER8_VECTOR__
12053
12054 /* vec_vsubcuw */
12055
12056 static __inline__ vector unsigned int __attribute__((__always_inline__))
12057 vec_vsubcuw(vector unsigned int __a, vector unsigned int __b) {
12058   return __builtin_altivec_vsubcuw(__a, __b);
12059 }
12060
12061 /* vec_subs */
12062
12063 static __inline__ vector signed char __ATTRS_o_ai
12064 vec_subs(vector signed char __a, vector signed char __b) {
12065   return __builtin_altivec_vsubsbs(__a, __b);
12066 }
12067
12068 static __inline__ vector signed char __ATTRS_o_ai
12069 vec_subs(vector bool char __a, vector signed char __b) {
12070   return __builtin_altivec_vsubsbs((vector signed char)__a, __b);
12071 }
12072
12073 static __inline__ vector signed char __ATTRS_o_ai
12074 vec_subs(vector signed char __a, vector bool char __b) {
12075   return __builtin_altivec_vsubsbs(__a, (vector signed char)__b);
12076 }
12077
12078 static __inline__ vector unsigned char __ATTRS_o_ai
12079 vec_subs(vector unsigned char __a, vector unsigned char __b) {
12080   return __builtin_altivec_vsububs(__a, __b);
12081 }
12082
12083 static __inline__ vector unsigned char __ATTRS_o_ai
12084 vec_subs(vector bool char __a, vector unsigned char __b) {
12085   return __builtin_altivec_vsububs((vector unsigned char)__a, __b);
12086 }
12087
12088 static __inline__ vector unsigned char __ATTRS_o_ai
12089 vec_subs(vector unsigned char __a, vector bool char __b) {
12090   return __builtin_altivec_vsububs(__a, (vector unsigned char)__b);
12091 }
12092
12093 static __inline__ vector short __ATTRS_o_ai vec_subs(vector short __a,
12094                                                      vector short __b) {
12095   return __builtin_altivec_vsubshs(__a, __b);
12096 }
12097
12098 static __inline__ vector short __ATTRS_o_ai vec_subs(vector bool short __a,
12099                                                      vector short __b) {
12100   return __builtin_altivec_vsubshs((vector short)__a, __b);
12101 }
12102
12103 static __inline__ vector short __ATTRS_o_ai vec_subs(vector short __a,
12104                                                      vector bool short __b) {
12105   return __builtin_altivec_vsubshs(__a, (vector short)__b);
12106 }
12107
12108 static __inline__ vector unsigned short __ATTRS_o_ai
12109 vec_subs(vector unsigned short __a, vector unsigned short __b) {
12110   return __builtin_altivec_vsubuhs(__a, __b);
12111 }
12112
12113 static __inline__ vector unsigned short __ATTRS_o_ai
12114 vec_subs(vector bool short __a, vector unsigned short __b) {
12115   return __builtin_altivec_vsubuhs((vector unsigned short)__a, __b);
12116 }
12117
12118 static __inline__ vector unsigned short __ATTRS_o_ai
12119 vec_subs(vector unsigned short __a, vector bool short __b) {
12120   return __builtin_altivec_vsubuhs(__a, (vector unsigned short)__b);
12121 }
12122
12123 static __inline__ vector int __ATTRS_o_ai vec_subs(vector int __a,
12124                                                    vector int __b) {
12125   return __builtin_altivec_vsubsws(__a, __b);
12126 }
12127
12128 static __inline__ vector int __ATTRS_o_ai vec_subs(vector bool int __a,
12129                                                    vector int __b) {
12130   return __builtin_altivec_vsubsws((vector int)__a, __b);
12131 }
12132
12133 static __inline__ vector int __ATTRS_o_ai vec_subs(vector int __a,
12134                                                    vector bool int __b) {
12135   return __builtin_altivec_vsubsws(__a, (vector int)__b);
12136 }
12137
12138 static __inline__ vector unsigned int __ATTRS_o_ai
12139 vec_subs(vector unsigned int __a, vector unsigned int __b) {
12140   return __builtin_altivec_vsubuws(__a, __b);
12141 }
12142
12143 static __inline__ vector unsigned int __ATTRS_o_ai
12144 vec_subs(vector bool int __a, vector unsigned int __b) {
12145   return __builtin_altivec_vsubuws((vector unsigned int)__a, __b);
12146 }
12147
12148 static __inline__ vector unsigned int __ATTRS_o_ai
12149 vec_subs(vector unsigned int __a, vector bool int __b) {
12150   return __builtin_altivec_vsubuws(__a, (vector unsigned int)__b);
12151 }
12152
12153 /* vec_vsubsbs */
12154
12155 static __inline__ vector signed char __ATTRS_o_ai
12156 vec_vsubsbs(vector signed char __a, vector signed char __b) {
12157   return __builtin_altivec_vsubsbs(__a, __b);
12158 }
12159
12160 static __inline__ vector signed char __ATTRS_o_ai
12161 vec_vsubsbs(vector bool char __a, vector signed char __b) {
12162   return __builtin_altivec_vsubsbs((vector signed char)__a, __b);
12163 }
12164
12165 static __inline__ vector signed char __ATTRS_o_ai
12166 vec_vsubsbs(vector signed char __a, vector bool char __b) {
12167   return __builtin_altivec_vsubsbs(__a, (vector signed char)__b);
12168 }
12169
12170 /* vec_vsububs */
12171
12172 static __inline__ vector unsigned char __ATTRS_o_ai
12173 vec_vsububs(vector unsigned char __a, vector unsigned char __b) {
12174   return __builtin_altivec_vsububs(__a, __b);
12175 }
12176
12177 static __inline__ vector unsigned char __ATTRS_o_ai
12178 vec_vsububs(vector bool char __a, vector unsigned char __b) {
12179   return __builtin_altivec_vsububs((vector unsigned char)__a, __b);
12180 }
12181
12182 static __inline__ vector unsigned char __ATTRS_o_ai
12183 vec_vsububs(vector unsigned char __a, vector bool char __b) {
12184   return __builtin_altivec_vsububs(__a, (vector unsigned char)__b);
12185 }
12186
12187 /* vec_vsubshs */
12188
12189 static __inline__ vector short __ATTRS_o_ai vec_vsubshs(vector short __a,
12190                                                         vector short __b) {
12191   return __builtin_altivec_vsubshs(__a, __b);
12192 }
12193
12194 static __inline__ vector short __ATTRS_o_ai vec_vsubshs(vector bool short __a,
12195                                                         vector short __b) {
12196   return __builtin_altivec_vsubshs((vector short)__a, __b);
12197 }
12198
12199 static __inline__ vector short __ATTRS_o_ai vec_vsubshs(vector short __a,
12200                                                         vector bool short __b) {
12201   return __builtin_altivec_vsubshs(__a, (vector short)__b);
12202 }
12203
12204 /* vec_vsubuhs */
12205
12206 static __inline__ vector unsigned short __ATTRS_o_ai
12207 vec_vsubuhs(vector unsigned short __a, vector unsigned short __b) {
12208   return __builtin_altivec_vsubuhs(__a, __b);
12209 }
12210
12211 static __inline__ vector unsigned short __ATTRS_o_ai
12212 vec_vsubuhs(vector bool short __a, vector unsigned short __b) {
12213   return __builtin_altivec_vsubuhs((vector unsigned short)__a, __b);
12214 }
12215
12216 static __inline__ vector unsigned short __ATTRS_o_ai
12217 vec_vsubuhs(vector unsigned short __a, vector bool short __b) {
12218   return __builtin_altivec_vsubuhs(__a, (vector unsigned short)__b);
12219 }
12220
12221 /* vec_vsubsws */
12222
12223 static __inline__ vector int __ATTRS_o_ai vec_vsubsws(vector int __a,
12224                                                       vector int __b) {
12225   return __builtin_altivec_vsubsws(__a, __b);
12226 }
12227
12228 static __inline__ vector int __ATTRS_o_ai vec_vsubsws(vector bool int __a,
12229                                                       vector int __b) {
12230   return __builtin_altivec_vsubsws((vector int)__a, __b);
12231 }
12232
12233 static __inline__ vector int __ATTRS_o_ai vec_vsubsws(vector int __a,
12234                                                       vector bool int __b) {
12235   return __builtin_altivec_vsubsws(__a, (vector int)__b);
12236 }
12237
12238 /* vec_vsubuws */
12239
12240 static __inline__ vector unsigned int __ATTRS_o_ai
12241 vec_vsubuws(vector unsigned int __a, vector unsigned int __b) {
12242   return __builtin_altivec_vsubuws(__a, __b);
12243 }
12244
12245 static __inline__ vector unsigned int __ATTRS_o_ai
12246 vec_vsubuws(vector bool int __a, vector unsigned int __b) {
12247   return __builtin_altivec_vsubuws((vector unsigned int)__a, __b);
12248 }
12249
12250 static __inline__ vector unsigned int __ATTRS_o_ai
12251 vec_vsubuws(vector unsigned int __a, vector bool int __b) {
12252   return __builtin_altivec_vsubuws(__a, (vector unsigned int)__b);
12253 }
12254
12255 #ifdef __POWER8_VECTOR__
12256 /* vec_vsubuqm */
12257
12258 #ifdef __SIZEOF_INT128__
12259 static __inline__ vector signed __int128 __ATTRS_o_ai
12260 vec_vsubuqm(vector signed __int128 __a, vector signed __int128 __b) {
12261   return __a - __b;
12262 }
12263
12264 static __inline__ vector unsigned __int128 __ATTRS_o_ai
12265 vec_vsubuqm(vector unsigned __int128 __a, vector unsigned __int128 __b) {
12266   return __a - __b;
12267 }
12268 #endif
12269
12270 static __inline__ vector unsigned char __attribute__((__always_inline__))
12271 vec_sub_u128(vector unsigned char __a, vector unsigned char __b) {
12272   return __builtin_altivec_vsubuqm(__a, __b);
12273 }
12274
12275 /* vec_vsubeuqm */
12276
12277 #ifdef __SIZEOF_INT128__
12278 static __inline__ vector signed __int128 __ATTRS_o_ai
12279 vec_vsubeuqm(vector signed __int128 __a, vector signed __int128 __b,
12280              vector signed __int128 __c) {
12281   return __builtin_altivec_vsubeuqm(__a, __b, __c);
12282 }
12283
12284 static __inline__ vector unsigned __int128 __ATTRS_o_ai
12285 vec_vsubeuqm(vector unsigned __int128 __a, vector unsigned __int128 __b,
12286              vector unsigned __int128 __c) {
12287   return __builtin_altivec_vsubeuqm(__a, __b, __c);
12288 }
12289
12290 static __inline__ vector signed __int128 __ATTRS_o_ai
12291 vec_sube(vector signed __int128 __a, vector signed __int128 __b,
12292              vector signed __int128 __c) {
12293   return __builtin_altivec_vsubeuqm(__a, __b, __c);
12294 }
12295
12296 static __inline__ vector unsigned __int128 __ATTRS_o_ai
12297 vec_sube(vector unsigned __int128 __a, vector unsigned __int128 __b,
12298              vector unsigned __int128 __c) {
12299   return __builtin_altivec_vsubeuqm(__a, __b, __c);
12300 }
12301 #endif
12302
12303 static __inline__ vector unsigned char __attribute__((__always_inline__))
12304 vec_sube_u128(vector unsigned char __a, vector unsigned char __b,
12305               vector unsigned char __c) {
12306   return (vector unsigned char)__builtin_altivec_vsubeuqm(__a, __b, __c);
12307 }
12308
12309 /* vec_vsubcuq */
12310
12311 #ifdef __SIZEOF_INT128__
12312 static __inline__ vector signed __int128 __ATTRS_o_ai
12313 vec_vsubcuq(vector signed __int128 __a, vector signed __int128 __b) {
12314   return __builtin_altivec_vsubcuq(__a, __b);
12315 }
12316
12317 static __inline__ vector unsigned __int128 __ATTRS_o_ai
12318 vec_vsubcuq(vector unsigned __int128 __a, vector unsigned __int128 __b) {
12319   return __builtin_altivec_vsubcuq(__a, __b);
12320 }
12321
12322 /* vec_vsubecuq */
12323
12324 static __inline__ vector signed __int128 __ATTRS_o_ai
12325 vec_vsubecuq(vector signed __int128 __a, vector signed __int128 __b,
12326              vector signed __int128 __c) {
12327   return __builtin_altivec_vsubecuq(__a, __b, __c);
12328 }
12329
12330 static __inline__ vector unsigned __int128 __ATTRS_o_ai
12331 vec_vsubecuq(vector unsigned __int128 __a, vector unsigned __int128 __b,
12332              vector unsigned __int128 __c) {
12333   return __builtin_altivec_vsubecuq(__a, __b, __c);
12334 }
12335 #endif
12336
12337 #ifdef __powerpc64__
12338 static __inline__ vector signed int __ATTRS_o_ai
12339 vec_subec(vector signed int __a, vector signed int __b,
12340              vector signed int __c) {
12341   return vec_addec(__a, ~__b, __c);
12342 }
12343
12344 static __inline__ vector unsigned int __ATTRS_o_ai
12345 vec_subec(vector unsigned int __a, vector unsigned int __b,
12346              vector unsigned int __c) {
12347   return vec_addec(__a, ~__b, __c);
12348 }
12349 #endif
12350
12351 #ifdef __SIZEOF_INT128__
12352 static __inline__ vector signed __int128 __ATTRS_o_ai
12353 vec_subec(vector signed __int128 __a, vector signed __int128 __b,
12354              vector signed __int128 __c) {
12355   return __builtin_altivec_vsubecuq(__a, __b, __c);
12356 }
12357
12358 static __inline__ vector unsigned __int128 __ATTRS_o_ai
12359 vec_subec(vector unsigned __int128 __a, vector unsigned __int128 __b,
12360              vector unsigned __int128 __c) {
12361   return __builtin_altivec_vsubecuq(__a, __b, __c);
12362 }
12363 #endif
12364
12365 static __inline__ vector unsigned char __attribute__((__always_inline__))
12366 vec_subec_u128(vector unsigned char __a, vector unsigned char __b,
12367                vector unsigned char __c) {
12368   return (vector unsigned char)__builtin_altivec_vsubecuq(__a, __b, __c);
12369 }
12370 #endif // __POWER8_VECTOR__
12371
12372 static __inline__ vector signed int __ATTRS_o_ai
12373 vec_sube(vector signed int __a, vector signed int __b,
12374          vector signed int __c) {
12375   vector signed int __mask = {1, 1, 1, 1};
12376   vector signed int __carry = __c & __mask;
12377   return vec_adde(__a, ~__b, __carry);
12378 }
12379
12380 static __inline__ vector unsigned int __ATTRS_o_ai
12381 vec_sube(vector unsigned int __a, vector unsigned int __b,
12382          vector unsigned int __c) {
12383   vector unsigned int __mask = {1, 1, 1, 1};
12384   vector unsigned int __carry = __c & __mask;
12385   return vec_adde(__a, ~__b, __carry);
12386 }
12387 /* vec_sum4s */
12388
12389 static __inline__ vector int __ATTRS_o_ai vec_sum4s(vector signed char __a,
12390                                                     vector int __b) {
12391   return __builtin_altivec_vsum4sbs(__a, __b);
12392 }
12393
12394 static __inline__ vector unsigned int __ATTRS_o_ai
12395 vec_sum4s(vector unsigned char __a, vector unsigned int __b) {
12396   return __builtin_altivec_vsum4ubs(__a, __b);
12397 }
12398
12399 static __inline__ vector int __ATTRS_o_ai vec_sum4s(vector signed short __a,
12400                                                     vector int __b) {
12401   return __builtin_altivec_vsum4shs(__a, __b);
12402 }
12403
12404 /* vec_vsum4sbs */
12405
12406 static __inline__ vector int __attribute__((__always_inline__))
12407 vec_vsum4sbs(vector signed char __a, vector int __b) {
12408   return __builtin_altivec_vsum4sbs(__a, __b);
12409 }
12410
12411 /* vec_vsum4ubs */
12412
12413 static __inline__ vector unsigned int __attribute__((__always_inline__))
12414 vec_vsum4ubs(vector unsigned char __a, vector unsigned int __b) {
12415   return __builtin_altivec_vsum4ubs(__a, __b);
12416 }
12417
12418 /* vec_vsum4shs */
12419
12420 static __inline__ vector int __attribute__((__always_inline__))
12421 vec_vsum4shs(vector signed short __a, vector int __b) {
12422   return __builtin_altivec_vsum4shs(__a, __b);
12423 }
12424
12425 /* vec_sum2s */
12426
12427 /* The vsum2sws instruction has a big-endian bias, so that the second
12428    input vector and the result always reference big-endian elements
12429    1 and 3 (little-endian element 0 and 2).  For ease of porting the
12430    programmer wants elements 1 and 3 in both cases, so for little
12431    endian we must perform some permutes.  */
12432
12433 static __inline__ vector signed int __attribute__((__always_inline__))
12434 vec_sum2s(vector int __a, vector int __b) {
12435 #ifdef __LITTLE_ENDIAN__
12436   vector int __c = (vector signed int)vec_perm(
12437       __b, __b, (vector unsigned char)(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15,
12438                                        8, 9, 10, 11));
12439   __c = __builtin_altivec_vsum2sws(__a, __c);
12440   return (vector signed int)vec_perm(
12441       __c, __c, (vector unsigned char)(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15,
12442                                        8, 9, 10, 11));
12443 #else
12444   return __builtin_altivec_vsum2sws(__a, __b);
12445 #endif
12446 }
12447
12448 /* vec_vsum2sws */
12449
12450 static __inline__ vector signed int __attribute__((__always_inline__))
12451 vec_vsum2sws(vector int __a, vector int __b) {
12452 #ifdef __LITTLE_ENDIAN__
12453   vector int __c = (vector signed int)vec_perm(
12454       __b, __b, (vector unsigned char)(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15,
12455                                        8, 9, 10, 11));
12456   __c = __builtin_altivec_vsum2sws(__a, __c);
12457   return (vector signed int)vec_perm(
12458       __c, __c, (vector unsigned char)(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15,
12459                                        8, 9, 10, 11));
12460 #else
12461   return __builtin_altivec_vsum2sws(__a, __b);
12462 #endif
12463 }
12464
12465 /* vec_sums */
12466
12467 /* The vsumsws instruction has a big-endian bias, so that the second
12468    input vector and the result always reference big-endian element 3
12469    (little-endian element 0).  For ease of porting the programmer
12470    wants element 3 in both cases, so for little endian we must perform
12471    some permutes.  */
12472
12473 static __inline__ vector signed int __attribute__((__always_inline__))
12474 vec_sums(vector signed int __a, vector signed int __b) {
12475 #ifdef __LITTLE_ENDIAN__
12476   __b = (vector signed int)vec_splat(__b, 3);
12477   __b = __builtin_altivec_vsumsws(__a, __b);
12478   return (vector signed int)(0, 0, 0, __b[0]);
12479 #else
12480   return __builtin_altivec_vsumsws(__a, __b);
12481 #endif
12482 }
12483
12484 /* vec_vsumsws */
12485
12486 static __inline__ vector signed int __attribute__((__always_inline__))
12487 vec_vsumsws(vector signed int __a, vector signed int __b) {
12488 #ifdef __LITTLE_ENDIAN__
12489   __b = (vector signed int)vec_splat(__b, 3);
12490   __b = __builtin_altivec_vsumsws(__a, __b);
12491   return (vector signed int)(0, 0, 0, __b[0]);
12492 #else
12493   return __builtin_altivec_vsumsws(__a, __b);
12494 #endif
12495 }
12496
12497 /* vec_trunc */
12498
12499 static __inline__ vector float __ATTRS_o_ai vec_trunc(vector float __a) {
12500 #ifdef __VSX__
12501   return __builtin_vsx_xvrspiz(__a);
12502 #else
12503   return __builtin_altivec_vrfiz(__a);
12504 #endif
12505 }
12506
12507 #ifdef __VSX__
12508 static __inline__ vector double __ATTRS_o_ai vec_trunc(vector double __a) {
12509   return __builtin_vsx_xvrdpiz(__a);
12510 }
12511 #endif
12512
12513 /* vec_roundz */
12514 static __inline__ vector float __ATTRS_o_ai vec_roundz(vector float __a) {
12515   return vec_trunc(__a);
12516 }
12517
12518 #ifdef __VSX__
12519 static __inline__ vector double __ATTRS_o_ai vec_roundz(vector double __a) {
12520   return vec_trunc(__a);
12521 }
12522 #endif
12523
12524 /* vec_vrfiz */
12525
12526 static __inline__ vector float __attribute__((__always_inline__))
12527 vec_vrfiz(vector float __a) {
12528   return __builtin_altivec_vrfiz(__a);
12529 }
12530
12531 /* vec_unpackh */
12532
12533 /* The vector unpack instructions all have a big-endian bias, so for
12534    little endian we must reverse the meanings of "high" and "low."  */
12535 #ifdef __LITTLE_ENDIAN__
12536 #define vec_vupkhpx(__a) __builtin_altivec_vupklpx((vector short)(__a))
12537 #define vec_vupklpx(__a) __builtin_altivec_vupkhpx((vector short)(__a))
12538 #else
12539 #define vec_vupkhpx(__a) __builtin_altivec_vupkhpx((vector short)(__a))
12540 #define vec_vupklpx(__a) __builtin_altivec_vupklpx((vector short)(__a))
12541 #endif
12542
12543 static __inline__ vector short __ATTRS_o_ai
12544 vec_unpackh(vector signed char __a) {
12545 #ifdef __LITTLE_ENDIAN__
12546   return __builtin_altivec_vupklsb((vector char)__a);
12547 #else
12548   return __builtin_altivec_vupkhsb((vector char)__a);
12549 #endif
12550 }
12551
12552 static __inline__ vector bool short __ATTRS_o_ai
12553 vec_unpackh(vector bool char __a) {
12554 #ifdef __LITTLE_ENDIAN__
12555   return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
12556 #else
12557   return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
12558 #endif
12559 }
12560
12561 static __inline__ vector int __ATTRS_o_ai vec_unpackh(vector short __a) {
12562 #ifdef __LITTLE_ENDIAN__
12563   return __builtin_altivec_vupklsh(__a);
12564 #else
12565   return __builtin_altivec_vupkhsh(__a);
12566 #endif
12567 }
12568
12569 static __inline__ vector bool int __ATTRS_o_ai
12570 vec_unpackh(vector bool short __a) {
12571 #ifdef __LITTLE_ENDIAN__
12572   return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
12573 #else
12574   return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
12575 #endif
12576 }
12577
12578 static __inline__ vector unsigned int __ATTRS_o_ai
12579 vec_unpackh(vector pixel __a) {
12580 #ifdef __LITTLE_ENDIAN__
12581   return (vector unsigned int)__builtin_altivec_vupklpx((vector short)__a);
12582 #else
12583   return (vector unsigned int)__builtin_altivec_vupkhpx((vector short)__a);
12584 #endif
12585 }
12586
12587 #ifdef __POWER8_VECTOR__
12588 static __inline__ vector long long __ATTRS_o_ai vec_unpackh(vector int __a) {
12589 #ifdef __LITTLE_ENDIAN__
12590   return __builtin_altivec_vupklsw(__a);
12591 #else
12592   return __builtin_altivec_vupkhsw(__a);
12593 #endif
12594 }
12595
12596 static __inline__ vector bool long long __ATTRS_o_ai
12597 vec_unpackh(vector bool int __a) {
12598 #ifdef __LITTLE_ENDIAN__
12599   return (vector bool long long)__builtin_altivec_vupklsw((vector int)__a);
12600 #else
12601   return (vector bool long long)__builtin_altivec_vupkhsw((vector int)__a);
12602 #endif
12603 }
12604
12605 static __inline__ vector double __ATTRS_o_ai
12606 vec_unpackh(vector float __a) {
12607   return (vector double)(__a[0], __a[1]);
12608 }
12609 #endif
12610
12611 /* vec_vupkhsb */
12612
12613 static __inline__ vector short __ATTRS_o_ai
12614 vec_vupkhsb(vector signed char __a) {
12615 #ifdef __LITTLE_ENDIAN__
12616   return __builtin_altivec_vupklsb((vector char)__a);
12617 #else
12618   return __builtin_altivec_vupkhsb((vector char)__a);
12619 #endif
12620 }
12621
12622 static __inline__ vector bool short __ATTRS_o_ai
12623 vec_vupkhsb(vector bool char __a) {
12624 #ifdef __LITTLE_ENDIAN__
12625   return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
12626 #else
12627   return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
12628 #endif
12629 }
12630
12631 /* vec_vupkhsh */
12632
12633 static __inline__ vector int __ATTRS_o_ai vec_vupkhsh(vector short __a) {
12634 #ifdef __LITTLE_ENDIAN__
12635   return __builtin_altivec_vupklsh(__a);
12636 #else
12637   return __builtin_altivec_vupkhsh(__a);
12638 #endif
12639 }
12640
12641 static __inline__ vector bool int __ATTRS_o_ai
12642 vec_vupkhsh(vector bool short __a) {
12643 #ifdef __LITTLE_ENDIAN__
12644   return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
12645 #else
12646   return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
12647 #endif
12648 }
12649
12650 static __inline__ vector unsigned int __ATTRS_o_ai
12651 vec_vupkhsh(vector pixel __a) {
12652 #ifdef __LITTLE_ENDIAN__
12653   return (vector unsigned int)__builtin_altivec_vupklpx((vector short)__a);
12654 #else
12655   return (vector unsigned int)__builtin_altivec_vupkhpx((vector short)__a);
12656 #endif
12657 }
12658
12659 /* vec_vupkhsw */
12660
12661 #ifdef __POWER8_VECTOR__
12662 static __inline__ vector long long __ATTRS_o_ai vec_vupkhsw(vector int __a) {
12663 #ifdef __LITTLE_ENDIAN__
12664   return __builtin_altivec_vupklsw(__a);
12665 #else
12666   return __builtin_altivec_vupkhsw(__a);
12667 #endif
12668 }
12669
12670 static __inline__ vector bool long long __ATTRS_o_ai
12671 vec_vupkhsw(vector bool int __a) {
12672 #ifdef __LITTLE_ENDIAN__
12673   return (vector bool long long)__builtin_altivec_vupklsw((vector int)__a);
12674 #else
12675   return (vector bool long long)__builtin_altivec_vupkhsw((vector int)__a);
12676 #endif
12677 }
12678 #endif
12679
12680 /* vec_unpackl */
12681
12682 static __inline__ vector short __ATTRS_o_ai
12683 vec_unpackl(vector signed char __a) {
12684 #ifdef __LITTLE_ENDIAN__
12685   return __builtin_altivec_vupkhsb((vector char)__a);
12686 #else
12687   return __builtin_altivec_vupklsb((vector char)__a);
12688 #endif
12689 }
12690
12691 static __inline__ vector bool short __ATTRS_o_ai
12692 vec_unpackl(vector bool char __a) {
12693 #ifdef __LITTLE_ENDIAN__
12694   return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
12695 #else
12696   return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
12697 #endif
12698 }
12699
12700 static __inline__ vector int __ATTRS_o_ai vec_unpackl(vector short __a) {
12701 #ifdef __LITTLE_ENDIAN__
12702   return __builtin_altivec_vupkhsh(__a);
12703 #else
12704   return __builtin_altivec_vupklsh(__a);
12705 #endif
12706 }
12707
12708 static __inline__ vector bool int __ATTRS_o_ai
12709 vec_unpackl(vector bool short __a) {
12710 #ifdef __LITTLE_ENDIAN__
12711   return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
12712 #else
12713   return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
12714 #endif
12715 }
12716
12717 static __inline__ vector unsigned int __ATTRS_o_ai
12718 vec_unpackl(vector pixel __a) {
12719 #ifdef __LITTLE_ENDIAN__
12720   return (vector unsigned int)__builtin_altivec_vupkhpx((vector short)__a);
12721 #else
12722   return (vector unsigned int)__builtin_altivec_vupklpx((vector short)__a);
12723 #endif
12724 }
12725
12726 #ifdef __POWER8_VECTOR__
12727 static __inline__ vector long long __ATTRS_o_ai vec_unpackl(vector int __a) {
12728 #ifdef __LITTLE_ENDIAN__
12729   return __builtin_altivec_vupkhsw(__a);
12730 #else
12731   return __builtin_altivec_vupklsw(__a);
12732 #endif
12733 }
12734
12735 static __inline__ vector bool long long __ATTRS_o_ai
12736 vec_unpackl(vector bool int __a) {
12737 #ifdef __LITTLE_ENDIAN__
12738   return (vector bool long long)__builtin_altivec_vupkhsw((vector int)__a);
12739 #else
12740   return (vector bool long long)__builtin_altivec_vupklsw((vector int)__a);
12741 #endif
12742 }
12743
12744 static __inline__ vector double __ATTRS_o_ai
12745 vec_unpackl(vector float __a) {
12746   return (vector double)(__a[2], __a[3]);
12747 }
12748 #endif
12749
12750 /* vec_vupklsb */
12751
12752 static __inline__ vector short __ATTRS_o_ai
12753 vec_vupklsb(vector signed char __a) {
12754 #ifdef __LITTLE_ENDIAN__
12755   return __builtin_altivec_vupkhsb((vector char)__a);
12756 #else
12757   return __builtin_altivec_vupklsb((vector char)__a);
12758 #endif
12759 }
12760
12761 static __inline__ vector bool short __ATTRS_o_ai
12762 vec_vupklsb(vector bool char __a) {
12763 #ifdef __LITTLE_ENDIAN__
12764   return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
12765 #else
12766   return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
12767 #endif
12768 }
12769
12770 /* vec_vupklsh */
12771
12772 static __inline__ vector int __ATTRS_o_ai vec_vupklsh(vector short __a) {
12773 #ifdef __LITTLE_ENDIAN__
12774   return __builtin_altivec_vupkhsh(__a);
12775 #else
12776   return __builtin_altivec_vupklsh(__a);
12777 #endif
12778 }
12779
12780 static __inline__ vector bool int __ATTRS_o_ai
12781 vec_vupklsh(vector bool short __a) {
12782 #ifdef __LITTLE_ENDIAN__
12783   return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
12784 #else
12785   return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
12786 #endif
12787 }
12788
12789 static __inline__ vector unsigned int __ATTRS_o_ai
12790 vec_vupklsh(vector pixel __a) {
12791 #ifdef __LITTLE_ENDIAN__
12792   return (vector unsigned int)__builtin_altivec_vupkhpx((vector short)__a);
12793 #else
12794   return (vector unsigned int)__builtin_altivec_vupklpx((vector short)__a);
12795 #endif
12796 }
12797
12798 /* vec_vupklsw */
12799
12800 #ifdef __POWER8_VECTOR__
12801 static __inline__ vector long long __ATTRS_o_ai vec_vupklsw(vector int __a) {
12802 #ifdef __LITTLE_ENDIAN__
12803   return __builtin_altivec_vupkhsw(__a);
12804 #else
12805   return __builtin_altivec_vupklsw(__a);
12806 #endif
12807 }
12808
12809 static __inline__ vector bool long long __ATTRS_o_ai
12810 vec_vupklsw(vector bool int __a) {
12811 #ifdef __LITTLE_ENDIAN__
12812   return (vector bool long long)__builtin_altivec_vupkhsw((vector int)__a);
12813 #else
12814   return (vector bool long long)__builtin_altivec_vupklsw((vector int)__a);
12815 #endif
12816 }
12817 #endif
12818
12819 /* vec_vsx_ld */
12820
12821 #ifdef __VSX__
12822
12823 static __inline__ vector bool int __ATTRS_o_ai
12824 vec_vsx_ld(int __a, const vector bool int *__b) {
12825   return (vector bool int)__builtin_vsx_lxvw4x(__a, __b);
12826 }
12827
12828 static __inline__ vector signed int __ATTRS_o_ai
12829 vec_vsx_ld(int __a, const vector signed int *__b) {
12830   return (vector signed int)__builtin_vsx_lxvw4x(__a, __b);
12831 }
12832
12833 static __inline__ vector signed int __ATTRS_o_ai
12834 vec_vsx_ld(int __a, const signed int *__b) {
12835   return (vector signed int)__builtin_vsx_lxvw4x(__a, __b);
12836 }
12837
12838 static __inline__ vector unsigned int __ATTRS_o_ai
12839 vec_vsx_ld(int __a, const vector unsigned int *__b) {
12840   return (vector unsigned int)__builtin_vsx_lxvw4x(__a, __b);
12841 }
12842
12843 static __inline__ vector unsigned int __ATTRS_o_ai
12844 vec_vsx_ld(int __a, const unsigned int *__b) {
12845   return (vector unsigned int)__builtin_vsx_lxvw4x(__a, __b);
12846 }
12847
12848 static __inline__ vector float __ATTRS_o_ai
12849 vec_vsx_ld(int __a, const vector float *__b) {
12850   return (vector float)__builtin_vsx_lxvw4x(__a, __b);
12851 }
12852
12853 static __inline__ vector float __ATTRS_o_ai vec_vsx_ld(int __a,
12854                                                        const float *__b) {
12855   return (vector float)__builtin_vsx_lxvw4x(__a, __b);
12856 }
12857
12858 static __inline__ vector signed long long __ATTRS_o_ai
12859 vec_vsx_ld(int __a, const vector signed long long *__b) {
12860   return (vector signed long long)__builtin_vsx_lxvd2x(__a, __b);
12861 }
12862
12863 static __inline__ vector unsigned long long __ATTRS_o_ai
12864 vec_vsx_ld(int __a, const vector unsigned long long *__b) {
12865   return (vector unsigned long long)__builtin_vsx_lxvd2x(__a, __b);
12866 }
12867
12868 static __inline__ vector double __ATTRS_o_ai
12869 vec_vsx_ld(int __a, const vector double *__b) {
12870   return (vector double)__builtin_vsx_lxvd2x(__a, __b);
12871 }
12872
12873 static __inline__ vector double __ATTRS_o_ai
12874 vec_vsx_ld(int __a, const double *__b) {
12875   return (vector double)__builtin_vsx_lxvd2x(__a, __b);
12876 }
12877
12878 static __inline__ vector bool short __ATTRS_o_ai
12879 vec_vsx_ld(int __a, const vector bool short *__b) {
12880   return (vector bool short)__builtin_vsx_lxvw4x(__a, __b);
12881 }
12882
12883 static __inline__ vector signed short __ATTRS_o_ai
12884 vec_vsx_ld(int __a, const vector signed short *__b) {
12885   return (vector signed short)__builtin_vsx_lxvw4x(__a, __b);
12886 }
12887
12888 static __inline__ vector signed short __ATTRS_o_ai
12889 vec_vsx_ld(int __a, const signed short *__b) {
12890   return (vector signed short)__builtin_vsx_lxvw4x(__a, __b);
12891 }
12892
12893 static __inline__ vector unsigned short __ATTRS_o_ai
12894 vec_vsx_ld(int __a, const vector unsigned short *__b) {
12895   return (vector unsigned short)__builtin_vsx_lxvw4x(__a, __b);
12896 }
12897
12898 static __inline__ vector unsigned short __ATTRS_o_ai
12899 vec_vsx_ld(int __a, const unsigned short *__b) {
12900   return (vector unsigned short)__builtin_vsx_lxvw4x(__a, __b);
12901 }
12902
12903 static __inline__ vector bool char __ATTRS_o_ai
12904 vec_vsx_ld(int __a, const vector bool char *__b) {
12905   return (vector bool char)__builtin_vsx_lxvw4x(__a, __b);
12906 }
12907
12908 static __inline__ vector signed char __ATTRS_o_ai
12909 vec_vsx_ld(int __a, const vector signed char *__b) {
12910   return (vector signed char)__builtin_vsx_lxvw4x(__a, __b);
12911 }
12912
12913 static __inline__ vector signed char __ATTRS_o_ai
12914 vec_vsx_ld(int __a, const signed char *__b) {
12915   return (vector signed char)__builtin_vsx_lxvw4x(__a, __b);
12916 }
12917
12918 static __inline__ vector unsigned char __ATTRS_o_ai
12919 vec_vsx_ld(int __a, const vector unsigned char *__b) {
12920   return (vector unsigned char)__builtin_vsx_lxvw4x(__a, __b);
12921 }
12922
12923 static __inline__ vector unsigned char __ATTRS_o_ai
12924 vec_vsx_ld(int __a, const unsigned char *__b) {
12925   return (vector unsigned char)__builtin_vsx_lxvw4x(__a, __b);
12926 }
12927
12928 #endif
12929
12930 /* vec_vsx_st */
12931
12932 #ifdef __VSX__
12933
12934 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool int __a, int __b,
12935                                                vector bool int *__c) {
12936   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12937 }
12938
12939 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool int __a, int __b,
12940                                                signed int *__c) {
12941   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12942 }
12943
12944 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool int __a, int __b,
12945                                                unsigned int *__c) {
12946   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12947 }
12948
12949 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed int __a, int __b,
12950                                                vector signed int *__c) {
12951   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12952 }
12953
12954 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed int __a, int __b,
12955                                                signed int *__c) {
12956   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12957 }
12958
12959 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned int __a, int __b,
12960                                                vector unsigned int *__c) {
12961   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12962 }
12963
12964 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned int __a, int __b,
12965                                                unsigned int *__c) {
12966   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12967 }
12968
12969 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector float __a, int __b,
12970                                                vector float *__c) {
12971   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12972 }
12973
12974 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector float __a, int __b,
12975                                                float *__c) {
12976   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12977 }
12978
12979 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed long long __a,
12980                                                int __b,
12981                                                vector signed long long *__c) {
12982   __builtin_vsx_stxvd2x((vector double)__a, __b, __c);
12983 }
12984
12985 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned long long __a,
12986                                                int __b,
12987                                                vector unsigned long long *__c) {
12988   __builtin_vsx_stxvd2x((vector double)__a, __b, __c);
12989 }
12990
12991 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector double __a, int __b,
12992                                                vector double *__c) {
12993   __builtin_vsx_stxvd2x((vector double)__a, __b, __c);
12994 }
12995
12996 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector double __a, int __b,
12997                                                double *__c) {
12998   __builtin_vsx_stxvd2x((vector double)__a, __b, __c);
12999 }
13000
13001 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool short __a, int __b,
13002                                                vector bool short *__c) {
13003   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13004 }
13005
13006 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool short __a, int __b,
13007                                                signed short *__c) {
13008   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13009 }
13010
13011 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool short __a, int __b,
13012                                                unsigned short *__c) {
13013   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13014 }
13015 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed short __a, int __b,
13016                                                vector signed short *__c) {
13017   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13018 }
13019
13020 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed short __a, int __b,
13021                                                signed short *__c) {
13022   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13023 }
13024
13025 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned short __a,
13026                                                int __b,
13027                                                vector unsigned short *__c) {
13028   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13029 }
13030
13031 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned short __a,
13032                                                int __b, unsigned short *__c) {
13033   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13034 }
13035
13036 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool char __a, int __b,
13037                                                vector bool char *__c) {
13038   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13039 }
13040
13041 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool char __a, int __b,
13042                                                signed char *__c) {
13043   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13044 }
13045
13046 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool char __a, int __b,
13047                                                unsigned char *__c) {
13048   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13049 }
13050
13051 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed char __a, int __b,
13052                                                vector signed char *__c) {
13053   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13054 }
13055
13056 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed char __a, int __b,
13057                                                signed char *__c) {
13058   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13059 }
13060
13061 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned char __a,
13062                                                int __b,
13063                                                vector unsigned char *__c) {
13064   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13065 }
13066
13067 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned char __a,
13068                                                int __b, unsigned char *__c) {
13069   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13070 }
13071
13072 #endif
13073
13074 #ifdef __VSX__
13075 #define vec_xxpermdi __builtin_vsx_xxpermdi
13076 #define vec_xxsldwi __builtin_vsx_xxsldwi
13077 #define vec_permi(__a, __b, __c)                                               \
13078   _Generic((__a), vector signed long long                                      \
13079            : __builtin_shufflevector((__a), (__b), (((__c) >> 1) & 0x1),       \
13080                                      (((__c)&0x1) + 2)),                       \
13081              vector unsigned long long                                         \
13082            : __builtin_shufflevector((__a), (__b), (((__c) >> 1) & 0x1),       \
13083                                      (((__c)&0x1) + 2)),                       \
13084              vector double                                                     \
13085            : __builtin_shufflevector((__a), (__b), (((__c) >> 1) & 0x1),       \
13086                                      (((__c)&0x1) + 2)))
13087 #endif
13088
13089 /* vec_xor */
13090
13091 #define __builtin_altivec_vxor vec_xor
13092
13093 static __inline__ vector signed char __ATTRS_o_ai
13094 vec_xor(vector signed char __a, vector signed char __b) {
13095   return __a ^ __b;
13096 }
13097
13098 static __inline__ vector signed char __ATTRS_o_ai
13099 vec_xor(vector bool char __a, vector signed char __b) {
13100   return (vector signed char)__a ^ __b;
13101 }
13102
13103 static __inline__ vector signed char __ATTRS_o_ai
13104 vec_xor(vector signed char __a, vector bool char __b) {
13105   return __a ^ (vector signed char)__b;
13106 }
13107
13108 static __inline__ vector unsigned char __ATTRS_o_ai
13109 vec_xor(vector unsigned char __a, vector unsigned char __b) {
13110   return __a ^ __b;
13111 }
13112
13113 static __inline__ vector unsigned char __ATTRS_o_ai
13114 vec_xor(vector bool char __a, vector unsigned char __b) {
13115   return (vector unsigned char)__a ^ __b;
13116 }
13117
13118 static __inline__ vector unsigned char __ATTRS_o_ai
13119 vec_xor(vector unsigned char __a, vector bool char __b) {
13120   return __a ^ (vector unsigned char)__b;
13121 }
13122
13123 static __inline__ vector bool char __ATTRS_o_ai vec_xor(vector bool char __a,
13124                                                         vector bool char __b) {
13125   return __a ^ __b;
13126 }
13127
13128 static __inline__ vector short __ATTRS_o_ai vec_xor(vector short __a,
13129                                                     vector short __b) {
13130   return __a ^ __b;
13131 }
13132
13133 static __inline__ vector short __ATTRS_o_ai vec_xor(vector bool short __a,
13134                                                     vector short __b) {
13135   return (vector short)__a ^ __b;
13136 }
13137
13138 static __inline__ vector short __ATTRS_o_ai vec_xor(vector short __a,
13139                                                     vector bool short __b) {
13140   return __a ^ (vector short)__b;
13141 }
13142
13143 static __inline__ vector unsigned short __ATTRS_o_ai
13144 vec_xor(vector unsigned short __a, vector unsigned short __b) {
13145   return __a ^ __b;
13146 }
13147
13148 static __inline__ vector unsigned short __ATTRS_o_ai
13149 vec_xor(vector bool short __a, vector unsigned short __b) {
13150   return (vector unsigned short)__a ^ __b;
13151 }
13152
13153 static __inline__ vector unsigned short __ATTRS_o_ai
13154 vec_xor(vector unsigned short __a, vector bool short __b) {
13155   return __a ^ (vector unsigned short)__b;
13156 }
13157
13158 static __inline__ vector bool short __ATTRS_o_ai
13159 vec_xor(vector bool short __a, vector bool short __b) {
13160   return __a ^ __b;
13161 }
13162
13163 static __inline__ vector int __ATTRS_o_ai vec_xor(vector int __a,
13164                                                   vector int __b) {
13165   return __a ^ __b;
13166 }
13167
13168 static __inline__ vector int __ATTRS_o_ai vec_xor(vector bool int __a,
13169                                                   vector int __b) {
13170   return (vector int)__a ^ __b;
13171 }
13172
13173 static __inline__ vector int __ATTRS_o_ai vec_xor(vector int __a,
13174                                                   vector bool int __b) {
13175   return __a ^ (vector int)__b;
13176 }
13177
13178 static __inline__ vector unsigned int __ATTRS_o_ai
13179 vec_xor(vector unsigned int __a, vector unsigned int __b) {
13180   return __a ^ __b;
13181 }
13182
13183 static __inline__ vector unsigned int __ATTRS_o_ai
13184 vec_xor(vector bool int __a, vector unsigned int __b) {
13185   return (vector unsigned int)__a ^ __b;
13186 }
13187
13188 static __inline__ vector unsigned int __ATTRS_o_ai
13189 vec_xor(vector unsigned int __a, vector bool int __b) {
13190   return __a ^ (vector unsigned int)__b;
13191 }
13192
13193 static __inline__ vector bool int __ATTRS_o_ai vec_xor(vector bool int __a,
13194                                                        vector bool int __b) {
13195   return __a ^ __b;
13196 }
13197
13198 static __inline__ vector float __ATTRS_o_ai vec_xor(vector float __a,
13199                                                     vector float __b) {
13200   vector unsigned int __res =
13201       (vector unsigned int)__a ^ (vector unsigned int)__b;
13202   return (vector float)__res;
13203 }
13204
13205 static __inline__ vector float __ATTRS_o_ai vec_xor(vector bool int __a,
13206                                                     vector float __b) {
13207   vector unsigned int __res =
13208       (vector unsigned int)__a ^ (vector unsigned int)__b;
13209   return (vector float)__res;
13210 }
13211
13212 static __inline__ vector float __ATTRS_o_ai vec_xor(vector float __a,
13213                                                     vector bool int __b) {
13214   vector unsigned int __res =
13215       (vector unsigned int)__a ^ (vector unsigned int)__b;
13216   return (vector float)__res;
13217 }
13218
13219 #ifdef __VSX__
13220 static __inline__ vector signed long long __ATTRS_o_ai
13221 vec_xor(vector signed long long __a, vector signed long long __b) {
13222   return __a ^ __b;
13223 }
13224
13225 static __inline__ vector signed long long __ATTRS_o_ai
13226 vec_xor(vector bool long long __a, vector signed long long __b) {
13227   return (vector signed long long)__a ^ __b;
13228 }
13229
13230 static __inline__ vector signed long long __ATTRS_o_ai
13231 vec_xor(vector signed long long __a, vector bool long long __b) {
13232   return __a ^ (vector signed long long)__b;
13233 }
13234
13235 static __inline__ vector unsigned long long __ATTRS_o_ai
13236 vec_xor(vector unsigned long long __a, vector unsigned long long __b) {
13237   return __a ^ __b;
13238 }
13239
13240 static __inline__ vector unsigned long long __ATTRS_o_ai
13241 vec_xor(vector bool long long __a, vector unsigned long long __b) {
13242   return (vector unsigned long long)__a ^ __b;
13243 }
13244
13245 static __inline__ vector unsigned long long __ATTRS_o_ai
13246 vec_xor(vector unsigned long long __a, vector bool long long __b) {
13247   return __a ^ (vector unsigned long long)__b;
13248 }
13249
13250 static __inline__ vector bool long long __ATTRS_o_ai
13251 vec_xor(vector bool long long __a, vector bool long long __b) {
13252   return __a ^ __b;
13253 }
13254
13255 static __inline__ vector double __ATTRS_o_ai vec_xor(vector double __a,
13256                                                      vector double __b) {
13257   return (vector double)((vector unsigned long long)__a ^
13258                          (vector unsigned long long)__b);
13259 }
13260
13261 static __inline__ vector double __ATTRS_o_ai
13262 vec_xor(vector double __a, vector bool long long __b) {
13263   return (vector double)((vector unsigned long long)__a ^
13264                          (vector unsigned long long)__b);
13265 }
13266
13267 static __inline__ vector double __ATTRS_o_ai vec_xor(vector bool long long __a,
13268                                                      vector double __b) {
13269   return (vector double)((vector unsigned long long)__a ^
13270                          (vector unsigned long long)__b);
13271 }
13272 #endif
13273
13274 /* vec_vxor */
13275
13276 static __inline__ vector signed char __ATTRS_o_ai
13277 vec_vxor(vector signed char __a, vector signed char __b) {
13278   return __a ^ __b;
13279 }
13280
13281 static __inline__ vector signed char __ATTRS_o_ai
13282 vec_vxor(vector bool char __a, vector signed char __b) {
13283   return (vector signed char)__a ^ __b;
13284 }
13285
13286 static __inline__ vector signed char __ATTRS_o_ai
13287 vec_vxor(vector signed char __a, vector bool char __b) {
13288   return __a ^ (vector signed char)__b;
13289 }
13290
13291 static __inline__ vector unsigned char __ATTRS_o_ai
13292 vec_vxor(vector unsigned char __a, vector unsigned char __b) {
13293   return __a ^ __b;
13294 }
13295
13296 static __inline__ vector unsigned char __ATTRS_o_ai
13297 vec_vxor(vector bool char __a, vector unsigned char __b) {
13298   return (vector unsigned char)__a ^ __b;
13299 }
13300
13301 static __inline__ vector unsigned char __ATTRS_o_ai
13302 vec_vxor(vector unsigned char __a, vector bool char __b) {
13303   return __a ^ (vector unsigned char)__b;
13304 }
13305
13306 static __inline__ vector bool char __ATTRS_o_ai vec_vxor(vector bool char __a,
13307                                                          vector bool char __b) {
13308   return __a ^ __b;
13309 }
13310
13311 static __inline__ vector short __ATTRS_o_ai vec_vxor(vector short __a,
13312                                                      vector short __b) {
13313   return __a ^ __b;
13314 }
13315
13316 static __inline__ vector short __ATTRS_o_ai vec_vxor(vector bool short __a,
13317                                                      vector short __b) {
13318   return (vector short)__a ^ __b;
13319 }
13320
13321 static __inline__ vector short __ATTRS_o_ai vec_vxor(vector short __a,
13322                                                      vector bool short __b) {
13323   return __a ^ (vector short)__b;
13324 }
13325
13326 static __inline__ vector unsigned short __ATTRS_o_ai
13327 vec_vxor(vector unsigned short __a, vector unsigned short __b) {
13328   return __a ^ __b;
13329 }
13330
13331 static __inline__ vector unsigned short __ATTRS_o_ai
13332 vec_vxor(vector bool short __a, vector unsigned short __b) {
13333   return (vector unsigned short)__a ^ __b;
13334 }
13335
13336 static __inline__ vector unsigned short __ATTRS_o_ai
13337 vec_vxor(vector unsigned short __a, vector bool short __b) {
13338   return __a ^ (vector unsigned short)__b;
13339 }
13340
13341 static __inline__ vector bool short __ATTRS_o_ai
13342 vec_vxor(vector bool short __a, vector bool short __b) {
13343   return __a ^ __b;
13344 }
13345
13346 static __inline__ vector int __ATTRS_o_ai vec_vxor(vector int __a,
13347                                                    vector int __b) {
13348   return __a ^ __b;
13349 }
13350
13351 static __inline__ vector int __ATTRS_o_ai vec_vxor(vector bool int __a,
13352                                                    vector int __b) {
13353   return (vector int)__a ^ __b;
13354 }
13355
13356 static __inline__ vector int __ATTRS_o_ai vec_vxor(vector int __a,
13357                                                    vector bool int __b) {
13358   return __a ^ (vector int)__b;
13359 }
13360
13361 static __inline__ vector unsigned int __ATTRS_o_ai
13362 vec_vxor(vector unsigned int __a, vector unsigned int __b) {
13363   return __a ^ __b;
13364 }
13365
13366 static __inline__ vector unsigned int __ATTRS_o_ai
13367 vec_vxor(vector bool int __a, vector unsigned int __b) {
13368   return (vector unsigned int)__a ^ __b;
13369 }
13370
13371 static __inline__ vector unsigned int __ATTRS_o_ai
13372 vec_vxor(vector unsigned int __a, vector bool int __b) {
13373   return __a ^ (vector unsigned int)__b;
13374 }
13375
13376 static __inline__ vector bool int __ATTRS_o_ai vec_vxor(vector bool int __a,
13377                                                         vector bool int __b) {
13378   return __a ^ __b;
13379 }
13380
13381 static __inline__ vector float __ATTRS_o_ai vec_vxor(vector float __a,
13382                                                      vector float __b) {
13383   vector unsigned int __res =
13384       (vector unsigned int)__a ^ (vector unsigned int)__b;
13385   return (vector float)__res;
13386 }
13387
13388 static __inline__ vector float __ATTRS_o_ai vec_vxor(vector bool int __a,
13389                                                      vector float __b) {
13390   vector unsigned int __res =
13391       (vector unsigned int)__a ^ (vector unsigned int)__b;
13392   return (vector float)__res;
13393 }
13394
13395 static __inline__ vector float __ATTRS_o_ai vec_vxor(vector float __a,
13396                                                      vector bool int __b) {
13397   vector unsigned int __res =
13398       (vector unsigned int)__a ^ (vector unsigned int)__b;
13399   return (vector float)__res;
13400 }
13401
13402 #ifdef __VSX__
13403 static __inline__ vector signed long long __ATTRS_o_ai
13404 vec_vxor(vector signed long long __a, vector signed long long __b) {
13405   return __a ^ __b;
13406 }
13407
13408 static __inline__ vector signed long long __ATTRS_o_ai
13409 vec_vxor(vector bool long long __a, vector signed long long __b) {
13410   return (vector signed long long)__a ^ __b;
13411 }
13412
13413 static __inline__ vector signed long long __ATTRS_o_ai
13414 vec_vxor(vector signed long long __a, vector bool long long __b) {
13415   return __a ^ (vector signed long long)__b;
13416 }
13417
13418 static __inline__ vector unsigned long long __ATTRS_o_ai
13419 vec_vxor(vector unsigned long long __a, vector unsigned long long __b) {
13420   return __a ^ __b;
13421 }
13422
13423 static __inline__ vector unsigned long long __ATTRS_o_ai
13424 vec_vxor(vector bool long long __a, vector unsigned long long __b) {
13425   return (vector unsigned long long)__a ^ __b;
13426 }
13427
13428 static __inline__ vector unsigned long long __ATTRS_o_ai
13429 vec_vxor(vector unsigned long long __a, vector bool long long __b) {
13430   return __a ^ (vector unsigned long long)__b;
13431 }
13432
13433 static __inline__ vector bool long long __ATTRS_o_ai
13434 vec_vxor(vector bool long long __a, vector bool long long __b) {
13435   return __a ^ __b;
13436 }
13437 #endif
13438
13439 /* ------------------------ extensions for CBEA ----------------------------- */
13440
13441 /* vec_extract */
13442
13443 static __inline__ signed char __ATTRS_o_ai vec_extract(vector signed char __a,
13444                                                        unsigned int __b) {
13445   return __a[__b & 0xf];
13446 }
13447
13448 static __inline__ unsigned char __ATTRS_o_ai
13449 vec_extract(vector unsigned char __a, unsigned int __b) {
13450   return __a[__b & 0xf];
13451 }
13452
13453 static __inline__ unsigned char __ATTRS_o_ai vec_extract(vector bool char __a,
13454                                                          unsigned int __b) {
13455   return __a[__b & 0xf];
13456 }
13457
13458 static __inline__ signed short __ATTRS_o_ai vec_extract(vector signed short __a,
13459                                                         unsigned int __b) {
13460   return __a[__b & 0x7];
13461 }
13462
13463 static __inline__ unsigned short __ATTRS_o_ai
13464 vec_extract(vector unsigned short __a, unsigned int __b) {
13465   return __a[__b & 0x7];
13466 }
13467
13468 static __inline__ unsigned short __ATTRS_o_ai vec_extract(vector bool short __a,
13469                                                           unsigned int __b) {
13470   return __a[__b & 0x7];
13471 }
13472
13473 static __inline__ signed int __ATTRS_o_ai vec_extract(vector signed int __a,
13474                                                       unsigned int __b) {
13475   return __a[__b & 0x3];
13476 }
13477
13478 static __inline__ unsigned int __ATTRS_o_ai vec_extract(vector unsigned int __a,
13479                                                         unsigned int __b) {
13480   return __a[__b & 0x3];
13481 }
13482
13483 static __inline__ unsigned int __ATTRS_o_ai vec_extract(vector bool int __a,
13484                                                         unsigned int __b) {
13485   return __a[__b & 0x3];
13486 }
13487
13488 #ifdef __VSX__
13489 static __inline__ signed long long __ATTRS_o_ai
13490 vec_extract(vector signed long long __a, unsigned int __b) {
13491   return __a[__b & 0x1];
13492 }
13493
13494 static __inline__ unsigned long long __ATTRS_o_ai
13495 vec_extract(vector unsigned long long __a, unsigned int __b) {
13496   return __a[__b & 0x1];
13497 }
13498
13499 static __inline__ unsigned long long __ATTRS_o_ai
13500 vec_extract(vector bool long long __a, unsigned int __b) {
13501   return __a[__b & 0x1];
13502 }
13503
13504 static __inline__ double __ATTRS_o_ai vec_extract(vector double __a,
13505                                                   unsigned int __b) {
13506   return __a[__b & 0x1];
13507 }
13508 #endif
13509
13510 static __inline__ float __ATTRS_o_ai vec_extract(vector float __a,
13511                                                  unsigned int __b) {
13512   return __a[__b & 0x3];
13513 }
13514
13515 #ifdef __POWER9_VECTOR__
13516
13517 #define vec_insert4b __builtin_vsx_insertword
13518 #define vec_extract4b __builtin_vsx_extractuword
13519
13520 /* vec_extract_exp */
13521
13522 static __inline__ vector unsigned int __ATTRS_o_ai
13523 vec_extract_exp(vector float __a) {
13524   return __builtin_vsx_xvxexpsp(__a);
13525 }
13526
13527 static __inline__ vector unsigned long long __ATTRS_o_ai
13528 vec_extract_exp(vector double __a) {
13529   return __builtin_vsx_xvxexpdp(__a);
13530 }
13531
13532 /* vec_extract_sig */
13533
13534 static __inline__ vector unsigned int __ATTRS_o_ai
13535 vec_extract_sig(vector float __a) {
13536   return __builtin_vsx_xvxsigsp(__a);
13537 }
13538
13539 static __inline__ vector unsigned long long __ATTRS_o_ai
13540 vec_extract_sig (vector double __a) {
13541   return __builtin_vsx_xvxsigdp(__a);
13542 }
13543
13544 static __inline__ vector float __ATTRS_o_ai
13545 vec_extract_fp32_from_shorth(vector unsigned short __a) {
13546   vector unsigned short __b =
13547 #ifdef __LITTLE_ENDIAN__
13548             __builtin_shufflevector(__a, __a, 0, -1, 1, -1, 2, -1, 3, -1);
13549 #else
13550             __builtin_shufflevector(__a, __a, -1, 0, -1, 1, -1, 2, -1, 3);
13551 #endif
13552   return __builtin_vsx_xvcvhpsp(__b);
13553 }
13554
13555 static __inline__ vector float __ATTRS_o_ai
13556 vec_extract_fp32_from_shortl(vector unsigned short __a) {
13557   vector unsigned short __b =
13558 #ifdef __LITTLE_ENDIAN__
13559             __builtin_shufflevector(__a, __a, 4, -1, 5, -1, 6, -1, 7, -1);
13560 #else
13561             __builtin_shufflevector(__a, __a, -1, 4, -1, 5, -1, 6, -1, 7);
13562 #endif
13563   return __builtin_vsx_xvcvhpsp(__b);
13564 }
13565 #endif /* __POWER9_VECTOR__ */
13566
13567 /* vec_insert */
13568
13569 static __inline__ vector signed char __ATTRS_o_ai
13570 vec_insert(signed char __a, vector signed char __b, int __c) {
13571   __b[__c] = __a;
13572   return __b;
13573 }
13574
13575 static __inline__ vector unsigned char __ATTRS_o_ai
13576 vec_insert(unsigned char __a, vector unsigned char __b, int __c) {
13577   __b[__c] = __a;
13578   return __b;
13579 }
13580
13581 static __inline__ vector bool char __ATTRS_o_ai vec_insert(unsigned char __a,
13582                                                            vector bool char __b,
13583                                                            int __c) {
13584   __b[__c] = __a;
13585   return __b;
13586 }
13587
13588 static __inline__ vector signed short __ATTRS_o_ai
13589 vec_insert(signed short __a, vector signed short __b, int __c) {
13590   __b[__c] = __a;
13591   return __b;
13592 }
13593
13594 static __inline__ vector unsigned short __ATTRS_o_ai
13595 vec_insert(unsigned short __a, vector unsigned short __b, int __c) {
13596   __b[__c] = __a;
13597   return __b;
13598 }
13599
13600 static __inline__ vector bool short __ATTRS_o_ai
13601 vec_insert(unsigned short __a, vector bool short __b, int __c) {
13602   __b[__c] = __a;
13603   return __b;
13604 }
13605
13606 static __inline__ vector signed int __ATTRS_o_ai
13607 vec_insert(signed int __a, vector signed int __b, int __c) {
13608   __b[__c] = __a;
13609   return __b;
13610 }
13611
13612 static __inline__ vector unsigned int __ATTRS_o_ai
13613 vec_insert(unsigned int __a, vector unsigned int __b, int __c) {
13614   __b[__c] = __a;
13615   return __b;
13616 }
13617
13618 static __inline__ vector bool int __ATTRS_o_ai vec_insert(unsigned int __a,
13619                                                           vector bool int __b,
13620                                                           int __c) {
13621   __b[__c] = __a;
13622   return __b;
13623 }
13624
13625 #ifdef __VSX__
13626 static __inline__ vector signed long long __ATTRS_o_ai
13627 vec_insert(signed long long __a, vector signed long long __b, int __c) {
13628   __b[__c] = __a;
13629   return __b;
13630 }
13631
13632 static __inline__ vector unsigned long long __ATTRS_o_ai
13633 vec_insert(unsigned long long __a, vector unsigned long long __b, int __c) {
13634   __b[__c] = __a;
13635   return __b;
13636 }
13637
13638 static __inline__ vector bool long long __ATTRS_o_ai
13639 vec_insert(unsigned long long __a, vector bool long long __b, int __c) {
13640   __b[__c] = __a;
13641   return __b;
13642 }
13643 static __inline__ vector double __ATTRS_o_ai vec_insert(double __a,
13644                                                         vector double __b,
13645                                                         int __c) {
13646   __b[__c] = __a;
13647   return __b;
13648 }
13649 #endif
13650
13651 static __inline__ vector float __ATTRS_o_ai vec_insert(float __a,
13652                                                        vector float __b,
13653                                                        int __c) {
13654   __b[__c] = __a;
13655   return __b;
13656 }
13657
13658 /* vec_lvlx */
13659
13660 static __inline__ vector signed char __ATTRS_o_ai
13661 vec_lvlx(int __a, const signed char *__b) {
13662   return vec_perm(vec_ld(__a, __b), (vector signed char)(0),
13663                   vec_lvsl(__a, __b));
13664 }
13665
13666 static __inline__ vector signed char __ATTRS_o_ai
13667 vec_lvlx(int __a, const vector signed char *__b) {
13668   return vec_perm(vec_ld(__a, __b), (vector signed char)(0),
13669                   vec_lvsl(__a, (unsigned char *)__b));
13670 }
13671
13672 static __inline__ vector unsigned char __ATTRS_o_ai
13673 vec_lvlx(int __a, const unsigned char *__b) {
13674   return vec_perm(vec_ld(__a, __b), (vector unsigned char)(0),
13675                   vec_lvsl(__a, __b));
13676 }
13677
13678 static __inline__ vector unsigned char __ATTRS_o_ai
13679 vec_lvlx(int __a, const vector unsigned char *__b) {
13680   return vec_perm(vec_ld(__a, __b), (vector unsigned char)(0),
13681                   vec_lvsl(__a, (unsigned char *)__b));
13682 }
13683
13684 static __inline__ vector bool char __ATTRS_o_ai
13685 vec_lvlx(int __a, const vector bool char *__b) {
13686   return vec_perm(vec_ld(__a, __b), (vector bool char)(0),
13687                   vec_lvsl(__a, (unsigned char *)__b));
13688 }
13689
13690 static __inline__ vector short __ATTRS_o_ai vec_lvlx(int __a,
13691                                                      const short *__b) {
13692   return vec_perm(vec_ld(__a, __b), (vector short)(0), vec_lvsl(__a, __b));
13693 }
13694
13695 static __inline__ vector short __ATTRS_o_ai vec_lvlx(int __a,
13696                                                      const vector short *__b) {
13697   return vec_perm(vec_ld(__a, __b), (vector short)(0),
13698                   vec_lvsl(__a, (unsigned char *)__b));
13699 }
13700
13701 static __inline__ vector unsigned short __ATTRS_o_ai
13702 vec_lvlx(int __a, const unsigned short *__b) {
13703   return vec_perm(vec_ld(__a, __b), (vector unsigned short)(0),
13704                   vec_lvsl(__a, __b));
13705 }
13706
13707 static __inline__ vector unsigned short __ATTRS_o_ai
13708 vec_lvlx(int __a, const vector unsigned short *__b) {
13709   return vec_perm(vec_ld(__a, __b), (vector unsigned short)(0),
13710                   vec_lvsl(__a, (unsigned char *)__b));
13711 }
13712
13713 static __inline__ vector bool short __ATTRS_o_ai
13714 vec_lvlx(int __a, const vector bool short *__b) {
13715   return vec_perm(vec_ld(__a, __b), (vector bool short)(0),
13716                   vec_lvsl(__a, (unsigned char *)__b));
13717 }
13718
13719 static __inline__ vector pixel __ATTRS_o_ai vec_lvlx(int __a,
13720                                                      const vector pixel *__b) {
13721   return vec_perm(vec_ld(__a, __b), (vector pixel)(0),
13722                   vec_lvsl(__a, (unsigned char *)__b));
13723 }
13724
13725 static __inline__ vector int __ATTRS_o_ai vec_lvlx(int __a, const int *__b) {
13726   return vec_perm(vec_ld(__a, __b), (vector int)(0), vec_lvsl(__a, __b));
13727 }
13728
13729 static __inline__ vector int __ATTRS_o_ai vec_lvlx(int __a,
13730                                                    const vector int *__b) {
13731   return vec_perm(vec_ld(__a, __b), (vector int)(0),
13732                   vec_lvsl(__a, (unsigned char *)__b));
13733 }
13734
13735 static __inline__ vector unsigned int __ATTRS_o_ai
13736 vec_lvlx(int __a, const unsigned int *__b) {
13737   return vec_perm(vec_ld(__a, __b), (vector unsigned int)(0),
13738                   vec_lvsl(__a, __b));
13739 }
13740
13741 static __inline__ vector unsigned int __ATTRS_o_ai
13742 vec_lvlx(int __a, const vector unsigned int *__b) {
13743   return vec_perm(vec_ld(__a, __b), (vector unsigned int)(0),
13744                   vec_lvsl(__a, (unsigned char *)__b));
13745 }
13746
13747 static __inline__ vector bool int __ATTRS_o_ai
13748 vec_lvlx(int __a, const vector bool int *__b) {
13749   return vec_perm(vec_ld(__a, __b), (vector bool int)(0),
13750                   vec_lvsl(__a, (unsigned char *)__b));
13751 }
13752
13753 static __inline__ vector float __ATTRS_o_ai vec_lvlx(int __a,
13754                                                      const float *__b) {
13755   return vec_perm(vec_ld(__a, __b), (vector float)(0), vec_lvsl(__a, __b));
13756 }
13757
13758 static __inline__ vector float __ATTRS_o_ai vec_lvlx(int __a,
13759                                                      const vector float *__b) {
13760   return vec_perm(vec_ld(__a, __b), (vector float)(0),
13761                   vec_lvsl(__a, (unsigned char *)__b));
13762 }
13763
13764 /* vec_lvlxl */
13765
13766 static __inline__ vector signed char __ATTRS_o_ai
13767 vec_lvlxl(int __a, const signed char *__b) {
13768   return vec_perm(vec_ldl(__a, __b), (vector signed char)(0),
13769                   vec_lvsl(__a, __b));
13770 }
13771
13772 static __inline__ vector signed char __ATTRS_o_ai
13773 vec_lvlxl(int __a, const vector signed char *__b) {
13774   return vec_perm(vec_ldl(__a, __b), (vector signed char)(0),
13775                   vec_lvsl(__a, (unsigned char *)__b));
13776 }
13777
13778 static __inline__ vector unsigned char __ATTRS_o_ai
13779 vec_lvlxl(int __a, const unsigned char *__b) {
13780   return vec_perm(vec_ldl(__a, __b), (vector unsigned char)(0),
13781                   vec_lvsl(__a, __b));
13782 }
13783
13784 static __inline__ vector unsigned char __ATTRS_o_ai
13785 vec_lvlxl(int __a, const vector unsigned char *__b) {
13786   return vec_perm(vec_ldl(__a, __b), (vector unsigned char)(0),
13787                   vec_lvsl(__a, (unsigned char *)__b));
13788 }
13789
13790 static __inline__ vector bool char __ATTRS_o_ai
13791 vec_lvlxl(int __a, const vector bool char *__b) {
13792   return vec_perm(vec_ldl(__a, __b), (vector bool char)(0),
13793                   vec_lvsl(__a, (unsigned char *)__b));
13794 }
13795
13796 static __inline__ vector short __ATTRS_o_ai vec_lvlxl(int __a,
13797                                                       const short *__b) {
13798   return vec_perm(vec_ldl(__a, __b), (vector short)(0), vec_lvsl(__a, __b));
13799 }
13800
13801 static __inline__ vector short __ATTRS_o_ai vec_lvlxl(int __a,
13802                                                       const vector short *__b) {
13803   return vec_perm(vec_ldl(__a, __b), (vector short)(0),
13804                   vec_lvsl(__a, (unsigned char *)__b));
13805 }
13806
13807 static __inline__ vector unsigned short __ATTRS_o_ai
13808 vec_lvlxl(int __a, const unsigned short *__b) {
13809   return vec_perm(vec_ldl(__a, __b), (vector unsigned short)(0),
13810                   vec_lvsl(__a, __b));
13811 }
13812
13813 static __inline__ vector unsigned short __ATTRS_o_ai
13814 vec_lvlxl(int __a, const vector unsigned short *__b) {
13815   return vec_perm(vec_ldl(__a, __b), (vector unsigned short)(0),
13816                   vec_lvsl(__a, (unsigned char *)__b));
13817 }
13818
13819 static __inline__ vector bool short __ATTRS_o_ai
13820 vec_lvlxl(int __a, const vector bool short *__b) {
13821   return vec_perm(vec_ldl(__a, __b), (vector bool short)(0),
13822                   vec_lvsl(__a, (unsigned char *)__b));
13823 }
13824
13825 static __inline__ vector pixel __ATTRS_o_ai vec_lvlxl(int __a,
13826                                                       const vector pixel *__b) {
13827   return vec_perm(vec_ldl(__a, __b), (vector pixel)(0),
13828                   vec_lvsl(__a, (unsigned char *)__b));
13829 }
13830
13831 static __inline__ vector int __ATTRS_o_ai vec_lvlxl(int __a, const int *__b) {
13832   return vec_perm(vec_ldl(__a, __b), (vector int)(0), vec_lvsl(__a, __b));
13833 }
13834
13835 static __inline__ vector int __ATTRS_o_ai vec_lvlxl(int __a,
13836                                                     const vector int *__b) {
13837   return vec_perm(vec_ldl(__a, __b), (vector int)(0),
13838                   vec_lvsl(__a, (unsigned char *)__b));
13839 }
13840
13841 static __inline__ vector unsigned int __ATTRS_o_ai
13842 vec_lvlxl(int __a, const unsigned int *__b) {
13843   return vec_perm(vec_ldl(__a, __b), (vector unsigned int)(0),
13844                   vec_lvsl(__a, __b));
13845 }
13846
13847 static __inline__ vector unsigned int __ATTRS_o_ai
13848 vec_lvlxl(int __a, const vector unsigned int *__b) {
13849   return vec_perm(vec_ldl(__a, __b), (vector unsigned int)(0),
13850                   vec_lvsl(__a, (unsigned char *)__b));
13851 }
13852
13853 static __inline__ vector bool int __ATTRS_o_ai
13854 vec_lvlxl(int __a, const vector bool int *__b) {
13855   return vec_perm(vec_ldl(__a, __b), (vector bool int)(0),
13856                   vec_lvsl(__a, (unsigned char *)__b));
13857 }
13858
13859 static __inline__ vector float __ATTRS_o_ai vec_lvlxl(int __a,
13860                                                       const float *__b) {
13861   return vec_perm(vec_ldl(__a, __b), (vector float)(0), vec_lvsl(__a, __b));
13862 }
13863
13864 static __inline__ vector float __ATTRS_o_ai vec_lvlxl(int __a,
13865                                                       vector float *__b) {
13866   return vec_perm(vec_ldl(__a, __b), (vector float)(0),
13867                   vec_lvsl(__a, (unsigned char *)__b));
13868 }
13869
13870 /* vec_lvrx */
13871
13872 static __inline__ vector signed char __ATTRS_o_ai
13873 vec_lvrx(int __a, const signed char *__b) {
13874   return vec_perm((vector signed char)(0), vec_ld(__a, __b),
13875                   vec_lvsl(__a, __b));
13876 }
13877
13878 static __inline__ vector signed char __ATTRS_o_ai
13879 vec_lvrx(int __a, const vector signed char *__b) {
13880   return vec_perm((vector signed char)(0), vec_ld(__a, __b),
13881                   vec_lvsl(__a, (unsigned char *)__b));
13882 }
13883
13884 static __inline__ vector unsigned char __ATTRS_o_ai
13885 vec_lvrx(int __a, const unsigned char *__b) {
13886   return vec_perm((vector unsigned char)(0), vec_ld(__a, __b),
13887                   vec_lvsl(__a, __b));
13888 }
13889
13890 static __inline__ vector unsigned char __ATTRS_o_ai
13891 vec_lvrx(int __a, const vector unsigned char *__b) {
13892   return vec_perm((vector unsigned char)(0), vec_ld(__a, __b),
13893                   vec_lvsl(__a, (unsigned char *)__b));
13894 }
13895
13896 static __inline__ vector bool char __ATTRS_o_ai
13897 vec_lvrx(int __a, const vector bool char *__b) {
13898   return vec_perm((vector bool char)(0), vec_ld(__a, __b),
13899                   vec_lvsl(__a, (unsigned char *)__b));
13900 }
13901
13902 static __inline__ vector short __ATTRS_o_ai vec_lvrx(int __a,
13903                                                      const short *__b) {
13904   return vec_perm((vector short)(0), vec_ld(__a, __b), vec_lvsl(__a, __b));
13905 }
13906
13907 static __inline__ vector short __ATTRS_o_ai vec_lvrx(int __a,
13908                                                      const vector short *__b) {
13909   return vec_perm((vector short)(0), vec_ld(__a, __b),
13910                   vec_lvsl(__a, (unsigned char *)__b));
13911 }
13912
13913 static __inline__ vector unsigned short __ATTRS_o_ai
13914 vec_lvrx(int __a, const unsigned short *__b) {
13915   return vec_perm((vector unsigned short)(0), vec_ld(__a, __b),
13916                   vec_lvsl(__a, __b));
13917 }
13918
13919 static __inline__ vector unsigned short __ATTRS_o_ai
13920 vec_lvrx(int __a, const vector unsigned short *__b) {
13921   return vec_perm((vector unsigned short)(0), vec_ld(__a, __b),
13922                   vec_lvsl(__a, (unsigned char *)__b));
13923 }
13924
13925 static __inline__ vector bool short __ATTRS_o_ai
13926 vec_lvrx(int __a, const vector bool short *__b) {
13927   return vec_perm((vector bool short)(0), vec_ld(__a, __b),
13928                   vec_lvsl(__a, (unsigned char *)__b));
13929 }
13930
13931 static __inline__ vector pixel __ATTRS_o_ai vec_lvrx(int __a,
13932                                                      const vector pixel *__b) {
13933   return vec_perm((vector pixel)(0), vec_ld(__a, __b),
13934                   vec_lvsl(__a, (unsigned char *)__b));
13935 }
13936
13937 static __inline__ vector int __ATTRS_o_ai vec_lvrx(int __a, const int *__b) {
13938   return vec_perm((vector int)(0), vec_ld(__a, __b), vec_lvsl(__a, __b));
13939 }
13940
13941 static __inline__ vector int __ATTRS_o_ai vec_lvrx(int __a,
13942                                                    const vector int *__b) {
13943   return vec_perm((vector int)(0), vec_ld(__a, __b),
13944                   vec_lvsl(__a, (unsigned char *)__b));
13945 }
13946
13947 static __inline__ vector unsigned int __ATTRS_o_ai
13948 vec_lvrx(int __a, const unsigned int *__b) {
13949   return vec_perm((vector unsigned int)(0), vec_ld(__a, __b),
13950                   vec_lvsl(__a, __b));
13951 }
13952
13953 static __inline__ vector unsigned int __ATTRS_o_ai
13954 vec_lvrx(int __a, const vector unsigned int *__b) {
13955   return vec_perm((vector unsigned int)(0), vec_ld(__a, __b),
13956                   vec_lvsl(__a, (unsigned char *)__b));
13957 }
13958
13959 static __inline__ vector bool int __ATTRS_o_ai
13960 vec_lvrx(int __a, const vector bool int *__b) {
13961   return vec_perm((vector bool int)(0), vec_ld(__a, __b),
13962                   vec_lvsl(__a, (unsigned char *)__b));
13963 }
13964
13965 static __inline__ vector float __ATTRS_o_ai vec_lvrx(int __a,
13966                                                      const float *__b) {
13967   return vec_perm((vector float)(0), vec_ld(__a, __b), vec_lvsl(__a, __b));
13968 }
13969
13970 static __inline__ vector float __ATTRS_o_ai vec_lvrx(int __a,
13971                                                      const vector float *__b) {
13972   return vec_perm((vector float)(0), vec_ld(__a, __b),
13973                   vec_lvsl(__a, (unsigned char *)__b));
13974 }
13975
13976 /* vec_lvrxl */
13977
13978 static __inline__ vector signed char __ATTRS_o_ai
13979 vec_lvrxl(int __a, const signed char *__b) {
13980   return vec_perm((vector signed char)(0), vec_ldl(__a, __b),
13981                   vec_lvsl(__a, __b));
13982 }
13983
13984 static __inline__ vector signed char __ATTRS_o_ai
13985 vec_lvrxl(int __a, const vector signed char *__b) {
13986   return vec_perm((vector signed char)(0), vec_ldl(__a, __b),
13987                   vec_lvsl(__a, (unsigned char *)__b));
13988 }
13989
13990 static __inline__ vector unsigned char __ATTRS_o_ai
13991 vec_lvrxl(int __a, const unsigned char *__b) {
13992   return vec_perm((vector unsigned char)(0), vec_ldl(__a, __b),
13993                   vec_lvsl(__a, __b));
13994 }
13995
13996 static __inline__ vector unsigned char __ATTRS_o_ai
13997 vec_lvrxl(int __a, const vector unsigned char *__b) {
13998   return vec_perm((vector unsigned char)(0), vec_ldl(__a, __b),
13999                   vec_lvsl(__a, (unsigned char *)__b));
14000 }
14001
14002 static __inline__ vector bool char __ATTRS_o_ai
14003 vec_lvrxl(int __a, const vector bool char *__b) {
14004   return vec_perm((vector bool char)(0), vec_ldl(__a, __b),
14005                   vec_lvsl(__a, (unsigned char *)__b));
14006 }
14007
14008 static __inline__ vector short __ATTRS_o_ai vec_lvrxl(int __a,
14009                                                       const short *__b) {
14010   return vec_perm((vector short)(0), vec_ldl(__a, __b), vec_lvsl(__a, __b));
14011 }
14012
14013 static __inline__ vector short __ATTRS_o_ai vec_lvrxl(int __a,
14014                                                       const vector short *__b) {
14015   return vec_perm((vector short)(0), vec_ldl(__a, __b),
14016                   vec_lvsl(__a, (unsigned char *)__b));
14017 }
14018
14019 static __inline__ vector unsigned short __ATTRS_o_ai
14020 vec_lvrxl(int __a, const unsigned short *__b) {
14021   return vec_perm((vector unsigned short)(0), vec_ldl(__a, __b),
14022                   vec_lvsl(__a, __b));
14023 }
14024
14025 static __inline__ vector unsigned short __ATTRS_o_ai
14026 vec_lvrxl(int __a, const vector unsigned short *__b) {
14027   return vec_perm((vector unsigned short)(0), vec_ldl(__a, __b),
14028                   vec_lvsl(__a, (unsigned char *)__b));
14029 }
14030
14031 static __inline__ vector bool short __ATTRS_o_ai
14032 vec_lvrxl(int __a, const vector bool short *__b) {
14033   return vec_perm((vector bool short)(0), vec_ldl(__a, __b),
14034                   vec_lvsl(__a, (unsigned char *)__b));
14035 }
14036
14037 static __inline__ vector pixel __ATTRS_o_ai vec_lvrxl(int __a,
14038                                                       const vector pixel *__b) {
14039   return vec_perm((vector pixel)(0), vec_ldl(__a, __b),
14040                   vec_lvsl(__a, (unsigned char *)__b));
14041 }
14042
14043 static __inline__ vector int __ATTRS_o_ai vec_lvrxl(int __a, const int *__b) {
14044   return vec_perm((vector int)(0), vec_ldl(__a, __b), vec_lvsl(__a, __b));
14045 }
14046
14047 static __inline__ vector int __ATTRS_o_ai vec_lvrxl(int __a,
14048                                                     const vector int *__b) {
14049   return vec_perm((vector int)(0), vec_ldl(__a, __b),
14050                   vec_lvsl(__a, (unsigned char *)__b));
14051 }
14052
14053 static __inline__ vector unsigned int __ATTRS_o_ai
14054 vec_lvrxl(int __a, const unsigned int *__b) {
14055   return vec_perm((vector unsigned int)(0), vec_ldl(__a, __b),
14056                   vec_lvsl(__a, __b));
14057 }
14058
14059 static __inline__ vector unsigned int __ATTRS_o_ai
14060 vec_lvrxl(int __a, const vector unsigned int *__b) {
14061   return vec_perm((vector unsigned int)(0), vec_ldl(__a, __b),
14062                   vec_lvsl(__a, (unsigned char *)__b));
14063 }
14064
14065 static __inline__ vector bool int __ATTRS_o_ai
14066 vec_lvrxl(int __a, const vector bool int *__b) {
14067   return vec_perm((vector bool int)(0), vec_ldl(__a, __b),
14068                   vec_lvsl(__a, (unsigned char *)__b));
14069 }
14070
14071 static __inline__ vector float __ATTRS_o_ai vec_lvrxl(int __a,
14072                                                       const float *__b) {
14073   return vec_perm((vector float)(0), vec_ldl(__a, __b), vec_lvsl(__a, __b));
14074 }
14075
14076 static __inline__ vector float __ATTRS_o_ai vec_lvrxl(int __a,
14077                                                       const vector float *__b) {
14078   return vec_perm((vector float)(0), vec_ldl(__a, __b),
14079                   vec_lvsl(__a, (unsigned char *)__b));
14080 }
14081
14082 /* vec_stvlx */
14083
14084 static __inline__ void __ATTRS_o_ai vec_stvlx(vector signed char __a, int __b,
14085                                               signed char *__c) {
14086   return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
14087                 __c);
14088 }
14089
14090 static __inline__ void __ATTRS_o_ai vec_stvlx(vector signed char __a, int __b,
14091                                               vector signed char *__c) {
14092   return vec_st(
14093       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14094       __b, __c);
14095 }
14096
14097 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned char __a, int __b,
14098                                               unsigned char *__c) {
14099   return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
14100                 __c);
14101 }
14102
14103 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned char __a, int __b,
14104                                               vector unsigned char *__c) {
14105   return vec_st(
14106       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14107       __b, __c);
14108 }
14109
14110 static __inline__ void __ATTRS_o_ai vec_stvlx(vector bool char __a, int __b,
14111                                               vector bool char *__c) {
14112   return vec_st(
14113       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14114       __b, __c);
14115 }
14116
14117 static __inline__ void __ATTRS_o_ai vec_stvlx(vector short __a, int __b,
14118                                               short *__c) {
14119   return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
14120                 __c);
14121 }
14122
14123 static __inline__ void __ATTRS_o_ai vec_stvlx(vector short __a, int __b,
14124                                               vector short *__c) {
14125   return vec_st(
14126       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14127       __b, __c);
14128 }
14129
14130 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned short __a,
14131                                               int __b, unsigned short *__c) {
14132   return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
14133                 __c);
14134 }
14135
14136 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned short __a,
14137                                               int __b,
14138                                               vector unsigned short *__c) {
14139   return vec_st(
14140       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14141       __b, __c);
14142 }
14143
14144 static __inline__ void __ATTRS_o_ai vec_stvlx(vector bool short __a, int __b,
14145                                               vector bool short *__c) {
14146   return vec_st(
14147       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14148       __b, __c);
14149 }
14150
14151 static __inline__ void __ATTRS_o_ai vec_stvlx(vector pixel __a, int __b,
14152                                               vector pixel *__c) {
14153   return vec_st(
14154       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14155       __b, __c);
14156 }
14157
14158 static __inline__ void __ATTRS_o_ai vec_stvlx(vector int __a, int __b,
14159                                               int *__c) {
14160   return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
14161                 __c);
14162 }
14163
14164 static __inline__ void __ATTRS_o_ai vec_stvlx(vector int __a, int __b,
14165                                               vector int *__c) {
14166   return vec_st(
14167       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14168       __b, __c);
14169 }
14170
14171 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned int __a, int __b,
14172                                               unsigned int *__c) {
14173   return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
14174                 __c);
14175 }
14176
14177 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned int __a, int __b,
14178                                               vector unsigned int *__c) {
14179   return vec_st(
14180       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14181       __b, __c);
14182 }
14183
14184 static __inline__ void __ATTRS_o_ai vec_stvlx(vector bool int __a, int __b,
14185                                               vector bool int *__c) {
14186   return vec_st(
14187       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14188       __b, __c);
14189 }
14190
14191 static __inline__ void __ATTRS_o_ai vec_stvlx(vector float __a, int __b,
14192                                               vector float *__c) {
14193   return vec_st(
14194       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14195       __b, __c);
14196 }
14197
14198 /* vec_stvlxl */
14199
14200 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector signed char __a, int __b,
14201                                                signed char *__c) {
14202   return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
14203                  __c);
14204 }
14205
14206 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector signed char __a, int __b,
14207                                                vector signed char *__c) {
14208   return vec_stl(
14209       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14210       __b, __c);
14211 }
14212
14213 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned char __a,
14214                                                int __b, unsigned char *__c) {
14215   return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
14216                  __c);
14217 }
14218
14219 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned char __a,
14220                                                int __b,
14221                                                vector unsigned char *__c) {
14222   return vec_stl(
14223       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14224       __b, __c);
14225 }
14226
14227 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector bool char __a, int __b,
14228                                                vector bool char *__c) {
14229   return vec_stl(
14230       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14231       __b, __c);
14232 }
14233
14234 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector short __a, int __b,
14235                                                short *__c) {
14236   return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
14237                  __c);
14238 }
14239
14240 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector short __a, int __b,
14241                                                vector short *__c) {
14242   return vec_stl(
14243       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14244       __b, __c);
14245 }
14246
14247 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned short __a,
14248                                                int __b, unsigned short *__c) {
14249   return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
14250                  __c);
14251 }
14252
14253 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned short __a,
14254                                                int __b,
14255                                                vector unsigned short *__c) {
14256   return vec_stl(
14257       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14258       __b, __c);
14259 }
14260
14261 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector bool short __a, int __b,
14262                                                vector bool short *__c) {
14263   return vec_stl(
14264       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14265       __b, __c);
14266 }
14267
14268 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector pixel __a, int __b,
14269                                                vector pixel *__c) {
14270   return vec_stl(
14271       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14272       __b, __c);
14273 }
14274
14275 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector int __a, int __b,
14276                                                int *__c) {
14277   return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
14278                  __c);
14279 }
14280
14281 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector int __a, int __b,
14282                                                vector int *__c) {
14283   return vec_stl(
14284       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14285       __b, __c);
14286 }
14287
14288 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned int __a, int __b,
14289                                                unsigned int *__c) {
14290   return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
14291                  __c);
14292 }
14293
14294 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned int __a, int __b,
14295                                                vector unsigned int *__c) {
14296   return vec_stl(
14297       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14298       __b, __c);
14299 }
14300
14301 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector bool int __a, int __b,
14302                                                vector bool int *__c) {
14303   return vec_stl(
14304       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14305       __b, __c);
14306 }
14307
14308 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector float __a, int __b,
14309                                                vector float *__c) {
14310   return vec_stl(
14311       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14312       __b, __c);
14313 }
14314
14315 /* vec_stvrx */
14316
14317 static __inline__ void __ATTRS_o_ai vec_stvrx(vector signed char __a, int __b,
14318                                               signed char *__c) {
14319   return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
14320                 __c);
14321 }
14322
14323 static __inline__ void __ATTRS_o_ai vec_stvrx(vector signed char __a, int __b,
14324                                               vector signed char *__c) {
14325   return vec_st(
14326       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14327       __b, __c);
14328 }
14329
14330 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned char __a, int __b,
14331                                               unsigned char *__c) {
14332   return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
14333                 __c);
14334 }
14335
14336 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned char __a, int __b,
14337                                               vector unsigned char *__c) {
14338   return vec_st(
14339       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14340       __b, __c);
14341 }
14342
14343 static __inline__ void __ATTRS_o_ai vec_stvrx(vector bool char __a, int __b,
14344                                               vector bool char *__c) {
14345   return vec_st(
14346       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14347       __b, __c);
14348 }
14349
14350 static __inline__ void __ATTRS_o_ai vec_stvrx(vector short __a, int __b,
14351                                               short *__c) {
14352   return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
14353                 __c);
14354 }
14355
14356 static __inline__ void __ATTRS_o_ai vec_stvrx(vector short __a, int __b,
14357                                               vector short *__c) {
14358   return vec_st(
14359       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14360       __b, __c);
14361 }
14362
14363 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned short __a,
14364                                               int __b, unsigned short *__c) {
14365   return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
14366                 __c);
14367 }
14368
14369 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned short __a,
14370                                               int __b,
14371                                               vector unsigned short *__c) {
14372   return vec_st(
14373       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14374       __b, __c);
14375 }
14376
14377 static __inline__ void __ATTRS_o_ai vec_stvrx(vector bool short __a, int __b,
14378                                               vector bool short *__c) {
14379   return vec_st(
14380       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14381       __b, __c);
14382 }
14383
14384 static __inline__ void __ATTRS_o_ai vec_stvrx(vector pixel __a, int __b,
14385                                               vector pixel *__c) {
14386   return vec_st(
14387       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14388       __b, __c);
14389 }
14390
14391 static __inline__ void __ATTRS_o_ai vec_stvrx(vector int __a, int __b,
14392                                               int *__c) {
14393   return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
14394                 __c);
14395 }
14396
14397 static __inline__ void __ATTRS_o_ai vec_stvrx(vector int __a, int __b,
14398                                               vector int *__c) {
14399   return vec_st(
14400       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14401       __b, __c);
14402 }
14403
14404 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned int __a, int __b,
14405                                               unsigned int *__c) {
14406   return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
14407                 __c);
14408 }
14409
14410 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned int __a, int __b,
14411                                               vector unsigned int *__c) {
14412   return vec_st(
14413       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14414       __b, __c);
14415 }
14416
14417 static __inline__ void __ATTRS_o_ai vec_stvrx(vector bool int __a, int __b,
14418                                               vector bool int *__c) {
14419   return vec_st(
14420       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14421       __b, __c);
14422 }
14423
14424 static __inline__ void __ATTRS_o_ai vec_stvrx(vector float __a, int __b,
14425                                               vector float *__c) {
14426   return vec_st(
14427       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14428       __b, __c);
14429 }
14430
14431 /* vec_stvrxl */
14432
14433 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector signed char __a, int __b,
14434                                                signed char *__c) {
14435   return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
14436                  __c);
14437 }
14438
14439 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector signed char __a, int __b,
14440                                                vector signed char *__c) {
14441   return vec_stl(
14442       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14443       __b, __c);
14444 }
14445
14446 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned char __a,
14447                                                int __b, unsigned char *__c) {
14448   return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
14449                  __c);
14450 }
14451
14452 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned char __a,
14453                                                int __b,
14454                                                vector unsigned char *__c) {
14455   return vec_stl(
14456       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14457       __b, __c);
14458 }
14459
14460 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector bool char __a, int __b,
14461                                                vector bool char *__c) {
14462   return vec_stl(
14463       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14464       __b, __c);
14465 }
14466
14467 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector short __a, int __b,
14468                                                short *__c) {
14469   return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
14470                  __c);
14471 }
14472
14473 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector short __a, int __b,
14474                                                vector short *__c) {
14475   return vec_stl(
14476       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14477       __b, __c);
14478 }
14479
14480 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned short __a,
14481                                                int __b, unsigned short *__c) {
14482   return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
14483                  __c);
14484 }
14485
14486 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned short __a,
14487                                                int __b,
14488                                                vector unsigned short *__c) {
14489   return vec_stl(
14490       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14491       __b, __c);
14492 }
14493
14494 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector bool short __a, int __b,
14495                                                vector bool short *__c) {
14496   return vec_stl(
14497       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14498       __b, __c);
14499 }
14500
14501 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector pixel __a, int __b,
14502                                                vector pixel *__c) {
14503   return vec_stl(
14504       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14505       __b, __c);
14506 }
14507
14508 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector int __a, int __b,
14509                                                int *__c) {
14510   return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
14511                  __c);
14512 }
14513
14514 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector int __a, int __b,
14515                                                vector int *__c) {
14516   return vec_stl(
14517       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14518       __b, __c);
14519 }
14520
14521 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned int __a, int __b,
14522                                                unsigned int *__c) {
14523   return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
14524                  __c);
14525 }
14526
14527 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned int __a, int __b,
14528                                                vector unsigned int *__c) {
14529   return vec_stl(
14530       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14531       __b, __c);
14532 }
14533
14534 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector bool int __a, int __b,
14535                                                vector bool int *__c) {
14536   return vec_stl(
14537       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14538       __b, __c);
14539 }
14540
14541 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector float __a, int __b,
14542                                                vector float *__c) {
14543   return vec_stl(
14544       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14545       __b, __c);
14546 }
14547
14548 /* vec_promote */
14549
14550 static __inline__ vector signed char __ATTRS_o_ai vec_promote(signed char __a,
14551                                                               int __b) {
14552   vector signed char __res = (vector signed char)(0);
14553   __res[__b & 0x7] = __a;
14554   return __res;
14555 }
14556
14557 static __inline__ vector unsigned char __ATTRS_o_ai
14558 vec_promote(unsigned char __a, int __b) {
14559   vector unsigned char __res = (vector unsigned char)(0);
14560   __res[__b & 0x7] = __a;
14561   return __res;
14562 }
14563
14564 static __inline__ vector short __ATTRS_o_ai vec_promote(short __a, int __b) {
14565   vector short __res = (vector short)(0);
14566   __res[__b & 0x7] = __a;
14567   return __res;
14568 }
14569
14570 static __inline__ vector unsigned short __ATTRS_o_ai
14571 vec_promote(unsigned short __a, int __b) {
14572   vector unsigned short __res = (vector unsigned short)(0);
14573   __res[__b & 0x7] = __a;
14574   return __res;
14575 }
14576
14577 static __inline__ vector int __ATTRS_o_ai vec_promote(int __a, int __b) {
14578   vector int __res = (vector int)(0);
14579   __res[__b & 0x3] = __a;
14580   return __res;
14581 }
14582
14583 static __inline__ vector unsigned int __ATTRS_o_ai vec_promote(unsigned int __a,
14584                                                                int __b) {
14585   vector unsigned int __res = (vector unsigned int)(0);
14586   __res[__b & 0x3] = __a;
14587   return __res;
14588 }
14589
14590 static __inline__ vector float __ATTRS_o_ai vec_promote(float __a, int __b) {
14591   vector float __res = (vector float)(0);
14592   __res[__b & 0x3] = __a;
14593   return __res;
14594 }
14595
14596 #ifdef __VSX__
14597 static __inline__ vector double __ATTRS_o_ai vec_promote(double __a, int __b) {
14598   vector double __res = (vector double)(0);
14599   __res[__b & 0x1] = __a;
14600   return __res;
14601 }
14602
14603 static __inline__ vector signed long long __ATTRS_o_ai
14604 vec_promote(signed long long __a, int __b) {
14605   vector signed long long __res = (vector signed long long)(0);
14606   __res[__b & 0x1] = __a;
14607   return __res;
14608 }
14609
14610 static __inline__ vector unsigned long long __ATTRS_o_ai
14611 vec_promote(unsigned long long __a, int __b) {
14612   vector unsigned long long __res = (vector unsigned long long)(0);
14613   __res[__b & 0x1] = __a;
14614   return __res;
14615 }
14616 #endif
14617
14618 /* vec_splats */
14619
14620 static __inline__ vector signed char __ATTRS_o_ai vec_splats(signed char __a) {
14621   return (vector signed char)(__a);
14622 }
14623
14624 static __inline__ vector unsigned char __ATTRS_o_ai
14625 vec_splats(unsigned char __a) {
14626   return (vector unsigned char)(__a);
14627 }
14628
14629 static __inline__ vector short __ATTRS_o_ai vec_splats(short __a) {
14630   return (vector short)(__a);
14631 }
14632
14633 static __inline__ vector unsigned short __ATTRS_o_ai
14634 vec_splats(unsigned short __a) {
14635   return (vector unsigned short)(__a);
14636 }
14637
14638 static __inline__ vector int __ATTRS_o_ai vec_splats(int __a) {
14639   return (vector int)(__a);
14640 }
14641
14642 static __inline__ vector unsigned int __ATTRS_o_ai
14643 vec_splats(unsigned int __a) {
14644   return (vector unsigned int)(__a);
14645 }
14646
14647 #ifdef __VSX__
14648 static __inline__ vector signed long long __ATTRS_o_ai
14649 vec_splats(signed long long __a) {
14650   return (vector signed long long)(__a);
14651 }
14652
14653 static __inline__ vector unsigned long long __ATTRS_o_ai
14654 vec_splats(unsigned long long __a) {
14655   return (vector unsigned long long)(__a);
14656 }
14657
14658 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__) &&                    \
14659     defined(__SIZEOF_INT128__)
14660 static __inline__ vector signed __int128 __ATTRS_o_ai
14661 vec_splats(signed __int128 __a) {
14662   return (vector signed __int128)(__a);
14663 }
14664
14665 static __inline__ vector unsigned __int128 __ATTRS_o_ai
14666 vec_splats(unsigned __int128 __a) {
14667   return (vector unsigned __int128)(__a);
14668 }
14669
14670 #endif
14671
14672 static __inline__ vector double __ATTRS_o_ai vec_splats(double __a) {
14673   return (vector double)(__a);
14674 }
14675 #endif
14676
14677 static __inline__ vector float __ATTRS_o_ai vec_splats(float __a) {
14678   return (vector float)(__a);
14679 }
14680
14681 /* ----------------------------- predicates --------------------------------- */
14682
14683 /* vec_all_eq */
14684
14685 static __inline__ int __ATTRS_o_ai vec_all_eq(vector signed char __a,
14686                                               vector signed char __b) {
14687   return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
14688                                       (vector char)__b);
14689 }
14690
14691 static __inline__ int __ATTRS_o_ai vec_all_eq(vector signed char __a,
14692                                               vector bool char __b) {
14693   return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
14694                                       (vector char)__b);
14695 }
14696
14697 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned char __a,
14698                                               vector unsigned char __b) {
14699   return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
14700                                       (vector char)__b);
14701 }
14702
14703 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned char __a,
14704                                               vector bool char __b) {
14705   return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
14706                                       (vector char)__b);
14707 }
14708
14709 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool char __a,
14710                                               vector signed char __b) {
14711   return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
14712                                       (vector char)__b);
14713 }
14714
14715 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool char __a,
14716                                               vector unsigned char __b) {
14717   return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
14718                                       (vector char)__b);
14719 }
14720
14721 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool char __a,
14722                                               vector bool char __b) {
14723   return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
14724                                       (vector char)__b);
14725 }
14726
14727 static __inline__ int __ATTRS_o_ai vec_all_eq(vector short __a,
14728                                               vector short __b) {
14729   return __builtin_altivec_vcmpequh_p(__CR6_LT, __a, __b);
14730 }
14731
14732 static __inline__ int __ATTRS_o_ai vec_all_eq(vector short __a,
14733                                               vector bool short __b) {
14734   return __builtin_altivec_vcmpequh_p(__CR6_LT, __a, (vector short)__b);
14735 }
14736
14737 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned short __a,
14738                                               vector unsigned short __b) {
14739   return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
14740                                       (vector short)__b);
14741 }
14742
14743 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned short __a,
14744                                               vector bool short __b) {
14745   return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
14746                                       (vector short)__b);
14747 }
14748
14749 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool short __a,
14750                                               vector short __b) {
14751   return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
14752                                       (vector short)__b);
14753 }
14754
14755 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool short __a,
14756                                               vector unsigned short __b) {
14757   return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
14758                                       (vector short)__b);
14759 }
14760
14761 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool short __a,
14762                                               vector bool short __b) {
14763   return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
14764                                       (vector short)__b);
14765 }
14766
14767 static __inline__ int __ATTRS_o_ai vec_all_eq(vector pixel __a,
14768                                               vector pixel __b) {
14769   return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
14770                                       (vector short)__b);
14771 }
14772
14773 static __inline__ int __ATTRS_o_ai vec_all_eq(vector int __a, vector int __b) {
14774   return __builtin_altivec_vcmpequw_p(__CR6_LT, __a, __b);
14775 }
14776
14777 static __inline__ int __ATTRS_o_ai vec_all_eq(vector int __a,
14778                                               vector bool int __b) {
14779   return __builtin_altivec_vcmpequw_p(__CR6_LT, __a, (vector int)__b);
14780 }
14781
14782 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned int __a,
14783                                               vector unsigned int __b) {
14784   return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
14785                                       (vector int)__b);
14786 }
14787
14788 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned int __a,
14789                                               vector bool int __b) {
14790   return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
14791                                       (vector int)__b);
14792 }
14793
14794 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool int __a,
14795                                               vector int __b) {
14796   return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
14797                                       (vector int)__b);
14798 }
14799
14800 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool int __a,
14801                                               vector unsigned int __b) {
14802   return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
14803                                       (vector int)__b);
14804 }
14805
14806 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool int __a,
14807                                               vector bool int __b) {
14808   return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
14809                                       (vector int)__b);
14810 }
14811
14812 #ifdef __VSX__
14813 static __inline__ int __ATTRS_o_ai vec_all_eq(vector signed long long __a,
14814                                               vector signed long long __b) {
14815   return __builtin_altivec_vcmpequd_p(__CR6_LT, __a, __b);
14816 }
14817
14818 static __inline__ int __ATTRS_o_ai vec_all_eq(vector long long __a,
14819                                               vector bool long long __b) {
14820   return __builtin_altivec_vcmpequd_p(__CR6_LT, __a, (vector long long)__b);
14821 }
14822
14823 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned long long __a,
14824                                               vector unsigned long long __b) {
14825   return __builtin_altivec_vcmpequd_p(__CR6_LT, (vector long long)__a,
14826                                       (vector long long)__b);
14827 }
14828
14829 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned long long __a,
14830                                               vector bool long long __b) {
14831   return __builtin_altivec_vcmpequd_p(__CR6_LT, (vector long long)__a,
14832                                       (vector long long)__b);
14833 }
14834
14835 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool long long __a,
14836                                               vector long long __b) {
14837   return __builtin_altivec_vcmpequd_p(__CR6_LT, (vector long long)__a,
14838                                       (vector long long)__b);
14839 }
14840
14841 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool long long __a,
14842                                               vector unsigned long long __b) {
14843   return __builtin_altivec_vcmpequd_p(__CR6_LT, (vector long long)__a,
14844                                       (vector long long)__b);
14845 }
14846
14847 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool long long __a,
14848                                               vector bool long long __b) {
14849   return __builtin_altivec_vcmpequd_p(__CR6_LT, (vector long long)__a,
14850                                       (vector long long)__b);
14851 }
14852 #endif
14853
14854 static __inline__ int __ATTRS_o_ai vec_all_eq(vector float __a,
14855                                               vector float __b) {
14856 #ifdef __VSX__
14857   return __builtin_vsx_xvcmpeqsp_p(__CR6_LT, __a, __b);
14858 #else
14859   return __builtin_altivec_vcmpeqfp_p(__CR6_LT, __a, __b);
14860 #endif
14861 }
14862
14863 #ifdef __VSX__
14864 static __inline__ int __ATTRS_o_ai vec_all_eq(vector double __a,
14865                                               vector double __b) {
14866   return __builtin_vsx_xvcmpeqdp_p(__CR6_LT, __a, __b);
14867 }
14868 #endif
14869
14870 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
14871 static __inline__ int __ATTRS_o_ai vec_all_eq(vector signed __int128 __a,
14872                                               vector signed __int128 __b) {
14873   return __builtin_altivec_vcmpequq_p(__CR6_LT, __a, __b);
14874 }
14875
14876 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned __int128 __a,
14877                                               vector unsigned __int128 __b) {
14878   return __builtin_altivec_vcmpequq_p(__CR6_LT, __a, __b);
14879 }
14880 #endif
14881
14882 /* vec_all_ge */
14883
14884 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed char __a,
14885                                               vector signed char __b) {
14886   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, __b, __a);
14887 }
14888
14889 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed char __a,
14890                                               vector bool char __b) {
14891   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, (vector signed char)__b, __a);
14892 }
14893
14894 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned char __a,
14895                                               vector unsigned char __b) {
14896   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __b, __a);
14897 }
14898
14899 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned char __a,
14900                                               vector bool char __b) {
14901   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__b, __a);
14902 }
14903
14904 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool char __a,
14905                                               vector signed char __b) {
14906   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, __b, (vector signed char)__a);
14907 }
14908
14909 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool char __a,
14910                                               vector unsigned char __b) {
14911   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __b, (vector unsigned char)__a);
14912 }
14913
14914 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool char __a,
14915                                               vector bool char __b) {
14916   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__b,
14917                                       (vector unsigned char)__a);
14918 }
14919
14920 static __inline__ int __ATTRS_o_ai vec_all_ge(vector short __a,
14921                                               vector short __b) {
14922   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, __b, __a);
14923 }
14924
14925 static __inline__ int __ATTRS_o_ai vec_all_ge(vector short __a,
14926                                               vector bool short __b) {
14927   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, (vector short)__b, __a);
14928 }
14929
14930 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned short __a,
14931                                               vector unsigned short __b) {
14932   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __b, __a);
14933 }
14934
14935 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned short __a,
14936                                               vector bool short __b) {
14937   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__b,
14938                                       __a);
14939 }
14940
14941 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool short __a,
14942                                               vector short __b) {
14943   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, __b, (vector signed short)__a);
14944 }
14945
14946 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool short __a,
14947                                               vector unsigned short __b) {
14948   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __b,
14949                                       (vector unsigned short)__a);
14950 }
14951
14952 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool short __a,
14953                                               vector bool short __b) {
14954   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__b,
14955                                       (vector unsigned short)__a);
14956 }
14957
14958 static __inline__ int __ATTRS_o_ai vec_all_ge(vector int __a, vector int __b) {
14959   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, __b, __a);
14960 }
14961
14962 static __inline__ int __ATTRS_o_ai vec_all_ge(vector int __a,
14963                                               vector bool int __b) {
14964   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, (vector int)__b, __a);
14965 }
14966
14967 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned int __a,
14968                                               vector unsigned int __b) {
14969   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __b, __a);
14970 }
14971
14972 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned int __a,
14973                                               vector bool int __b) {
14974   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__b, __a);
14975 }
14976
14977 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool int __a,
14978                                               vector int __b) {
14979   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, __b, (vector signed int)__a);
14980 }
14981
14982 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool int __a,
14983                                               vector unsigned int __b) {
14984   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __b, (vector unsigned int)__a);
14985 }
14986
14987 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool int __a,
14988                                               vector bool int __b) {
14989   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__b,
14990                                       (vector unsigned int)__a);
14991 }
14992
14993 #ifdef __VSX__
14994 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed long long __a,
14995                                               vector signed long long __b) {
14996   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, __b, __a);
14997 }
14998 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed long long __a,
14999                                               vector bool long long __b) {
15000   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, (vector signed long long)__b,
15001                                       __a);
15002 }
15003
15004 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned long long __a,
15005                                               vector unsigned long long __b) {
15006   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __b, __a);
15007 }
15008
15009 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned long long __a,
15010                                               vector bool long long __b) {
15011   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__b,
15012                                       __a);
15013 }
15014
15015 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool long long __a,
15016                                               vector signed long long __b) {
15017   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, __b,
15018                                       (vector signed long long)__a);
15019 }
15020
15021 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool long long __a,
15022                                               vector unsigned long long __b) {
15023   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __b,
15024                                       (vector unsigned long long)__a);
15025 }
15026
15027 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool long long __a,
15028                                               vector bool long long __b) {
15029   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__b,
15030                                       (vector unsigned long long)__a);
15031 }
15032 #endif
15033
15034 static __inline__ int __ATTRS_o_ai vec_all_ge(vector float __a,
15035                                               vector float __b) {
15036 #ifdef __VSX__
15037   return __builtin_vsx_xvcmpgesp_p(__CR6_LT, __a, __b);
15038 #else
15039   return __builtin_altivec_vcmpgefp_p(__CR6_LT, __a, __b);
15040 #endif
15041 }
15042
15043 #ifdef __VSX__
15044 static __inline__ int __ATTRS_o_ai vec_all_ge(vector double __a,
15045                                               vector double __b) {
15046   return __builtin_vsx_xvcmpgedp_p(__CR6_LT, __a, __b);
15047 }
15048 #endif
15049
15050 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
15051 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed __int128 __a,
15052                                               vector signed __int128 __b) {
15053   return __builtin_altivec_vcmpgtsq_p(__CR6_EQ, __b, __a);
15054 }
15055
15056 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned __int128 __a,
15057                                               vector unsigned __int128 __b) {
15058   return __builtin_altivec_vcmpgtuq_p(__CR6_EQ, __b, __a);
15059 }
15060 #endif
15061
15062 /* vec_all_gt */
15063
15064 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed char __a,
15065                                               vector signed char __b) {
15066   return __builtin_altivec_vcmpgtsb_p(__CR6_LT, __a, __b);
15067 }
15068
15069 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed char __a,
15070                                               vector bool char __b) {
15071   return __builtin_altivec_vcmpgtsb_p(__CR6_LT, __a, (vector signed char)__b);
15072 }
15073
15074 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned char __a,
15075                                               vector unsigned char __b) {
15076   return __builtin_altivec_vcmpgtub_p(__CR6_LT, __a, __b);
15077 }
15078
15079 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned char __a,
15080                                               vector bool char __b) {
15081   return __builtin_altivec_vcmpgtub_p(__CR6_LT, __a, (vector unsigned char)__b);
15082 }
15083
15084 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool char __a,
15085                                               vector signed char __b) {
15086   return __builtin_altivec_vcmpgtsb_p(__CR6_LT, (vector signed char)__a, __b);
15087 }
15088
15089 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool char __a,
15090                                               vector unsigned char __b) {
15091   return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__a, __b);
15092 }
15093
15094 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool char __a,
15095                                               vector bool char __b) {
15096   return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__a,
15097                                       (vector unsigned char)__b);
15098 }
15099
15100 static __inline__ int __ATTRS_o_ai vec_all_gt(vector short __a,
15101                                               vector short __b) {
15102   return __builtin_altivec_vcmpgtsh_p(__CR6_LT, __a, __b);
15103 }
15104
15105 static __inline__ int __ATTRS_o_ai vec_all_gt(vector short __a,
15106                                               vector bool short __b) {
15107   return __builtin_altivec_vcmpgtsh_p(__CR6_LT, __a, (vector short)__b);
15108 }
15109
15110 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned short __a,
15111                                               vector unsigned short __b) {
15112   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __a, __b);
15113 }
15114
15115 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned short __a,
15116                                               vector bool short __b) {
15117   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __a,
15118                                       (vector unsigned short)__b);
15119 }
15120
15121 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool short __a,
15122                                               vector short __b) {
15123   return __builtin_altivec_vcmpgtsh_p(__CR6_LT, (vector signed short)__a, __b);
15124 }
15125
15126 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool short __a,
15127                                               vector unsigned short __b) {
15128   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__a,
15129                                       __b);
15130 }
15131
15132 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool short __a,
15133                                               vector bool short __b) {
15134   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__a,
15135                                       (vector unsigned short)__b);
15136 }
15137
15138 static __inline__ int __ATTRS_o_ai vec_all_gt(vector int __a, vector int __b) {
15139   return __builtin_altivec_vcmpgtsw_p(__CR6_LT, __a, __b);
15140 }
15141
15142 static __inline__ int __ATTRS_o_ai vec_all_gt(vector int __a,
15143                                               vector bool int __b) {
15144   return __builtin_altivec_vcmpgtsw_p(__CR6_LT, __a, (vector int)__b);
15145 }
15146
15147 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned int __a,
15148                                               vector unsigned int __b) {
15149   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __a, __b);
15150 }
15151
15152 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned int __a,
15153                                               vector bool int __b) {
15154   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __a, (vector unsigned int)__b);
15155 }
15156
15157 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool int __a,
15158                                               vector int __b) {
15159   return __builtin_altivec_vcmpgtsw_p(__CR6_LT, (vector signed int)__a, __b);
15160 }
15161
15162 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool int __a,
15163                                               vector unsigned int __b) {
15164   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__a, __b);
15165 }
15166
15167 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool int __a,
15168                                               vector bool int __b) {
15169   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__a,
15170                                       (vector unsigned int)__b);
15171 }
15172
15173 #ifdef __VSX__
15174 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed long long __a,
15175                                               vector signed long long __b) {
15176   return __builtin_altivec_vcmpgtsd_p(__CR6_LT, __a, __b);
15177 }
15178 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed long long __a,
15179                                               vector bool long long __b) {
15180   return __builtin_altivec_vcmpgtsd_p(__CR6_LT, __a,
15181                                       (vector signed long long)__b);
15182 }
15183
15184 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned long long __a,
15185                                               vector unsigned long long __b) {
15186   return __builtin_altivec_vcmpgtud_p(__CR6_LT, __a, __b);
15187 }
15188
15189 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned long long __a,
15190                                               vector bool long long __b) {
15191   return __builtin_altivec_vcmpgtud_p(__CR6_LT, __a,
15192                                       (vector unsigned long long)__b);
15193 }
15194
15195 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool long long __a,
15196                                               vector signed long long __b) {
15197   return __builtin_altivec_vcmpgtsd_p(__CR6_LT, (vector signed long long)__a,
15198                                       __b);
15199 }
15200
15201 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool long long __a,
15202                                               vector unsigned long long __b) {
15203   return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__a,
15204                                       __b);
15205 }
15206
15207 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool long long __a,
15208                                               vector bool long long __b) {
15209   return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__a,
15210                                       (vector unsigned long long)__b);
15211 }
15212 #endif
15213
15214 static __inline__ int __ATTRS_o_ai vec_all_gt(vector float __a,
15215                                               vector float __b) {
15216 #ifdef __VSX__
15217   return __builtin_vsx_xvcmpgtsp_p(__CR6_LT, __a, __b);
15218 #else
15219   return __builtin_altivec_vcmpgtfp_p(__CR6_LT, __a, __b);
15220 #endif
15221 }
15222
15223 #ifdef __VSX__
15224 static __inline__ int __ATTRS_o_ai vec_all_gt(vector double __a,
15225                                               vector double __b) {
15226   return __builtin_vsx_xvcmpgtdp_p(__CR6_LT, __a, __b);
15227 }
15228 #endif
15229
15230 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
15231 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed __int128 __a,
15232                                               vector signed __int128 __b) {
15233   return __builtin_altivec_vcmpgtsq_p(__CR6_LT, __a, __b);
15234 }
15235
15236 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned __int128 __a,
15237                                               vector unsigned __int128 __b) {
15238   return __builtin_altivec_vcmpgtuq_p(__CR6_LT, __a, __b);
15239 }
15240 #endif
15241
15242 /* vec_all_in */
15243
15244 static __inline__ int __attribute__((__always_inline__))
15245 vec_all_in(vector float __a, vector float __b) {
15246   return __builtin_altivec_vcmpbfp_p(__CR6_EQ, __a, __b);
15247 }
15248
15249 /* vec_all_le */
15250
15251 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed char __a,
15252                                               vector signed char __b) {
15253   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, __a, __b);
15254 }
15255
15256 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed char __a,
15257                                               vector bool char __b) {
15258   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, __a, (vector signed char)__b);
15259 }
15260
15261 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned char __a,
15262                                               vector unsigned char __b) {
15263   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __a, __b);
15264 }
15265
15266 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned char __a,
15267                                               vector bool char __b) {
15268   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __a, (vector unsigned char)__b);
15269 }
15270
15271 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool char __a,
15272                                               vector signed char __b) {
15273   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, (vector signed char)__a, __b);
15274 }
15275
15276 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool char __a,
15277                                               vector unsigned char __b) {
15278   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__a, __b);
15279 }
15280
15281 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool char __a,
15282                                               vector bool char __b) {
15283   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__a,
15284                                       (vector unsigned char)__b);
15285 }
15286
15287 static __inline__ int __ATTRS_o_ai vec_all_le(vector short __a,
15288                                               vector short __b) {
15289   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, __a, __b);
15290 }
15291
15292 static __inline__ int __ATTRS_o_ai vec_all_le(vector short __a,
15293                                               vector bool short __b) {
15294   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, __a, (vector short)__b);
15295 }
15296
15297 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned short __a,
15298                                               vector unsigned short __b) {
15299   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __a, __b);
15300 }
15301
15302 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned short __a,
15303                                               vector bool short __b) {
15304   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __a,
15305                                       (vector unsigned short)__b);
15306 }
15307
15308 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool short __a,
15309                                               vector short __b) {
15310   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, (vector signed short)__a, __b);
15311 }
15312
15313 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool short __a,
15314                                               vector unsigned short __b) {
15315   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__a,
15316                                       __b);
15317 }
15318
15319 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool short __a,
15320                                               vector bool short __b) {
15321   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__a,
15322                                       (vector unsigned short)__b);
15323 }
15324
15325 static __inline__ int __ATTRS_o_ai vec_all_le(vector int __a, vector int __b) {
15326   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, __a, __b);
15327 }
15328
15329 static __inline__ int __ATTRS_o_ai vec_all_le(vector int __a,
15330                                               vector bool int __b) {
15331   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, __a, (vector int)__b);
15332 }
15333
15334 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned int __a,
15335                                               vector unsigned int __b) {
15336   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __a, __b);
15337 }
15338
15339 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned int __a,
15340                                               vector bool int __b) {
15341   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __a, (vector unsigned int)__b);
15342 }
15343
15344 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool int __a,
15345                                               vector int __b) {
15346   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, (vector signed int)__a, __b);
15347 }
15348
15349 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool int __a,
15350                                               vector unsigned int __b) {
15351   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__a, __b);
15352 }
15353
15354 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool int __a,
15355                                               vector bool int __b) {
15356   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__a,
15357                                       (vector unsigned int)__b);
15358 }
15359
15360 #ifdef __VSX__
15361 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed long long __a,
15362                                               vector signed long long __b) {
15363   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, __a, __b);
15364 }
15365
15366 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned long long __a,
15367                                               vector unsigned long long __b) {
15368   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __a, __b);
15369 }
15370
15371 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed long long __a,
15372                                               vector bool long long __b) {
15373   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, __a,
15374                                       (vector signed long long)__b);
15375 }
15376
15377 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned long long __a,
15378                                               vector bool long long __b) {
15379   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __a,
15380                                       (vector unsigned long long)__b);
15381 }
15382
15383 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool long long __a,
15384                                               vector signed long long __b) {
15385   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, (vector signed long long)__a,
15386                                       __b);
15387 }
15388
15389 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool long long __a,
15390                                               vector unsigned long long __b) {
15391   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__a,
15392                                       __b);
15393 }
15394
15395 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool long long __a,
15396                                               vector bool long long __b) {
15397   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__a,
15398                                       (vector unsigned long long)__b);
15399 }
15400 #endif
15401
15402 static __inline__ int __ATTRS_o_ai vec_all_le(vector float __a,
15403                                               vector float __b) {
15404 #ifdef __VSX__
15405   return __builtin_vsx_xvcmpgesp_p(__CR6_LT, __b, __a);
15406 #else
15407   return __builtin_altivec_vcmpgefp_p(__CR6_LT, __b, __a);
15408 #endif
15409 }
15410
15411 #ifdef __VSX__
15412 static __inline__ int __ATTRS_o_ai vec_all_le(vector double __a,
15413                                               vector double __b) {
15414   return __builtin_vsx_xvcmpgedp_p(__CR6_LT, __b, __a);
15415 }
15416 #endif
15417
15418 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
15419 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed __int128 __a,
15420                                               vector signed __int128 __b) {
15421   return __builtin_altivec_vcmpgtsq_p(__CR6_EQ, __a, __b);
15422 }
15423
15424 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned __int128 __a,
15425                                               vector unsigned __int128 __b) {
15426   return __builtin_altivec_vcmpgtuq_p(__CR6_EQ, __a, __b);
15427 }
15428 #endif
15429
15430 /* vec_all_lt */
15431
15432 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed char __a,
15433                                               vector signed char __b) {
15434   return __builtin_altivec_vcmpgtsb_p(__CR6_LT, __b, __a);
15435 }
15436
15437 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed char __a,
15438                                               vector bool char __b) {
15439   return __builtin_altivec_vcmpgtsb_p(__CR6_LT, (vector signed char)__b, __a);
15440 }
15441
15442 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned char __a,
15443                                               vector unsigned char __b) {
15444   return __builtin_altivec_vcmpgtub_p(__CR6_LT, __b, __a);
15445 }
15446
15447 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned char __a,
15448                                               vector bool char __b) {
15449   return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__b, __a);
15450 }
15451
15452 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool char __a,
15453                                               vector signed char __b) {
15454   return __builtin_altivec_vcmpgtsb_p(__CR6_LT, __b, (vector signed char)__a);
15455 }
15456
15457 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool char __a,
15458                                               vector unsigned char __b) {
15459   return __builtin_altivec_vcmpgtub_p(__CR6_LT, __b, (vector unsigned char)__a);
15460 }
15461
15462 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool char __a,
15463                                               vector bool char __b) {
15464   return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__b,
15465                                       (vector unsigned char)__a);
15466 }
15467
15468 static __inline__ int __ATTRS_o_ai vec_all_lt(vector short __a,
15469                                               vector short __b) {
15470   return __builtin_altivec_vcmpgtsh_p(__CR6_LT, __b, __a);
15471 }
15472
15473 static __inline__ int __ATTRS_o_ai vec_all_lt(vector short __a,
15474                                               vector bool short __b) {
15475   return __builtin_altivec_vcmpgtsh_p(__CR6_LT, (vector short)__b, __a);
15476 }
15477
15478 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned short __a,
15479                                               vector unsigned short __b) {
15480   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __b, __a);
15481 }
15482
15483 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned short __a,
15484                                               vector bool short __b) {
15485   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__b,
15486                                       __a);
15487 }
15488
15489 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool short __a,
15490                                               vector short __b) {
15491   return __builtin_altivec_vcmpgtsh_p(__CR6_LT, __b, (vector signed short)__a);
15492 }
15493
15494 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool short __a,
15495                                               vector unsigned short __b) {
15496   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __b,
15497                                       (vector unsigned short)__a);
15498 }
15499
15500 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool short __a,
15501                                               vector bool short __b) {
15502   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__b,
15503                                       (vector unsigned short)__a);
15504 }
15505
15506 static __inline__ int __ATTRS_o_ai vec_all_lt(vector int __a, vector int __b) {
15507   return __builtin_altivec_vcmpgtsw_p(__CR6_LT, __b, __a);
15508 }
15509
15510 static __inline__ int __ATTRS_o_ai vec_all_lt(vector int __a,
15511                                               vector bool int __b) {
15512   return __builtin_altivec_vcmpgtsw_p(__CR6_LT, (vector int)__b, __a);
15513 }
15514
15515 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned int __a,
15516                                               vector unsigned int __b) {
15517   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __b, __a);
15518 }
15519
15520 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned int __a,
15521                                               vector bool int __b) {
15522   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__b, __a);
15523 }
15524
15525 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool int __a,
15526                                               vector int __b) {
15527   return __builtin_altivec_vcmpgtsw_p(__CR6_LT, __b, (vector signed int)__a);
15528 }
15529
15530 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool int __a,
15531                                               vector unsigned int __b) {
15532   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __b, (vector unsigned int)__a);
15533 }
15534
15535 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool int __a,
15536                                               vector bool int __b) {
15537   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__b,
15538                                       (vector unsigned int)__a);
15539 }
15540
15541 #ifdef __VSX__
15542 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed long long __a,
15543                                               vector signed long long __b) {
15544   return __builtin_altivec_vcmpgtsd_p(__CR6_LT, __b, __a);
15545 }
15546
15547 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned long long __a,
15548                                               vector unsigned long long __b) {
15549   return __builtin_altivec_vcmpgtud_p(__CR6_LT, __b, __a);
15550 }
15551
15552 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed long long __a,
15553                                               vector bool long long __b) {
15554   return __builtin_altivec_vcmpgtsd_p(__CR6_LT, (vector signed long long)__b,
15555                                       __a);
15556 }
15557
15558 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned long long __a,
15559                                               vector bool long long __b) {
15560   return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__b,
15561                                       __a);
15562 }
15563
15564 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool long long __a,
15565                                               vector signed long long __b) {
15566   return __builtin_altivec_vcmpgtsd_p(__CR6_LT, __b,
15567                                       (vector signed long long)__a);
15568 }
15569
15570 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool long long __a,
15571                                               vector unsigned long long __b) {
15572   return __builtin_altivec_vcmpgtud_p(__CR6_LT, __b,
15573                                       (vector unsigned long long)__a);
15574 }
15575
15576 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool long long __a,
15577                                               vector bool long long __b) {
15578   return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__b,
15579                                       (vector unsigned long long)__a);
15580 }
15581 #endif
15582
15583 static __inline__ int __ATTRS_o_ai vec_all_lt(vector float __a,
15584                                               vector float __b) {
15585 #ifdef __VSX__
15586   return __builtin_vsx_xvcmpgtsp_p(__CR6_LT, __b, __a);
15587 #else
15588   return __builtin_altivec_vcmpgtfp_p(__CR6_LT, __b, __a);
15589 #endif
15590 }
15591
15592 #ifdef __VSX__
15593 static __inline__ int __ATTRS_o_ai vec_all_lt(vector double __a,
15594                                               vector double __b) {
15595   return __builtin_vsx_xvcmpgtdp_p(__CR6_LT, __b, __a);
15596 }
15597 #endif
15598
15599 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
15600 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed __int128 __a,
15601                                               vector signed __int128 __b) {
15602   return __builtin_altivec_vcmpgtsq_p(__CR6_LT, __b, __a);
15603 }
15604
15605 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned __int128 __a,
15606                                               vector unsigned __int128 __b) {
15607   return __builtin_altivec_vcmpgtuq_p(__CR6_LT, __b, __a);
15608 }
15609 #endif
15610
15611 /* vec_all_nan */
15612
15613 static __inline__ int __ATTRS_o_ai vec_all_nan(vector float __a) {
15614 #ifdef __VSX__
15615   return __builtin_vsx_xvcmpeqsp_p(__CR6_EQ, __a, __a);
15616 #else
15617   return __builtin_altivec_vcmpeqfp_p(__CR6_EQ, __a, __a);
15618 #endif
15619 }
15620
15621 #ifdef __VSX__
15622 static __inline__ int __ATTRS_o_ai vec_all_nan(vector double __a) {
15623   return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ, __a, __a);
15624 }
15625 #endif
15626
15627 /* vec_all_ne */
15628
15629 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed char __a,
15630                                               vector signed char __b) {
15631   return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
15632                                       (vector char)__b);
15633 }
15634
15635 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed char __a,
15636                                               vector bool char __b) {
15637   return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
15638                                       (vector char)__b);
15639 }
15640
15641 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned char __a,
15642                                               vector unsigned char __b) {
15643   return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
15644                                       (vector char)__b);
15645 }
15646
15647 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned char __a,
15648                                               vector bool char __b) {
15649   return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
15650                                       (vector char)__b);
15651 }
15652
15653 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool char __a,
15654                                               vector signed char __b) {
15655   return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
15656                                       (vector char)__b);
15657 }
15658
15659 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool char __a,
15660                                               vector unsigned char __b) {
15661   return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
15662                                       (vector char)__b);
15663 }
15664
15665 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool char __a,
15666                                               vector bool char __b) {
15667   return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
15668                                       (vector char)__b);
15669 }
15670
15671 static __inline__ int __ATTRS_o_ai vec_all_ne(vector short __a,
15672                                               vector short __b) {
15673   return __builtin_altivec_vcmpequh_p(__CR6_EQ, __a, __b);
15674 }
15675
15676 static __inline__ int __ATTRS_o_ai vec_all_ne(vector short __a,
15677                                               vector bool short __b) {
15678   return __builtin_altivec_vcmpequh_p(__CR6_EQ, __a, (vector short)__b);
15679 }
15680
15681 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned short __a,
15682                                               vector unsigned short __b) {
15683   return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
15684                                       (vector short)__b);
15685 }
15686
15687 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned short __a,
15688                                               vector bool short __b) {
15689   return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
15690                                       (vector short)__b);
15691 }
15692
15693 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool short __a,
15694                                               vector short __b) {
15695   return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
15696                                       (vector short)__b);
15697 }
15698
15699 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool short __a,
15700                                               vector unsigned short __b) {
15701   return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
15702                                       (vector short)__b);
15703 }
15704
15705 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool short __a,
15706                                               vector bool short __b) {
15707   return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
15708                                       (vector short)__b);
15709 }
15710
15711 static __inline__ int __ATTRS_o_ai vec_all_ne(vector pixel __a,
15712                                               vector pixel __b) {
15713   return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
15714                                       (vector short)__b);
15715 }
15716
15717 static __inline__ int __ATTRS_o_ai vec_all_ne(vector int __a, vector int __b) {
15718   return __builtin_altivec_vcmpequw_p(__CR6_EQ, __a, __b);
15719 }
15720
15721 static __inline__ int __ATTRS_o_ai vec_all_ne(vector int __a,
15722                                               vector bool int __b) {
15723   return __builtin_altivec_vcmpequw_p(__CR6_EQ, __a, (vector int)__b);
15724 }
15725
15726 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned int __a,
15727                                               vector unsigned int __b) {
15728   return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
15729                                       (vector int)__b);
15730 }
15731
15732 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned int __a,
15733                                               vector bool int __b) {
15734   return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
15735                                       (vector int)__b);
15736 }
15737
15738 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool int __a,
15739                                               vector int __b) {
15740   return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
15741                                       (vector int)__b);
15742 }
15743
15744 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool int __a,
15745                                               vector unsigned int __b) {
15746   return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
15747                                       (vector int)__b);
15748 }
15749
15750 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool int __a,
15751                                               vector bool int __b) {
15752   return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
15753                                       (vector int)__b);
15754 }
15755
15756 #ifdef __VSX__
15757 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed long long __a,
15758                                               vector signed long long __b) {
15759   return __builtin_altivec_vcmpequd_p(__CR6_EQ, __a, __b);
15760 }
15761
15762 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned long long __a,
15763                                               vector unsigned long long __b) {
15764   return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector long long)__a,
15765                                       (vector long long)__b);
15766 }
15767
15768 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed long long __a,
15769                                               vector bool long long __b) {
15770   return __builtin_altivec_vcmpequd_p(__CR6_EQ, __a,
15771                                       (vector signed long long)__b);
15772 }
15773
15774 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned long long __a,
15775                                               vector bool long long __b) {
15776   return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector signed long long)__a,
15777                                       (vector signed long long)__b);
15778 }
15779
15780 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool long long __a,
15781                                               vector signed long long __b) {
15782   return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector signed long long)__a,
15783                                       (vector signed long long)__b);
15784 }
15785
15786 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool long long __a,
15787                                               vector unsigned long long __b) {
15788   return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector signed long long)__a,
15789                                       (vector signed long long)__b);
15790 }
15791
15792 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool long long __a,
15793                                               vector bool long long __b) {
15794   return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector signed long long)__a,
15795                                       (vector signed long long)__b);
15796 }
15797 #endif
15798
15799 static __inline__ int __ATTRS_o_ai vec_all_ne(vector float __a,
15800                                               vector float __b) {
15801 #ifdef __VSX__
15802   return __builtin_vsx_xvcmpeqsp_p(__CR6_EQ, __a, __b);
15803 #else
15804   return __builtin_altivec_vcmpeqfp_p(__CR6_EQ, __a, __b);
15805 #endif
15806 }
15807
15808 #ifdef __VSX__
15809 static __inline__ int __ATTRS_o_ai vec_all_ne(vector double __a,
15810                                               vector double __b) {
15811   return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ, __a, __b);
15812 }
15813 #endif
15814
15815 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
15816 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed __int128 __a,
15817                                               vector signed __int128 __b) {
15818   return __builtin_altivec_vcmpequq_p(__CR6_EQ, __a, __b);
15819 }
15820
15821 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned __int128 __a,
15822                                               vector unsigned __int128 __b) {
15823   return __builtin_altivec_vcmpequq_p(__CR6_EQ, __a, __b);
15824 }
15825 #endif
15826
15827 /* vec_all_nge */
15828
15829 static __inline__ int __ATTRS_o_ai vec_all_nge(vector float __a,
15830                                                vector float __b) {
15831 #ifdef __VSX__
15832   return __builtin_vsx_xvcmpgesp_p(__CR6_EQ, __a, __b);
15833 #else
15834   return __builtin_altivec_vcmpgefp_p(__CR6_EQ, __a, __b);
15835 #endif
15836 }
15837
15838 #ifdef __VSX__
15839 static __inline__ int __ATTRS_o_ai vec_all_nge(vector double __a,
15840                                                vector double __b) {
15841   return __builtin_vsx_xvcmpgedp_p(__CR6_EQ, __a, __b);
15842 }
15843 #endif
15844
15845 /* vec_all_ngt */
15846
15847 static __inline__ int __ATTRS_o_ai vec_all_ngt(vector float __a,
15848                                                vector float __b) {
15849 #ifdef __VSX__
15850   return __builtin_vsx_xvcmpgtsp_p(__CR6_EQ, __a, __b);
15851 #else
15852   return __builtin_altivec_vcmpgtfp_p(__CR6_EQ, __a, __b);
15853 #endif
15854 }
15855
15856 #ifdef __VSX__
15857 static __inline__ int __ATTRS_o_ai vec_all_ngt(vector double __a,
15858                                                vector double __b) {
15859   return __builtin_vsx_xvcmpgtdp_p(__CR6_EQ, __a, __b);
15860 }
15861 #endif
15862
15863 /* vec_all_nle */
15864
15865 static __inline__ int __ATTRS_o_ai
15866 vec_all_nle(vector float __a, vector float __b) {
15867 #ifdef __VSX__
15868   return __builtin_vsx_xvcmpgesp_p(__CR6_EQ, __b, __a);
15869 #else
15870   return __builtin_altivec_vcmpgefp_p(__CR6_EQ, __b, __a);
15871 #endif
15872 }
15873
15874 #ifdef __VSX__
15875 static __inline__ int __ATTRS_o_ai vec_all_nle(vector double __a,
15876                                                vector double __b) {
15877   return __builtin_vsx_xvcmpgedp_p(__CR6_EQ, __b, __a);
15878 }
15879 #endif
15880
15881 /* vec_all_nlt */
15882
15883 static __inline__ int __ATTRS_o_ai
15884 vec_all_nlt(vector float __a, vector float __b) {
15885 #ifdef __VSX__
15886   return __builtin_vsx_xvcmpgtsp_p(__CR6_EQ, __b, __a);
15887 #else
15888   return __builtin_altivec_vcmpgtfp_p(__CR6_EQ, __b, __a);
15889 #endif
15890 }
15891
15892 #ifdef __VSX__
15893 static __inline__ int __ATTRS_o_ai vec_all_nlt(vector double __a,
15894                                                vector double __b) {
15895   return __builtin_vsx_xvcmpgtdp_p(__CR6_EQ, __b, __a);
15896 }
15897 #endif
15898
15899 /* vec_all_numeric */
15900
15901 static __inline__ int __ATTRS_o_ai
15902 vec_all_numeric(vector float __a) {
15903 #ifdef __VSX__
15904   return __builtin_vsx_xvcmpeqsp_p(__CR6_LT, __a, __a);
15905 #else
15906   return __builtin_altivec_vcmpeqfp_p(__CR6_LT, __a, __a);
15907 #endif
15908 }
15909
15910 #ifdef __VSX__
15911 static __inline__ int __ATTRS_o_ai vec_all_numeric(vector double __a) {
15912   return __builtin_vsx_xvcmpeqdp_p(__CR6_LT, __a, __a);
15913 }
15914 #endif
15915
15916 /* vec_any_eq */
15917
15918 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed char __a,
15919                                               vector signed char __b) {
15920   return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
15921                                       (vector char)__b);
15922 }
15923
15924 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed char __a,
15925                                               vector bool char __b) {
15926   return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
15927                                       (vector char)__b);
15928 }
15929
15930 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned char __a,
15931                                               vector unsigned char __b) {
15932   return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
15933                                       (vector char)__b);
15934 }
15935
15936 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned char __a,
15937                                               vector bool char __b) {
15938   return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
15939                                       (vector char)__b);
15940 }
15941
15942 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool char __a,
15943                                               vector signed char __b) {
15944   return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
15945                                       (vector char)__b);
15946 }
15947
15948 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool char __a,
15949                                               vector unsigned char __b) {
15950   return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
15951                                       (vector char)__b);
15952 }
15953
15954 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool char __a,
15955                                               vector bool char __b) {
15956   return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
15957                                       (vector char)__b);
15958 }
15959
15960 static __inline__ int __ATTRS_o_ai vec_any_eq(vector short __a,
15961                                               vector short __b) {
15962   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, __a, __b);
15963 }
15964
15965 static __inline__ int __ATTRS_o_ai vec_any_eq(vector short __a,
15966                                               vector bool short __b) {
15967   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, __a, (vector short)__b);
15968 }
15969
15970 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned short __a,
15971                                               vector unsigned short __b) {
15972   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
15973                                       (vector short)__b);
15974 }
15975
15976 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned short __a,
15977                                               vector bool short __b) {
15978   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
15979                                       (vector short)__b);
15980 }
15981
15982 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool short __a,
15983                                               vector short __b) {
15984   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
15985                                       (vector short)__b);
15986 }
15987
15988 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool short __a,
15989                                               vector unsigned short __b) {
15990   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
15991                                       (vector short)__b);
15992 }
15993
15994 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool short __a,
15995                                               vector bool short __b) {
15996   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
15997                                       (vector short)__b);
15998 }
15999
16000 static __inline__ int __ATTRS_o_ai vec_any_eq(vector pixel __a,
16001                                               vector pixel __b) {
16002   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
16003                                       (vector short)__b);
16004 }
16005
16006 static __inline__ int __ATTRS_o_ai vec_any_eq(vector int __a, vector int __b) {
16007   return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, __a, __b);
16008 }
16009
16010 static __inline__ int __ATTRS_o_ai vec_any_eq(vector int __a,
16011                                               vector bool int __b) {
16012   return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, __a, (vector int)__b);
16013 }
16014
16015 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned int __a,
16016                                               vector unsigned int __b) {
16017   return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
16018                                       (vector int)__b);
16019 }
16020
16021 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned int __a,
16022                                               vector bool int __b) {
16023   return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
16024                                       (vector int)__b);
16025 }
16026
16027 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool int __a,
16028                                               vector int __b) {
16029   return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
16030                                       (vector int)__b);
16031 }
16032
16033 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool int __a,
16034                                               vector unsigned int __b) {
16035   return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
16036                                       (vector int)__b);
16037 }
16038
16039 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool int __a,
16040                                               vector bool int __b) {
16041   return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
16042                                       (vector int)__b);
16043 }
16044
16045 #ifdef __VSX__
16046 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed long long __a,
16047                                               vector signed long long __b) {
16048   return __builtin_altivec_vcmpequd_p(__CR6_EQ_REV, __a, __b);
16049 }
16050
16051 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned long long __a,
16052                                               vector unsigned long long __b) {
16053   return __builtin_altivec_vcmpequd_p(__CR6_EQ_REV, (vector long long)__a,
16054                                       (vector long long)__b);
16055 }
16056
16057 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed long long __a,
16058                                               vector bool long long __b) {
16059   return __builtin_altivec_vcmpequd_p(__CR6_EQ_REV, __a,
16060                                       (vector signed long long)__b);
16061 }
16062
16063 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned long long __a,
16064                                               vector bool long long __b) {
16065   return __builtin_altivec_vcmpequd_p(
16066       __CR6_EQ_REV, (vector signed long long)__a, (vector signed long long)__b);
16067 }
16068
16069 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool long long __a,
16070                                               vector signed long long __b) {
16071   return __builtin_altivec_vcmpequd_p(
16072       __CR6_EQ_REV, (vector signed long long)__a, (vector signed long long)__b);
16073 }
16074
16075 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool long long __a,
16076                                               vector unsigned long long __b) {
16077   return __builtin_altivec_vcmpequd_p(
16078       __CR6_EQ_REV, (vector signed long long)__a, (vector signed long long)__b);
16079 }
16080
16081 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool long long __a,
16082                                               vector bool long long __b) {
16083   return __builtin_altivec_vcmpequd_p(
16084       __CR6_EQ_REV, (vector signed long long)__a, (vector signed long long)__b);
16085 }
16086 #endif
16087
16088 static __inline__ int __ATTRS_o_ai vec_any_eq(vector float __a,
16089                                               vector float __b) {
16090 #ifdef __VSX__
16091   return __builtin_vsx_xvcmpeqsp_p(__CR6_EQ_REV, __a, __b);
16092 #else
16093   return __builtin_altivec_vcmpeqfp_p(__CR6_EQ_REV, __a, __b);
16094 #endif
16095 }
16096
16097 #ifdef __VSX__
16098 static __inline__ int __ATTRS_o_ai vec_any_eq(vector double __a,
16099                                               vector double __b) {
16100   return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ_REV, __a, __b);
16101 }
16102 #endif
16103
16104 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
16105 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed __int128 __a,
16106                                               vector signed __int128 __b) {
16107   return __builtin_altivec_vcmpequq_p(__CR6_EQ_REV, __a, __b);
16108 }
16109
16110 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned __int128 __a,
16111                                               vector unsigned __int128 __b) {
16112   return __builtin_altivec_vcmpequq_p(__CR6_EQ_REV, __a, __b);
16113 }
16114 #endif
16115
16116 /* vec_any_ge */
16117
16118 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed char __a,
16119                                               vector signed char __b) {
16120   return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, __b, __a);
16121 }
16122
16123 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed char __a,
16124                                               vector bool char __b) {
16125   return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, (vector signed char)__b,
16126                                       __a);
16127 }
16128
16129 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned char __a,
16130                                               vector unsigned char __b) {
16131   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __b, __a);
16132 }
16133
16134 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned char __a,
16135                                               vector bool char __b) {
16136   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__b,
16137                                       __a);
16138 }
16139
16140 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool char __a,
16141                                               vector signed char __b) {
16142   return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, __b,
16143                                       (vector signed char)__a);
16144 }
16145
16146 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool char __a,
16147                                               vector unsigned char __b) {
16148   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __b,
16149                                       (vector unsigned char)__a);
16150 }
16151
16152 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool char __a,
16153                                               vector bool char __b) {
16154   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__b,
16155                                       (vector unsigned char)__a);
16156 }
16157
16158 static __inline__ int __ATTRS_o_ai vec_any_ge(vector short __a,
16159                                               vector short __b) {
16160   return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, __b, __a);
16161 }
16162
16163 static __inline__ int __ATTRS_o_ai vec_any_ge(vector short __a,
16164                                               vector bool short __b) {
16165   return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, (vector short)__b, __a);
16166 }
16167
16168 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned short __a,
16169                                               vector unsigned short __b) {
16170   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __b, __a);
16171 }
16172
16173 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned short __a,
16174                                               vector bool short __b) {
16175   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__b,
16176                                       __a);
16177 }
16178
16179 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool short __a,
16180                                               vector short __b) {
16181   return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, __b,
16182                                       (vector signed short)__a);
16183 }
16184
16185 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool short __a,
16186                                               vector unsigned short __b) {
16187   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __b,
16188                                       (vector unsigned short)__a);
16189 }
16190
16191 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool short __a,
16192                                               vector bool short __b) {
16193   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__b,
16194                                       (vector unsigned short)__a);
16195 }
16196
16197 static __inline__ int __ATTRS_o_ai vec_any_ge(vector int __a, vector int __b) {
16198   return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, __b, __a);
16199 }
16200
16201 static __inline__ int __ATTRS_o_ai vec_any_ge(vector int __a,
16202                                               vector bool int __b) {
16203   return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, (vector int)__b, __a);
16204 }
16205
16206 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned int __a,
16207                                               vector unsigned int __b) {
16208   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __b, __a);
16209 }
16210
16211 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned int __a,
16212                                               vector bool int __b) {
16213   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__b,
16214                                       __a);
16215 }
16216
16217 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool int __a,
16218                                               vector int __b) {
16219   return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, __b,
16220                                       (vector signed int)__a);
16221 }
16222
16223 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool int __a,
16224                                               vector unsigned int __b) {
16225   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __b,
16226                                       (vector unsigned int)__a);
16227 }
16228
16229 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool int __a,
16230                                               vector bool int __b) {
16231   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__b,
16232                                       (vector unsigned int)__a);
16233 }
16234
16235 #ifdef __VSX__
16236 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed long long __a,
16237                                               vector signed long long __b) {
16238   return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV, __b, __a);
16239 }
16240
16241 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned long long __a,
16242                                               vector unsigned long long __b) {
16243   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __b, __a);
16244 }
16245
16246 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed long long __a,
16247                                               vector bool long long __b) {
16248   return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV,
16249                                       (vector signed long long)__b, __a);
16250 }
16251
16252 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned long long __a,
16253                                               vector bool long long __b) {
16254   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
16255                                       (vector unsigned long long)__b, __a);
16256 }
16257
16258 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool long long __a,
16259                                               vector signed long long __b) {
16260   return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV, __b,
16261                                       (vector signed long long)__a);
16262 }
16263
16264 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool long long __a,
16265                                               vector unsigned long long __b) {
16266   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __b,
16267                                       (vector unsigned long long)__a);
16268 }
16269
16270 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool long long __a,
16271                                               vector bool long long __b) {
16272   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
16273                                       (vector unsigned long long)__b,
16274                                       (vector unsigned long long)__a);
16275 }
16276 #endif
16277
16278 static __inline__ int __ATTRS_o_ai vec_any_ge(vector float __a,
16279                                               vector float __b) {
16280 #ifdef __VSX__
16281   return __builtin_vsx_xvcmpgesp_p(__CR6_EQ_REV, __a, __b);
16282 #else
16283   return __builtin_altivec_vcmpgefp_p(__CR6_EQ_REV, __a, __b);
16284 #endif
16285 }
16286
16287 #ifdef __VSX__
16288 static __inline__ int __ATTRS_o_ai vec_any_ge(vector double __a,
16289                                               vector double __b) {
16290   return __builtin_vsx_xvcmpgedp_p(__CR6_EQ_REV, __a, __b);
16291 }
16292 #endif
16293
16294 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
16295 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed __int128 __a,
16296                                               vector signed __int128 __b) {
16297   return __builtin_altivec_vcmpgtsq_p(__CR6_LT_REV, __b, __a);
16298 }
16299
16300 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned __int128 __a,
16301                                               vector unsigned __int128 __b) {
16302   return __builtin_altivec_vcmpgtuq_p(__CR6_LT_REV, __b, __a);
16303 }
16304 #endif
16305
16306 /* vec_any_gt */
16307
16308 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed char __a,
16309                                               vector signed char __b) {
16310   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, __a, __b);
16311 }
16312
16313 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed char __a,
16314                                               vector bool char __b) {
16315   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, __a,
16316                                       (vector signed char)__b);
16317 }
16318
16319 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned char __a,
16320                                               vector unsigned char __b) {
16321   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __a, __b);
16322 }
16323
16324 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned char __a,
16325                                               vector bool char __b) {
16326   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __a,
16327                                       (vector unsigned char)__b);
16328 }
16329
16330 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool char __a,
16331                                               vector signed char __b) {
16332   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, (vector signed char)__a,
16333                                       __b);
16334 }
16335
16336 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool char __a,
16337                                               vector unsigned char __b) {
16338   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__a,
16339                                       __b);
16340 }
16341
16342 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool char __a,
16343                                               vector bool char __b) {
16344   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__a,
16345                                       (vector unsigned char)__b);
16346 }
16347
16348 static __inline__ int __ATTRS_o_ai vec_any_gt(vector short __a,
16349                                               vector short __b) {
16350   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, __a, __b);
16351 }
16352
16353 static __inline__ int __ATTRS_o_ai vec_any_gt(vector short __a,
16354                                               vector bool short __b) {
16355   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, __a, (vector short)__b);
16356 }
16357
16358 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned short __a,
16359                                               vector unsigned short __b) {
16360   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __a, __b);
16361 }
16362
16363 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned short __a,
16364                                               vector bool short __b) {
16365   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __a,
16366                                       (vector unsigned short)__b);
16367 }
16368
16369 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool short __a,
16370                                               vector short __b) {
16371   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, (vector signed short)__a,
16372                                       __b);
16373 }
16374
16375 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool short __a,
16376                                               vector unsigned short __b) {
16377   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__a,
16378                                       __b);
16379 }
16380
16381 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool short __a,
16382                                               vector bool short __b) {
16383   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__a,
16384                                       (vector unsigned short)__b);
16385 }
16386
16387 static __inline__ int __ATTRS_o_ai vec_any_gt(vector int __a, vector int __b) {
16388   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, __a, __b);
16389 }
16390
16391 static __inline__ int __ATTRS_o_ai vec_any_gt(vector int __a,
16392                                               vector bool int __b) {
16393   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, __a, (vector int)__b);
16394 }
16395
16396 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned int __a,
16397                                               vector unsigned int __b) {
16398   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __a, __b);
16399 }
16400
16401 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned int __a,
16402                                               vector bool int __b) {
16403   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __a,
16404                                       (vector unsigned int)__b);
16405 }
16406
16407 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool int __a,
16408                                               vector int __b) {
16409   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, (vector signed int)__a,
16410                                       __b);
16411 }
16412
16413 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool int __a,
16414                                               vector unsigned int __b) {
16415   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__a,
16416                                       __b);
16417 }
16418
16419 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool int __a,
16420                                               vector bool int __b) {
16421   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__a,
16422                                       (vector unsigned int)__b);
16423 }
16424
16425 #ifdef __VSX__
16426 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed long long __a,
16427                                               vector signed long long __b) {
16428   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV, __a, __b);
16429 }
16430
16431 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned long long __a,
16432                                               vector unsigned long long __b) {
16433   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __a, __b);
16434 }
16435
16436 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed long long __a,
16437                                               vector bool long long __b) {
16438   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV, __a,
16439                                       (vector signed long long)__b);
16440 }
16441
16442 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned long long __a,
16443                                               vector bool long long __b) {
16444   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __a,
16445                                       (vector unsigned long long)__b);
16446 }
16447
16448 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool long long __a,
16449                                               vector signed long long __b) {
16450   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV,
16451                                       (vector signed long long)__a, __b);
16452 }
16453
16454 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool long long __a,
16455                                               vector unsigned long long __b) {
16456   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
16457                                       (vector unsigned long long)__a, __b);
16458 }
16459
16460 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool long long __a,
16461                                               vector bool long long __b) {
16462   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
16463                                       (vector unsigned long long)__a,
16464                                       (vector unsigned long long)__b);
16465 }
16466 #endif
16467
16468 static __inline__ int __ATTRS_o_ai vec_any_gt(vector float __a,
16469                                               vector float __b) {
16470 #ifdef __VSX__
16471   return __builtin_vsx_xvcmpgtsp_p(__CR6_EQ_REV, __a, __b);
16472 #else
16473   return __builtin_altivec_vcmpgtfp_p(__CR6_EQ_REV, __a, __b);
16474 #endif
16475 }
16476
16477 #ifdef __VSX__
16478 static __inline__ int __ATTRS_o_ai vec_any_gt(vector double __a,
16479                                               vector double __b) {
16480   return __builtin_vsx_xvcmpgtdp_p(__CR6_EQ_REV, __a, __b);
16481 }
16482 #endif
16483
16484 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
16485 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed __int128 __a,
16486                                               vector signed __int128 __b) {
16487   return __builtin_altivec_vcmpgtsq_p(__CR6_EQ_REV, __a, __b);
16488 }
16489
16490 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned __int128 __a,
16491                                               vector unsigned __int128 __b) {
16492   return __builtin_altivec_vcmpgtuq_p(__CR6_EQ_REV, __a, __b);
16493 }
16494 #endif
16495
16496 /* vec_any_le */
16497
16498 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed char __a,
16499                                               vector signed char __b) {
16500   return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, __a, __b);
16501 }
16502
16503 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed char __a,
16504                                               vector bool char __b) {
16505   return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, __a,
16506                                       (vector signed char)__b);
16507 }
16508
16509 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned char __a,
16510                                               vector unsigned char __b) {
16511   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __a, __b);
16512 }
16513
16514 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned char __a,
16515                                               vector bool char __b) {
16516   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __a,
16517                                       (vector unsigned char)__b);
16518 }
16519
16520 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool char __a,
16521                                               vector signed char __b) {
16522   return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, (vector signed char)__a,
16523                                       __b);
16524 }
16525
16526 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool char __a,
16527                                               vector unsigned char __b) {
16528   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__a,
16529                                       __b);
16530 }
16531
16532 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool char __a,
16533                                               vector bool char __b) {
16534   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__a,
16535                                       (vector unsigned char)__b);
16536 }
16537
16538 static __inline__ int __ATTRS_o_ai vec_any_le(vector short __a,
16539                                               vector short __b) {
16540   return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, __a, __b);
16541 }
16542
16543 static __inline__ int __ATTRS_o_ai vec_any_le(vector short __a,
16544                                               vector bool short __b) {
16545   return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, __a, (vector short)__b);
16546 }
16547
16548 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned short __a,
16549                                               vector unsigned short __b) {
16550   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __a, __b);
16551 }
16552
16553 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned short __a,
16554                                               vector bool short __b) {
16555   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __a,
16556                                       (vector unsigned short)__b);
16557 }
16558
16559 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool short __a,
16560                                               vector short __b) {
16561   return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, (vector signed short)__a,
16562                                       __b);
16563 }
16564
16565 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool short __a,
16566                                               vector unsigned short __b) {
16567   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__a,
16568                                       __b);
16569 }
16570
16571 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool short __a,
16572                                               vector bool short __b) {
16573   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__a,
16574                                       (vector unsigned short)__b);
16575 }
16576
16577 static __inline__ int __ATTRS_o_ai vec_any_le(vector int __a, vector int __b) {
16578   return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, __a, __b);
16579 }
16580
16581 static __inline__ int __ATTRS_o_ai vec_any_le(vector int __a,
16582                                               vector bool int __b) {
16583   return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, __a, (vector int)__b);
16584 }
16585
16586 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned int __a,
16587                                               vector unsigned int __b) {
16588   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __a, __b);
16589 }
16590
16591 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned int __a,
16592                                               vector bool int __b) {
16593   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __a,
16594                                       (vector unsigned int)__b);
16595 }
16596
16597 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool int __a,
16598                                               vector int __b) {
16599   return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, (vector signed int)__a,
16600                                       __b);
16601 }
16602
16603 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool int __a,
16604                                               vector unsigned int __b) {
16605   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__a,
16606                                       __b);
16607 }
16608
16609 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool int __a,
16610                                               vector bool int __b) {
16611   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__a,
16612                                       (vector unsigned int)__b);
16613 }
16614
16615 #ifdef __VSX__
16616 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed long long __a,
16617                                               vector signed long long __b) {
16618   return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV, __a, __b);
16619 }
16620
16621 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned long long __a,
16622                                               vector unsigned long long __b) {
16623   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __a, __b);
16624 }
16625
16626 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed long long __a,
16627                                               vector bool long long __b) {
16628   return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV, __a,
16629                                       (vector signed long long)__b);
16630 }
16631
16632 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned long long __a,
16633                                               vector bool long long __b) {
16634   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __a,
16635                                       (vector unsigned long long)__b);
16636 }
16637
16638 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool long long __a,
16639                                               vector signed long long __b) {
16640   return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV,
16641                                       (vector signed long long)__a, __b);
16642 }
16643
16644 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool long long __a,
16645                                               vector unsigned long long __b) {
16646   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
16647                                       (vector unsigned long long)__a, __b);
16648 }
16649
16650 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool long long __a,
16651                                               vector bool long long __b) {
16652   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
16653                                       (vector unsigned long long)__a,
16654                                       (vector unsigned long long)__b);
16655 }
16656 #endif
16657
16658 static __inline__ int __ATTRS_o_ai vec_any_le(vector float __a,
16659                                               vector float __b) {
16660 #ifdef __VSX__
16661   return __builtin_vsx_xvcmpgesp_p(__CR6_EQ_REV, __b, __a);
16662 #else
16663   return __builtin_altivec_vcmpgefp_p(__CR6_EQ_REV, __b, __a);
16664 #endif
16665 }
16666
16667 #ifdef __VSX__
16668 static __inline__ int __ATTRS_o_ai vec_any_le(vector double __a,
16669                                               vector double __b) {
16670   return __builtin_vsx_xvcmpgedp_p(__CR6_EQ_REV, __b, __a);
16671 }
16672 #endif
16673
16674 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
16675 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed __int128 __a,
16676                                               vector signed __int128 __b) {
16677   return __builtin_altivec_vcmpgtsq_p(__CR6_LT_REV, __a, __b);
16678 }
16679
16680 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned __int128 __a,
16681                                               vector unsigned __int128 __b) {
16682   return __builtin_altivec_vcmpgtuq_p(__CR6_LT_REV, __a, __b);
16683 }
16684 #endif
16685
16686 /* vec_any_lt */
16687
16688 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed char __a,
16689                                               vector signed char __b) {
16690   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, __b, __a);
16691 }
16692
16693 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed char __a,
16694                                               vector bool char __b) {
16695   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, (vector signed char)__b,
16696                                       __a);
16697 }
16698
16699 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned char __a,
16700                                               vector unsigned char __b) {
16701   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __b, __a);
16702 }
16703
16704 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned char __a,
16705                                               vector bool char __b) {
16706   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__b,
16707                                       __a);
16708 }
16709
16710 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool char __a,
16711                                               vector signed char __b) {
16712   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, __b,
16713                                       (vector signed char)__a);
16714 }
16715
16716 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool char __a,
16717                                               vector unsigned char __b) {
16718   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __b,
16719                                       (vector unsigned char)__a);
16720 }
16721
16722 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool char __a,
16723                                               vector bool char __b) {
16724   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__b,
16725                                       (vector unsigned char)__a);
16726 }
16727
16728 static __inline__ int __ATTRS_o_ai vec_any_lt(vector short __a,
16729                                               vector short __b) {
16730   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, __b, __a);
16731 }
16732
16733 static __inline__ int __ATTRS_o_ai vec_any_lt(vector short __a,
16734                                               vector bool short __b) {
16735   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, (vector short)__b, __a);
16736 }
16737
16738 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned short __a,
16739                                               vector unsigned short __b) {
16740   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __b, __a);
16741 }
16742
16743 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned short __a,
16744                                               vector bool short __b) {
16745   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__b,
16746                                       __a);
16747 }
16748
16749 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool short __a,
16750                                               vector short __b) {
16751   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, __b,
16752                                       (vector signed short)__a);
16753 }
16754
16755 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool short __a,
16756                                               vector unsigned short __b) {
16757   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __b,
16758                                       (vector unsigned short)__a);
16759 }
16760
16761 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool short __a,
16762                                               vector bool short __b) {
16763   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__b,
16764                                       (vector unsigned short)__a);
16765 }
16766
16767 static __inline__ int __ATTRS_o_ai vec_any_lt(vector int __a, vector int __b) {
16768   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, __b, __a);
16769 }
16770
16771 static __inline__ int __ATTRS_o_ai vec_any_lt(vector int __a,
16772                                               vector bool int __b) {
16773   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, (vector int)__b, __a);
16774 }
16775
16776 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned int __a,
16777                                               vector unsigned int __b) {
16778   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __b, __a);
16779 }
16780
16781 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned int __a,
16782                                               vector bool int __b) {
16783   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__b,
16784                                       __a);
16785 }
16786
16787 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool int __a,
16788                                               vector int __b) {
16789   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, __b,
16790                                       (vector signed int)__a);
16791 }
16792
16793 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool int __a,
16794                                               vector unsigned int __b) {
16795   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __b,
16796                                       (vector unsigned int)__a);
16797 }
16798
16799 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool int __a,
16800                                               vector bool int __b) {
16801   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__b,
16802                                       (vector unsigned int)__a);
16803 }
16804
16805 #ifdef __VSX__
16806 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed long long __a,
16807                                               vector signed long long __b) {
16808   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV, __b, __a);
16809 }
16810
16811 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned long long __a,
16812                                               vector unsigned long long __b) {
16813   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __b, __a);
16814 }
16815
16816 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed long long __a,
16817                                               vector bool long long __b) {
16818   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV,
16819                                       (vector signed long long)__b, __a);
16820 }
16821
16822 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned long long __a,
16823                                               vector bool long long __b) {
16824   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
16825                                       (vector unsigned long long)__b, __a);
16826 }
16827
16828 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool long long __a,
16829                                               vector signed long long __b) {
16830   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV, __b,
16831                                       (vector signed long long)__a);
16832 }
16833
16834 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool long long __a,
16835                                               vector unsigned long long __b) {
16836   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __b,
16837                                       (vector unsigned long long)__a);
16838 }
16839
16840 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool long long __a,
16841                                               vector bool long long __b) {
16842   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
16843                                       (vector unsigned long long)__b,
16844                                       (vector unsigned long long)__a);
16845 }
16846 #endif
16847
16848 static __inline__ int __ATTRS_o_ai vec_any_lt(vector float __a,
16849                                               vector float __b) {
16850 #ifdef __VSX__
16851   return __builtin_vsx_xvcmpgtsp_p(__CR6_EQ_REV, __b, __a);
16852 #else
16853   return __builtin_altivec_vcmpgtfp_p(__CR6_EQ_REV, __b, __a);
16854 #endif
16855 }
16856
16857 #ifdef __VSX__
16858 static __inline__ int __ATTRS_o_ai vec_any_lt(vector double __a,
16859                                               vector double __b) {
16860   return __builtin_vsx_xvcmpgtdp_p(__CR6_EQ_REV, __b, __a);
16861 }
16862 #endif
16863
16864 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
16865 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed __int128 __a,
16866                                               vector signed __int128 __b) {
16867   return __builtin_altivec_vcmpgtsq_p(__CR6_EQ_REV, __b, __a);
16868 }
16869
16870 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned __int128 __a,
16871                                               vector unsigned __int128 __b) {
16872   return __builtin_altivec_vcmpgtuq_p(__CR6_EQ_REV, __b, __a);
16873 }
16874 #endif
16875
16876 /* vec_any_nan */
16877
16878 static __inline__ int __ATTRS_o_ai vec_any_nan(vector float __a) {
16879 #ifdef __VSX__
16880   return __builtin_vsx_xvcmpeqsp_p(__CR6_LT_REV, __a, __a);
16881 #else
16882   return __builtin_altivec_vcmpeqfp_p(__CR6_LT_REV, __a, __a);
16883 #endif
16884 }
16885 #ifdef __VSX__
16886 static __inline__ int __ATTRS_o_ai vec_any_nan(vector double __a) {
16887   return __builtin_vsx_xvcmpeqdp_p(__CR6_LT_REV, __a, __a);
16888 }
16889 #endif
16890
16891 /* vec_any_ne */
16892
16893 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed char __a,
16894                                               vector signed char __b) {
16895   return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
16896                                       (vector char)__b);
16897 }
16898
16899 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed char __a,
16900                                               vector bool char __b) {
16901   return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
16902                                       (vector char)__b);
16903 }
16904
16905 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned char __a,
16906                                               vector unsigned char __b) {
16907   return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
16908                                       (vector char)__b);
16909 }
16910
16911 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned char __a,
16912                                               vector bool char __b) {
16913   return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
16914                                       (vector char)__b);
16915 }
16916
16917 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool char __a,
16918                                               vector signed char __b) {
16919   return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
16920                                       (vector char)__b);
16921 }
16922
16923 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool char __a,
16924                                               vector unsigned char __b) {
16925   return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
16926                                       (vector char)__b);
16927 }
16928
16929 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool char __a,
16930                                               vector bool char __b) {
16931   return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
16932                                       (vector char)__b);
16933 }
16934
16935 static __inline__ int __ATTRS_o_ai vec_any_ne(vector short __a,
16936                                               vector short __b) {
16937   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, __a, __b);
16938 }
16939
16940 static __inline__ int __ATTRS_o_ai vec_any_ne(vector short __a,
16941                                               vector bool short __b) {
16942   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, __a, (vector short)__b);
16943 }
16944
16945 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned short __a,
16946                                               vector unsigned short __b) {
16947   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
16948                                       (vector short)__b);
16949 }
16950
16951 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned short __a,
16952                                               vector bool short __b) {
16953   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
16954                                       (vector short)__b);
16955 }
16956
16957 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool short __a,
16958                                               vector short __b) {
16959   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
16960                                       (vector short)__b);
16961 }
16962
16963 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool short __a,
16964                                               vector unsigned short __b) {
16965   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
16966                                       (vector short)__b);
16967 }
16968
16969 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool short __a,
16970                                               vector bool short __b) {
16971   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
16972                                       (vector short)__b);
16973 }
16974
16975 static __inline__ int __ATTRS_o_ai vec_any_ne(vector pixel __a,
16976                                               vector pixel __b) {
16977   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
16978                                       (vector short)__b);
16979 }
16980
16981 static __inline__ int __ATTRS_o_ai vec_any_ne(vector int __a, vector int __b) {
16982   return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, __a, __b);
16983 }
16984
16985 static __inline__ int __ATTRS_o_ai vec_any_ne(vector int __a,
16986                                               vector bool int __b) {
16987   return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, __a, (vector int)__b);
16988 }
16989
16990 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned int __a,
16991                                               vector unsigned int __b) {
16992   return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
16993                                       (vector int)__b);
16994 }
16995
16996 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned int __a,
16997                                               vector bool int __b) {
16998   return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
16999                                       (vector int)__b);
17000 }
17001
17002 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool int __a,
17003                                               vector int __b) {
17004   return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
17005                                       (vector int)__b);
17006 }
17007
17008 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool int __a,
17009                                               vector unsigned int __b) {
17010   return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
17011                                       (vector int)__b);
17012 }
17013
17014 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool int __a,
17015                                               vector bool int __b) {
17016   return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
17017                                       (vector int)__b);
17018 }
17019
17020 #ifdef __VSX__
17021 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed long long __a,
17022                                               vector signed long long __b) {
17023   return __builtin_altivec_vcmpequd_p(__CR6_LT_REV, __a, __b);
17024 }
17025
17026 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned long long __a,
17027                                               vector unsigned long long __b) {
17028   return __builtin_altivec_vcmpequd_p(__CR6_LT_REV, (vector long long)__a,
17029                                       (vector long long)__b);
17030 }
17031
17032 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed long long __a,
17033                                               vector bool long long __b) {
17034   return __builtin_altivec_vcmpequd_p(__CR6_LT_REV, __a,
17035                                       (vector signed long long)__b);
17036 }
17037
17038 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned long long __a,
17039                                               vector bool long long __b) {
17040   return __builtin_altivec_vcmpequd_p(
17041       __CR6_LT_REV, (vector signed long long)__a, (vector signed long long)__b);
17042 }
17043
17044 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool long long __a,
17045                                               vector signed long long __b) {
17046   return __builtin_altivec_vcmpequd_p(
17047       __CR6_LT_REV, (vector signed long long)__a, (vector signed long long)__b);
17048 }
17049
17050 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool long long __a,
17051                                               vector unsigned long long __b) {
17052   return __builtin_altivec_vcmpequd_p(
17053       __CR6_LT_REV, (vector signed long long)__a, (vector signed long long)__b);
17054 }
17055
17056 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool long long __a,
17057                                               vector bool long long __b) {
17058   return __builtin_altivec_vcmpequd_p(
17059       __CR6_LT_REV, (vector signed long long)__a, (vector signed long long)__b);
17060 }
17061 #endif
17062
17063 static __inline__ int __ATTRS_o_ai vec_any_ne(vector float __a,
17064                                               vector float __b) {
17065 #ifdef __VSX__
17066   return __builtin_vsx_xvcmpeqsp_p(__CR6_LT_REV, __a, __b);
17067 #else
17068   return __builtin_altivec_vcmpeqfp_p(__CR6_LT_REV, __a, __b);
17069 #endif
17070 }
17071
17072 #ifdef __VSX__
17073 static __inline__ int __ATTRS_o_ai vec_any_ne(vector double __a,
17074                                               vector double __b) {
17075   return __builtin_vsx_xvcmpeqdp_p(__CR6_LT_REV, __a, __b);
17076 }
17077 #endif
17078
17079 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
17080 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed __int128 __a,
17081                                               vector signed __int128 __b) {
17082   return __builtin_altivec_vcmpequq_p(__CR6_LT_REV, __a, __b);
17083 }
17084
17085 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned __int128 __a,
17086                                               vector unsigned __int128 __b) {
17087   return __builtin_altivec_vcmpequq_p(__CR6_LT_REV, __a, __b);
17088 }
17089 #endif
17090
17091 /* vec_any_nge */
17092
17093 static __inline__ int __ATTRS_o_ai vec_any_nge(vector float __a,
17094                                                vector float __b) {
17095 #ifdef __VSX__
17096   return __builtin_vsx_xvcmpgesp_p(__CR6_LT_REV, __a, __b);
17097 #else
17098   return __builtin_altivec_vcmpgefp_p(__CR6_LT_REV, __a, __b);
17099 #endif
17100 }
17101
17102 #ifdef __VSX__
17103 static __inline__ int __ATTRS_o_ai vec_any_nge(vector double __a,
17104                                                vector double __b) {
17105   return __builtin_vsx_xvcmpgedp_p(__CR6_LT_REV, __a, __b);
17106 }
17107 #endif
17108
17109 /* vec_any_ngt */
17110
17111 static __inline__ int __ATTRS_o_ai vec_any_ngt(vector float __a,
17112                                                vector float __b) {
17113 #ifdef __VSX__
17114   return __builtin_vsx_xvcmpgtsp_p(__CR6_LT_REV, __a, __b);
17115 #else
17116   return __builtin_altivec_vcmpgtfp_p(__CR6_LT_REV, __a, __b);
17117 #endif
17118 }
17119
17120 #ifdef __VSX__
17121 static __inline__ int __ATTRS_o_ai vec_any_ngt(vector double __a,
17122                                                vector double __b) {
17123   return __builtin_vsx_xvcmpgtdp_p(__CR6_LT_REV, __a, __b);
17124 }
17125 #endif
17126
17127 /* vec_any_nle */
17128
17129 static __inline__ int __ATTRS_o_ai vec_any_nle(vector float __a,
17130                                                vector float __b) {
17131 #ifdef __VSX__
17132   return __builtin_vsx_xvcmpgesp_p(__CR6_LT_REV, __b, __a);
17133 #else
17134   return __builtin_altivec_vcmpgefp_p(__CR6_LT_REV, __b, __a);
17135 #endif
17136 }
17137
17138 #ifdef __VSX__
17139 static __inline__ int __ATTRS_o_ai vec_any_nle(vector double __a,
17140                                                vector double __b) {
17141   return __builtin_vsx_xvcmpgedp_p(__CR6_LT_REV, __b, __a);
17142 }
17143 #endif
17144
17145 /* vec_any_nlt */
17146
17147 static __inline__ int __ATTRS_o_ai vec_any_nlt(vector float __a,
17148                                                vector float __b) {
17149 #ifdef __VSX__
17150   return __builtin_vsx_xvcmpgtsp_p(__CR6_LT_REV, __b, __a);
17151 #else
17152   return __builtin_altivec_vcmpgtfp_p(__CR6_LT_REV, __b, __a);
17153 #endif
17154 }
17155
17156 #ifdef __VSX__
17157 static __inline__ int __ATTRS_o_ai vec_any_nlt(vector double __a,
17158                                                vector double __b) {
17159   return __builtin_vsx_xvcmpgtdp_p(__CR6_LT_REV, __b, __a);
17160 }
17161 #endif
17162
17163 /* vec_any_numeric */
17164
17165 static __inline__ int __ATTRS_o_ai vec_any_numeric(vector float __a) {
17166 #ifdef __VSX__
17167   return __builtin_vsx_xvcmpeqsp_p(__CR6_EQ_REV, __a, __a);
17168 #else
17169   return __builtin_altivec_vcmpeqfp_p(__CR6_EQ_REV, __a, __a);
17170 #endif
17171 }
17172
17173 #ifdef __VSX__
17174 static __inline__ int __ATTRS_o_ai vec_any_numeric(vector double __a) {
17175   return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ_REV, __a, __a);
17176 }
17177 #endif
17178
17179 /* vec_any_out */
17180
17181 static __inline__ int __attribute__((__always_inline__))
17182 vec_any_out(vector float __a, vector float __b) {
17183   return __builtin_altivec_vcmpbfp_p(__CR6_EQ_REV, __a, __b);
17184 }
17185
17186 /* Power 8 Crypto functions
17187 Note: We diverge from the current GCC implementation with regard
17188 to cryptography and related functions as follows:
17189 - Only the SHA and AES instructions and builtins are disabled by -mno-crypto
17190 - The remaining ones are only available on Power8 and up so
17191   require -mpower8-vector
17192 The justification for this is that export requirements require that
17193 Category:Vector.Crypto is optional (i.e. compliant hardware may not provide
17194 support). As a result, we need to be able to turn off support for those.
17195 The remaining ones (currently controlled by -mcrypto for GCC) still
17196 need to be provided on compliant hardware even if Vector.Crypto is not
17197 provided.
17198 */
17199 #ifdef __CRYPTO__
17200 #define vec_sbox_be __builtin_altivec_crypto_vsbox
17201 #define vec_cipher_be __builtin_altivec_crypto_vcipher
17202 #define vec_cipherlast_be __builtin_altivec_crypto_vcipherlast
17203 #define vec_ncipher_be __builtin_altivec_crypto_vncipher
17204 #define vec_ncipherlast_be __builtin_altivec_crypto_vncipherlast
17205
17206 static __inline__ vector unsigned long long __attribute__((__always_inline__))
17207 __builtin_crypto_vsbox(vector unsigned long long __a) {
17208   return __builtin_altivec_crypto_vsbox(__a);
17209 }
17210
17211 static __inline__ vector unsigned long long __attribute__((__always_inline__))
17212 __builtin_crypto_vcipher(vector unsigned long long __a,
17213                          vector unsigned long long __b) {
17214   return __builtin_altivec_crypto_vcipher(__a, __b);
17215 }
17216
17217 static __inline__ vector unsigned long long __attribute__((__always_inline__))
17218 __builtin_crypto_vcipherlast(vector unsigned long long __a,
17219                              vector unsigned long long __b) {
17220   return __builtin_altivec_crypto_vcipherlast(__a, __b);
17221 }
17222
17223 static __inline__ vector unsigned long long __attribute__((__always_inline__))
17224 __builtin_crypto_vncipher(vector unsigned long long __a,
17225                           vector unsigned long long __b) {
17226   return __builtin_altivec_crypto_vncipher(__a, __b);
17227 }
17228
17229 static __inline__ vector unsigned long long __attribute__((__always_inline__))
17230 __builtin_crypto_vncipherlast(vector unsigned long long __a,
17231                               vector unsigned long long __b) {
17232   return __builtin_altivec_crypto_vncipherlast(__a, __b);
17233 }
17234
17235 #define __builtin_crypto_vshasigmad __builtin_altivec_crypto_vshasigmad
17236 #define __builtin_crypto_vshasigmaw __builtin_altivec_crypto_vshasigmaw
17237
17238 #define vec_shasigma_be(X, Y, Z)                                               \
17239   _Generic((X), vector unsigned int                                            \
17240            : __builtin_crypto_vshasigmaw, vector unsigned long long            \
17241            : __builtin_crypto_vshasigmad)((X), (Y), (Z))
17242 #endif
17243
17244 #ifdef __POWER8_VECTOR__
17245 static __inline__ vector bool char __ATTRS_o_ai
17246 vec_permxor(vector bool char __a, vector bool char __b,
17247             vector bool char __c) {
17248   return __builtin_altivec_crypto_vpermxor(__a, __b, __c);
17249 }
17250
17251 static __inline__ vector signed char __ATTRS_o_ai
17252 vec_permxor(vector signed char __a, vector signed char __b,
17253             vector signed char __c) {
17254   return __builtin_altivec_crypto_vpermxor(__a, __b, __c);
17255 }
17256
17257 static __inline__ vector unsigned char __ATTRS_o_ai
17258 vec_permxor(vector unsigned char __a, vector unsigned char __b,
17259             vector unsigned char __c) {
17260   return __builtin_altivec_crypto_vpermxor(__a, __b, __c);
17261 }
17262
17263 static __inline__ vector unsigned char __ATTRS_o_ai
17264 __builtin_crypto_vpermxor(vector unsigned char __a, vector unsigned char __b,
17265                           vector unsigned char __c) {
17266   return __builtin_altivec_crypto_vpermxor(__a, __b, __c);
17267 }
17268
17269 static __inline__ vector unsigned short __ATTRS_o_ai
17270 __builtin_crypto_vpermxor(vector unsigned short __a, vector unsigned short __b,
17271                           vector unsigned short __c) {
17272   return (vector unsigned short)__builtin_altivec_crypto_vpermxor(
17273       (vector unsigned char)__a, (vector unsigned char)__b,
17274       (vector unsigned char)__c);
17275 }
17276
17277 static __inline__ vector unsigned int __ATTRS_o_ai __builtin_crypto_vpermxor(
17278     vector unsigned int __a, vector unsigned int __b, vector unsigned int __c) {
17279   return (vector unsigned int)__builtin_altivec_crypto_vpermxor(
17280       (vector unsigned char)__a, (vector unsigned char)__b,
17281       (vector unsigned char)__c);
17282 }
17283
17284 static __inline__ vector unsigned long long __ATTRS_o_ai
17285 __builtin_crypto_vpermxor(vector unsigned long long __a,
17286                           vector unsigned long long __b,
17287                           vector unsigned long long __c) {
17288   return (vector unsigned long long)__builtin_altivec_crypto_vpermxor(
17289       (vector unsigned char)__a, (vector unsigned char)__b,
17290       (vector unsigned char)__c);
17291 }
17292
17293 static __inline__ vector unsigned char __ATTRS_o_ai
17294 __builtin_crypto_vpmsumb(vector unsigned char __a, vector unsigned char __b) {
17295   return __builtin_altivec_crypto_vpmsumb(__a, __b);
17296 }
17297
17298 static __inline__ vector unsigned short __ATTRS_o_ai
17299 __builtin_crypto_vpmsumb(vector unsigned short __a, vector unsigned short __b) {
17300   return __builtin_altivec_crypto_vpmsumh(__a, __b);
17301 }
17302
17303 static __inline__ vector unsigned int __ATTRS_o_ai
17304 __builtin_crypto_vpmsumb(vector unsigned int __a, vector unsigned int __b) {
17305   return __builtin_altivec_crypto_vpmsumw(__a, __b);
17306 }
17307
17308 static __inline__ vector unsigned long long __ATTRS_o_ai
17309 __builtin_crypto_vpmsumb(vector unsigned long long __a,
17310                          vector unsigned long long __b) {
17311   return __builtin_altivec_crypto_vpmsumd(__a, __b);
17312 }
17313
17314 static __inline__ vector signed char __ATTRS_o_ai
17315 vec_vgbbd(vector signed char __a) {
17316   return __builtin_altivec_vgbbd((vector unsigned char)__a);
17317 }
17318
17319 #define vec_pmsum_be __builtin_crypto_vpmsumb
17320 #define vec_gb __builtin_altivec_vgbbd
17321
17322 static __inline__ vector unsigned char __ATTRS_o_ai
17323 vec_vgbbd(vector unsigned char __a) {
17324   return __builtin_altivec_vgbbd(__a);
17325 }
17326
17327 static __inline__ vector signed long long __ATTRS_o_ai
17328 vec_gbb(vector signed long long __a) {
17329   return __builtin_altivec_vgbbd((vector unsigned char)__a);
17330 }
17331
17332 static __inline__ vector unsigned long long __ATTRS_o_ai
17333 vec_gbb(vector unsigned long long __a) {
17334   return __builtin_altivec_vgbbd((vector unsigned char)__a);
17335 }
17336
17337 static __inline__ vector long long __ATTRS_o_ai
17338 vec_vbpermq(vector signed char __a, vector signed char __b) {
17339   return __builtin_altivec_vbpermq((vector unsigned char)__a,
17340                                    (vector unsigned char)__b);
17341 }
17342
17343 static __inline__ vector long long __ATTRS_o_ai
17344 vec_vbpermq(vector unsigned char __a, vector unsigned char __b) {
17345   return __builtin_altivec_vbpermq(__a, __b);
17346 }
17347
17348 #if defined(__powerpc64__) && defined(__SIZEOF_INT128__)
17349 static __inline__ vector unsigned long long __attribute__((__always_inline__))
17350 vec_bperm(vector unsigned __int128 __a, vector unsigned char __b) {
17351   return __builtin_altivec_vbpermq((vector unsigned char)__a,
17352                                    (vector unsigned char)__b);
17353 }
17354 #endif
17355 #endif
17356
17357
17358 /* vec_reve */
17359
17360 static inline __ATTRS_o_ai vector bool char vec_reve(vector bool char __a) {
17361   return __builtin_shufflevector(__a, __a, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6,
17362                                  5, 4, 3, 2, 1, 0);
17363 }
17364
17365 static inline __ATTRS_o_ai vector signed char vec_reve(vector signed char __a) {
17366   return __builtin_shufflevector(__a, __a, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6,
17367                                  5, 4, 3, 2, 1, 0);
17368 }
17369
17370 static inline __ATTRS_o_ai vector unsigned char
17371 vec_reve(vector unsigned char __a) {
17372   return __builtin_shufflevector(__a, __a, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6,
17373                                  5, 4, 3, 2, 1, 0);
17374 }
17375
17376 static inline __ATTRS_o_ai vector bool int vec_reve(vector bool int __a) {
17377   return __builtin_shufflevector(__a, __a, 3, 2, 1, 0);
17378 }
17379
17380 static inline __ATTRS_o_ai vector signed int vec_reve(vector signed int __a) {
17381   return __builtin_shufflevector(__a, __a, 3, 2, 1, 0);
17382 }
17383
17384 static inline __ATTRS_o_ai vector unsigned int
17385 vec_reve(vector unsigned int __a) {
17386   return __builtin_shufflevector(__a, __a, 3, 2, 1, 0);
17387 }
17388
17389 static inline __ATTRS_o_ai vector bool short vec_reve(vector bool short __a) {
17390   return __builtin_shufflevector(__a, __a, 7, 6, 5, 4, 3, 2, 1, 0);
17391 }
17392
17393 static inline __ATTRS_o_ai vector signed short
17394 vec_reve(vector signed short __a) {
17395   return __builtin_shufflevector(__a, __a, 7, 6, 5, 4, 3, 2, 1, 0);
17396 }
17397
17398 static inline __ATTRS_o_ai vector unsigned short
17399 vec_reve(vector unsigned short __a) {
17400   return __builtin_shufflevector(__a, __a, 7, 6, 5, 4, 3, 2, 1, 0);
17401 }
17402
17403 static inline __ATTRS_o_ai vector float vec_reve(vector float __a) {
17404   return __builtin_shufflevector(__a, __a, 3, 2, 1, 0);
17405 }
17406
17407 #ifdef __VSX__
17408 static inline __ATTRS_o_ai vector bool long long
17409 vec_reve(vector bool long long __a) {
17410   return __builtin_shufflevector(__a, __a, 1, 0);
17411 }
17412
17413 static inline __ATTRS_o_ai vector signed long long
17414 vec_reve(vector signed long long __a) {
17415   return __builtin_shufflevector(__a, __a, 1, 0);
17416 }
17417
17418 static inline __ATTRS_o_ai vector unsigned long long
17419 vec_reve(vector unsigned long long __a) {
17420   return __builtin_shufflevector(__a, __a, 1, 0);
17421 }
17422
17423 static inline __ATTRS_o_ai vector double vec_reve(vector double __a) {
17424   return __builtin_shufflevector(__a, __a, 1, 0);
17425 }
17426 #endif
17427
17428 /* vec_revb */
17429 static __inline__ vector bool char __ATTRS_o_ai
17430 vec_revb(vector bool char __a) {
17431   return __a;
17432 }
17433
17434 static __inline__ vector signed char __ATTRS_o_ai
17435 vec_revb(vector signed char __a) {
17436   return __a;
17437 }
17438
17439 static __inline__ vector unsigned char __ATTRS_o_ai
17440 vec_revb(vector unsigned char __a) {
17441   return __a;
17442 }
17443
17444 static __inline__ vector bool short __ATTRS_o_ai
17445 vec_revb(vector bool short __a) {
17446   vector unsigned char __indices =
17447       { 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14 };
17448   return vec_perm(__a, __a, __indices);
17449 }
17450
17451 static __inline__ vector signed short __ATTRS_o_ai
17452 vec_revb(vector signed short __a) {
17453   vector unsigned char __indices =
17454       { 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14 };
17455   return vec_perm(__a, __a, __indices);
17456 }
17457
17458 static __inline__ vector unsigned short __ATTRS_o_ai
17459 vec_revb(vector unsigned short __a) {
17460   vector unsigned char __indices =
17461      { 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14 };
17462   return vec_perm(__a, __a, __indices);
17463 }
17464
17465 static __inline__ vector bool int __ATTRS_o_ai
17466 vec_revb(vector bool int __a) {
17467   vector unsigned char __indices =
17468       { 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12 };
17469   return vec_perm(__a, __a, __indices);
17470 }
17471
17472 static __inline__ vector signed int __ATTRS_o_ai
17473 vec_revb(vector signed int __a) {
17474   vector unsigned char __indices =
17475       { 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12 };
17476   return vec_perm(__a, __a, __indices);
17477 }
17478
17479 static __inline__ vector unsigned int __ATTRS_o_ai
17480 vec_revb(vector unsigned int __a) {
17481   vector unsigned char __indices =
17482       { 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12 };
17483   return vec_perm(__a, __a, __indices);
17484 }
17485
17486 static __inline__ vector float __ATTRS_o_ai
17487 vec_revb(vector float __a) {
17488  vector unsigned char __indices =
17489       { 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12 };
17490  return vec_perm(__a, __a, __indices);
17491 }
17492
17493 #ifdef __VSX__
17494 static __inline__ vector bool long long __ATTRS_o_ai
17495 vec_revb(vector bool long long __a) {
17496   vector unsigned char __indices =
17497       { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8 };
17498   return vec_perm(__a, __a, __indices);
17499 }
17500
17501 static __inline__ vector signed long long __ATTRS_o_ai
17502 vec_revb(vector signed long long __a) {
17503   vector unsigned char __indices =
17504       { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8 };
17505   return vec_perm(__a, __a, __indices);
17506 }
17507
17508 static __inline__ vector unsigned long long __ATTRS_o_ai
17509 vec_revb(vector unsigned long long __a) {
17510   vector unsigned char __indices =
17511       { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8 };
17512   return vec_perm(__a, __a, __indices);
17513 }
17514
17515 static __inline__ vector double __ATTRS_o_ai
17516 vec_revb(vector double __a) {
17517   vector unsigned char __indices =
17518       { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8 };
17519   return vec_perm(__a, __a, __indices);
17520 }
17521 #endif /* End __VSX__ */
17522
17523 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__) &&                    \
17524     defined(__SIZEOF_INT128__)
17525 static __inline__ vector signed __int128 __ATTRS_o_ai
17526 vec_revb(vector signed __int128 __a) {
17527   vector unsigned char __indices =
17528       { 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
17529   return (vector signed __int128)vec_perm((vector signed int)__a,
17530                                           (vector signed int)__a,
17531                                            __indices);
17532 }
17533
17534 static __inline__ vector unsigned __int128 __ATTRS_o_ai
17535 vec_revb(vector unsigned __int128 __a) {
17536   vector unsigned char __indices =
17537       { 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
17538   return (vector unsigned __int128)vec_perm((vector signed int)__a,
17539                                             (vector signed int)__a,
17540                                              __indices);
17541 }
17542 #endif /* END __POWER8_VECTOR__ && __powerpc64__ */
17543
17544 /* vec_xl */
17545
17546 #define vec_xld2 vec_xl
17547 #define vec_xlw4 vec_xl
17548 typedef vector signed char unaligned_vec_schar __attribute__((aligned(1)));
17549 typedef vector unsigned char unaligned_vec_uchar __attribute__((aligned(1)));
17550 typedef vector signed short unaligned_vec_sshort __attribute__((aligned(1)));
17551 typedef vector unsigned short unaligned_vec_ushort __attribute__((aligned(1)));
17552 typedef vector signed int unaligned_vec_sint __attribute__((aligned(1)));
17553 typedef vector unsigned int unaligned_vec_uint __attribute__((aligned(1)));
17554 typedef vector float unaligned_vec_float __attribute__((aligned(1)));
17555
17556 static inline __ATTRS_o_ai vector signed char vec_xl(ptrdiff_t __offset,
17557                                                      const signed char *__ptr) {
17558   return *(unaligned_vec_schar *)(__ptr + __offset);
17559 }
17560
17561 static inline __ATTRS_o_ai vector unsigned char
17562 vec_xl(ptrdiff_t __offset, const unsigned char *__ptr) {
17563   return *(unaligned_vec_uchar*)(__ptr + __offset);
17564 }
17565
17566 static inline __ATTRS_o_ai vector signed short
17567 vec_xl(ptrdiff_t __offset, const signed short *__ptr) {
17568   signed char *__addr = (signed char *)__ptr + __offset;
17569   return *(unaligned_vec_sshort *)__addr;
17570 }
17571
17572 static inline __ATTRS_o_ai vector unsigned short
17573 vec_xl(ptrdiff_t __offset, const unsigned short *__ptr) {
17574   signed char *__addr = (signed char *)__ptr + __offset;
17575   return *(unaligned_vec_ushort *)__addr;
17576 }
17577
17578 static inline __ATTRS_o_ai vector signed int vec_xl(ptrdiff_t __offset,
17579                                                     const signed int *__ptr) {
17580   signed char *__addr = (signed char *)__ptr + __offset;
17581   return *(unaligned_vec_sint *)__addr;
17582 }
17583
17584 static inline __ATTRS_o_ai vector unsigned int
17585 vec_xl(ptrdiff_t __offset, const unsigned int *__ptr) {
17586   signed char *__addr = (signed char *)__ptr + __offset;
17587   return *(unaligned_vec_uint *)__addr;
17588 }
17589
17590 static inline __ATTRS_o_ai vector float vec_xl(ptrdiff_t __offset,
17591                                                const float *__ptr) {
17592   signed char *__addr = (signed char *)__ptr + __offset;
17593   return *(unaligned_vec_float *)__addr;
17594 }
17595
17596 #ifdef __VSX__
17597 typedef vector signed long long unaligned_vec_sll __attribute__((aligned(1)));
17598 typedef vector unsigned long long unaligned_vec_ull __attribute__((aligned(1)));
17599 typedef vector double unaligned_vec_double __attribute__((aligned(1)));
17600
17601 static inline __ATTRS_o_ai vector signed long long
17602 vec_xl(ptrdiff_t __offset, const signed long long *__ptr) {
17603   signed char *__addr = (signed char *)__ptr + __offset;
17604   return *(unaligned_vec_sll *)__addr;
17605 }
17606
17607 static inline __ATTRS_o_ai vector unsigned long long
17608 vec_xl(ptrdiff_t __offset, const unsigned long long *__ptr) {
17609   signed char *__addr = (signed char *)__ptr + __offset;
17610   return *(unaligned_vec_ull *)__addr;
17611 }
17612
17613 static inline __ATTRS_o_ai vector double vec_xl(ptrdiff_t __offset,
17614                                                 const double *__ptr) {
17615   signed char *__addr = (signed char *)__ptr + __offset;
17616   return *(unaligned_vec_double *)__addr;
17617 }
17618 #endif
17619
17620 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__) &&                    \
17621     defined(__SIZEOF_INT128__)
17622 typedef vector signed __int128 unaligned_vec_si128 __attribute__((aligned(1)));
17623 typedef vector unsigned __int128 unaligned_vec_ui128
17624     __attribute__((aligned(1)));
17625 static inline __ATTRS_o_ai vector signed __int128
17626 vec_xl(ptrdiff_t __offset, const signed __int128 *__ptr) {
17627   signed char *__addr = (signed char *)__ptr + __offset;
17628   return *(unaligned_vec_si128 *)__addr;
17629 }
17630
17631 static inline __ATTRS_o_ai vector unsigned __int128
17632 vec_xl(ptrdiff_t __offset, const unsigned __int128 *__ptr) {
17633   signed char *__addr = (signed char *)__ptr + __offset;
17634   return *(unaligned_vec_ui128 *)__addr;
17635 }
17636 #endif
17637
17638 /* vec_xl_be */
17639
17640 #ifdef __LITTLE_ENDIAN__
17641 static __inline__ vector signed char __ATTRS_o_ai
17642 vec_xl_be(ptrdiff_t __offset, const signed char *__ptr) {
17643   vector signed char __vec = (vector signed char)__builtin_vsx_lxvd2x_be(__offset, __ptr);
17644   return __builtin_shufflevector(__vec, __vec, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14,
17645                                  13, 12, 11, 10, 9, 8);
17646 }
17647
17648 static __inline__ vector unsigned char __ATTRS_o_ai
17649 vec_xl_be(ptrdiff_t __offset, const unsigned char *__ptr) {
17650   vector unsigned char __vec = (vector unsigned char)__builtin_vsx_lxvd2x_be(__offset, __ptr);
17651   return __builtin_shufflevector(__vec, __vec, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14,
17652                                  13, 12, 11, 10, 9, 8);
17653 }
17654
17655 static __inline__ vector signed short __ATTRS_o_ai
17656 vec_xl_be(ptrdiff_t __offset, const signed short *__ptr) {
17657   vector signed short __vec = (vector signed short)__builtin_vsx_lxvd2x_be(__offset, __ptr);
17658   return __builtin_shufflevector(__vec, __vec, 3, 2, 1, 0, 7, 6, 5, 4);
17659 }
17660
17661 static __inline__ vector unsigned short __ATTRS_o_ai
17662 vec_xl_be(ptrdiff_t __offset, const unsigned short *__ptr) {
17663   vector unsigned short __vec = (vector unsigned short)__builtin_vsx_lxvd2x_be(__offset, __ptr);
17664   return __builtin_shufflevector(__vec, __vec, 3, 2, 1, 0, 7, 6, 5, 4);
17665 }
17666
17667 static __inline__ vector signed int __ATTRS_o_ai
17668 vec_xl_be(signed long long  __offset, const signed int *__ptr) {
17669   return (vector signed int)__builtin_vsx_lxvw4x_be(__offset, __ptr);
17670 }
17671
17672 static __inline__ vector unsigned int __ATTRS_o_ai
17673 vec_xl_be(signed long long  __offset, const unsigned int *__ptr) {
17674   return (vector unsigned int)__builtin_vsx_lxvw4x_be(__offset, __ptr);
17675 }
17676
17677 static __inline__ vector float __ATTRS_o_ai
17678 vec_xl_be(signed long long  __offset, const float *__ptr) {
17679   return (vector float)__builtin_vsx_lxvw4x_be(__offset, __ptr);
17680 }
17681
17682 #ifdef __VSX__
17683 static __inline__ vector signed long long __ATTRS_o_ai
17684 vec_xl_be(signed long long  __offset, const signed long long *__ptr) {
17685   return (vector signed long long)__builtin_vsx_lxvd2x_be(__offset, __ptr);
17686 }
17687
17688 static __inline__ vector unsigned long long __ATTRS_o_ai
17689 vec_xl_be(signed long long  __offset, const unsigned long long *__ptr) {
17690   return (vector unsigned long long)__builtin_vsx_lxvd2x_be(__offset, __ptr);
17691 }
17692
17693 static __inline__ vector double __ATTRS_o_ai
17694 vec_xl_be(signed long long  __offset, const double *__ptr) {
17695   return (vector double)__builtin_vsx_lxvd2x_be(__offset, __ptr);
17696 }
17697 #endif
17698
17699 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__) &&                    \
17700     defined(__SIZEOF_INT128__)
17701 static __inline__ vector signed __int128 __ATTRS_o_ai
17702 vec_xl_be(signed long long  __offset, const signed __int128 *__ptr) {
17703   return vec_xl(__offset, __ptr);
17704 }
17705
17706 static __inline__ vector unsigned __int128 __ATTRS_o_ai
17707 vec_xl_be(signed long long  __offset, const unsigned __int128 *__ptr) {
17708   return vec_xl(__offset, __ptr);
17709 }
17710 #endif
17711 #else
17712   #define vec_xl_be vec_xl
17713 #endif
17714
17715 #if defined(__POWER10_VECTOR__) && defined(__VSX__) &&                         \
17716     defined(__SIZEOF_INT128__)
17717
17718 /* vect_xl_sext */
17719
17720 static __inline__ vector unsigned __int128 __ATTRS_o_ai
17721 vec_xl_sext(ptrdiff_t __offset, const signed char *__pointer) {
17722   return (vector unsigned __int128)*(__pointer + __offset);
17723 }
17724
17725 static __inline__ vector unsigned __int128 __ATTRS_o_ai
17726 vec_xl_sext(ptrdiff_t __offset, const signed short *__pointer) {
17727   return (vector unsigned __int128)*(__pointer + __offset);
17728 }
17729
17730 static __inline__ vector unsigned __int128 __ATTRS_o_ai
17731 vec_xl_sext(ptrdiff_t __offset, const signed int *__pointer) {
17732   return (vector unsigned __int128)*(__pointer + __offset);
17733 }
17734
17735 static __inline__ vector unsigned __int128 __ATTRS_o_ai
17736 vec_xl_sext(ptrdiff_t __offset, const signed long long *__pointer) {
17737   return (vector unsigned __int128)*(__pointer + __offset);
17738 }
17739
17740 /* vec_xl_zext */
17741
17742 static __inline__ vector unsigned __int128 __ATTRS_o_ai
17743 vec_xl_zext(ptrdiff_t __offset, const unsigned char *__pointer) {
17744   return (vector unsigned __int128)*(__pointer + __offset);
17745 }
17746
17747 static __inline__ vector unsigned __int128 __ATTRS_o_ai
17748 vec_xl_zext(ptrdiff_t __offset, const unsigned short *__pointer) {
17749   return (vector unsigned __int128)*(__pointer + __offset);
17750 }
17751
17752 static __inline__ vector unsigned __int128 __ATTRS_o_ai
17753 vec_xl_zext(ptrdiff_t __offset, const unsigned int *__pointer) {
17754   return (vector unsigned __int128)*(__pointer + __offset);
17755 }
17756
17757 static __inline__ vector unsigned __int128 __ATTRS_o_ai
17758 vec_xl_zext(ptrdiff_t __offset, const unsigned long long *__pointer) {
17759   return (vector unsigned __int128)*(__pointer + __offset);
17760 }
17761
17762 #endif
17763
17764 /* vec_xlds */
17765 #ifdef __VSX__
17766 static __inline__ vector signed long long __ATTRS_o_ai
17767 vec_xlds(ptrdiff_t __offset, const signed long long *__ptr) {
17768   signed long long *__addr = (signed long long*)((signed char *)__ptr + __offset);
17769   return (vector signed long long) *__addr;
17770 }
17771
17772 static __inline__ vector unsigned long long __ATTRS_o_ai
17773 vec_xlds(ptrdiff_t __offset, const unsigned long long *__ptr) {
17774   unsigned long long *__addr = (unsigned long long *)((signed char *)__ptr + __offset);
17775   return (unaligned_vec_ull) *__addr;
17776 }
17777
17778 static __inline__ vector double __ATTRS_o_ai vec_xlds(ptrdiff_t __offset,
17779                                                       const double *__ptr) {
17780   double *__addr = (double*)((signed char *)__ptr + __offset);
17781   return (unaligned_vec_double) *__addr;
17782 }
17783
17784 /* vec_load_splats */
17785 static __inline__ vector signed int __ATTRS_o_ai
17786 vec_load_splats(signed long long __offset, const signed int *__ptr) {
17787   signed int *__addr = (signed int*)((signed char *)__ptr + __offset);
17788   return (vector signed int)*__addr;
17789 }
17790
17791 static __inline__ vector signed int __ATTRS_o_ai
17792 vec_load_splats(unsigned long long __offset, const signed int *__ptr) {
17793   signed int *__addr = (signed int*)((signed char *)__ptr + __offset);
17794   return (vector signed int)*__addr;
17795 }
17796
17797 static __inline__ vector unsigned int __ATTRS_o_ai
17798 vec_load_splats(signed long long __offset, const unsigned int *__ptr) {
17799   unsigned int *__addr = (unsigned int*)((signed char *)__ptr + __offset);
17800   return (vector unsigned int)*__addr;
17801 }
17802
17803 static __inline__ vector unsigned int __ATTRS_o_ai
17804 vec_load_splats(unsigned long long __offset, const unsigned int *__ptr) {
17805   unsigned int *__addr = (unsigned int*)((signed char *)__ptr + __offset);
17806   return (vector unsigned int)*__addr;
17807 }
17808
17809 static __inline__ vector float __ATTRS_o_ai
17810 vec_load_splats(signed long long __offset, const float *__ptr) {
17811   float *__addr = (float*)((signed char *)__ptr + __offset);
17812   return (vector float)*__addr;
17813 }
17814
17815 static __inline__ vector float __ATTRS_o_ai
17816 vec_load_splats(unsigned long long __offset, const float *__ptr) {
17817   float *__addr = (float*)((signed char *)__ptr + __offset);
17818   return (vector float)*__addr;
17819 }
17820 #endif
17821
17822 /* vec_xst */
17823
17824 #define vec_xstd2 vec_xst
17825 #define vec_xstw4 vec_xst
17826 static inline __ATTRS_o_ai void
17827 vec_xst(vector signed char __vec, ptrdiff_t __offset, signed char *__ptr) {
17828   *(unaligned_vec_schar *)(__ptr + __offset) = __vec;
17829 }
17830
17831 static inline __ATTRS_o_ai void
17832 vec_xst(vector unsigned char __vec, ptrdiff_t __offset, unsigned char *__ptr) {
17833   *(unaligned_vec_uchar *)(__ptr + __offset) = __vec;
17834 }
17835
17836 static inline __ATTRS_o_ai void
17837 vec_xst(vector signed short __vec, ptrdiff_t __offset, signed short *__ptr) {
17838   signed char *__addr = (signed char *)__ptr + __offset;
17839   *(unaligned_vec_sshort *)__addr = __vec;
17840 }
17841
17842 static inline __ATTRS_o_ai void vec_xst(vector unsigned short __vec,
17843                                         ptrdiff_t __offset,
17844                                         unsigned short *__ptr) {
17845   signed char *__addr = (signed char *)__ptr + __offset;
17846   *(unaligned_vec_ushort *)__addr = __vec;
17847 }
17848
17849 static inline __ATTRS_o_ai void vec_xst(vector signed int __vec,
17850                                         ptrdiff_t __offset, signed int *__ptr) {
17851   signed char *__addr = (signed char *)__ptr + __offset;
17852   *(unaligned_vec_sint *)__addr = __vec;
17853 }
17854
17855 static inline __ATTRS_o_ai void
17856 vec_xst(vector unsigned int __vec, ptrdiff_t __offset, unsigned int *__ptr) {
17857   signed char *__addr = (signed char *)__ptr + __offset;
17858   *(unaligned_vec_uint *)__addr = __vec;
17859 }
17860
17861 static inline __ATTRS_o_ai void vec_xst(vector float __vec, ptrdiff_t __offset,
17862                                         float *__ptr) {
17863   signed char *__addr = (signed char *)__ptr + __offset;
17864   *(unaligned_vec_float *)__addr = __vec;
17865 }
17866
17867 #ifdef __VSX__
17868 static inline __ATTRS_o_ai void vec_xst(vector signed long long __vec,
17869                                         ptrdiff_t __offset,
17870                                         signed long long *__ptr) {
17871   signed char *__addr = (signed char *)__ptr + __offset;
17872   *(unaligned_vec_sll *)__addr = __vec;
17873 }
17874
17875 static inline __ATTRS_o_ai void vec_xst(vector unsigned long long __vec,
17876                                         ptrdiff_t __offset,
17877                                         unsigned long long *__ptr) {
17878   signed char *__addr = (signed char *)__ptr + __offset;
17879   *(unaligned_vec_ull *)__addr = __vec;
17880 }
17881
17882 static inline __ATTRS_o_ai void vec_xst(vector double __vec, ptrdiff_t __offset,
17883                                         double *__ptr) {
17884   signed char *__addr = (signed char *)__ptr + __offset;
17885   *(unaligned_vec_double *)__addr = __vec;
17886 }
17887 #endif
17888
17889 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__) &&                    \
17890     defined(__SIZEOF_INT128__)
17891 static inline __ATTRS_o_ai void vec_xst(vector signed __int128 __vec,
17892                                         ptrdiff_t __offset,
17893                                         signed __int128 *__ptr) {
17894   signed char *__addr = (signed char *)__ptr + __offset;
17895   *(unaligned_vec_si128 *)__addr = __vec;
17896 }
17897
17898 static inline __ATTRS_o_ai void vec_xst(vector unsigned __int128 __vec,
17899                                         ptrdiff_t __offset,
17900                                         unsigned __int128 *__ptr) {
17901   signed char *__addr = (signed char *)__ptr + __offset;
17902   *(unaligned_vec_ui128 *)__addr = __vec;
17903 }
17904 #endif
17905
17906 /* vec_xst_trunc */
17907
17908 #if defined(__POWER10_VECTOR__) && defined(__VSX__) &&                         \
17909     defined(__SIZEOF_INT128__)
17910 static inline __ATTRS_o_ai void vec_xst_trunc(vector signed __int128 __vec,
17911                                               ptrdiff_t __offset,
17912                                               signed char *__ptr) {
17913   *(__ptr + __offset) = (signed char)__vec[0];
17914 }
17915
17916 static inline __ATTRS_o_ai void vec_xst_trunc(vector unsigned __int128 __vec,
17917                                               ptrdiff_t __offset,
17918                                               unsigned char *__ptr) {
17919   *(__ptr + __offset) = (unsigned char)__vec[0];
17920 }
17921
17922 static inline __ATTRS_o_ai void vec_xst_trunc(vector signed __int128 __vec,
17923                                               ptrdiff_t __offset,
17924                                               signed short *__ptr) {
17925   *(__ptr + __offset) = (signed short)__vec[0];
17926 }
17927
17928 static inline __ATTRS_o_ai void vec_xst_trunc(vector unsigned __int128 __vec,
17929                                               ptrdiff_t __offset,
17930                                               unsigned short *__ptr) {
17931   *(__ptr + __offset) = (unsigned short)__vec[0];
17932 }
17933
17934 static inline __ATTRS_o_ai void vec_xst_trunc(vector signed __int128 __vec,
17935                                               ptrdiff_t __offset,
17936                                               signed int *__ptr) {
17937   *(__ptr + __offset) = (signed int)__vec[0];
17938 }
17939
17940 static inline __ATTRS_o_ai void vec_xst_trunc(vector unsigned __int128 __vec,
17941                                               ptrdiff_t __offset,
17942                                               unsigned int *__ptr) {
17943   *(__ptr + __offset) = (unsigned int)__vec[0];
17944 }
17945
17946 static inline __ATTRS_o_ai void vec_xst_trunc(vector signed __int128 __vec,
17947                                               ptrdiff_t __offset,
17948                                               signed long long *__ptr) {
17949   *(__ptr + __offset) = (signed long long)__vec[0];
17950 }
17951
17952 static inline __ATTRS_o_ai void vec_xst_trunc(vector unsigned __int128 __vec,
17953                                               ptrdiff_t __offset,
17954                                               unsigned long long *__ptr) {
17955   *(__ptr + __offset) = (unsigned long long)__vec[0];
17956 }
17957 #endif
17958
17959 /* vec_xst_be */
17960
17961 #ifdef __LITTLE_ENDIAN__
17962 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed char __vec,
17963                                                signed long long  __offset,
17964                                                signed char *__ptr) {
17965   vector signed char __tmp =
17966      __builtin_shufflevector(__vec, __vec, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14,
17967                              13, 12, 11, 10, 9, 8);
17968   typedef __attribute__((vector_size(sizeof(__tmp)))) double __vector_double;
17969   __builtin_vsx_stxvd2x_be((__vector_double)__tmp, __offset, __ptr);
17970 }
17971
17972 static __inline__ void __ATTRS_o_ai vec_xst_be(vector unsigned char __vec,
17973                                                signed long long  __offset,
17974                                                unsigned char *__ptr) {
17975   vector unsigned char __tmp =
17976      __builtin_shufflevector(__vec, __vec, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14,
17977                              13, 12, 11, 10, 9, 8);
17978   typedef __attribute__((vector_size(sizeof(__tmp)))) double __vector_double;
17979   __builtin_vsx_stxvd2x_be((__vector_double)__tmp, __offset, __ptr);
17980 }
17981
17982 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed short __vec,
17983                                                signed long long  __offset,
17984                                                signed short *__ptr) {
17985   vector signed short __tmp =
17986      __builtin_shufflevector(__vec, __vec, 3, 2, 1, 0, 7, 6, 5, 4);
17987   typedef __attribute__((vector_size(sizeof(__tmp)))) double __vector_double;
17988   __builtin_vsx_stxvd2x_be((__vector_double)__tmp, __offset, __ptr);
17989 }
17990
17991 static __inline__ void __ATTRS_o_ai vec_xst_be(vector unsigned short __vec,
17992                                                signed long long  __offset,
17993                                                unsigned short *__ptr) {
17994   vector unsigned short __tmp =
17995      __builtin_shufflevector(__vec, __vec, 3, 2, 1, 0, 7, 6, 5, 4);
17996   typedef __attribute__((vector_size(sizeof(__tmp)))) double __vector_double;
17997   __builtin_vsx_stxvd2x_be((__vector_double)__tmp, __offset, __ptr);
17998 }
17999
18000 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed int __vec,
18001                                                signed long long  __offset,
18002                                                signed int *__ptr) {
18003   __builtin_vsx_stxvw4x_be(__vec, __offset, __ptr);
18004 }
18005
18006 static __inline__ void __ATTRS_o_ai vec_xst_be(vector unsigned int __vec,
18007                                                signed long long  __offset,
18008                                                unsigned int *__ptr) {
18009   __builtin_vsx_stxvw4x_be((vector int)__vec, __offset, __ptr);
18010 }
18011
18012 static __inline__ void __ATTRS_o_ai vec_xst_be(vector float __vec,
18013                                                signed long long  __offset,
18014                                                float *__ptr) {
18015   __builtin_vsx_stxvw4x_be((vector int)__vec, __offset, __ptr);
18016 }
18017
18018 #ifdef __VSX__
18019 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed long long __vec,
18020                                                signed long long  __offset,
18021                                                signed long long *__ptr) {
18022   __builtin_vsx_stxvd2x_be((vector double)__vec, __offset, __ptr);
18023 }
18024
18025 static __inline__ void __ATTRS_o_ai vec_xst_be(vector unsigned long long __vec,
18026                                                signed long long  __offset,
18027                                                unsigned long long *__ptr) {
18028   __builtin_vsx_stxvd2x_be((vector double)__vec, __offset, __ptr);
18029 }
18030
18031 static __inline__ void __ATTRS_o_ai vec_xst_be(vector double __vec,
18032                                                signed long long  __offset,
18033                                                double *__ptr) {
18034   __builtin_vsx_stxvd2x_be((vector double)__vec, __offset, __ptr);
18035 }
18036 #endif
18037
18038 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__) &&                    \
18039     defined(__SIZEOF_INT128__)
18040 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed __int128 __vec,
18041                                                signed long long  __offset,
18042                                                signed __int128 *__ptr) {
18043   vec_xst(__vec, __offset, __ptr);
18044 }
18045
18046 static __inline__ void __ATTRS_o_ai vec_xst_be(vector unsigned __int128 __vec,
18047                                                signed long long  __offset,
18048                                                unsigned __int128 *__ptr) {
18049   vec_xst(__vec, __offset, __ptr);
18050 }
18051 #endif
18052 #else
18053   #define vec_xst_be vec_xst
18054 #endif
18055
18056 #ifdef __POWER9_VECTOR__
18057 #define vec_test_data_class(__a, __b)                                          \
18058   _Generic(                                                                    \
18059       (__a), vector float                                                      \
18060       : (vector bool int)__builtin_vsx_xvtstdcsp((vector float)(__a), (__b)),  \
18061         vector double                                                          \
18062       : (vector bool long long)__builtin_vsx_xvtstdcdp((vector double)(__a),   \
18063                                                        (__b)))
18064
18065 #endif /* #ifdef __POWER9_VECTOR__ */
18066
18067 static vector float __ATTRS_o_ai vec_neg(vector float __a) {
18068   return -__a;
18069 }
18070
18071 #ifdef __VSX__
18072 static vector double __ATTRS_o_ai vec_neg(vector double __a) {
18073   return -__a;
18074 }
18075
18076 #endif
18077
18078 #ifdef __VSX__
18079 static vector long long __ATTRS_o_ai vec_neg(vector long long __a) {
18080   return -__a;
18081 }
18082 #endif
18083
18084 static vector signed int __ATTRS_o_ai vec_neg(vector signed int __a) {
18085   return -__a;
18086 }
18087
18088 static vector signed short __ATTRS_o_ai vec_neg(vector signed short __a) {
18089   return -__a;
18090 }
18091
18092 static vector signed char __ATTRS_o_ai vec_neg(vector signed char __a) {
18093   return -__a;
18094 }
18095
18096 static vector float __ATTRS_o_ai vec_nabs(vector float __a) {
18097   return - vec_abs(__a);
18098 }
18099
18100 #ifdef __VSX__
18101 static vector double __ATTRS_o_ai vec_nabs(vector double __a) {
18102   return - vec_abs(__a);
18103 }
18104
18105 #endif
18106
18107 #ifdef __POWER8_VECTOR__
18108 static vector long long __ATTRS_o_ai vec_nabs(vector long long __a) {
18109   return __builtin_altivec_vminsd(__a, -__a);
18110 }
18111 #endif
18112
18113 static vector signed int __ATTRS_o_ai vec_nabs(vector signed int __a) {
18114   return __builtin_altivec_vminsw(__a, -__a);
18115 }
18116
18117 static vector signed short __ATTRS_o_ai vec_nabs(vector signed short __a) {
18118   return __builtin_altivec_vminsh(__a, -__a);
18119 }
18120
18121 static vector signed char __ATTRS_o_ai vec_nabs(vector signed char __a) {
18122   return __builtin_altivec_vminsb(__a, -__a);
18123 }
18124
18125 static vector float __ATTRS_o_ai vec_recipdiv(vector float __a,
18126                                               vector float __b) {
18127   return __builtin_ppc_recipdivf(__a, __b);
18128 }
18129
18130 #ifdef __VSX__
18131 static vector double __ATTRS_o_ai vec_recipdiv(vector double __a,
18132                                                vector double __b) {
18133   return __builtin_ppc_recipdivd(__a, __b);
18134 }
18135 #endif
18136
18137 #ifdef __POWER10_VECTOR__
18138
18139 /* vec_extractm */
18140
18141 static __inline__ unsigned int __ATTRS_o_ai
18142 vec_extractm(vector unsigned char __a) {
18143   return __builtin_altivec_vextractbm(__a);
18144 }
18145
18146 static __inline__ unsigned int __ATTRS_o_ai
18147 vec_extractm(vector unsigned short __a) {
18148   return __builtin_altivec_vextracthm(__a);
18149 }
18150
18151 static __inline__ unsigned int __ATTRS_o_ai
18152 vec_extractm(vector unsigned int __a) {
18153   return __builtin_altivec_vextractwm(__a);
18154 }
18155
18156 static __inline__ unsigned int __ATTRS_o_ai
18157 vec_extractm(vector unsigned long long __a) {
18158   return __builtin_altivec_vextractdm(__a);
18159 }
18160
18161 #ifdef __SIZEOF_INT128__
18162 static __inline__ unsigned int __ATTRS_o_ai
18163 vec_extractm(vector unsigned __int128 __a) {
18164   return __builtin_altivec_vextractqm(__a);
18165 }
18166 #endif
18167
18168 /* vec_expandm */
18169
18170 static __inline__ vector unsigned char __ATTRS_o_ai
18171 vec_expandm(vector unsigned char __a) {
18172   return __builtin_altivec_vexpandbm(__a);
18173 }
18174
18175 static __inline__ vector unsigned short __ATTRS_o_ai
18176 vec_expandm(vector unsigned short __a) {
18177   return __builtin_altivec_vexpandhm(__a);
18178 }
18179
18180 static __inline__ vector unsigned int __ATTRS_o_ai
18181 vec_expandm(vector unsigned int __a) {
18182   return __builtin_altivec_vexpandwm(__a);
18183 }
18184
18185 static __inline__ vector unsigned long long __ATTRS_o_ai
18186 vec_expandm(vector unsigned long long __a) {
18187   return __builtin_altivec_vexpanddm(__a);
18188 }
18189
18190 #ifdef __SIZEOF_INT128__
18191 static __inline__ vector unsigned __int128 __ATTRS_o_ai
18192 vec_expandm(vector unsigned __int128 __a) {
18193   return __builtin_altivec_vexpandqm(__a);
18194 }
18195 #endif
18196
18197 /* vec_cntm */
18198
18199 #define vec_cntm(__a, __mp)                                                    \
18200   _Generic((__a), vector unsigned char                                         \
18201            : __builtin_altivec_vcntmbb((__a), (unsigned int)(__mp)),           \
18202              vector unsigned short                                             \
18203            : __builtin_altivec_vcntmbh((__a), (unsigned int)(__mp)),           \
18204              vector unsigned int                                               \
18205            : __builtin_altivec_vcntmbw((__a), (unsigned int)(__mp)),           \
18206              vector unsigned long long                                         \
18207            : __builtin_altivec_vcntmbd((__a), (unsigned int)(__mp)))
18208
18209 /* vec_gen[b|h|w|d|q]m */
18210
18211 static __inline__ vector unsigned char __ATTRS_o_ai
18212 vec_genbm(unsigned long long __bm) {
18213   return __builtin_altivec_mtvsrbm(__bm);
18214 }
18215
18216 static __inline__ vector unsigned short __ATTRS_o_ai
18217 vec_genhm(unsigned long long __bm) {
18218   return __builtin_altivec_mtvsrhm(__bm);
18219 }
18220
18221 static __inline__ vector unsigned int __ATTRS_o_ai
18222 vec_genwm(unsigned long long __bm) {
18223   return __builtin_altivec_mtvsrwm(__bm);
18224 }
18225
18226 static __inline__ vector unsigned long long __ATTRS_o_ai
18227 vec_gendm(unsigned long long __bm) {
18228   return __builtin_altivec_mtvsrdm(__bm);
18229 }
18230
18231 #ifdef __SIZEOF_INT128__
18232 static __inline__ vector unsigned __int128 __ATTRS_o_ai
18233 vec_genqm(unsigned long long __bm) {
18234   return __builtin_altivec_mtvsrqm(__bm);
18235 }
18236 #endif
18237
18238 /* vec_pdep */
18239
18240 static __inline__ vector unsigned long long __ATTRS_o_ai
18241 vec_pdep(vector unsigned long long __a, vector unsigned long long __b) {
18242   return __builtin_altivec_vpdepd(__a, __b);
18243 }
18244
18245 /* vec_pext */
18246
18247 static __inline__ vector unsigned long long __ATTRS_o_ai
18248 vec_pext(vector unsigned long long __a, vector unsigned long long __b) {
18249   return __builtin_altivec_vpextd(__a, __b);
18250 }
18251
18252 /* vec_cfuge */
18253
18254 static __inline__ vector unsigned long long __ATTRS_o_ai
18255 vec_cfuge(vector unsigned long long __a, vector unsigned long long __b) {
18256   return __builtin_altivec_vcfuged(__a, __b);
18257 }
18258
18259 /* vec_gnb */
18260
18261 #define vec_gnb(__a, __b) __builtin_altivec_vgnb(__a, __b)
18262
18263 /* vec_ternarylogic */
18264 #ifdef __VSX__
18265 #ifdef __SIZEOF_INT128__
18266 #define vec_ternarylogic(__a, __b, __c, __imm)                                 \
18267   _Generic((__a), vector unsigned char                                         \
18268            : __builtin_vsx_xxeval((vector unsigned long long)(__a),            \
18269                                   (vector unsigned long long)(__b),            \
18270                                   (vector unsigned long long)(__c), (__imm)),  \
18271              vector unsigned short                                             \
18272            : __builtin_vsx_xxeval((vector unsigned long long)(__a),            \
18273                                   (vector unsigned long long)(__b),            \
18274                                   (vector unsigned long long)(__c), (__imm)),  \
18275              vector unsigned int                                               \
18276            : __builtin_vsx_xxeval((vector unsigned long long)(__a),            \
18277                                   (vector unsigned long long)(__b),            \
18278                                   (vector unsigned long long)(__c), (__imm)),  \
18279              vector unsigned long long                                         \
18280            : __builtin_vsx_xxeval((vector unsigned long long)(__a),            \
18281                                   (vector unsigned long long)(__b),            \
18282                                   (vector unsigned long long)(__c), (__imm)),  \
18283              vector unsigned __int128                                          \
18284            : __builtin_vsx_xxeval((vector unsigned long long)(__a),            \
18285                                   (vector unsigned long long)(__b),            \
18286                                   (vector unsigned long long)(__c), (__imm)))
18287 #else
18288 #define vec_ternarylogic(__a, __b, __c, __imm)                                 \
18289   _Generic((__a), vector unsigned char                                         \
18290            : __builtin_vsx_xxeval((vector unsigned long long)(__a),            \
18291                                   (vector unsigned long long)(__b),            \
18292                                   (vector unsigned long long)(__c), (__imm)),  \
18293              vector unsigned short                                             \
18294            : __builtin_vsx_xxeval((vector unsigned long long)(__a),            \
18295                                   (vector unsigned long long)(__b),            \
18296                                   (vector unsigned long long)(__c), (__imm)),  \
18297              vector unsigned int                                               \
18298            : __builtin_vsx_xxeval((vector unsigned long long)(__a),            \
18299                                   (vector unsigned long long)(__b),            \
18300                                   (vector unsigned long long)(__c), (__imm)),  \
18301              vector unsigned long long                                         \
18302            : __builtin_vsx_xxeval((vector unsigned long long)(__a),            \
18303                                   (vector unsigned long long)(__b),            \
18304                                   (vector unsigned long long)(__c), (__imm)))
18305 #endif /* __SIZEOF_INT128__ */
18306 #endif /* __VSX__ */
18307
18308 /* vec_genpcvm */
18309
18310 #ifdef __VSX__
18311 #define vec_genpcvm(__a, __imm)                                                \
18312   _Generic((__a), vector unsigned char                                         \
18313            : __builtin_vsx_xxgenpcvbm((__a), (int)(__imm)),                    \
18314              vector unsigned short                                             \
18315            : __builtin_vsx_xxgenpcvhm((__a), (int)(__imm)),                    \
18316              vector unsigned int                                               \
18317            : __builtin_vsx_xxgenpcvwm((__a), (int)(__imm)),                    \
18318              vector unsigned long long                                         \
18319            : __builtin_vsx_xxgenpcvdm((__a), (int)(__imm)))
18320 #endif /* __VSX__ */
18321
18322 /* vec_clrl */
18323
18324 static __inline__ vector signed char __ATTRS_o_ai
18325 vec_clrl(vector signed char __a, unsigned int __n) {
18326 #ifdef __LITTLE_ENDIAN__
18327   return __builtin_altivec_vclrrb(__a, __n);
18328 #else
18329   return __builtin_altivec_vclrlb( __a, __n);
18330 #endif
18331 }
18332
18333 static __inline__ vector unsigned char __ATTRS_o_ai
18334 vec_clrl(vector unsigned char __a, unsigned int __n) {
18335 #ifdef __LITTLE_ENDIAN__
18336   return __builtin_altivec_vclrrb((vector signed char)__a, __n);
18337 #else
18338   return __builtin_altivec_vclrlb((vector signed char)__a, __n);
18339 #endif
18340 }
18341
18342 /* vec_clrr */
18343
18344 static __inline__ vector signed char __ATTRS_o_ai
18345 vec_clrr(vector signed char __a, unsigned int __n) {
18346 #ifdef __LITTLE_ENDIAN__
18347   return __builtin_altivec_vclrlb(__a, __n);
18348 #else
18349   return __builtin_altivec_vclrrb( __a, __n);
18350 #endif
18351 }
18352
18353 static __inline__ vector unsigned char __ATTRS_o_ai
18354 vec_clrr(vector unsigned char __a, unsigned int __n) {
18355 #ifdef __LITTLE_ENDIAN__
18356   return __builtin_altivec_vclrlb((vector signed char)__a, __n);
18357 #else
18358   return __builtin_altivec_vclrrb((vector signed char)__a, __n);
18359 #endif
18360 }
18361
18362 /* vec_cntlzm */
18363
18364 static __inline__ vector unsigned long long __ATTRS_o_ai
18365 vec_cntlzm(vector unsigned long long __a, vector unsigned long long __b) {
18366   return __builtin_altivec_vclzdm(__a, __b);
18367 }
18368
18369 /* vec_cnttzm */
18370
18371 static __inline__ vector unsigned long long __ATTRS_o_ai
18372 vec_cnttzm(vector unsigned long long __a, vector unsigned long long __b) {
18373   return __builtin_altivec_vctzdm(__a, __b);
18374 }
18375
18376 /* vec_mod */
18377
18378 static __inline__ vector signed int __ATTRS_o_ai
18379 vec_mod(vector signed int __a, vector signed int __b) {
18380   return __a % __b;
18381 }
18382
18383 static __inline__ vector unsigned int __ATTRS_o_ai
18384 vec_mod(vector unsigned int __a, vector unsigned int __b) {
18385   return __a % __b;
18386 }
18387
18388 static __inline__ vector signed long long __ATTRS_o_ai
18389 vec_mod(vector signed long long __a, vector signed long long __b) {
18390   return __a % __b;
18391 }
18392
18393 static __inline__ vector unsigned long long __ATTRS_o_ai
18394 vec_mod(vector unsigned long long __a, vector unsigned long long __b) {
18395   return __a % __b;
18396 }
18397
18398 #ifdef __SIZEOF_INT128__
18399 static __inline__ vector signed __int128 __ATTRS_o_ai
18400 vec_mod(vector signed __int128 __a, vector signed __int128 __b) {
18401   return __a % __b;
18402 }
18403
18404 static __inline__ vector unsigned __int128 __ATTRS_o_ai
18405 vec_mod(vector unsigned __int128 __a, vector unsigned __int128 __b) {
18406   return  __a % __b;
18407 }
18408 #endif
18409
18410 /* vec_sldbi */
18411
18412 #define vec_sldb(__a, __b, __c) __builtin_altivec_vsldbi(__a, __b, (__c & 0x7))
18413
18414 /* vec_srdbi */
18415
18416 #define vec_srdb(__a, __b, __c) __builtin_altivec_vsrdbi(__a, __b, (__c & 0x7))
18417
18418 /* vec_insertl */
18419
18420 static __inline__ vector unsigned char __ATTRS_o_ai
18421 vec_insertl(unsigned char __a, vector unsigned char __b, unsigned int __c) {
18422 #ifdef __LITTLE_ENDIAN__
18423   return __builtin_altivec_vinsbrx(__b, __c, __a);
18424 #else
18425   return __builtin_altivec_vinsblx(__b, __c, __a);
18426 #endif
18427 }
18428
18429 static __inline__ vector unsigned short __ATTRS_o_ai
18430 vec_insertl(unsigned short __a, vector unsigned short __b, unsigned int __c) {
18431 #ifdef __LITTLE_ENDIAN__
18432   return __builtin_altivec_vinshrx(__b, __c, __a);
18433 #else
18434   return __builtin_altivec_vinshlx(__b, __c, __a);
18435 #endif
18436 }
18437
18438 static __inline__ vector unsigned int __ATTRS_o_ai
18439 vec_insertl(unsigned int __a, vector unsigned int __b, unsigned int __c) {
18440 #ifdef __LITTLE_ENDIAN__
18441   return __builtin_altivec_vinswrx(__b, __c, __a);
18442 #else
18443   return __builtin_altivec_vinswlx(__b, __c, __a);
18444 #endif
18445 }
18446
18447 static __inline__ vector unsigned long long __ATTRS_o_ai
18448 vec_insertl(unsigned long long __a, vector unsigned long long __b,
18449             unsigned int __c) {
18450 #ifdef __LITTLE_ENDIAN__
18451   return __builtin_altivec_vinsdrx(__b, __c, __a);
18452 #else
18453   return __builtin_altivec_vinsdlx(__b, __c, __a);
18454 #endif
18455 }
18456
18457 static __inline__ vector unsigned char __ATTRS_o_ai
18458 vec_insertl(vector unsigned char __a, vector unsigned char __b,
18459             unsigned int __c) {
18460 #ifdef __LITTLE_ENDIAN__
18461   return __builtin_altivec_vinsbvrx(__b, __c, __a);
18462 #else
18463   return __builtin_altivec_vinsbvlx(__b, __c, __a);
18464 #endif
18465 }
18466
18467 static __inline__ vector unsigned short __ATTRS_o_ai
18468 vec_insertl(vector unsigned short __a, vector unsigned short __b,
18469             unsigned int __c) {
18470 #ifdef __LITTLE_ENDIAN__
18471   return __builtin_altivec_vinshvrx(__b, __c, __a);
18472 #else
18473   return __builtin_altivec_vinshvlx(__b, __c, __a);
18474 #endif
18475 }
18476
18477 static __inline__ vector unsigned int __ATTRS_o_ai
18478 vec_insertl(vector unsigned int __a, vector unsigned int __b,
18479             unsigned int __c) {
18480 #ifdef __LITTLE_ENDIAN__
18481   return __builtin_altivec_vinswvrx(__b, __c, __a);
18482 #else
18483   return __builtin_altivec_vinswvlx(__b, __c, __a);
18484 #endif
18485 }
18486
18487 /* vec_inserth */
18488
18489 static __inline__ vector unsigned char __ATTRS_o_ai
18490 vec_inserth(unsigned char __a, vector unsigned char __b, unsigned int __c) {
18491 #ifdef __LITTLE_ENDIAN__
18492   return __builtin_altivec_vinsblx(__b, __c, __a);
18493 #else
18494   return __builtin_altivec_vinsbrx(__b, __c, __a);
18495 #endif
18496 }
18497
18498 static __inline__ vector unsigned short __ATTRS_o_ai
18499 vec_inserth(unsigned short __a, vector unsigned short __b, unsigned int __c) {
18500 #ifdef __LITTLE_ENDIAN__
18501   return __builtin_altivec_vinshlx(__b, __c, __a);
18502 #else
18503   return __builtin_altivec_vinshrx(__b, __c, __a);
18504 #endif
18505 }
18506
18507 static __inline__ vector unsigned int __ATTRS_o_ai
18508 vec_inserth(unsigned int __a, vector unsigned int __b, unsigned int __c) {
18509 #ifdef __LITTLE_ENDIAN__
18510   return __builtin_altivec_vinswlx(__b, __c, __a);
18511 #else
18512   return __builtin_altivec_vinswrx(__b, __c, __a);
18513 #endif
18514 }
18515
18516 static __inline__ vector unsigned long long __ATTRS_o_ai
18517 vec_inserth(unsigned long long __a, vector unsigned long long __b,
18518             unsigned int __c) {
18519 #ifdef __LITTLE_ENDIAN__
18520   return __builtin_altivec_vinsdlx(__b, __c, __a);
18521 #else
18522   return __builtin_altivec_vinsdrx(__b, __c, __a);
18523 #endif
18524 }
18525
18526 static __inline__ vector unsigned char __ATTRS_o_ai
18527 vec_inserth(vector unsigned char __a, vector unsigned char __b,
18528             unsigned int __c) {
18529 #ifdef __LITTLE_ENDIAN__
18530   return __builtin_altivec_vinsbvlx(__b, __c, __a);
18531 #else
18532   return __builtin_altivec_vinsbvrx(__b, __c, __a);
18533 #endif
18534 }
18535
18536 static __inline__ vector unsigned short __ATTRS_o_ai
18537 vec_inserth(vector unsigned short __a, vector unsigned short __b,
18538             unsigned int __c) {
18539 #ifdef __LITTLE_ENDIAN__
18540   return __builtin_altivec_vinshvlx(__b, __c, __a);
18541 #else
18542   return __builtin_altivec_vinshvrx(__b, __c, __a);
18543 #endif
18544 }
18545
18546 static __inline__ vector unsigned int __ATTRS_o_ai
18547 vec_inserth(vector unsigned int __a, vector unsigned int __b,
18548             unsigned int __c) {
18549 #ifdef __LITTLE_ENDIAN__
18550   return __builtin_altivec_vinswvlx(__b, __c, __a);
18551 #else
18552   return __builtin_altivec_vinswvrx(__b, __c, __a);
18553 #endif
18554 }
18555
18556 /* vec_extractl */
18557
18558 static __inline__ vector unsigned long long __ATTRS_o_ai vec_extractl(
18559     vector unsigned char __a, vector unsigned char __b, unsigned int __c) {
18560 #ifdef __LITTLE_ENDIAN__
18561   return __builtin_altivec_vextdubvrx(__a, __b, __c);
18562 #else
18563   vector unsigned long long __ret = __builtin_altivec_vextdubvlx(__a, __b, __c);
18564   return vec_sld(__ret, __ret, 8);
18565 #endif
18566 }
18567
18568 static __inline__ vector unsigned long long __ATTRS_o_ai vec_extractl(
18569     vector unsigned short __a, vector unsigned short __b, unsigned int __c) {
18570 #ifdef __LITTLE_ENDIAN__
18571   return __builtin_altivec_vextduhvrx(__a, __b, __c);
18572 #else
18573   vector unsigned long long __ret = __builtin_altivec_vextduhvlx(__a, __b, __c);
18574   return vec_sld(__ret, __ret, 8);
18575 #endif
18576 }
18577
18578 static __inline__ vector unsigned long long __ATTRS_o_ai vec_extractl(
18579     vector unsigned int __a, vector unsigned int __b, unsigned int __c) {
18580 #ifdef __LITTLE_ENDIAN__
18581   return __builtin_altivec_vextduwvrx(__a, __b, __c);
18582 #else
18583   vector unsigned long long __ret = __builtin_altivec_vextduwvlx(__a, __b, __c);
18584   return vec_sld(__ret, __ret, 8);
18585 #endif
18586 }
18587
18588 static __inline__ vector unsigned long long __ATTRS_o_ai
18589 vec_extractl(vector unsigned long long __a, vector unsigned long long __b,
18590              unsigned int __c) {
18591 #ifdef __LITTLE_ENDIAN__
18592   return __builtin_altivec_vextddvrx(__a, __b, __c);
18593 #else
18594   vector unsigned long long __ret = __builtin_altivec_vextddvlx(__a, __b, __c);
18595   return vec_sld(__ret, __ret, 8);
18596 #endif
18597 }
18598
18599 /* vec_extracth */
18600
18601 static __inline__ vector unsigned long long __ATTRS_o_ai vec_extracth(
18602     vector unsigned char __a, vector unsigned char __b, unsigned int __c) {
18603 #ifdef __LITTLE_ENDIAN__
18604   return __builtin_altivec_vextdubvlx(__a, __b, __c);
18605 #else
18606   vector unsigned long long __ret = __builtin_altivec_vextdubvrx(__a, __b, __c);
18607   return vec_sld(__ret, __ret, 8);
18608 #endif
18609 }
18610
18611 static __inline__ vector unsigned long long __ATTRS_o_ai vec_extracth(
18612     vector unsigned short __a, vector unsigned short __b, unsigned int __c) {
18613 #ifdef __LITTLE_ENDIAN__
18614   return __builtin_altivec_vextduhvlx(__a, __b, __c);
18615 #else
18616   vector unsigned long long __ret = __builtin_altivec_vextduhvrx(__a, __b, __c);
18617   return vec_sld(__ret, __ret, 8);
18618 #endif
18619 }
18620
18621 static __inline__ vector unsigned long long __ATTRS_o_ai vec_extracth(
18622     vector unsigned int __a, vector unsigned int __b, unsigned int __c) {
18623 #ifdef __LITTLE_ENDIAN__
18624   return __builtin_altivec_vextduwvlx(__a, __b, __c);
18625 #else
18626   vector unsigned long long __ret = __builtin_altivec_vextduwvrx(__a, __b, __c);
18627   return vec_sld(__ret, __ret, 8);
18628 #endif
18629 }
18630
18631 static __inline__ vector unsigned long long __ATTRS_o_ai
18632 vec_extracth(vector unsigned long long __a, vector unsigned long long __b,
18633              unsigned int __c) {
18634 #ifdef __LITTLE_ENDIAN__
18635   return __builtin_altivec_vextddvlx(__a, __b, __c);
18636 #else
18637   vector unsigned long long __ret = __builtin_altivec_vextddvrx(__a, __b, __c);
18638   return vec_sld(__ret, __ret, 8);
18639 #endif
18640 }
18641
18642 #ifdef __VSX__
18643
18644 /* vec_permx */
18645
18646 #define vec_permx(__a, __b, __c, __d)                                          \
18647   __builtin_vsx_xxpermx((__a), (__b), (__c), (__d))
18648
18649 /* vec_blendv */
18650
18651 static __inline__ vector signed char __ATTRS_o_ai
18652 vec_blendv(vector signed char __a, vector signed char __b,
18653            vector unsigned char __c) {
18654   return __builtin_vsx_xxblendvb(__a, __b, __c);
18655 }
18656
18657 static __inline__ vector unsigned char __ATTRS_o_ai
18658 vec_blendv(vector unsigned char __a, vector unsigned char __b,
18659            vector unsigned char __c) {
18660   return __builtin_vsx_xxblendvb(__a, __b, __c);
18661 }
18662
18663 static __inline__ vector signed short __ATTRS_o_ai
18664 vec_blendv(vector signed short __a, vector signed short __b,
18665            vector unsigned short __c) {
18666   return __builtin_vsx_xxblendvh(__a, __b, __c);
18667 }
18668
18669 static __inline__ vector unsigned short __ATTRS_o_ai
18670 vec_blendv(vector unsigned short __a, vector unsigned short __b,
18671            vector unsigned short __c) {
18672   return __builtin_vsx_xxblendvh(__a, __b, __c);
18673 }
18674
18675 static __inline__ vector signed int __ATTRS_o_ai
18676 vec_blendv(vector signed int __a, vector signed int __b,
18677            vector unsigned int __c) {
18678   return __builtin_vsx_xxblendvw(__a, __b, __c);
18679 }
18680
18681 static __inline__ vector unsigned int __ATTRS_o_ai
18682 vec_blendv(vector unsigned int __a, vector unsigned int __b,
18683            vector unsigned int __c) {
18684   return __builtin_vsx_xxblendvw(__a, __b, __c);
18685 }
18686
18687 static __inline__ vector signed long long __ATTRS_o_ai
18688 vec_blendv(vector signed long long __a, vector signed long long __b,
18689            vector unsigned long long __c) {
18690   return __builtin_vsx_xxblendvd(__a, __b, __c);
18691 }
18692
18693 static __inline__ vector unsigned long long __ATTRS_o_ai
18694 vec_blendv(vector unsigned long long __a, vector unsigned long long __b,
18695            vector unsigned long long __c) {
18696   return __builtin_vsx_xxblendvd(__a, __b, __c);
18697 }
18698
18699 static __inline__ vector float __ATTRS_o_ai
18700 vec_blendv(vector float __a, vector float __b, vector unsigned int __c) {
18701   return __builtin_vsx_xxblendvw(__a, __b, __c);
18702 }
18703
18704 static __inline__ vector double __ATTRS_o_ai
18705 vec_blendv(vector double __a, vector double __b,
18706            vector unsigned long long __c) {
18707   return __builtin_vsx_xxblendvd(__a, __b, __c);
18708 }
18709
18710 /* vec_replace_elt */
18711
18712 #define vec_replace_elt __builtin_altivec_vec_replace_elt
18713
18714 /* vec_replace_unaligned */
18715
18716 #define vec_replace_unaligned __builtin_altivec_vec_replace_unaligned
18717
18718 /* vec_splati */
18719
18720 #define vec_splati(__a)                                                        \
18721   _Generic((__a), signed int                                                   \
18722            : ((vector signed int)__a), unsigned int                            \
18723            : ((vector unsigned int)__a), float                                 \
18724            : ((vector float)__a))
18725
18726 /* vec_spatid */
18727
18728 static __inline__ vector double __ATTRS_o_ai vec_splatid(const float __a) {
18729   return ((vector double)((double)__a));
18730 }
18731
18732 /* vec_splati_ins */
18733
18734 static __inline__ vector signed int __ATTRS_o_ai vec_splati_ins(
18735     vector signed int __a, const unsigned int __b, const signed int __c) {
18736 #ifdef __LITTLE_ENDIAN__
18737   __a[1 - __b] = __c;
18738   __a[3 - __b] = __c;
18739 #else
18740   __a[__b] = __c;
18741   __a[2 + __b] = __c;
18742 #endif
18743   return __a;
18744 }
18745
18746 static __inline__ vector unsigned int __ATTRS_o_ai vec_splati_ins(
18747     vector unsigned int __a, const unsigned int __b, const unsigned int __c) {
18748 #ifdef __LITTLE_ENDIAN__
18749   __a[1 - __b] = __c;
18750   __a[3 - __b] = __c;
18751 #else
18752   __a[__b] = __c;
18753   __a[2 + __b] = __c;
18754 #endif
18755   return __a;
18756 }
18757
18758 static __inline__ vector float __ATTRS_o_ai
18759 vec_splati_ins(vector float __a, const unsigned int __b, const float __c) {
18760 #ifdef __LITTLE_ENDIAN__
18761   __a[1 - __b] = __c;
18762   __a[3 - __b] = __c;
18763 #else
18764   __a[__b] = __c;
18765   __a[2 + __b] = __c;
18766 #endif
18767   return __a;
18768 }
18769
18770 /* vec_test_lsbb_all_ones */
18771
18772 static __inline__ int __ATTRS_o_ai
18773 vec_test_lsbb_all_ones(vector unsigned char __a) {
18774   return __builtin_vsx_xvtlsbb(__a, 1);
18775 }
18776
18777 /* vec_test_lsbb_all_zeros */
18778
18779 static __inline__ int __ATTRS_o_ai
18780 vec_test_lsbb_all_zeros(vector unsigned char __a) {
18781   return __builtin_vsx_xvtlsbb(__a, 0);
18782 }
18783 #endif /* __VSX__ */
18784
18785 /* vec_stril */
18786
18787 static __inline__ vector unsigned char __ATTRS_o_ai
18788 vec_stril(vector unsigned char __a) {
18789 #ifdef __LITTLE_ENDIAN__
18790   return __builtin_altivec_vstribr((vector signed char)__a);
18791 #else
18792   return __builtin_altivec_vstribl((vector signed char)__a);
18793 #endif
18794 }
18795
18796 static __inline__ vector signed char __ATTRS_o_ai
18797 vec_stril(vector signed char __a) {
18798 #ifdef __LITTLE_ENDIAN__
18799   return __builtin_altivec_vstribr(__a);
18800 #else
18801   return __builtin_altivec_vstribl(__a);
18802 #endif
18803 }
18804
18805 static __inline__ vector unsigned short __ATTRS_o_ai
18806 vec_stril(vector unsigned short __a) {
18807 #ifdef __LITTLE_ENDIAN__
18808   return __builtin_altivec_vstrihr((vector signed short)__a);
18809 #else
18810   return __builtin_altivec_vstrihl((vector signed short)__a);
18811 #endif
18812 }
18813
18814 static __inline__ vector signed short __ATTRS_o_ai
18815 vec_stril(vector signed short __a) {
18816 #ifdef __LITTLE_ENDIAN__
18817   return __builtin_altivec_vstrihr(__a);
18818 #else
18819   return __builtin_altivec_vstrihl(__a);
18820 #endif
18821 }
18822
18823 /* vec_stril_p */
18824
18825 static __inline__ int __ATTRS_o_ai vec_stril_p(vector unsigned char __a) {
18826 #ifdef __LITTLE_ENDIAN__
18827   return __builtin_altivec_vstribr_p(__CR6_EQ, (vector signed char)__a);
18828 #else
18829   return __builtin_altivec_vstribl_p(__CR6_EQ, (vector signed char)__a);
18830 #endif
18831 }
18832
18833 static __inline__ int __ATTRS_o_ai vec_stril_p(vector signed char __a) {
18834 #ifdef __LITTLE_ENDIAN__
18835   return __builtin_altivec_vstribr_p(__CR6_EQ, __a);
18836 #else
18837   return __builtin_altivec_vstribl_p(__CR6_EQ, __a);
18838 #endif
18839 }
18840
18841 static __inline__ int __ATTRS_o_ai vec_stril_p(vector unsigned short __a) {
18842 #ifdef __LITTLE_ENDIAN__
18843   return __builtin_altivec_vstrihr_p(__CR6_EQ, (vector signed short)__a);
18844 #else
18845   return __builtin_altivec_vstrihl_p(__CR6_EQ, (vector signed short)__a);
18846 #endif
18847 }
18848
18849 static __inline__ int __ATTRS_o_ai vec_stril_p(vector signed short __a) {
18850 #ifdef __LITTLE_ENDIAN__
18851   return __builtin_altivec_vstrihr_p(__CR6_EQ, __a);
18852 #else
18853   return __builtin_altivec_vstrihl_p(__CR6_EQ, __a);
18854 #endif
18855 }
18856
18857 /* vec_strir */
18858
18859 static __inline__ vector unsigned char __ATTRS_o_ai
18860 vec_strir(vector unsigned char __a) {
18861 #ifdef __LITTLE_ENDIAN__
18862   return __builtin_altivec_vstribl((vector signed char)__a);
18863 #else
18864   return __builtin_altivec_vstribr((vector signed char)__a);
18865 #endif
18866 }
18867
18868 static __inline__ vector signed char __ATTRS_o_ai
18869 vec_strir(vector signed char __a) {
18870 #ifdef __LITTLE_ENDIAN__
18871   return __builtin_altivec_vstribl(__a);
18872 #else
18873   return __builtin_altivec_vstribr(__a);
18874 #endif
18875 }
18876
18877 static __inline__ vector unsigned short __ATTRS_o_ai
18878 vec_strir(vector unsigned short __a) {
18879 #ifdef __LITTLE_ENDIAN__
18880   return __builtin_altivec_vstrihl((vector signed short)__a);
18881 #else
18882   return __builtin_altivec_vstrihr((vector signed short)__a);
18883 #endif
18884 }
18885
18886 static __inline__ vector signed short __ATTRS_o_ai
18887 vec_strir(vector signed short __a) {
18888 #ifdef __LITTLE_ENDIAN__
18889   return __builtin_altivec_vstrihl(__a);
18890 #else
18891   return __builtin_altivec_vstrihr(__a);
18892 #endif
18893 }
18894
18895 /* vec_strir_p */
18896
18897 static __inline__ int __ATTRS_o_ai vec_strir_p(vector unsigned char __a) {
18898 #ifdef __LITTLE_ENDIAN__
18899   return __builtin_altivec_vstribl_p(__CR6_EQ, (vector signed char)__a);
18900 #else
18901   return __builtin_altivec_vstribr_p(__CR6_EQ, (vector signed char)__a);
18902 #endif
18903 }
18904
18905 static __inline__ int __ATTRS_o_ai vec_strir_p(vector signed char __a) {
18906 #ifdef __LITTLE_ENDIAN__
18907   return __builtin_altivec_vstribl_p(__CR6_EQ, __a);
18908 #else
18909   return __builtin_altivec_vstribr_p(__CR6_EQ, __a);
18910 #endif
18911 }
18912
18913 static __inline__ int __ATTRS_o_ai vec_strir_p(vector unsigned short __a) {
18914 #ifdef __LITTLE_ENDIAN__
18915   return __builtin_altivec_vstrihl_p(__CR6_EQ, (vector signed short)__a);
18916 #else
18917   return __builtin_altivec_vstrihr_p(__CR6_EQ, (vector signed short)__a);
18918 #endif
18919 }
18920
18921 static __inline__ int __ATTRS_o_ai vec_strir_p(vector signed short __a) {
18922 #ifdef __LITTLE_ENDIAN__
18923   return __builtin_altivec_vstrihl_p(__CR6_EQ, __a);
18924 #else
18925   return __builtin_altivec_vstrihr_p(__CR6_EQ, __a);
18926 #endif
18927 }
18928
18929 /* vs[l | r | ra] */
18930
18931 #ifdef __SIZEOF_INT128__
18932 static __inline__ vector unsigned __int128 __ATTRS_o_ai
18933 vec_sl(vector unsigned __int128 __a, vector unsigned __int128 __b) {
18934   return __a << (__b % (vector unsigned __int128)(sizeof(unsigned __int128) *
18935                                                   __CHAR_BIT__));
18936 }
18937
18938 static __inline__ vector signed __int128 __ATTRS_o_ai
18939 vec_sl(vector signed __int128 __a, vector unsigned __int128 __b) {
18940   return __a << (__b % (vector unsigned __int128)(sizeof(unsigned __int128) *
18941                                                   __CHAR_BIT__));
18942 }
18943
18944 static __inline__ vector unsigned __int128 __ATTRS_o_ai
18945 vec_sr(vector unsigned __int128 __a, vector unsigned __int128 __b) {
18946   return __a >> (__b % (vector unsigned __int128)(sizeof(unsigned __int128) *
18947                                                   __CHAR_BIT__));
18948 }
18949
18950 static __inline__ vector signed __int128 __ATTRS_o_ai
18951 vec_sr(vector signed __int128 __a, vector unsigned __int128 __b) {
18952   return (
18953       vector signed __int128)(((vector unsigned __int128)__a) >>
18954                               (__b %
18955                                (vector unsigned __int128)(sizeof(
18956                                                               unsigned __int128) *
18957                                                           __CHAR_BIT__)));
18958 }
18959
18960 static __inline__ vector unsigned __int128 __ATTRS_o_ai
18961 vec_sra(vector unsigned __int128 __a, vector unsigned __int128 __b) {
18962   return (
18963       vector unsigned __int128)(((vector signed __int128)__a) >>
18964                                 (__b %
18965                                  (vector unsigned __int128)(sizeof(
18966                                                                 unsigned __int128) *
18967                                                             __CHAR_BIT__)));
18968 }
18969
18970 static __inline__ vector signed __int128 __ATTRS_o_ai
18971 vec_sra(vector signed __int128 __a, vector unsigned __int128 __b) {
18972   return __a >> (__b % (vector unsigned __int128)(sizeof(unsigned __int128) *
18973                                                   __CHAR_BIT__));
18974 }
18975
18976 #endif /* __SIZEOF_INT128__ */
18977 #endif /* __POWER10_VECTOR__ */
18978
18979 #undef __ATTRS_o_ai
18980
18981 #endif /* __ALTIVEC_H */