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 #define __CR6_GT 4
  23 #define __CR6_GT_REV 5
  24 #define __CR6_SO 6
  25 #define __CR6_SO_REV 7
  26
  27 /* Constants for vec_test_data_class */
  28 #define __VEC_CLASS_FP_SUBNORMAL_N (1 << 0)
  29 #define __VEC_CLASS_FP_SUBNORMAL_P (1 << 1)
  30 #define __VEC_CLASS_FP_SUBNORMAL (__VEC_CLASS_FP_SUBNORMAL_P | \
  31                                   __VEC_CLASS_FP_SUBNORMAL_N)
  32 #define __VEC_CLASS_FP_ZERO_N (1<<2)
  33 #define __VEC_CLASS_FP_ZERO_P (1<<3)
  34 #define __VEC_CLASS_FP_ZERO (__VEC_CLASS_FP_ZERO_P           | \
  35                              __VEC_CLASS_FP_ZERO_N)
  36 #define __VEC_CLASS_FP_INFINITY_N (1<<4)
  37 #define __VEC_CLASS_FP_INFINITY_P (1<<5)
  38 #define __VEC_CLASS_FP_INFINITY (__VEC_CLASS_FP_INFINITY_P   | \
  39                                  __VEC_CLASS_FP_INFINITY_N)
  40 #define __VEC_CLASS_FP_NAN (1<<6)
  41 #define __VEC_CLASS_FP_NOT_NORMAL (__VEC_CLASS_FP_NAN        | \
  42                                    __VEC_CLASS_FP_SUBNORMAL  | \
  43                                    __VEC_CLASS_FP_ZERO       | \
  44                                    __VEC_CLASS_FP_INFINITY)
  45
  46 #define __ATTRS_o_ai __attribute__((__overloadable__, __always_inline__))
  47
  48 #include <stddef.h>
  49
  50 static __inline__ vector signed char __ATTRS_o_ai vec_perm(
  51     vector signed char __a, vector signed char __b, vector unsigned char __c);
  52
  53 static __inline__ vector unsigned char __ATTRS_o_ai
  54 vec_perm(vector unsigned char __a, vector unsigned char __b,
  55          vector unsigned char __c);
  56
  57 static __inline__ vector bool char __ATTRS_o_ai
  58 vec_perm(vector bool char __a, vector bool char __b, vector unsigned char __c);
  59
  60 static __inline__ vector short __ATTRS_o_ai vec_perm(vector signed short __a,
  61                                                      vector signed short __b,
  62                                                      vector unsigned char __c);
  63
  64 static __inline__ vector unsigned short __ATTRS_o_ai
  65 vec_perm(vector unsigned short __a, vector unsigned short __b,
  66          vector unsigned char __c);
  67
  68 static __inline__ vector bool short __ATTRS_o_ai vec_perm(
  69     vector bool short __a, vector bool short __b, vector unsigned char __c);
  70
  71 static __inline__ vector pixel __ATTRS_o_ai vec_perm(vector pixel __a,
  72                                                      vector pixel __b,
  73                                                      vector unsigned char __c);
  74
  75 static __inline__ vector int __ATTRS_o_ai vec_perm(vector signed int __a,
  76                                                    vector signed int __b,
  77                                                    vector unsigned char __c);
  78
  79 static __inline__ vector unsigned int __ATTRS_o_ai vec_perm(
  80     vector unsigned int __a, vector unsigned int __b, vector unsigned char __c);
  81
  82 static __inline__ vector bool int __ATTRS_o_ai
  83 vec_perm(vector bool int __a, vector bool int __b, vector unsigned char __c);
  84
  85 static __inline__ vector float __ATTRS_o_ai vec_perm(vector float __a,
  86                                                      vector float __b,
  87                                                      vector unsigned char __c);
  88
  89 #ifdef __VSX__
  90 static __inline__ vector long long __ATTRS_o_ai
  91 vec_perm(vector signed long long __a, vector signed long long __b,
  92          vector unsigned char __c);
  93
  94 static __inline__ vector unsigned long long __ATTRS_o_ai
  95 vec_perm(vector unsigned long long __a, vector unsigned long long __b,
  96          vector unsigned char __c);
  97
  98 static __inline__ vector bool long long __ATTRS_o_ai
  99 vec_perm(vector bool long long __a, vector bool long long __b,
 100          vector unsigned char __c);
 101
 102 static __inline__ vector double __ATTRS_o_ai vec_perm(vector double __a,
 103                                                       vector double __b,
 104                                                       vector unsigned char __c);
 105 #endif
 106
 107 static __inline__ vector unsigned char __ATTRS_o_ai
 108 vec_xor(vector unsigned char __a, vector unsigned char __b);
 109
 110 /* vec_abs */
 111
 112 #define __builtin_altivec_abs_v16qi vec_abs
 113 #define __builtin_altivec_abs_v8hi vec_abs
 114 #define __builtin_altivec_abs_v4si vec_abs
 115
 116 static __inline__ vector signed char __ATTRS_o_ai
 117 vec_abs(vector signed char __a) {
 118   return __builtin_altivec_vmaxsb(__a, -__a);
 119 }
 120
 121 static __inline__ vector signed short __ATTRS_o_ai
 122 vec_abs(vector signed short __a) {
 123   return __builtin_altivec_vmaxsh(__a, -__a);
 124 }
 125
 126 static __inline__ vector signed int __ATTRS_o_ai
 127 vec_abs(vector signed int __a) {
 128   return __builtin_altivec_vmaxsw(__a, -__a);
 129 }
 130
 131 #ifdef __POWER8_VECTOR__
 132 static __inline__ vector signed long long __ATTRS_o_ai
 133 vec_abs(vector signed long long __a) {
 134   return __builtin_altivec_vmaxsd(__a, -__a);
 135 }
 136 #endif
 137
 138 static __inline__ vector float __ATTRS_o_ai vec_abs(vector float __a) {
 139 #ifdef __VSX__
 140   return __builtin_vsx_xvabssp(__a);
 141 #else
 142   vector unsigned int __res =
 143       (vector unsigned int)__a & (vector unsigned int)(0x7FFFFFFF);
 144   return (vector float)__res;
 145 #endif
 146 }
 147
 148 #ifdef __VSX__
 149 static __inline__ vector double __ATTRS_o_ai vec_abs(vector double __a) {
 150   return __builtin_vsx_xvabsdp(__a);
 151 }
 152 #endif
 153
 154 /* vec_abss */
 155 #define __builtin_altivec_abss_v16qi vec_abss
 156 #define __builtin_altivec_abss_v8hi vec_abss
 157 #define __builtin_altivec_abss_v4si vec_abss
 158
 159 static __inline__ vector signed char __ATTRS_o_ai
 160 vec_abss(vector signed char __a) {
 161   return __builtin_altivec_vmaxsb(
 162       __a, __builtin_altivec_vsubsbs((vector signed char)(0), __a));
 163 }
 164
 165 static __inline__ vector signed short __ATTRS_o_ai
 166 vec_abss(vector signed short __a) {
 167   return __builtin_altivec_vmaxsh(
 168       __a, __builtin_altivec_vsubshs((vector signed short)(0), __a));
 169 }
 170
 171 static __inline__ vector signed int __ATTRS_o_ai
 172 vec_abss(vector signed int __a) {
 173   return __builtin_altivec_vmaxsw(
 174       __a, __builtin_altivec_vsubsws((vector signed int)(0), __a));
 175 }
 176
 177 /* vec_absd */
 178 #if defined(__POWER9_VECTOR__)
 179
 180 static __inline__ vector unsigned char __ATTRS_o_ai
 181 vec_absd(vector unsigned char __a, vector unsigned char __b) {
 182   return __builtin_altivec_vabsdub(__a, __b);
 183 }
 184
 185 static __inline__ vector unsigned short __ATTRS_o_ai
 186 vec_absd(vector unsigned short __a, vector unsigned short __b) {
 187   return __builtin_altivec_vabsduh(__a, __b);
 188 }
 189
 190 static __inline__ vector unsigned int __ATTRS_o_ai
 191 vec_absd(vector unsigned int __a,  vector unsigned int __b) {
 192   return __builtin_altivec_vabsduw(__a, __b);
 193 }
 194
 195 #endif /* End __POWER9_VECTOR__ */
 196
 197 /* vec_add */
 198
 199 static __inline__ vector signed char __ATTRS_o_ai
 200 vec_add(vector signed char __a, vector signed char __b) {
 201   return __a + __b;
 202 }
 203
 204 static __inline__ vector signed char __ATTRS_o_ai
 205 vec_add(vector bool char __a, vector signed char __b) {
 206   return (vector signed char)__a + __b;
 207 }
 208
 209 static __inline__ vector signed char __ATTRS_o_ai
 210 vec_add(vector signed char __a, vector bool char __b) {
 211   return __a + (vector signed char)__b;
 212 }
 213
 214 static __inline__ vector unsigned char __ATTRS_o_ai
 215 vec_add(vector unsigned char __a, vector unsigned char __b) {
 216   return __a + __b;
 217 }
 218
 219 static __inline__ vector unsigned char __ATTRS_o_ai
 220 vec_add(vector bool char __a, vector unsigned char __b) {
 221   return (vector unsigned char)__a + __b;
 222 }
 223
 224 static __inline__ vector unsigned char __ATTRS_o_ai
 225 vec_add(vector unsigned char __a, vector bool char __b) {
 226   return __a + (vector unsigned char)__b;
 227 }
 228
 229 static __inline__ vector short __ATTRS_o_ai vec_add(vector short __a,
 230                                                     vector short __b) {
 231   return __a + __b;
 232 }
 233
 234 static __inline__ vector short __ATTRS_o_ai vec_add(vector bool short __a,
 235                                                     vector short __b) {
 236   return (vector short)__a + __b;
 237 }
 238
 239 static __inline__ vector short __ATTRS_o_ai vec_add(vector short __a,
 240                                                     vector bool short __b) {
 241   return __a + (vector short)__b;
 242 }
 243
 244 static __inline__ vector unsigned short __ATTRS_o_ai
 245 vec_add(vector unsigned short __a, vector unsigned short __b) {
 246   return __a + __b;
 247 }
 248
 249 static __inline__ vector unsigned short __ATTRS_o_ai
 250 vec_add(vector bool short __a, vector unsigned short __b) {
 251   return (vector unsigned short)__a + __b;
 252 }
 253
 254 static __inline__ vector unsigned short __ATTRS_o_ai
 255 vec_add(vector unsigned short __a, vector bool short __b) {
 256   return __a + (vector unsigned short)__b;
 257 }
 258
 259 static __inline__ vector int __ATTRS_o_ai vec_add(vector int __a,
 260                                                   vector int __b) {
 261   return __a + __b;
 262 }
 263
 264 static __inline__ vector int __ATTRS_o_ai vec_add(vector bool int __a,
 265                                                   vector int __b) {
 266   return (vector int)__a + __b;
 267 }
 268
 269 static __inline__ vector int __ATTRS_o_ai vec_add(vector int __a,
 270                                                   vector bool int __b) {
 271   return __a + (vector int)__b;
 272 }
 273
 274 static __inline__ vector unsigned int __ATTRS_o_ai
 275 vec_add(vector unsigned int __a, vector unsigned int __b) {
 276   return __a + __b;
 277 }
 278
 279 static __inline__ vector unsigned int __ATTRS_o_ai
 280 vec_add(vector bool int __a, vector unsigned int __b) {
 281   return (vector unsigned int)__a + __b;
 282 }
 283
 284 static __inline__ vector unsigned int __ATTRS_o_ai
 285 vec_add(vector unsigned int __a, vector bool int __b) {
 286   return __a + (vector unsigned int)__b;
 287 }
 288
 289 #ifdef __POWER8_VECTOR__
 290 static __inline__ vector signed long long __ATTRS_o_ai
 291 vec_add(vector signed long long __a, vector signed long long __b) {
 292   return __a + __b;
 293 }
 294
 295 static __inline__ vector unsigned long long __ATTRS_o_ai
 296 vec_add(vector unsigned long long __a, vector unsigned long long __b) {
 297   return __a + __b;
 298 }
 299
 300 #ifdef __SIZEOF_INT128__
 301 static __inline__ vector signed __int128 __ATTRS_o_ai
 302 vec_add(vector signed __int128 __a, vector signed __int128 __b) {
 303   return __a + __b;
 304 }
 305
 306 static __inline__ vector unsigned __int128 __ATTRS_o_ai
 307 vec_add(vector unsigned __int128 __a, vector unsigned __int128 __b) {
 308   return __a + __b;
 309 }
 310 #endif
 311
 312 static __inline__ vector unsigned char __attribute__((__always_inline__))
 313 vec_add_u128(vector unsigned char __a, vector unsigned char __b) {
 314   return (vector unsigned char)__builtin_altivec_vadduqm(__a, __b);
 315 }
 316 #elif defined(__VSX__)
 317 static __inline__ vector signed long long __ATTRS_o_ai
 318 vec_add(vector signed long long __a, vector signed long long __b) {
 319 #ifdef __LITTLE_ENDIAN__
 320   // Little endian systems on CPU's prior to Power8 don't really exist
 321   // so scalarizing is fine.
 322   return __a + __b;
 323 #else
 324   vector unsigned int __res =
 325       (vector unsigned int)__a + (vector unsigned int)__b;
 326   vector unsigned int __carry = __builtin_altivec_vaddcuw(
 327       (vector unsigned int)__a, (vector unsigned int)__b);
 328   __carry = (vector unsigned int)__builtin_shufflevector(
 329       (vector unsigned char)__carry, (vector unsigned char)__carry, 0, 0, 0, 7,
 330       0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 0);
 331   return (vector signed long long)(__res + __carry);
 332 #endif
 333 }
 334
 335 static __inline__ vector unsigned long long __ATTRS_o_ai
 336 vec_add(vector unsigned long long __a, vector unsigned long long __b) {
 337   return (vector unsigned long long)vec_add((vector signed long long)__a,
 338                                             (vector signed long long)__b);
 339 }
 340 #endif // __POWER8_VECTOR__
 341
 342 static __inline__ vector float __ATTRS_o_ai vec_add(vector float __a,
 343                                                     vector float __b) {
 344   return __a + __b;
 345 }
 346
 347 #ifdef __VSX__
 348 static __inline__ vector double __ATTRS_o_ai vec_add(vector double __a,
 349                                                      vector double __b) {
 350   return __a + __b;
 351 }
 352 #endif // __VSX__
 353
 354 /* vec_adde */
 355
 356 #ifdef __POWER8_VECTOR__
 357 #ifdef __SIZEOF_INT128__
 358 static __inline__ vector signed __int128 __ATTRS_o_ai
 359 vec_adde(vector signed __int128 __a, vector signed __int128 __b,
 360          vector signed __int128 __c) {
 361   return (vector signed __int128)__builtin_altivec_vaddeuqm(
 362       (vector unsigned __int128)__a, (vector unsigned __int128)__b,
 363       (vector unsigned __int128)__c);
 364 }
 365
 366 static __inline__ vector unsigned __int128 __ATTRS_o_ai
 367 vec_adde(vector unsigned __int128 __a, vector unsigned __int128 __b,
 368          vector unsigned __int128 __c) {
 369   return __builtin_altivec_vaddeuqm(__a, __b, __c);
 370 }
 371 #endif
 372
 373 static __inline__ vector unsigned char __attribute__((__always_inline__))
 374 vec_adde_u128(vector unsigned char __a, vector unsigned char __b,
 375               vector unsigned char __c) {
 376   return (vector unsigned char)__builtin_altivec_vaddeuqm_c(
 377       (vector unsigned char)__a, (vector unsigned char)__b,
 378       (vector unsigned char)__c);
 379 }
 380 #endif
 381
 382 static __inline__ vector signed int __ATTRS_o_ai
 383 vec_adde(vector signed int __a, vector signed int __b,
 384          vector signed int __c) {
 385   vector signed int __mask = {1, 1, 1, 1};
 386   vector signed int __carry = __c & __mask;
 387   return vec_add(vec_add(__a, __b), __carry);
 388 }
 389
 390 static __inline__ vector unsigned int __ATTRS_o_ai
 391 vec_adde(vector unsigned int __a, vector unsigned int __b,
 392          vector unsigned int __c) {
 393   vector unsigned int __mask = {1, 1, 1, 1};
 394   vector unsigned int __carry = __c & __mask;
 395   return vec_add(vec_add(__a, __b), __carry);
 396 }
 397
 398 /* vec_addec */
 399
 400 #ifdef __POWER8_VECTOR__
 401 #ifdef __SIZEOF_INT128__
 402 static __inline__ vector signed __int128 __ATTRS_o_ai
 403 vec_addec(vector signed __int128 __a, vector signed __int128 __b,
 404           vector signed __int128 __c) {
 405   return (vector signed __int128)__builtin_altivec_vaddecuq(
 406       (vector unsigned __int128)__a, (vector unsigned __int128)__b,
 407       (vector unsigned __int128)__c);
 408 }
 409
 410 static __inline__ vector unsigned __int128 __ATTRS_o_ai
 411 vec_addec(vector unsigned __int128 __a, vector unsigned __int128 __b,
 412           vector unsigned __int128 __c) {
 413   return __builtin_altivec_vaddecuq(__a, __b, __c);
 414 }
 415 #endif
 416
 417 static __inline__ vector unsigned char __attribute__((__always_inline__))
 418 vec_addec_u128(vector unsigned char __a, vector unsigned char __b,
 419                vector unsigned char __c) {
 420   return (vector unsigned char)__builtin_altivec_vaddecuq_c(
 421       (vector unsigned char)__a, (vector unsigned char)__b,
 422       (vector unsigned char)__c);
 423 }
 424
 425 #ifdef __powerpc64__
 426 static __inline__ vector signed int __ATTRS_o_ai
 427 vec_addec(vector signed int __a, vector signed int __b,
 428           vector signed int __c) {
 429
 430   signed int __result[4];
 431   for (int i = 0; i < 4; i++) {
 432     unsigned int __tempa = (unsigned int) __a[i];
 433     unsigned int __tempb = (unsigned int) __b[i];
 434     unsigned int __tempc = (unsigned int) __c[i];
 435     __tempc = __tempc & 0x00000001;
 436     unsigned long long __longa = (unsigned long long) __tempa;
 437     unsigned long long __longb = (unsigned long long) __tempb;
 438     unsigned long long __longc = (unsigned long long) __tempc;
 439     unsigned long long __sum = __longa + __longb + __longc;
 440     unsigned long long __res = (__sum >> 32) & 0x01;
 441     unsigned long long __tempres = (unsigned int) __res;
 442     __result[i] = (signed int) __tempres;
 443   }
 444
 445   vector signed int ret = { __result[0], __result[1], __result[2], __result[3] };
 446   return ret;
 447 }
 448
 449 static __inline__ vector unsigned int __ATTRS_o_ai
 450 vec_addec(vector unsigned int __a, vector unsigned int __b,
 451           vector unsigned int __c) {
 452
 453   unsigned int __result[4];
 454   for (int i = 0; i < 4; i++) {
 455     unsigned int __tempc = __c[i] & 1;
 456     unsigned long long __longa = (unsigned long long) __a[i];
 457     unsigned long long __longb = (unsigned long long) __b[i];
 458     unsigned long long __longc = (unsigned long long) __tempc;
 459     unsigned long long __sum = __longa + __longb + __longc;
 460     unsigned long long __res = (__sum >> 32) & 0x01;
 461     unsigned long long __tempres = (unsigned int) __res;
 462     __result[i] = (signed int) __tempres;
 463   }
 464
 465   vector unsigned int ret = { __result[0], __result[1], __result[2], __result[3] };
 466   return ret;
 467 }
 468 #endif // __powerpc64__
 469 #endif // __POWER8_VECTOR__
 470
 471 /* vec_vaddubm */
 472
 473 #define __builtin_altivec_vaddubm vec_vaddubm
 474
 475 static __inline__ vector signed char __ATTRS_o_ai
 476 vec_vaddubm(vector signed char __a, vector signed char __b) {
 477   return __a + __b;
 478 }
 479
 480 static __inline__ vector signed char __ATTRS_o_ai
 481 vec_vaddubm(vector bool char __a, vector signed char __b) {
 482   return (vector signed char)__a + __b;
 483 }
 484
 485 static __inline__ vector signed char __ATTRS_o_ai
 486 vec_vaddubm(vector signed char __a, vector bool char __b) {
 487   return __a + (vector signed char)__b;
 488 }
 489
 490 static __inline__ vector unsigned char __ATTRS_o_ai
 491 vec_vaddubm(vector unsigned char __a, vector unsigned char __b) {
 492   return __a + __b;
 493 }
 494
 495 static __inline__ vector unsigned char __ATTRS_o_ai
 496 vec_vaddubm(vector bool char __a, vector unsigned char __b) {
 497   return (vector unsigned char)__a + __b;
 498 }
 499
 500 static __inline__ vector unsigned char __ATTRS_o_ai
 501 vec_vaddubm(vector unsigned char __a, vector bool char __b) {
 502   return __a + (vector unsigned char)__b;
 503 }
 504
 505 /* vec_vadduhm */
 506
 507 #define __builtin_altivec_vadduhm vec_vadduhm
 508
 509 static __inline__ vector short __ATTRS_o_ai vec_vadduhm(vector short __a,
 510                                                         vector short __b) {
 511   return __a + __b;
 512 }
 513
 514 static __inline__ vector short __ATTRS_o_ai vec_vadduhm(vector bool short __a,
 515                                                         vector short __b) {
 516   return (vector short)__a + __b;
 517 }
 518
 519 static __inline__ vector short __ATTRS_o_ai vec_vadduhm(vector short __a,
 520                                                         vector bool short __b) {
 521   return __a + (vector short)__b;
 522 }
 523
 524 static __inline__ vector unsigned short __ATTRS_o_ai
 525 vec_vadduhm(vector unsigned short __a, vector unsigned short __b) {
 526   return __a + __b;
 527 }
 528
 529 static __inline__ vector unsigned short __ATTRS_o_ai
 530 vec_vadduhm(vector bool short __a, vector unsigned short __b) {
 531   return (vector unsigned short)__a + __b;
 532 }
 533
 534 static __inline__ vector unsigned short __ATTRS_o_ai
 535 vec_vadduhm(vector unsigned short __a, vector bool short __b) {
 536   return __a + (vector unsigned short)__b;
 537 }
 538
 539 /* vec_vadduwm */
 540
 541 #define __builtin_altivec_vadduwm vec_vadduwm
 542
 543 static __inline__ vector int __ATTRS_o_ai vec_vadduwm(vector int __a,
 544                                                       vector int __b) {
 545   return __a + __b;
 546 }
 547
 548 static __inline__ vector int __ATTRS_o_ai vec_vadduwm(vector bool int __a,
 549                                                       vector int __b) {
 550   return (vector int)__a + __b;
 551 }
 552
 553 static __inline__ vector int __ATTRS_o_ai vec_vadduwm(vector int __a,
 554                                                       vector bool int __b) {
 555   return __a + (vector int)__b;
 556 }
 557
 558 static __inline__ vector unsigned int __ATTRS_o_ai
 559 vec_vadduwm(vector unsigned int __a, vector unsigned int __b) {
 560   return __a + __b;
 561 }
 562
 563 static __inline__ vector unsigned int __ATTRS_o_ai
 564 vec_vadduwm(vector bool int __a, vector unsigned int __b) {
 565   return (vector unsigned int)__a + __b;
 566 }
 567
 568 static __inline__ vector unsigned int __ATTRS_o_ai
 569 vec_vadduwm(vector unsigned int __a, vector bool int __b) {
 570   return __a + (vector unsigned int)__b;
 571 }
 572
 573 /* vec_vaddfp */
 574
 575 #define __builtin_altivec_vaddfp vec_vaddfp
 576
 577 static __inline__ vector float __attribute__((__always_inline__))
 578 vec_vaddfp(vector float __a, vector float __b) {
 579   return __a + __b;
 580 }
 581
 582 /* vec_addc */
 583
 584 static __inline__ vector signed int __ATTRS_o_ai
 585 vec_addc(vector signed int __a, vector signed int __b) {
 586   return (vector signed int)__builtin_altivec_vaddcuw((vector unsigned int)__a,
 587                                                       (vector unsigned int)__b);
 588 }
 589
 590 static __inline__ vector unsigned int __ATTRS_o_ai
 591 vec_addc(vector unsigned int __a, vector unsigned int __b) {
 592   return __builtin_altivec_vaddcuw(__a, __b);
 593 }
 594
 595 #ifdef __POWER8_VECTOR__
 596 #ifdef __SIZEOF_INT128__
 597 static __inline__ vector signed __int128 __ATTRS_o_ai
 598 vec_addc(vector signed __int128 __a, vector signed __int128 __b) {
 599   return (vector signed __int128)__builtin_altivec_vaddcuq(
 600       (vector unsigned __int128)__a, (vector unsigned __int128)__b);
 601 }
 602
 603 static __inline__ vector unsigned __int128 __ATTRS_o_ai
 604 vec_addc(vector unsigned __int128 __a, vector unsigned __int128 __b) {
 605   return __builtin_altivec_vaddcuq(__a, __b);
 606 }
 607 #endif
 608
 609 static __inline__ vector unsigned char __attribute__((__always_inline__))
 610 vec_addc_u128(vector unsigned char __a, vector unsigned char __b) {
 611   return (vector unsigned char)__builtin_altivec_vaddcuq_c(
 612       (vector unsigned char)__a, (vector unsigned char)__b);
 613 }
 614 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
 615
 616 /* vec_vaddcuw */
 617
 618 static __inline__ vector unsigned int __attribute__((__always_inline__))
 619 vec_vaddcuw(vector unsigned int __a, vector unsigned int __b) {
 620   return __builtin_altivec_vaddcuw(__a, __b);
 621 }
 622
 623 /* vec_adds */
 624
 625 static __inline__ vector signed char __ATTRS_o_ai
 626 vec_adds(vector signed char __a, vector signed char __b) {
 627   return __builtin_altivec_vaddsbs(__a, __b);
 628 }
 629
 630 static __inline__ vector signed char __ATTRS_o_ai
 631 vec_adds(vector bool char __a, vector signed char __b) {
 632   return __builtin_altivec_vaddsbs((vector signed char)__a, __b);
 633 }
 634
 635 static __inline__ vector signed char __ATTRS_o_ai
 636 vec_adds(vector signed char __a, vector bool char __b) {
 637   return __builtin_altivec_vaddsbs(__a, (vector signed char)__b);
 638 }
 639
 640 static __inline__ vector unsigned char __ATTRS_o_ai
 641 vec_adds(vector unsigned char __a, vector unsigned char __b) {
 642   return __builtin_altivec_vaddubs(__a, __b);
 643 }
 644
 645 static __inline__ vector unsigned char __ATTRS_o_ai
 646 vec_adds(vector bool char __a, vector unsigned char __b) {
 647   return __builtin_altivec_vaddubs((vector unsigned char)__a, __b);
 648 }
 649
 650 static __inline__ vector unsigned char __ATTRS_o_ai
 651 vec_adds(vector unsigned char __a, vector bool char __b) {
 652   return __builtin_altivec_vaddubs(__a, (vector unsigned char)__b);
 653 }
 654
 655 static __inline__ vector short __ATTRS_o_ai vec_adds(vector short __a,
 656                                                      vector short __b) {
 657   return __builtin_altivec_vaddshs(__a, __b);
 658 }
 659
 660 static __inline__ vector short __ATTRS_o_ai vec_adds(vector bool short __a,
 661                                                      vector short __b) {
 662   return __builtin_altivec_vaddshs((vector short)__a, __b);
 663 }
 664
 665 static __inline__ vector short __ATTRS_o_ai vec_adds(vector short __a,
 666                                                      vector bool short __b) {
 667   return __builtin_altivec_vaddshs(__a, (vector short)__b);
 668 }
 669
 670 static __inline__ vector unsigned short __ATTRS_o_ai
 671 vec_adds(vector unsigned short __a, vector unsigned short __b) {
 672   return __builtin_altivec_vadduhs(__a, __b);
 673 }
 674
 675 static __inline__ vector unsigned short __ATTRS_o_ai
 676 vec_adds(vector bool short __a, vector unsigned short __b) {
 677   return __builtin_altivec_vadduhs((vector unsigned short)__a, __b);
 678 }
 679
 680 static __inline__ vector unsigned short __ATTRS_o_ai
 681 vec_adds(vector unsigned short __a, vector bool short __b) {
 682   return __builtin_altivec_vadduhs(__a, (vector unsigned short)__b);
 683 }
 684
 685 static __inline__ vector int __ATTRS_o_ai vec_adds(vector int __a,
 686                                                    vector int __b) {
 687   return __builtin_altivec_vaddsws(__a, __b);
 688 }
 689
 690 static __inline__ vector int __ATTRS_o_ai vec_adds(vector bool int __a,
 691                                                    vector int __b) {
 692   return __builtin_altivec_vaddsws((vector int)__a, __b);
 693 }
 694
 695 static __inline__ vector int __ATTRS_o_ai vec_adds(vector int __a,
 696                                                    vector bool int __b) {
 697   return __builtin_altivec_vaddsws(__a, (vector int)__b);
 698 }
 699
 700 static __inline__ vector unsigned int __ATTRS_o_ai
 701 vec_adds(vector unsigned int __a, vector unsigned int __b) {
 702   return __builtin_altivec_vadduws(__a, __b);
 703 }
 704
 705 static __inline__ vector unsigned int __ATTRS_o_ai
 706 vec_adds(vector bool int __a, vector unsigned int __b) {
 707   return __builtin_altivec_vadduws((vector unsigned int)__a, __b);
 708 }
 709
 710 static __inline__ vector unsigned int __ATTRS_o_ai
 711 vec_adds(vector unsigned int __a, vector bool int __b) {
 712   return __builtin_altivec_vadduws(__a, (vector unsigned int)__b);
 713 }
 714
 715 /* vec_vaddsbs */
 716
 717 static __inline__ vector signed char __ATTRS_o_ai
 718 vec_vaddsbs(vector signed char __a, vector signed char __b) {
 719   return __builtin_altivec_vaddsbs(__a, __b);
 720 }
 721
 722 static __inline__ vector signed char __ATTRS_o_ai
 723 vec_vaddsbs(vector bool char __a, vector signed char __b) {
 724   return __builtin_altivec_vaddsbs((vector signed char)__a, __b);
 725 }
 726
 727 static __inline__ vector signed char __ATTRS_o_ai
 728 vec_vaddsbs(vector signed char __a, vector bool char __b) {
 729   return __builtin_altivec_vaddsbs(__a, (vector signed char)__b);
 730 }
 731
 732 /* vec_vaddubs */
 733
 734 static __inline__ vector unsigned char __ATTRS_o_ai
 735 vec_vaddubs(vector unsigned char __a, vector unsigned char __b) {
 736   return __builtin_altivec_vaddubs(__a, __b);
 737 }
 738
 739 static __inline__ vector unsigned char __ATTRS_o_ai
 740 vec_vaddubs(vector bool char __a, vector unsigned char __b) {
 741   return __builtin_altivec_vaddubs((vector unsigned char)__a, __b);
 742 }
 743
 744 static __inline__ vector unsigned char __ATTRS_o_ai
 745 vec_vaddubs(vector unsigned char __a, vector bool char __b) {
 746   return __builtin_altivec_vaddubs(__a, (vector unsigned char)__b);
 747 }
 748
 749 /* vec_vaddshs */
 750
 751 static __inline__ vector short __ATTRS_o_ai vec_vaddshs(vector short __a,
 752                                                         vector short __b) {
 753   return __builtin_altivec_vaddshs(__a, __b);
 754 }
 755
 756 static __inline__ vector short __ATTRS_o_ai vec_vaddshs(vector bool short __a,
 757                                                         vector short __b) {
 758   return __builtin_altivec_vaddshs((vector short)__a, __b);
 759 }
 760
 761 static __inline__ vector short __ATTRS_o_ai vec_vaddshs(vector short __a,
 762                                                         vector bool short __b) {
 763   return __builtin_altivec_vaddshs(__a, (vector short)__b);
 764 }
 765
 766 /* vec_vadduhs */
 767
 768 static __inline__ vector unsigned short __ATTRS_o_ai
 769 vec_vadduhs(vector unsigned short __a, vector unsigned short __b) {
 770   return __builtin_altivec_vadduhs(__a, __b);
 771 }
 772
 773 static __inline__ vector unsigned short __ATTRS_o_ai
 774 vec_vadduhs(vector bool short __a, vector unsigned short __b) {
 775   return __builtin_altivec_vadduhs((vector unsigned short)__a, __b);
 776 }
 777
 778 static __inline__ vector unsigned short __ATTRS_o_ai
 779 vec_vadduhs(vector unsigned short __a, vector bool short __b) {
 780   return __builtin_altivec_vadduhs(__a, (vector unsigned short)__b);
 781 }
 782
 783 /* vec_vaddsws */
 784
 785 static __inline__ vector int __ATTRS_o_ai vec_vaddsws(vector int __a,
 786                                                       vector int __b) {
 787   return __builtin_altivec_vaddsws(__a, __b);
 788 }
 789
 790 static __inline__ vector int __ATTRS_o_ai vec_vaddsws(vector bool int __a,
 791                                                       vector int __b) {
 792   return __builtin_altivec_vaddsws((vector int)__a, __b);
 793 }
 794
 795 static __inline__ vector int __ATTRS_o_ai vec_vaddsws(vector int __a,
 796                                                       vector bool int __b) {
 797   return __builtin_altivec_vaddsws(__a, (vector int)__b);
 798 }
 799
 800 /* vec_vadduws */
 801
 802 static __inline__ vector unsigned int __ATTRS_o_ai
 803 vec_vadduws(vector unsigned int __a, vector unsigned int __b) {
 804   return __builtin_altivec_vadduws(__a, __b);
 805 }
 806
 807 static __inline__ vector unsigned int __ATTRS_o_ai
 808 vec_vadduws(vector bool int __a, vector unsigned int __b) {
 809   return __builtin_altivec_vadduws((vector unsigned int)__a, __b);
 810 }
 811
 812 static __inline__ vector unsigned int __ATTRS_o_ai
 813 vec_vadduws(vector unsigned int __a, vector bool int __b) {
 814   return __builtin_altivec_vadduws(__a, (vector unsigned int)__b);
 815 }
 816
 817 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__) &&                    \
 818     defined(__SIZEOF_INT128__)
 819 /* vec_vadduqm */
 820
 821 static __inline__ vector signed __int128 __ATTRS_o_ai
 822 vec_vadduqm(vector signed __int128 __a, vector signed __int128 __b) {
 823   return __a + __b;
 824 }
 825
 826 static __inline__ vector unsigned __int128 __ATTRS_o_ai
 827 vec_vadduqm(vector unsigned __int128 __a, vector unsigned __int128 __b) {
 828   return __a + __b;
 829 }
 830
 831 /* vec_vaddeuqm */
 832
 833 static __inline__ vector signed __int128 __ATTRS_o_ai
 834 vec_vaddeuqm(vector signed __int128 __a, vector signed __int128 __b,
 835              vector signed __int128 __c) {
 836   return (vector signed __int128)__builtin_altivec_vaddeuqm(
 837       (vector unsigned __int128)__a, (vector unsigned __int128)__b,
 838       (vector unsigned __int128)__c);
 839 }
 840
 841 static __inline__ vector unsigned __int128 __ATTRS_o_ai
 842 vec_vaddeuqm(vector unsigned __int128 __a, vector unsigned __int128 __b,
 843              vector unsigned __int128 __c) {
 844   return __builtin_altivec_vaddeuqm(__a, __b, __c);
 845 }
 846
 847 /* vec_vaddcuq */
 848
 849 static __inline__ vector signed __int128 __ATTRS_o_ai
 850 vec_vaddcuq(vector signed __int128 __a, vector signed __int128 __b) {
 851   return (vector signed __int128)__builtin_altivec_vaddcuq(
 852       (vector unsigned __int128)__a, (vector unsigned __int128)__b);
 853 }
 854
 855 static __inline__ vector unsigned __int128 __ATTRS_o_ai
 856 vec_vaddcuq(vector unsigned __int128 __a, vector unsigned __int128 __b) {
 857   return __builtin_altivec_vaddcuq(__a, __b);
 858 }
 859
 860 /* vec_vaddecuq */
 861
 862 static __inline__ vector signed __int128 __ATTRS_o_ai
 863 vec_vaddecuq(vector signed __int128 __a, vector signed __int128 __b,
 864              vector signed __int128 __c) {
 865   return (vector signed __int128)__builtin_altivec_vaddecuq(
 866       (vector unsigned __int128)__a, (vector unsigned __int128)__b,
 867       (vector unsigned __int128)__c);
 868 }
 869
 870 static __inline__ vector unsigned __int128 __ATTRS_o_ai
 871 vec_vaddecuq(vector unsigned __int128 __a, vector unsigned __int128 __b,
 872              vector unsigned __int128 __c) {
 873   return __builtin_altivec_vaddecuq(__a, __b, __c);
 874 }
 875 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
 876
 877 /* vec_and */
 878
 879 #define __builtin_altivec_vand vec_and
 880
 881 static __inline__ vector signed char __ATTRS_o_ai
 882 vec_and(vector signed char __a, vector signed char __b) {
 883   return __a & __b;
 884 }
 885
 886 static __inline__ vector signed char __ATTRS_o_ai
 887 vec_and(vector bool char __a, vector signed char __b) {
 888   return (vector signed char)__a & __b;
 889 }
 890
 891 static __inline__ vector signed char __ATTRS_o_ai
 892 vec_and(vector signed char __a, vector bool char __b) {
 893   return __a & (vector signed char)__b;
 894 }
 895
 896 static __inline__ vector unsigned char __ATTRS_o_ai
 897 vec_and(vector unsigned char __a, vector unsigned char __b) {
 898   return __a & __b;
 899 }
 900
 901 static __inline__ vector unsigned char __ATTRS_o_ai
 902 vec_and(vector bool char __a, vector unsigned char __b) {
 903   return (vector unsigned char)__a & __b;
 904 }
 905
 906 static __inline__ vector unsigned char __ATTRS_o_ai
 907 vec_and(vector unsigned char __a, vector bool char __b) {
 908   return __a & (vector unsigned char)__b;
 909 }
 910
 911 static __inline__ vector bool char __ATTRS_o_ai vec_and(vector bool char __a,
 912                                                         vector bool char __b) {
 913   return __a & __b;
 914 }
 915
 916 static __inline__ vector short __ATTRS_o_ai vec_and(vector short __a,
 917                                                     vector short __b) {
 918   return __a & __b;
 919 }
 920
 921 static __inline__ vector short __ATTRS_o_ai vec_and(vector bool short __a,
 922                                                     vector short __b) {
 923   return (vector short)__a & __b;
 924 }
 925
 926 static __inline__ vector short __ATTRS_o_ai vec_and(vector short __a,
 927                                                     vector bool short __b) {
 928   return __a & (vector short)__b;
 929 }
 930
 931 static __inline__ vector unsigned short __ATTRS_o_ai
 932 vec_and(vector unsigned short __a, vector unsigned short __b) {
 933   return __a & __b;
 934 }
 935
 936 static __inline__ vector unsigned short __ATTRS_o_ai
 937 vec_and(vector bool short __a, vector unsigned short __b) {
 938   return (vector unsigned short)__a & __b;
 939 }
 940
 941 static __inline__ vector unsigned short __ATTRS_o_ai
 942 vec_and(vector unsigned short __a, vector bool short __b) {
 943   return __a & (vector unsigned short)__b;
 944 }
 945
 946 static __inline__ vector bool short __ATTRS_o_ai
 947 vec_and(vector bool short __a, vector bool short __b) {
 948   return __a & __b;
 949 }
 950
 951 static __inline__ vector int __ATTRS_o_ai vec_and(vector int __a,
 952                                                   vector int __b) {
 953   return __a & __b;
 954 }
 955
 956 static __inline__ vector int __ATTRS_o_ai vec_and(vector bool int __a,
 957                                                   vector int __b) {
 958   return (vector int)__a & __b;
 959 }
 960
 961 static __inline__ vector int __ATTRS_o_ai vec_and(vector int __a,
 962                                                   vector bool int __b) {
 963   return __a & (vector int)__b;
 964 }
 965
 966 static __inline__ vector unsigned int __ATTRS_o_ai
 967 vec_and(vector unsigned int __a, vector unsigned int __b) {
 968   return __a & __b;
 969 }
 970
 971 static __inline__ vector unsigned int __ATTRS_o_ai
 972 vec_and(vector bool int __a, vector unsigned int __b) {
 973   return (vector unsigned int)__a & __b;
 974 }
 975
 976 static __inline__ vector unsigned int __ATTRS_o_ai
 977 vec_and(vector unsigned int __a, vector bool int __b) {
 978   return __a & (vector unsigned int)__b;
 979 }
 980
 981 static __inline__ vector bool int __ATTRS_o_ai vec_and(vector bool int __a,
 982                                                        vector bool int __b) {
 983   return __a & __b;
 984 }
 985
 986 static __inline__ vector float __ATTRS_o_ai vec_and(vector float __a,
 987                                                     vector float __b) {
 988   vector unsigned int __res =
 989       (vector unsigned int)__a & (vector unsigned int)__b;
 990   return (vector float)__res;
 991 }
 992
 993 static __inline__ vector float __ATTRS_o_ai vec_and(vector bool int __a,
 994                                                     vector float __b) {
 995   vector unsigned int __res =
 996       (vector unsigned int)__a & (vector unsigned int)__b;
 997   return (vector float)__res;
 998 }
 999
1000 static __inline__ vector float __ATTRS_o_ai vec_and(vector float __a,
1001                                                     vector bool int __b) {
1002   vector unsigned int __res =
1003       (vector unsigned int)__a & (vector unsigned int)__b;
1004   return (vector float)__res;
1005 }
1006
1007 #ifdef __VSX__
1008 static __inline__ vector double __ATTRS_o_ai vec_and(vector bool long long __a,
1009                                                      vector double __b) {
1010   vector unsigned long long __res =
1011       (vector unsigned long long)__a & (vector unsigned long long)__b;
1012   return (vector double)__res;
1013 }
1014
1015 static __inline__ vector double __ATTRS_o_ai
1016 vec_and(vector double __a, vector bool long long __b) {
1017   vector unsigned long long __res =
1018       (vector unsigned long long)__a & (vector unsigned long long)__b;
1019   return (vector double)__res;
1020 }
1021
1022 static __inline__ vector double __ATTRS_o_ai vec_and(vector double __a,
1023                                                      vector double __b) {
1024   vector unsigned long long __res =
1025       (vector unsigned long long)__a & (vector unsigned long long)__b;
1026   return (vector double)__res;
1027 }
1028
1029 static __inline__ vector signed long long __ATTRS_o_ai
1030 vec_and(vector signed long long __a, vector signed long long __b) {
1031   return __a & __b;
1032 }
1033
1034 static __inline__ vector signed long long __ATTRS_o_ai
1035 vec_and(vector bool long long __a, vector signed long long __b) {
1036   return (vector signed long long)__a & __b;
1037 }
1038
1039 static __inline__ vector signed long long __ATTRS_o_ai
1040 vec_and(vector signed long long __a, vector bool long long __b) {
1041   return __a & (vector signed long long)__b;
1042 }
1043
1044 static __inline__ vector unsigned long long __ATTRS_o_ai
1045 vec_and(vector unsigned long long __a, vector unsigned long long __b) {
1046   return __a & __b;
1047 }
1048
1049 static __inline__ vector unsigned long long __ATTRS_o_ai
1050 vec_and(vector bool long long __a, vector unsigned long long __b) {
1051   return (vector unsigned long long)__a & __b;
1052 }
1053
1054 static __inline__ vector unsigned long long __ATTRS_o_ai
1055 vec_and(vector unsigned long long __a, vector bool long long __b) {
1056   return __a & (vector unsigned long long)__b;
1057 }
1058
1059 static __inline__ vector bool long long __ATTRS_o_ai
1060 vec_and(vector bool long long __a, vector bool long long __b) {
1061   return __a & __b;
1062 }
1063 #endif
1064
1065 /* vec_vand */
1066
1067 static __inline__ vector signed char __ATTRS_o_ai
1068 vec_vand(vector signed char __a, vector signed char __b) {
1069   return __a & __b;
1070 }
1071
1072 static __inline__ vector signed char __ATTRS_o_ai
1073 vec_vand(vector bool char __a, vector signed char __b) {
1074   return (vector signed char)__a & __b;
1075 }
1076
1077 static __inline__ vector signed char __ATTRS_o_ai
1078 vec_vand(vector signed char __a, vector bool char __b) {
1079   return __a & (vector signed char)__b;
1080 }
1081
1082 static __inline__ vector unsigned char __ATTRS_o_ai
1083 vec_vand(vector unsigned char __a, vector unsigned char __b) {
1084   return __a & __b;
1085 }
1086
1087 static __inline__ vector unsigned char __ATTRS_o_ai
1088 vec_vand(vector bool char __a, vector unsigned char __b) {
1089   return (vector unsigned char)__a & __b;
1090 }
1091
1092 static __inline__ vector unsigned char __ATTRS_o_ai
1093 vec_vand(vector unsigned char __a, vector bool char __b) {
1094   return __a & (vector unsigned char)__b;
1095 }
1096
1097 static __inline__ vector bool char __ATTRS_o_ai vec_vand(vector bool char __a,
1098                                                          vector bool char __b) {
1099   return __a & __b;
1100 }
1101
1102 static __inline__ vector short __ATTRS_o_ai vec_vand(vector short __a,
1103                                                      vector short __b) {
1104   return __a & __b;
1105 }
1106
1107 static __inline__ vector short __ATTRS_o_ai vec_vand(vector bool short __a,
1108                                                      vector short __b) {
1109   return (vector short)__a & __b;
1110 }
1111
1112 static __inline__ vector short __ATTRS_o_ai vec_vand(vector short __a,
1113                                                      vector bool short __b) {
1114   return __a & (vector short)__b;
1115 }
1116
1117 static __inline__ vector unsigned short __ATTRS_o_ai
1118 vec_vand(vector unsigned short __a, vector unsigned short __b) {
1119   return __a & __b;
1120 }
1121
1122 static __inline__ vector unsigned short __ATTRS_o_ai
1123 vec_vand(vector bool short __a, vector unsigned short __b) {
1124   return (vector unsigned short)__a & __b;
1125 }
1126
1127 static __inline__ vector unsigned short __ATTRS_o_ai
1128 vec_vand(vector unsigned short __a, vector bool short __b) {
1129   return __a & (vector unsigned short)__b;
1130 }
1131
1132 static __inline__ vector bool short __ATTRS_o_ai
1133 vec_vand(vector bool short __a, vector bool short __b) {
1134   return __a & __b;
1135 }
1136
1137 static __inline__ vector int __ATTRS_o_ai vec_vand(vector int __a,
1138                                                    vector int __b) {
1139   return __a & __b;
1140 }
1141
1142 static __inline__ vector int __ATTRS_o_ai vec_vand(vector bool int __a,
1143                                                    vector int __b) {
1144   return (vector int)__a & __b;
1145 }
1146
1147 static __inline__ vector int __ATTRS_o_ai vec_vand(vector int __a,
1148                                                    vector bool int __b) {
1149   return __a & (vector int)__b;
1150 }
1151
1152 static __inline__ vector unsigned int __ATTRS_o_ai
1153 vec_vand(vector unsigned int __a, vector unsigned int __b) {
1154   return __a & __b;
1155 }
1156
1157 static __inline__ vector unsigned int __ATTRS_o_ai
1158 vec_vand(vector bool int __a, vector unsigned int __b) {
1159   return (vector unsigned int)__a & __b;
1160 }
1161
1162 static __inline__ vector unsigned int __ATTRS_o_ai
1163 vec_vand(vector unsigned int __a, vector bool int __b) {
1164   return __a & (vector unsigned int)__b;
1165 }
1166
1167 static __inline__ vector bool int __ATTRS_o_ai vec_vand(vector bool int __a,
1168                                                         vector bool int __b) {
1169   return __a & __b;
1170 }
1171
1172 static __inline__ vector float __ATTRS_o_ai vec_vand(vector float __a,
1173                                                      vector float __b) {
1174   vector unsigned int __res =
1175       (vector unsigned int)__a & (vector unsigned int)__b;
1176   return (vector float)__res;
1177 }
1178
1179 static __inline__ vector float __ATTRS_o_ai vec_vand(vector bool int __a,
1180                                                      vector float __b) {
1181   vector unsigned int __res =
1182       (vector unsigned int)__a & (vector unsigned int)__b;
1183   return (vector float)__res;
1184 }
1185
1186 static __inline__ vector float __ATTRS_o_ai vec_vand(vector float __a,
1187                                                      vector bool int __b) {
1188   vector unsigned int __res =
1189       (vector unsigned int)__a & (vector unsigned int)__b;
1190   return (vector float)__res;
1191 }
1192
1193 #ifdef __VSX__
1194 static __inline__ vector signed long long __ATTRS_o_ai
1195 vec_vand(vector signed long long __a, vector signed long long __b) {
1196   return __a & __b;
1197 }
1198
1199 static __inline__ vector signed long long __ATTRS_o_ai
1200 vec_vand(vector bool long long __a, vector signed long long __b) {
1201   return (vector signed long long)__a & __b;
1202 }
1203
1204 static __inline__ vector signed long long __ATTRS_o_ai
1205 vec_vand(vector signed long long __a, vector bool long long __b) {
1206   return __a & (vector signed long long)__b;
1207 }
1208
1209 static __inline__ vector unsigned long long __ATTRS_o_ai
1210 vec_vand(vector unsigned long long __a, vector unsigned long long __b) {
1211   return __a & __b;
1212 }
1213
1214 static __inline__ vector unsigned long long __ATTRS_o_ai
1215 vec_vand(vector bool long long __a, vector unsigned long long __b) {
1216   return (vector unsigned long long)__a & __b;
1217 }
1218
1219 static __inline__ vector unsigned long long __ATTRS_o_ai
1220 vec_vand(vector unsigned long long __a, vector bool long long __b) {
1221   return __a & (vector unsigned long long)__b;
1222 }
1223
1224 static __inline__ vector bool long long __ATTRS_o_ai
1225 vec_vand(vector bool long long __a, vector bool long long __b) {
1226   return __a & __b;
1227 }
1228 #endif
1229
1230 /* vec_andc */
1231
1232 #define __builtin_altivec_vandc vec_andc
1233
1234 static __inline__ vector signed char __ATTRS_o_ai
1235 vec_andc(vector signed char __a, vector signed char __b) {
1236   return __a & ~__b;
1237 }
1238
1239 static __inline__ vector signed char __ATTRS_o_ai
1240 vec_andc(vector bool char __a, vector signed char __b) {
1241   return (vector signed char)__a & ~__b;
1242 }
1243
1244 static __inline__ vector signed char __ATTRS_o_ai
1245 vec_andc(vector signed char __a, vector bool char __b) {
1246   return __a & ~(vector signed char)__b;
1247 }
1248
1249 static __inline__ vector unsigned char __ATTRS_o_ai
1250 vec_andc(vector unsigned char __a, vector unsigned char __b) {
1251   return __a & ~__b;
1252 }
1253
1254 static __inline__ vector unsigned char __ATTRS_o_ai
1255 vec_andc(vector bool char __a, vector unsigned char __b) {
1256   return (vector unsigned char)__a & ~__b;
1257 }
1258
1259 static __inline__ vector unsigned char __ATTRS_o_ai
1260 vec_andc(vector unsigned char __a, vector bool char __b) {
1261   return __a & ~(vector unsigned char)__b;
1262 }
1263
1264 static __inline__ vector bool char __ATTRS_o_ai vec_andc(vector bool char __a,
1265                                                          vector bool char __b) {
1266   return __a & ~__b;
1267 }
1268
1269 static __inline__ vector short __ATTRS_o_ai vec_andc(vector short __a,
1270                                                      vector short __b) {
1271   return __a & ~__b;
1272 }
1273
1274 static __inline__ vector short __ATTRS_o_ai vec_andc(vector bool short __a,
1275                                                      vector short __b) {
1276   return (vector short)__a & ~__b;
1277 }
1278
1279 static __inline__ vector short __ATTRS_o_ai vec_andc(vector short __a,
1280                                                      vector bool short __b) {
1281   return __a & ~(vector short)__b;
1282 }
1283
1284 static __inline__ vector unsigned short __ATTRS_o_ai
1285 vec_andc(vector unsigned short __a, vector unsigned short __b) {
1286   return __a & ~__b;
1287 }
1288
1289 static __inline__ vector unsigned short __ATTRS_o_ai
1290 vec_andc(vector bool short __a, vector unsigned short __b) {
1291   return (vector unsigned short)__a & ~__b;
1292 }
1293
1294 static __inline__ vector unsigned short __ATTRS_o_ai
1295 vec_andc(vector unsigned short __a, vector bool short __b) {
1296   return __a & ~(vector unsigned short)__b;
1297 }
1298
1299 static __inline__ vector bool short __ATTRS_o_ai
1300 vec_andc(vector bool short __a, vector bool short __b) {
1301   return __a & ~__b;
1302 }
1303
1304 static __inline__ vector int __ATTRS_o_ai vec_andc(vector int __a,
1305                                                    vector int __b) {
1306   return __a & ~__b;
1307 }
1308
1309 static __inline__ vector int __ATTRS_o_ai vec_andc(vector bool int __a,
1310                                                    vector int __b) {
1311   return (vector int)__a & ~__b;
1312 }
1313
1314 static __inline__ vector int __ATTRS_o_ai vec_andc(vector int __a,
1315                                                    vector bool int __b) {
1316   return __a & ~(vector int)__b;
1317 }
1318
1319 static __inline__ vector unsigned int __ATTRS_o_ai
1320 vec_andc(vector unsigned int __a, vector unsigned int __b) {
1321   return __a & ~__b;
1322 }
1323
1324 static __inline__ vector unsigned int __ATTRS_o_ai
1325 vec_andc(vector bool int __a, vector unsigned int __b) {
1326   return (vector unsigned int)__a & ~__b;
1327 }
1328
1329 static __inline__ vector unsigned int __ATTRS_o_ai
1330 vec_andc(vector unsigned int __a, vector bool int __b) {
1331   return __a & ~(vector unsigned int)__b;
1332 }
1333
1334 static __inline__ vector bool int __ATTRS_o_ai vec_andc(vector bool int __a,
1335                                                         vector bool int __b) {
1336   return __a & ~__b;
1337 }
1338
1339 static __inline__ vector float __ATTRS_o_ai vec_andc(vector float __a,
1340                                                      vector float __b) {
1341   vector unsigned int __res =
1342       (vector unsigned int)__a & ~(vector unsigned int)__b;
1343   return (vector float)__res;
1344 }
1345
1346 static __inline__ vector float __ATTRS_o_ai vec_andc(vector bool int __a,
1347                                                      vector float __b) {
1348   vector unsigned int __res =
1349       (vector unsigned int)__a & ~(vector unsigned int)__b;
1350   return (vector float)__res;
1351 }
1352
1353 static __inline__ vector float __ATTRS_o_ai vec_andc(vector float __a,
1354                                                      vector bool int __b) {
1355   vector unsigned int __res =
1356       (vector unsigned int)__a & ~(vector unsigned int)__b;
1357   return (vector float)__res;
1358 }
1359
1360 #ifdef __VSX__
1361 static __inline__ vector double __ATTRS_o_ai vec_andc(vector bool long long __a,
1362                                                       vector double __b) {
1363   vector unsigned long long __res =
1364       (vector unsigned long long)__a & ~(vector unsigned long long)__b;
1365   return (vector double)__res;
1366 }
1367
1368 static __inline__ vector double __ATTRS_o_ai
1369 vec_andc(vector double __a, vector bool long long __b) {
1370   vector unsigned long long __res =
1371       (vector unsigned long long)__a & ~(vector unsigned long long)__b;
1372   return (vector double)__res;
1373 }
1374
1375 static __inline__ vector double __ATTRS_o_ai vec_andc(vector double __a,
1376                                                       vector double __b) {
1377   vector unsigned long long __res =
1378       (vector unsigned long long)__a & ~(vector unsigned long long)__b;
1379   return (vector double)__res;
1380 }
1381
1382 static __inline__ vector signed long long __ATTRS_o_ai
1383 vec_andc(vector signed long long __a, vector signed long long __b) {
1384   return __a & ~__b;
1385 }
1386
1387 static __inline__ vector signed long long __ATTRS_o_ai
1388 vec_andc(vector bool long long __a, vector signed long long __b) {
1389   return (vector signed long long)__a & ~__b;
1390 }
1391
1392 static __inline__ vector signed long long __ATTRS_o_ai
1393 vec_andc(vector signed long long __a, vector bool long long __b) {
1394   return __a & ~(vector signed long long)__b;
1395 }
1396
1397 static __inline__ vector unsigned long long __ATTRS_o_ai
1398 vec_andc(vector unsigned long long __a, vector unsigned long long __b) {
1399   return __a & ~__b;
1400 }
1401
1402 static __inline__ vector unsigned long long __ATTRS_o_ai
1403 vec_andc(vector bool long long __a, vector unsigned long long __b) {
1404   return (vector unsigned long long)__a & ~__b;
1405 }
1406
1407 static __inline__ vector unsigned long long __ATTRS_o_ai
1408 vec_andc(vector unsigned long long __a, vector bool long long __b) {
1409   return __a & ~(vector unsigned long long)__b;
1410 }
1411
1412 static __inline__ vector bool long long __ATTRS_o_ai
1413 vec_andc(vector bool long long __a, vector bool long long __b) {
1414   return __a & ~__b;
1415 }
1416 #endif
1417
1418 /* vec_vandc */
1419
1420 static __inline__ vector signed char __ATTRS_o_ai
1421 vec_vandc(vector signed char __a, vector signed char __b) {
1422   return __a & ~__b;
1423 }
1424
1425 static __inline__ vector signed char __ATTRS_o_ai
1426 vec_vandc(vector bool char __a, vector signed char __b) {
1427   return (vector signed char)__a & ~__b;
1428 }
1429
1430 static __inline__ vector signed char __ATTRS_o_ai
1431 vec_vandc(vector signed char __a, vector bool char __b) {
1432   return __a & ~(vector signed char)__b;
1433 }
1434
1435 static __inline__ vector unsigned char __ATTRS_o_ai
1436 vec_vandc(vector unsigned char __a, vector unsigned char __b) {
1437   return __a & ~__b;
1438 }
1439
1440 static __inline__ vector unsigned char __ATTRS_o_ai
1441 vec_vandc(vector bool char __a, vector unsigned char __b) {
1442   return (vector unsigned char)__a & ~__b;
1443 }
1444
1445 static __inline__ vector unsigned char __ATTRS_o_ai
1446 vec_vandc(vector unsigned char __a, vector bool char __b) {
1447   return __a & ~(vector unsigned char)__b;
1448 }
1449
1450 static __inline__ vector bool char __ATTRS_o_ai
1451 vec_vandc(vector bool char __a, vector bool char __b) {
1452   return __a & ~__b;
1453 }
1454
1455 static __inline__ vector short __ATTRS_o_ai vec_vandc(vector short __a,
1456                                                       vector short __b) {
1457   return __a & ~__b;
1458 }
1459
1460 static __inline__ vector short __ATTRS_o_ai vec_vandc(vector bool short __a,
1461                                                       vector short __b) {
1462   return (vector short)__a & ~__b;
1463 }
1464
1465 static __inline__ vector short __ATTRS_o_ai vec_vandc(vector short __a,
1466                                                       vector bool short __b) {
1467   return __a & ~(vector short)__b;
1468 }
1469
1470 static __inline__ vector unsigned short __ATTRS_o_ai
1471 vec_vandc(vector unsigned short __a, vector unsigned short __b) {
1472   return __a & ~__b;
1473 }
1474
1475 static __inline__ vector unsigned short __ATTRS_o_ai
1476 vec_vandc(vector bool short __a, vector unsigned short __b) {
1477   return (vector unsigned short)__a & ~__b;
1478 }
1479
1480 static __inline__ vector unsigned short __ATTRS_o_ai
1481 vec_vandc(vector unsigned short __a, vector bool short __b) {
1482   return __a & ~(vector unsigned short)__b;
1483 }
1484
1485 static __inline__ vector bool short __ATTRS_o_ai
1486 vec_vandc(vector bool short __a, vector bool short __b) {
1487   return __a & ~__b;
1488 }
1489
1490 static __inline__ vector int __ATTRS_o_ai vec_vandc(vector int __a,
1491                                                     vector int __b) {
1492   return __a & ~__b;
1493 }
1494
1495 static __inline__ vector int __ATTRS_o_ai vec_vandc(vector bool int __a,
1496                                                     vector int __b) {
1497   return (vector int)__a & ~__b;
1498 }
1499
1500 static __inline__ vector int __ATTRS_o_ai vec_vandc(vector int __a,
1501                                                     vector bool int __b) {
1502   return __a & ~(vector int)__b;
1503 }
1504
1505 static __inline__ vector unsigned int __ATTRS_o_ai
1506 vec_vandc(vector unsigned int __a, vector unsigned int __b) {
1507   return __a & ~__b;
1508 }
1509
1510 static __inline__ vector unsigned int __ATTRS_o_ai
1511 vec_vandc(vector bool int __a, vector unsigned int __b) {
1512   return (vector unsigned int)__a & ~__b;
1513 }
1514
1515 static __inline__ vector unsigned int __ATTRS_o_ai
1516 vec_vandc(vector unsigned int __a, vector bool int __b) {
1517   return __a & ~(vector unsigned int)__b;
1518 }
1519
1520 static __inline__ vector bool int __ATTRS_o_ai vec_vandc(vector bool int __a,
1521                                                          vector bool int __b) {
1522   return __a & ~__b;
1523 }
1524
1525 static __inline__ vector float __ATTRS_o_ai vec_vandc(vector float __a,
1526                                                       vector float __b) {
1527   vector unsigned int __res =
1528       (vector unsigned int)__a & ~(vector unsigned int)__b;
1529   return (vector float)__res;
1530 }
1531
1532 static __inline__ vector float __ATTRS_o_ai vec_vandc(vector bool int __a,
1533                                                       vector float __b) {
1534   vector unsigned int __res =
1535       (vector unsigned int)__a & ~(vector unsigned int)__b;
1536   return (vector float)__res;
1537 }
1538
1539 static __inline__ vector float __ATTRS_o_ai vec_vandc(vector float __a,
1540                                                       vector bool int __b) {
1541   vector unsigned int __res =
1542       (vector unsigned int)__a & ~(vector unsigned int)__b;
1543   return (vector float)__res;
1544 }
1545
1546 #ifdef __VSX__
1547 static __inline__ vector signed long long __ATTRS_o_ai
1548 vec_vandc(vector signed long long __a, vector signed long long __b) {
1549   return __a & ~__b;
1550 }
1551
1552 static __inline__ vector signed long long __ATTRS_o_ai
1553 vec_vandc(vector bool long long __a, vector signed long long __b) {
1554   return (vector signed long long)__a & ~__b;
1555 }
1556
1557 static __inline__ vector signed long long __ATTRS_o_ai
1558 vec_vandc(vector signed long long __a, vector bool long long __b) {
1559   return __a & ~(vector signed long long)__b;
1560 }
1561
1562 static __inline__ vector unsigned long long __ATTRS_o_ai
1563 vec_vandc(vector unsigned long long __a, vector unsigned long long __b) {
1564   return __a & ~__b;
1565 }
1566
1567 static __inline__ vector unsigned long long __ATTRS_o_ai
1568 vec_vandc(vector bool long long __a, vector unsigned long long __b) {
1569   return (vector unsigned long long)__a & ~__b;
1570 }
1571
1572 static __inline__ vector unsigned long long __ATTRS_o_ai
1573 vec_vandc(vector unsigned long long __a, vector bool long long __b) {
1574   return __a & ~(vector unsigned long long)__b;
1575 }
1576
1577 static __inline__ vector bool long long __ATTRS_o_ai
1578 vec_vandc(vector bool long long __a, vector bool long long __b) {
1579   return __a & ~__b;
1580 }
1581 #endif
1582
1583 /* vec_avg */
1584
1585 static __inline__ vector signed char __ATTRS_o_ai
1586 vec_avg(vector signed char __a, vector signed char __b) {
1587   return __builtin_altivec_vavgsb(__a, __b);
1588 }
1589
1590 static __inline__ vector unsigned char __ATTRS_o_ai
1591 vec_avg(vector unsigned char __a, vector unsigned char __b) {
1592   return __builtin_altivec_vavgub(__a, __b);
1593 }
1594
1595 static __inline__ vector short __ATTRS_o_ai vec_avg(vector short __a,
1596                                                     vector short __b) {
1597   return __builtin_altivec_vavgsh(__a, __b);
1598 }
1599
1600 static __inline__ vector unsigned short __ATTRS_o_ai
1601 vec_avg(vector unsigned short __a, vector unsigned short __b) {
1602   return __builtin_altivec_vavguh(__a, __b);
1603 }
1604
1605 static __inline__ vector int __ATTRS_o_ai vec_avg(vector int __a,
1606                                                   vector int __b) {
1607   return __builtin_altivec_vavgsw(__a, __b);
1608 }
1609
1610 static __inline__ vector unsigned int __ATTRS_o_ai
1611 vec_avg(vector unsigned int __a, vector unsigned int __b) {
1612   return __builtin_altivec_vavguw(__a, __b);
1613 }
1614
1615 /* vec_vavgsb */
1616
1617 static __inline__ vector signed char __attribute__((__always_inline__))
1618 vec_vavgsb(vector signed char __a, vector signed char __b) {
1619   return __builtin_altivec_vavgsb(__a, __b);
1620 }
1621
1622 /* vec_vavgub */
1623
1624 static __inline__ vector unsigned char __attribute__((__always_inline__))
1625 vec_vavgub(vector unsigned char __a, vector unsigned char __b) {
1626   return __builtin_altivec_vavgub(__a, __b);
1627 }
1628
1629 /* vec_vavgsh */
1630
1631 static __inline__ vector short __attribute__((__always_inline__))
1632 vec_vavgsh(vector short __a, vector short __b) {
1633   return __builtin_altivec_vavgsh(__a, __b);
1634 }
1635
1636 /* vec_vavguh */
1637
1638 static __inline__ vector unsigned short __attribute__((__always_inline__))
1639 vec_vavguh(vector unsigned short __a, vector unsigned short __b) {
1640   return __builtin_altivec_vavguh(__a, __b);
1641 }
1642
1643 /* vec_vavgsw */
1644
1645 static __inline__ vector int __attribute__((__always_inline__))
1646 vec_vavgsw(vector int __a, vector int __b) {
1647   return __builtin_altivec_vavgsw(__a, __b);
1648 }
1649
1650 /* vec_vavguw */
1651
1652 static __inline__ vector unsigned int __attribute__((__always_inline__))
1653 vec_vavguw(vector unsigned int __a, vector unsigned int __b) {
1654   return __builtin_altivec_vavguw(__a, __b);
1655 }
1656
1657 /* vec_ceil */
1658
1659 static __inline__ vector float __ATTRS_o_ai vec_ceil(vector float __a) {
1660 #ifdef __VSX__
1661   return __builtin_vsx_xvrspip(__a);
1662 #else
1663   return __builtin_altivec_vrfip(__a);
1664 #endif
1665 }
1666
1667 #ifdef __VSX__
1668 static __inline__ vector double __ATTRS_o_ai vec_ceil(vector double __a) {
1669   return __builtin_vsx_xvrdpip(__a);
1670 }
1671 #endif
1672
1673 /* vec_roundp */
1674 static __inline__ vector float __ATTRS_o_ai vec_roundp(vector float __a) {
1675   return vec_ceil(__a);
1676 }
1677
1678 #ifdef __VSX__
1679 static __inline__ vector double __ATTRS_o_ai vec_roundp(vector double __a) {
1680   return vec_ceil(__a);
1681 }
1682 #endif
1683
1684 /* vec_vrfip */
1685
1686 static __inline__ vector float __attribute__((__always_inline__))
1687 vec_vrfip(vector float __a) {
1688   return __builtin_altivec_vrfip(__a);
1689 }
1690
1691 /* vec_cmpb */
1692
1693 static __inline__ vector int __attribute__((__always_inline__))
1694 vec_cmpb(vector float __a, vector float __b) {
1695   return __builtin_altivec_vcmpbfp(__a, __b);
1696 }
1697
1698 /* vec_vcmpbfp */
1699
1700 static __inline__ vector int __attribute__((__always_inline__))
1701 vec_vcmpbfp(vector float __a, vector float __b) {
1702   return __builtin_altivec_vcmpbfp(__a, __b);
1703 }
1704
1705 /* vec_cmpeq */
1706
1707 static __inline__ vector bool char __ATTRS_o_ai
1708 vec_cmpeq(vector signed char __a, vector signed char __b) {
1709   return (vector bool char)__builtin_altivec_vcmpequb((vector char)__a,
1710                                                       (vector char)__b);
1711 }
1712
1713 static __inline__ vector bool char __ATTRS_o_ai
1714 vec_cmpeq(vector unsigned char __a, vector unsigned char __b) {
1715   return (vector bool char)__builtin_altivec_vcmpequb((vector char)__a,
1716                                                       (vector char)__b);
1717 }
1718
1719 static __inline__ vector bool char __ATTRS_o_ai
1720 vec_cmpeq(vector bool char __a, vector bool char __b) {
1721   return (vector bool char)__builtin_altivec_vcmpequb((vector char)__a,
1722                                                       (vector char)__b);
1723 }
1724
1725 static __inline__ vector bool short __ATTRS_o_ai vec_cmpeq(vector short __a,
1726                                                            vector short __b) {
1727   return (vector bool short)__builtin_altivec_vcmpequh(__a, __b);
1728 }
1729
1730 static __inline__ vector bool short __ATTRS_o_ai
1731 vec_cmpeq(vector unsigned short __a, vector unsigned short __b) {
1732   return (vector bool short)__builtin_altivec_vcmpequh((vector short)__a,
1733                                                        (vector short)__b);
1734 }
1735
1736 static __inline__ vector bool short __ATTRS_o_ai
1737 vec_cmpeq(vector bool short __a, vector bool short __b) {
1738   return (vector bool short)__builtin_altivec_vcmpequh((vector short)__a,
1739                                                        (vector short)__b);
1740 }
1741
1742 static __inline__ vector bool int __ATTRS_o_ai vec_cmpeq(vector int __a,
1743                                                          vector int __b) {
1744   return (vector bool int)__builtin_altivec_vcmpequw(__a, __b);
1745 }
1746
1747 static __inline__ vector bool int __ATTRS_o_ai
1748 vec_cmpeq(vector unsigned int __a, vector unsigned int __b) {
1749   return (vector bool int)__builtin_altivec_vcmpequw((vector int)__a,
1750                                                      (vector int)__b);
1751 }
1752
1753 static __inline__ vector bool int __ATTRS_o_ai vec_cmpeq(vector bool int __a,
1754                                                          vector bool int __b) {
1755   return (vector bool int)__builtin_altivec_vcmpequw((vector int)__a,
1756                                                      (vector int)__b);
1757 }
1758
1759 #ifdef __POWER8_VECTOR__
1760 static __inline__ vector bool long long __ATTRS_o_ai
1761 vec_cmpeq(vector signed long long __a, vector signed long long __b) {
1762   return (vector bool long long)__builtin_altivec_vcmpequd(__a, __b);
1763 }
1764
1765 static __inline__ vector bool long long __ATTRS_o_ai
1766 vec_cmpeq(vector unsigned long long __a, vector unsigned long long __b) {
1767   return (vector bool long long)__builtin_altivec_vcmpequd(
1768       (vector long long)__a, (vector long long)__b);
1769 }
1770
1771 static __inline__ vector bool long long __ATTRS_o_ai
1772 vec_cmpeq(vector bool long long __a, vector bool long long __b) {
1773   return (vector bool long long)__builtin_altivec_vcmpequd(
1774       (vector long long)__a, (vector long long)__b);
1775 }
1776 #elif defined(__VSX__)
1777 static __inline__ vector bool long long __ATTRS_o_ai
1778 vec_cmpeq(vector signed long long __a, vector signed long long __b) {
1779   vector bool int __wordcmp =
1780       vec_cmpeq((vector signed int)__a, (vector signed int)__b);
1781 #ifdef __LITTLE_ENDIAN__
1782   __wordcmp &= __builtin_shufflevector(__wordcmp, __wordcmp, 3, 0, 1, 2);
1783   return (vector bool long long)__builtin_shufflevector(__wordcmp, __wordcmp, 1,
1784                                                         1, 3, 3);
1785 #else
1786   __wordcmp &= __builtin_shufflevector(__wordcmp, __wordcmp, 1, 2, 3, 0);
1787   return (vector bool long long)__builtin_shufflevector(__wordcmp, __wordcmp, 0,
1788                                                         0, 2, 2);
1789 #endif
1790 }
1791
1792 static __inline__ vector bool long long __ATTRS_o_ai
1793 vec_cmpeq(vector unsigned long long __a, vector unsigned long long __b) {
1794   return vec_cmpeq((vector signed long long)__a, (vector signed long long)__b);
1795 }
1796
1797 static __inline__ vector bool long long __ATTRS_o_ai
1798 vec_cmpeq(vector bool long long __a, vector bool long long __b) {
1799   return vec_cmpeq((vector signed long long)__a, (vector signed long long)__b);
1800 }
1801 #endif
1802
1803 static __inline__ vector bool int __ATTRS_o_ai vec_cmpeq(vector float __a,
1804                                                          vector float __b) {
1805 #ifdef __VSX__
1806   return (vector bool int)__builtin_vsx_xvcmpeqsp(__a, __b);
1807 #else
1808   return (vector bool int)__builtin_altivec_vcmpeqfp(__a, __b);
1809 #endif
1810 }
1811
1812 #ifdef __VSX__
1813 static __inline__ vector bool long long __ATTRS_o_ai
1814 vec_cmpeq(vector double __a, vector double __b) {
1815   return (vector bool long long)__builtin_vsx_xvcmpeqdp(__a, __b);
1816 }
1817 #endif
1818
1819 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
1820 static __inline__ vector bool __int128 __ATTRS_o_ai
1821 vec_cmpeq(vector signed __int128 __a, vector signed __int128 __b) {
1822   return (vector bool __int128)__builtin_altivec_vcmpequq(
1823       (vector unsigned __int128)__a, (vector unsigned __int128)__b);
1824 }
1825
1826 static __inline__ vector bool __int128 __ATTRS_o_ai
1827 vec_cmpeq(vector unsigned __int128 __a, vector unsigned __int128 __b) {
1828   return (vector bool __int128)__builtin_altivec_vcmpequq(
1829       (vector unsigned __int128)__a, (vector unsigned __int128)__b);
1830 }
1831
1832 static __inline__ vector bool __int128 __ATTRS_o_ai
1833 vec_cmpeq(vector bool __int128 __a, vector bool  __int128 __b) {
1834   return (vector bool __int128)__builtin_altivec_vcmpequq(
1835       (vector unsigned __int128)__a, (vector unsigned __int128)__b);
1836 }
1837 #endif
1838
1839 #ifdef __POWER9_VECTOR__
1840 /* vec_cmpne */
1841
1842 static __inline__ vector bool char __ATTRS_o_ai
1843 vec_cmpne(vector bool char __a, vector bool char __b) {
1844   return (vector bool char)__builtin_altivec_vcmpneb((vector char)__a,
1845                                                      (vector char)__b);
1846 }
1847
1848 static __inline__ vector bool char __ATTRS_o_ai
1849 vec_cmpne(vector signed char __a, vector signed char __b) {
1850   return (vector bool char)__builtin_altivec_vcmpneb((vector char)__a,
1851                                                      (vector char)__b);
1852 }
1853
1854 static __inline__ vector bool char __ATTRS_o_ai
1855 vec_cmpne(vector unsigned char __a, vector unsigned char __b) {
1856   return (vector bool char)__builtin_altivec_vcmpneb((vector char)__a,
1857                                                      (vector char)__b);
1858 }
1859
1860 static __inline__ vector bool short __ATTRS_o_ai
1861 vec_cmpne(vector bool short __a, vector bool short __b) {
1862   return (vector bool short)__builtin_altivec_vcmpneh((vector short)__a,
1863                                                       (vector short)__b);
1864 }
1865
1866 static __inline__ vector bool short __ATTRS_o_ai
1867 vec_cmpne(vector signed short __a, vector signed short __b) {
1868   return (vector bool short)__builtin_altivec_vcmpneh((vector short)__a,
1869                                                       (vector short)__b);
1870 }
1871
1872 static __inline__ vector bool short __ATTRS_o_ai
1873 vec_cmpne(vector unsigned short __a, vector unsigned short __b) {
1874   return (vector bool short)__builtin_altivec_vcmpneh((vector short)__a,
1875                                                       (vector short)__b);
1876 }
1877
1878 static __inline__ vector bool int __ATTRS_o_ai
1879 vec_cmpne(vector bool int __a, vector bool int __b) {
1880   return (vector bool int)__builtin_altivec_vcmpnew((vector int)__a,
1881                                                     (vector int)__b);
1882 }
1883
1884 static __inline__ vector bool int __ATTRS_o_ai
1885 vec_cmpne(vector signed int __a, vector signed int __b) {
1886   return (vector bool int)__builtin_altivec_vcmpnew((vector int)__a,
1887                                                     (vector int)__b);
1888 }
1889
1890 static __inline__ vector bool int __ATTRS_o_ai
1891 vec_cmpne(vector unsigned int __a, vector unsigned int __b) {
1892   return (vector bool int)__builtin_altivec_vcmpnew((vector int)__a,
1893                                                     (vector int)__b);
1894 }
1895
1896 static __inline__ vector bool int __ATTRS_o_ai
1897 vec_cmpne(vector float __a, vector float __b) {
1898   return (vector bool int)__builtin_altivec_vcmpnew((vector int)__a,
1899                                                     (vector int)__b);
1900 }
1901
1902 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
1903 static __inline__ vector bool __int128 __ATTRS_o_ai
1904 vec_cmpne(vector unsigned __int128 __a, vector unsigned __int128 __b) {
1905   return (vector bool __int128)~(__builtin_altivec_vcmpequq(
1906       (vector unsigned __int128)__a, (vector unsigned __int128)__b));
1907 }
1908
1909 static __inline__ vector bool __int128 __ATTRS_o_ai
1910 vec_cmpne(vector signed __int128 __a, vector signed __int128 __b) {
1911   return (vector bool __int128)~(__builtin_altivec_vcmpequq(
1912       (vector unsigned __int128)__a, (vector unsigned __int128)__b));
1913 }
1914
1915 static __inline__ vector bool __int128 __ATTRS_o_ai
1916 vec_cmpne(vector bool __int128 __a, vector bool __int128 __b) {
1917   return (vector bool __int128)~(__builtin_altivec_vcmpequq(
1918       (vector unsigned __int128)__a, (vector unsigned __int128)__b));
1919 }
1920 #endif
1921
1922 /* vec_cmpnez */
1923
1924 static __inline__ vector bool char __ATTRS_o_ai
1925 vec_cmpnez(vector signed char __a, vector signed char __b) {
1926   return (vector bool char)__builtin_altivec_vcmpnezb((vector char)__a,
1927                                                       (vector char)__b);
1928 }
1929
1930 static __inline__ vector bool char __ATTRS_o_ai
1931 vec_cmpnez(vector unsigned char __a, vector unsigned char __b) {
1932   return (vector bool char)__builtin_altivec_vcmpnezb((vector char)__a,
1933                                                       (vector char)__b);
1934 }
1935
1936 static __inline__ vector bool short __ATTRS_o_ai
1937 vec_cmpnez(vector signed short __a, vector signed short __b) {
1938   return (vector bool short)__builtin_altivec_vcmpnezh((vector short)__a,
1939                                                        (vector short)__b);
1940 }
1941
1942 static __inline__ vector bool short __ATTRS_o_ai
1943 vec_cmpnez(vector unsigned short __a, vector unsigned short __b) {
1944   return (vector bool short)__builtin_altivec_vcmpnezh((vector short)__a,
1945                                                        (vector short)__b);
1946 }
1947
1948 static __inline__ vector bool int __ATTRS_o_ai
1949 vec_cmpnez(vector signed int __a, vector signed int __b) {
1950   return (vector bool int)__builtin_altivec_vcmpnezw((vector int)__a,
1951                                                      (vector int)__b);
1952 }
1953
1954 static __inline__ vector bool int __ATTRS_o_ai
1955 vec_cmpnez(vector unsigned int __a, vector unsigned int __b) {
1956   return (vector bool int)__builtin_altivec_vcmpnezw((vector int)__a,
1957                                                      (vector int)__b);
1958 }
1959
1960 static __inline__ signed int __ATTRS_o_ai
1961 vec_cntlz_lsbb(vector signed char __a) {
1962 #ifdef __LITTLE_ENDIAN__
1963   return __builtin_altivec_vctzlsbb((vector unsigned char)__a);
1964 #else
1965   return __builtin_altivec_vclzlsbb((vector unsigned char)__a);
1966 #endif
1967 }
1968
1969 static __inline__ signed int __ATTRS_o_ai
1970 vec_cntlz_lsbb(vector unsigned char __a) {
1971 #ifdef __LITTLE_ENDIAN__
1972   return __builtin_altivec_vctzlsbb((vector unsigned char)__a);
1973 #else
1974   return __builtin_altivec_vclzlsbb(__a);
1975 #endif
1976 }
1977
1978 static __inline__ signed int __ATTRS_o_ai
1979 vec_cnttz_lsbb(vector signed char __a) {
1980 #ifdef __LITTLE_ENDIAN__
1981   return __builtin_altivec_vclzlsbb((vector unsigned char)__a);
1982 #else
1983   return __builtin_altivec_vctzlsbb((vector unsigned char)__a);
1984 #endif
1985 }
1986
1987 static __inline__ signed int __ATTRS_o_ai
1988 vec_cnttz_lsbb(vector unsigned char __a) {
1989 #ifdef __LITTLE_ENDIAN__
1990   return __builtin_altivec_vclzlsbb(__a);
1991 #else
1992   return __builtin_altivec_vctzlsbb(__a);
1993 #endif
1994 }
1995
1996 static __inline__ vector unsigned int __ATTRS_o_ai
1997 vec_parity_lsbb(vector unsigned int __a) {
1998   return __builtin_altivec_vprtybw(__a);
1999 }
2000
2001 static __inline__ vector unsigned int __ATTRS_o_ai
2002 vec_parity_lsbb(vector signed int __a) {
2003   return __builtin_altivec_vprtybw((vector unsigned int)__a);
2004 }
2005
2006 #ifdef __SIZEOF_INT128__
2007 static __inline__ vector unsigned __int128 __ATTRS_o_ai
2008 vec_parity_lsbb(vector unsigned __int128 __a) {
2009   return __builtin_altivec_vprtybq(__a);
2010 }
2011
2012 static __inline__ vector unsigned __int128 __ATTRS_o_ai
2013 vec_parity_lsbb(vector signed __int128 __a) {
2014   return __builtin_altivec_vprtybq((vector unsigned __int128)__a);
2015 }
2016 #endif
2017
2018 static __inline__ vector unsigned long long __ATTRS_o_ai
2019 vec_parity_lsbb(vector unsigned long long __a) {
2020   return __builtin_altivec_vprtybd(__a);
2021 }
2022
2023 static __inline__ vector unsigned long long __ATTRS_o_ai
2024 vec_parity_lsbb(vector signed long long __a) {
2025   return __builtin_altivec_vprtybd((vector unsigned long long)__a);
2026 }
2027
2028 #else
2029 /* vec_cmpne */
2030
2031 static __inline__ vector bool char __ATTRS_o_ai
2032 vec_cmpne(vector bool char __a, vector bool char __b) {
2033   return ~(vec_cmpeq(__a, __b));
2034 }
2035
2036 static __inline__ vector bool char __ATTRS_o_ai
2037 vec_cmpne(vector signed char __a, vector signed char __b) {
2038   return ~(vec_cmpeq(__a, __b));
2039 }
2040
2041 static __inline__ vector bool char __ATTRS_o_ai
2042 vec_cmpne(vector unsigned char __a, vector unsigned char __b) {
2043   return ~(vec_cmpeq(__a, __b));
2044 }
2045
2046 static __inline__ vector bool short __ATTRS_o_ai
2047 vec_cmpne(vector bool short __a, vector bool short __b) {
2048   return ~(vec_cmpeq(__a, __b));
2049 }
2050
2051 static __inline__ vector bool short __ATTRS_o_ai
2052 vec_cmpne(vector signed short __a, vector signed short __b) {
2053   return ~(vec_cmpeq(__a, __b));
2054 }
2055
2056 static __inline__ vector bool short __ATTRS_o_ai
2057 vec_cmpne(vector unsigned short __a, vector unsigned short __b) {
2058   return ~(vec_cmpeq(__a, __b));
2059 }
2060
2061 static __inline__ vector bool int __ATTRS_o_ai
2062 vec_cmpne(vector bool int __a, vector bool int __b) {
2063   return ~(vec_cmpeq(__a, __b));
2064 }
2065
2066 static __inline__ vector bool int __ATTRS_o_ai
2067 vec_cmpne(vector signed int __a, vector signed int __b) {
2068   return ~(vec_cmpeq(__a, __b));
2069 }
2070
2071 static __inline__ vector bool int __ATTRS_o_ai
2072 vec_cmpne(vector unsigned int __a, vector unsigned int __b) {
2073   return ~(vec_cmpeq(__a, __b));
2074 }
2075
2076 static __inline__ vector bool int __ATTRS_o_ai
2077 vec_cmpne(vector float __a, vector float __b) {
2078   return ~(vec_cmpeq(__a, __b));
2079 }
2080 #endif
2081
2082 #ifdef __POWER8_VECTOR__
2083 static __inline__ vector bool long long __ATTRS_o_ai
2084 vec_cmpne(vector bool long long __a, vector bool long long __b) {
2085   return (vector bool long long)
2086     ~(__builtin_altivec_vcmpequd((vector long long)__a, (vector long long)__b));
2087 }
2088
2089 static __inline__ vector bool long long __ATTRS_o_ai
2090 vec_cmpne(vector signed long long __a, vector signed long long __b) {
2091   return (vector bool long long)
2092     ~(__builtin_altivec_vcmpequd((vector long long)__a, (vector long long)__b));
2093 }
2094
2095 static __inline__ vector bool long long __ATTRS_o_ai
2096 vec_cmpne(vector unsigned long long __a, vector unsigned long long __b) {
2097   return (vector bool long long)
2098     ~(__builtin_altivec_vcmpequd((vector long long)__a, (vector long long)__b));
2099 }
2100 #elif defined(__VSX__)
2101 static __inline__ vector bool long long __ATTRS_o_ai
2102 vec_cmpne(vector bool long long __a, vector bool long long __b) {
2103   return (vector bool long long)~(
2104       vec_cmpeq((vector signed long long)__a, (vector signed long long)__b));
2105 }
2106
2107 static __inline__ vector bool long long __ATTRS_o_ai
2108 vec_cmpne(vector signed long long __a, vector signed long long __b) {
2109   return (vector bool long long)~(
2110       vec_cmpeq((vector signed long long)__a, (vector signed long long)__b));
2111 }
2112
2113 static __inline__ vector bool long long __ATTRS_o_ai
2114 vec_cmpne(vector unsigned long long __a, vector unsigned long long __b) {
2115   return (vector bool long long)~(
2116       vec_cmpeq((vector signed long long)__a, (vector signed long long)__b));
2117 }
2118 #endif
2119
2120 #ifdef __VSX__
2121 static __inline__ vector bool long long __ATTRS_o_ai
2122 vec_cmpne(vector double __a, vector double __b) {
2123   return (vector bool long long)
2124     ~(__builtin_altivec_vcmpequd((vector long long)__a, (vector long long)__b));
2125 }
2126 #endif
2127
2128 /* vec_cmpgt */
2129
2130 static __inline__ vector bool char __ATTRS_o_ai
2131 vec_cmpgt(vector signed char __a, vector signed char __b) {
2132   return (vector bool char)__builtin_altivec_vcmpgtsb(__a, __b);
2133 }
2134
2135 static __inline__ vector bool char __ATTRS_o_ai
2136 vec_cmpgt(vector unsigned char __a, vector unsigned char __b) {
2137   return (vector bool char)__builtin_altivec_vcmpgtub(__a, __b);
2138 }
2139
2140 static __inline__ vector bool short __ATTRS_o_ai vec_cmpgt(vector short __a,
2141                                                            vector short __b) {
2142   return (vector bool short)__builtin_altivec_vcmpgtsh(__a, __b);
2143 }
2144
2145 static __inline__ vector bool short __ATTRS_o_ai
2146 vec_cmpgt(vector unsigned short __a, vector unsigned short __b) {
2147   return (vector bool short)__builtin_altivec_vcmpgtuh(__a, __b);
2148 }
2149
2150 static __inline__ vector bool int __ATTRS_o_ai vec_cmpgt(vector int __a,
2151                                                          vector int __b) {
2152   return (vector bool int)__builtin_altivec_vcmpgtsw(__a, __b);
2153 }
2154
2155 static __inline__ vector bool int __ATTRS_o_ai
2156 vec_cmpgt(vector unsigned int __a, vector unsigned int __b) {
2157   return (vector bool int)__builtin_altivec_vcmpgtuw(__a, __b);
2158 }
2159
2160 #ifdef __POWER8_VECTOR__
2161 static __inline__ vector bool long long __ATTRS_o_ai
2162 vec_cmpgt(vector signed long long __a, vector signed long long __b) {
2163   return (vector bool long long)__builtin_altivec_vcmpgtsd(__a, __b);
2164 }
2165
2166 static __inline__ vector bool long long __ATTRS_o_ai
2167 vec_cmpgt(vector unsigned long long __a, vector unsigned long long __b) {
2168   return (vector bool long long)__builtin_altivec_vcmpgtud(__a, __b);
2169 }
2170 #elif defined(__VSX__)
2171 static __inline__ vector bool long long __ATTRS_o_ai
2172 vec_cmpgt(vector signed long long __a, vector signed long long __b) {
2173   vector signed int __sgtw = (vector signed int)vec_cmpgt(
2174       (vector signed int)__a, (vector signed int)__b);
2175   vector unsigned int __ugtw = (vector unsigned int)vec_cmpgt(
2176       (vector unsigned int)__a, (vector unsigned int)__b);
2177   vector unsigned int __eqw = (vector unsigned int)vec_cmpeq(
2178       (vector signed int)__a, (vector signed int)__b);
2179 #ifdef __LITTLE_ENDIAN__
2180   __ugtw = __builtin_shufflevector(__ugtw, __ugtw, 3, 0, 1, 2) & __eqw;
2181   __sgtw |= (vector signed int)__ugtw;
2182   return (vector bool long long)__builtin_shufflevector(__sgtw, __sgtw, 1, 1, 3,
2183                                                         3);
2184 #else
2185   __ugtw = __builtin_shufflevector(__ugtw, __ugtw, 1, 2, 3, 0) & __eqw;
2186   __sgtw |= (vector signed int)__ugtw;
2187   return (vector bool long long)__builtin_shufflevector(__sgtw, __sgtw, 0, 0, 2,
2188                                                         2);
2189 #endif
2190 }
2191
2192 static __inline__ vector bool long long __ATTRS_o_ai
2193 vec_cmpgt(vector unsigned long long __a, vector unsigned long long __b) {
2194   vector unsigned int __ugtw = (vector unsigned int)vec_cmpgt(
2195       (vector unsigned int)__a, (vector unsigned int)__b);
2196   vector unsigned int __eqw = (vector unsigned int)vec_cmpeq(
2197       (vector signed int)__a, (vector signed int)__b);
2198 #ifdef __LITTLE_ENDIAN__
2199   __eqw = __builtin_shufflevector(__ugtw, __ugtw, 3, 0, 1, 2) & __eqw;
2200   __ugtw |= __eqw;
2201   return (vector bool long long)__builtin_shufflevector(__ugtw, __ugtw, 1, 1, 3,
2202                                                         3);
2203 #else
2204   __eqw = __builtin_shufflevector(__ugtw, __ugtw, 1, 2, 3, 0) & __eqw;
2205   __ugtw |= __eqw;
2206   return (vector bool long long)__builtin_shufflevector(__ugtw, __ugtw, 0, 0, 2,
2207                                                         2);
2208 #endif
2209 }
2210 #endif
2211
2212 static __inline__ vector bool int __ATTRS_o_ai vec_cmpgt(vector float __a,
2213                                                          vector float __b) {
2214 #ifdef __VSX__
2215   return (vector bool int)__builtin_vsx_xvcmpgtsp(__a, __b);
2216 #else
2217   return (vector bool int)__builtin_altivec_vcmpgtfp(__a, __b);
2218 #endif
2219 }
2220
2221 #ifdef __VSX__
2222 static __inline__ vector bool long long __ATTRS_o_ai
2223 vec_cmpgt(vector double __a, vector double __b) {
2224   return (vector bool long long)__builtin_vsx_xvcmpgtdp(__a, __b);
2225 }
2226 #endif
2227
2228 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
2229 static __inline__ vector bool __int128 __ATTRS_o_ai
2230 vec_cmpgt(vector signed __int128 __a, vector signed __int128 __b) {
2231   return (vector bool __int128)__builtin_altivec_vcmpgtsq(__a, __b);
2232 }
2233
2234 static __inline__ vector bool __int128 __ATTRS_o_ai
2235 vec_cmpgt(vector unsigned __int128 __a, vector unsigned __int128 __b) {
2236   return (vector bool __int128)__builtin_altivec_vcmpgtuq(__a, __b);
2237 }
2238 #endif
2239
2240 /* vec_cmpge */
2241
2242 static __inline__ vector bool char __ATTRS_o_ai
2243 vec_cmpge(vector signed char __a, vector signed char __b) {
2244   return ~(vec_cmpgt(__b, __a));
2245 }
2246
2247 static __inline__ vector bool char __ATTRS_o_ai
2248 vec_cmpge(vector unsigned char __a, vector unsigned char __b) {
2249   return ~(vec_cmpgt(__b, __a));
2250 }
2251
2252 static __inline__ vector bool short __ATTRS_o_ai
2253 vec_cmpge(vector signed short __a, vector signed short __b) {
2254   return ~(vec_cmpgt(__b, __a));
2255 }
2256
2257 static __inline__ vector bool short __ATTRS_o_ai
2258 vec_cmpge(vector unsigned short __a, vector unsigned short __b) {
2259   return ~(vec_cmpgt(__b, __a));
2260 }
2261
2262 static __inline__ vector bool int __ATTRS_o_ai
2263 vec_cmpge(vector signed int __a, vector signed int __b) {
2264   return ~(vec_cmpgt(__b, __a));
2265 }
2266
2267 static __inline__ vector bool int __ATTRS_o_ai
2268 vec_cmpge(vector unsigned int __a, vector unsigned int __b) {
2269   return ~(vec_cmpgt(__b, __a));
2270 }
2271
2272 static __inline__ vector bool int __ATTRS_o_ai vec_cmpge(vector float __a,
2273                                                          vector float __b) {
2274 #ifdef __VSX__
2275   return (vector bool int)__builtin_vsx_xvcmpgesp(__a, __b);
2276 #else
2277   return (vector bool int)__builtin_altivec_vcmpgefp(__a, __b);
2278 #endif
2279 }
2280
2281 #ifdef __VSX__
2282 static __inline__ vector bool long long __ATTRS_o_ai
2283 vec_cmpge(vector double __a, vector double __b) {
2284   return (vector bool long long)__builtin_vsx_xvcmpgedp(__a, __b);
2285 }
2286
2287 static __inline__ vector bool long long __ATTRS_o_ai
2288 vec_cmpge(vector signed long long __a, vector signed long long __b) {
2289   return ~(vec_cmpgt(__b, __a));
2290 }
2291
2292 static __inline__ vector bool long long __ATTRS_o_ai
2293 vec_cmpge(vector unsigned long long __a, vector unsigned long long __b) {
2294   return ~(vec_cmpgt(__b, __a));
2295 }
2296 #endif
2297
2298 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
2299 static __inline__ vector bool __int128 __ATTRS_o_ai
2300 vec_cmpge(vector signed __int128 __a, vector signed __int128 __b) {
2301   return ~(vec_cmpgt(__b, __a));
2302 }
2303
2304 static __inline__ vector bool __int128 __ATTRS_o_ai
2305 vec_cmpge(vector unsigned __int128 __a, vector unsigned __int128 __b) {
2306   return ~(vec_cmpgt(__b, __a));
2307 }
2308 #endif
2309
2310 /* vec_vcmpgefp */
2311
2312 static __inline__ vector bool int __attribute__((__always_inline__))
2313 vec_vcmpgefp(vector float __a, vector float __b) {
2314   return (vector bool int)__builtin_altivec_vcmpgefp(__a, __b);
2315 }
2316
2317 /* vec_vcmpgtsb */
2318
2319 static __inline__ vector bool char __attribute__((__always_inline__))
2320 vec_vcmpgtsb(vector signed char __a, vector signed char __b) {
2321   return (vector bool char)__builtin_altivec_vcmpgtsb(__a, __b);
2322 }
2323
2324 /* vec_vcmpgtub */
2325
2326 static __inline__ vector bool char __attribute__((__always_inline__))
2327 vec_vcmpgtub(vector unsigned char __a, vector unsigned char __b) {
2328   return (vector bool char)__builtin_altivec_vcmpgtub(__a, __b);
2329 }
2330
2331 /* vec_vcmpgtsh */
2332
2333 static __inline__ vector bool short __attribute__((__always_inline__))
2334 vec_vcmpgtsh(vector short __a, vector short __b) {
2335   return (vector bool short)__builtin_altivec_vcmpgtsh(__a, __b);
2336 }
2337
2338 /* vec_vcmpgtuh */
2339
2340 static __inline__ vector bool short __attribute__((__always_inline__))
2341 vec_vcmpgtuh(vector unsigned short __a, vector unsigned short __b) {
2342   return (vector bool short)__builtin_altivec_vcmpgtuh(__a, __b);
2343 }
2344
2345 /* vec_vcmpgtsw */
2346
2347 static __inline__ vector bool int __attribute__((__always_inline__))
2348 vec_vcmpgtsw(vector int __a, vector int __b) {
2349   return (vector bool int)__builtin_altivec_vcmpgtsw(__a, __b);
2350 }
2351
2352 /* vec_vcmpgtuw */
2353
2354 static __inline__ vector bool int __attribute__((__always_inline__))
2355 vec_vcmpgtuw(vector unsigned int __a, vector unsigned int __b) {
2356   return (vector bool int)__builtin_altivec_vcmpgtuw(__a, __b);
2357 }
2358
2359 /* vec_vcmpgtfp */
2360
2361 static __inline__ vector bool int __attribute__((__always_inline__))
2362 vec_vcmpgtfp(vector float __a, vector float __b) {
2363   return (vector bool int)__builtin_altivec_vcmpgtfp(__a, __b);
2364 }
2365
2366 /* vec_cmple */
2367
2368 static __inline__ vector bool char __ATTRS_o_ai
2369 vec_cmple(vector signed char __a, vector signed char __b) {
2370   return vec_cmpge(__b, __a);
2371 }
2372
2373 static __inline__ vector bool char __ATTRS_o_ai
2374 vec_cmple(vector unsigned char __a, vector unsigned char __b) {
2375   return vec_cmpge(__b, __a);
2376 }
2377
2378 static __inline__ vector bool short __ATTRS_o_ai
2379 vec_cmple(vector signed short __a, vector signed short __b) {
2380   return vec_cmpge(__b, __a);
2381 }
2382
2383 static __inline__ vector bool short __ATTRS_o_ai
2384 vec_cmple(vector unsigned short __a, vector unsigned short __b) {
2385   return vec_cmpge(__b, __a);
2386 }
2387
2388 static __inline__ vector bool int __ATTRS_o_ai
2389 vec_cmple(vector signed int __a, vector signed int __b) {
2390   return vec_cmpge(__b, __a);
2391 }
2392
2393 static __inline__ vector bool int __ATTRS_o_ai
2394 vec_cmple(vector unsigned int __a, vector unsigned int __b) {
2395   return vec_cmpge(__b, __a);
2396 }
2397
2398 static __inline__ vector bool int __ATTRS_o_ai vec_cmple(vector float __a,
2399                                                          vector float __b) {
2400   return vec_cmpge(__b, __a);
2401 }
2402
2403 #ifdef __VSX__
2404 static __inline__ vector bool long long __ATTRS_o_ai
2405 vec_cmple(vector double __a, vector double __b) {
2406   return vec_cmpge(__b, __a);
2407 }
2408
2409 static __inline__ vector bool long long __ATTRS_o_ai
2410 vec_cmple(vector signed long long __a, vector signed long long __b) {
2411   return vec_cmpge(__b, __a);
2412 }
2413
2414 static __inline__ vector bool long long __ATTRS_o_ai
2415 vec_cmple(vector unsigned long long __a, vector unsigned long long __b) {
2416   return vec_cmpge(__b, __a);
2417 }
2418 #endif
2419
2420 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
2421 static __inline__ vector bool __int128 __ATTRS_o_ai
2422 vec_cmple(vector signed __int128 __a, vector signed __int128 __b) {
2423   return vec_cmpge(__b, __a);
2424 }
2425
2426 static __inline__ vector bool __int128 __ATTRS_o_ai
2427 vec_cmple(vector unsigned __int128 __a, vector unsigned __int128 __b) {
2428   return vec_cmpge(__b, __a);
2429 }
2430 #endif
2431
2432 /* vec_cmplt */
2433
2434 static __inline__ vector bool char __ATTRS_o_ai
2435 vec_cmplt(vector signed char __a, vector signed char __b) {
2436   return vec_cmpgt(__b, __a);
2437 }
2438
2439 static __inline__ vector bool char __ATTRS_o_ai
2440 vec_cmplt(vector unsigned char __a, vector unsigned char __b) {
2441   return vec_cmpgt(__b, __a);
2442 }
2443
2444 static __inline__ vector bool short __ATTRS_o_ai vec_cmplt(vector short __a,
2445                                                            vector short __b) {
2446   return vec_cmpgt(__b, __a);
2447 }
2448
2449 static __inline__ vector bool short __ATTRS_o_ai
2450 vec_cmplt(vector unsigned short __a, vector unsigned short __b) {
2451   return vec_cmpgt(__b, __a);
2452 }
2453
2454 static __inline__ vector bool int __ATTRS_o_ai vec_cmplt(vector int __a,
2455                                                          vector int __b) {
2456   return vec_cmpgt(__b, __a);
2457 }
2458
2459 static __inline__ vector bool int __ATTRS_o_ai
2460 vec_cmplt(vector unsigned int __a, vector unsigned int __b) {
2461   return vec_cmpgt(__b, __a);
2462 }
2463
2464 static __inline__ vector bool int __ATTRS_o_ai vec_cmplt(vector float __a,
2465                                                          vector float __b) {
2466   return vec_cmpgt(__b, __a);
2467 }
2468
2469 #ifdef __VSX__
2470 static __inline__ vector bool long long __ATTRS_o_ai
2471 vec_cmplt(vector double __a, vector double __b) {
2472   return vec_cmpgt(__b, __a);
2473 }
2474 #endif
2475
2476 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
2477 static __inline__ vector bool __int128 __ATTRS_o_ai
2478 vec_cmplt(vector signed __int128 __a, vector signed __int128 __b) {
2479   return vec_cmpgt(__b, __a);
2480 }
2481
2482 static __inline__ vector bool __int128 __ATTRS_o_ai
2483 vec_cmplt(vector unsigned __int128 __a, vector unsigned __int128 __b) {
2484   return vec_cmpgt(__b, __a);
2485 }
2486 #endif
2487
2488 #ifdef __VSX__
2489 static __inline__ vector bool long long __ATTRS_o_ai
2490 vec_cmplt(vector signed long long __a, vector signed long long __b) {
2491   return vec_cmpgt(__b, __a);
2492 }
2493
2494 static __inline__ vector bool long long __ATTRS_o_ai
2495 vec_cmplt(vector unsigned long long __a, vector unsigned long long __b) {
2496   return vec_cmpgt(__b, __a);
2497 }
2498 #endif
2499
2500 #ifdef __POWER8_VECTOR__
2501 /* vec_popcnt */
2502
2503 static __inline__ vector unsigned char __ATTRS_o_ai
2504 vec_popcnt(vector signed char __a) {
2505   return (vector unsigned char)__builtin_altivec_vpopcntb(
2506       (vector unsigned char)__a);
2507 }
2508 static __inline__ vector unsigned char __ATTRS_o_ai
2509 vec_popcnt(vector unsigned char __a) {
2510   return __builtin_altivec_vpopcntb(__a);
2511 }
2512 static __inline__ vector unsigned short __ATTRS_o_ai
2513 vec_popcnt(vector signed short __a) {
2514   return (vector unsigned short)__builtin_altivec_vpopcnth(
2515       (vector unsigned short)__a);
2516 }
2517 static __inline__ vector unsigned short __ATTRS_o_ai
2518 vec_popcnt(vector unsigned short __a) {
2519   return __builtin_altivec_vpopcnth(__a);
2520 }
2521 static __inline__ vector unsigned int __ATTRS_o_ai
2522 vec_popcnt(vector signed int __a) {
2523   return __builtin_altivec_vpopcntw((vector unsigned int)__a);
2524 }
2525 static __inline__ vector unsigned int __ATTRS_o_ai
2526 vec_popcnt(vector unsigned int __a) {
2527   return __builtin_altivec_vpopcntw(__a);
2528 }
2529 static __inline__ vector unsigned long long __ATTRS_o_ai
2530 vec_popcnt(vector signed long long __a) {
2531   return __builtin_altivec_vpopcntd((vector unsigned long long)__a);
2532 }
2533 static __inline__ vector unsigned long long __ATTRS_o_ai
2534 vec_popcnt(vector unsigned long long __a) {
2535   return __builtin_altivec_vpopcntd(__a);
2536 }
2537
2538 #define vec_vclz vec_cntlz
2539 /* vec_cntlz */
2540
2541 static __inline__ vector signed char __ATTRS_o_ai
2542 vec_cntlz(vector signed char __a) {
2543   return (vector signed char)__builtin_altivec_vclzb((vector unsigned char)__a);
2544 }
2545 static __inline__ vector unsigned char __ATTRS_o_ai
2546 vec_cntlz(vector unsigned char __a) {
2547   return __builtin_altivec_vclzb(__a);
2548 }
2549 static __inline__ vector signed short __ATTRS_o_ai
2550 vec_cntlz(vector signed short __a) {
2551   return (vector signed short)__builtin_altivec_vclzh(
2552       (vector unsigned short)__a);
2553 }
2554 static __inline__ vector unsigned short __ATTRS_o_ai
2555 vec_cntlz(vector unsigned short __a) {
2556   return __builtin_altivec_vclzh(__a);
2557 }
2558 static __inline__ vector signed int __ATTRS_o_ai
2559 vec_cntlz(vector signed int __a) {
2560   return (vector signed int)__builtin_altivec_vclzw((vector unsigned int)__a);
2561 }
2562 static __inline__ vector unsigned int __ATTRS_o_ai
2563 vec_cntlz(vector unsigned int __a) {
2564   return __builtin_altivec_vclzw(__a);
2565 }
2566 static __inline__ vector signed long long __ATTRS_o_ai
2567 vec_cntlz(vector signed long long __a) {
2568   return (vector signed long long)__builtin_altivec_vclzd(
2569       (vector unsigned long long)__a);
2570 }
2571 static __inline__ vector unsigned long long __ATTRS_o_ai
2572 vec_cntlz(vector unsigned long long __a) {
2573   return __builtin_altivec_vclzd(__a);
2574 }
2575 #endif
2576
2577 #ifdef __POWER9_VECTOR__
2578
2579 /* vec_cnttz */
2580
2581 static __inline__ vector signed char __ATTRS_o_ai
2582 vec_cnttz(vector signed char __a) {
2583   return (vector signed char)__builtin_altivec_vctzb((vector unsigned char)__a);
2584 }
2585 static __inline__ vector unsigned char __ATTRS_o_ai
2586 vec_cnttz(vector unsigned char __a) {
2587   return __builtin_altivec_vctzb(__a);
2588 }
2589 static __inline__ vector signed short __ATTRS_o_ai
2590 vec_cnttz(vector signed short __a) {
2591   return (vector signed short)__builtin_altivec_vctzh(
2592       (vector unsigned short)__a);
2593 }
2594 static __inline__ vector unsigned short __ATTRS_o_ai
2595 vec_cnttz(vector unsigned short __a) {
2596   return __builtin_altivec_vctzh(__a);
2597 }
2598 static __inline__ vector signed int __ATTRS_o_ai
2599 vec_cnttz(vector signed int __a) {
2600   return (vector signed int)__builtin_altivec_vctzw((vector unsigned int)__a);
2601 }
2602 static __inline__ vector unsigned int __ATTRS_o_ai
2603 vec_cnttz(vector unsigned int __a) {
2604   return __builtin_altivec_vctzw(__a);
2605 }
2606 static __inline__ vector signed long long __ATTRS_o_ai
2607 vec_cnttz(vector signed long long __a) {
2608   return (vector signed long long)__builtin_altivec_vctzd(
2609       (vector unsigned long long)__a);
2610 }
2611 static __inline__ vector unsigned long long __ATTRS_o_ai
2612 vec_cnttz(vector unsigned long long __a) {
2613   return __builtin_altivec_vctzd(__a);
2614 }
2615
2616 /* vec_first_match_index */
2617
2618 static __inline__ unsigned __ATTRS_o_ai
2619 vec_first_match_index(vector signed char __a, vector signed char __b) {
2620   vector unsigned long long __res =
2621 #ifdef __LITTLE_ENDIAN__
2622     vec_cnttz((vector unsigned long long)vec_cmpeq(__a, __b));
2623 #else
2624     vec_cntlz((vector unsigned long long)vec_cmpeq(__a, __b));
2625 #endif
2626   if (__res[0] == 64) {
2627     return (__res[1] + 64) >> 3;
2628   }
2629   return __res[0] >> 3;
2630 }
2631
2632 static __inline__ unsigned __ATTRS_o_ai
2633 vec_first_match_index(vector unsigned char __a, vector unsigned char __b) {
2634   vector unsigned long long __res =
2635 #ifdef __LITTLE_ENDIAN__
2636     vec_cnttz((vector unsigned long long)vec_cmpeq(__a, __b));
2637 #else
2638     vec_cntlz((vector unsigned long long)vec_cmpeq(__a, __b));
2639 #endif
2640   if (__res[0] == 64) {
2641     return (__res[1] + 64) >> 3;
2642   }
2643   return __res[0] >> 3;
2644 }
2645
2646 static __inline__ unsigned __ATTRS_o_ai
2647 vec_first_match_index(vector signed short __a, vector signed short __b) {
2648   vector unsigned long long __res =
2649 #ifdef __LITTLE_ENDIAN__
2650     vec_cnttz((vector unsigned long long)vec_cmpeq(__a, __b));
2651 #else
2652     vec_cntlz((vector unsigned long long)vec_cmpeq(__a, __b));
2653 #endif
2654   if (__res[0] == 64) {
2655     return (__res[1] + 64) >> 4;
2656   }
2657   return __res[0] >> 4;
2658 }
2659
2660 static __inline__ unsigned __ATTRS_o_ai
2661 vec_first_match_index(vector unsigned short __a, vector unsigned short __b) {
2662   vector unsigned long long __res =
2663 #ifdef __LITTLE_ENDIAN__
2664     vec_cnttz((vector unsigned long long)vec_cmpeq(__a, __b));
2665 #else
2666     vec_cntlz((vector unsigned long long)vec_cmpeq(__a, __b));
2667 #endif
2668   if (__res[0] == 64) {
2669     return (__res[1] + 64) >> 4;
2670   }
2671   return __res[0] >> 4;
2672 }
2673
2674 static __inline__ unsigned __ATTRS_o_ai
2675 vec_first_match_index(vector signed int __a, vector signed int __b) {
2676   vector unsigned long long __res =
2677 #ifdef __LITTLE_ENDIAN__
2678     vec_cnttz((vector unsigned long long)vec_cmpeq(__a, __b));
2679 #else
2680     vec_cntlz((vector unsigned long long)vec_cmpeq(__a, __b));
2681 #endif
2682   if (__res[0] == 64) {
2683     return (__res[1] + 64) >> 5;
2684   }
2685   return __res[0] >> 5;
2686 }
2687
2688 static __inline__ unsigned __ATTRS_o_ai
2689 vec_first_match_index(vector unsigned int __a, vector unsigned int __b) {
2690   vector unsigned long long __res =
2691 #ifdef __LITTLE_ENDIAN__
2692     vec_cnttz((vector unsigned long long)vec_cmpeq(__a, __b));
2693 #else
2694     vec_cntlz((vector unsigned long long)vec_cmpeq(__a, __b));
2695 #endif
2696   if (__res[0] == 64) {
2697     return (__res[1] + 64) >> 5;
2698   }
2699   return __res[0] >> 5;
2700 }
2701
2702 /* vec_first_match_or_eos_index */
2703
2704 static __inline__ unsigned __ATTRS_o_ai
2705 vec_first_match_or_eos_index(vector signed char __a, vector signed char __b) {
2706   /* Compare the result of the comparison of two vectors with either and OR the
2707      result. Either the elements are equal or one will equal the comparison
2708      result if either is zero.
2709   */
2710   vector bool char __tmp1 = vec_cmpeq(__a, __b);
2711   vector bool char __tmp2 = __tmp1 |
2712                             vec_cmpeq((vector signed char)__tmp1, __a) |
2713                             vec_cmpeq((vector signed char)__tmp1, __b);
2714
2715   vector unsigned long long __res =
2716 #ifdef __LITTLE_ENDIAN__
2717       vec_cnttz((vector unsigned long long)__tmp2);
2718 #else
2719       vec_cntlz((vector unsigned long long)__tmp2);
2720 #endif
2721   if (__res[0] == 64) {
2722     return (__res[1] + 64) >> 3;
2723   }
2724   return __res[0] >> 3;
2725 }
2726
2727 static __inline__ unsigned __ATTRS_o_ai
2728 vec_first_match_or_eos_index(vector unsigned char __a,
2729                              vector unsigned char __b) {
2730   vector bool char __tmp1 = vec_cmpeq(__a, __b);
2731   vector bool char __tmp2 = __tmp1 |
2732                             vec_cmpeq((vector unsigned char)__tmp1, __a) |
2733                             vec_cmpeq((vector unsigned char)__tmp1, __b);
2734
2735   vector unsigned long long __res =
2736 #ifdef __LITTLE_ENDIAN__
2737       vec_cnttz((vector unsigned long long)__tmp2);
2738 #else
2739       vec_cntlz((vector unsigned long long)__tmp2);
2740 #endif
2741   if (__res[0] == 64) {
2742     return (__res[1] + 64) >> 3;
2743   }
2744   return __res[0] >> 3;
2745 }
2746
2747 static __inline__ unsigned __ATTRS_o_ai
2748 vec_first_match_or_eos_index(vector signed short __a, vector signed short __b) {
2749   vector bool short __tmp1 = vec_cmpeq(__a, __b);
2750   vector bool short __tmp2 = __tmp1 |
2751                              vec_cmpeq((vector signed short)__tmp1, __a) |
2752                              vec_cmpeq((vector signed short)__tmp1, __b);
2753
2754   vector unsigned long long __res =
2755 #ifdef __LITTLE_ENDIAN__
2756       vec_cnttz((vector unsigned long long)__tmp2);
2757 #else
2758       vec_cntlz((vector unsigned long long)__tmp2);
2759 #endif
2760   if (__res[0] == 64) {
2761     return (__res[1] + 64) >> 4;
2762   }
2763   return __res[0] >> 4;
2764 }
2765
2766 static __inline__ unsigned __ATTRS_o_ai
2767 vec_first_match_or_eos_index(vector unsigned short __a,
2768                              vector unsigned short __b) {
2769   vector bool short __tmp1 = vec_cmpeq(__a, __b);
2770   vector bool short __tmp2 = __tmp1 |
2771                              vec_cmpeq((vector unsigned short)__tmp1, __a) |
2772                              vec_cmpeq((vector unsigned short)__tmp1, __b);
2773
2774   vector unsigned long long __res =
2775 #ifdef __LITTLE_ENDIAN__
2776       vec_cnttz((vector unsigned long long)__tmp2);
2777 #else
2778       vec_cntlz((vector unsigned long long)__tmp2);
2779 #endif
2780   if (__res[0] == 64) {
2781     return (__res[1] + 64) >> 4;
2782   }
2783   return __res[0] >> 4;
2784 }
2785
2786 static __inline__ unsigned __ATTRS_o_ai
2787 vec_first_match_or_eos_index(vector signed int __a, vector signed int __b) {
2788   vector bool int __tmp1 = vec_cmpeq(__a, __b);
2789   vector bool int __tmp2 = __tmp1 | vec_cmpeq((vector signed int)__tmp1, __a) |
2790                            vec_cmpeq((vector signed int)__tmp1, __b);
2791
2792   vector unsigned long long __res =
2793 #ifdef __LITTLE_ENDIAN__
2794       vec_cnttz((vector unsigned long long)__tmp2);
2795 #else
2796       vec_cntlz((vector unsigned long long)__tmp2);
2797 #endif
2798   if (__res[0] == 64) {
2799     return (__res[1] + 64) >> 5;
2800   }
2801   return __res[0] >> 5;
2802 }
2803
2804 static __inline__ unsigned __ATTRS_o_ai
2805 vec_first_match_or_eos_index(vector unsigned int __a, vector unsigned int __b) {
2806   vector bool int __tmp1 = vec_cmpeq(__a, __b);
2807   vector bool int __tmp2 = __tmp1 |
2808                            vec_cmpeq((vector unsigned int)__tmp1, __a) |
2809                            vec_cmpeq((vector unsigned int)__tmp1, __b);
2810
2811   vector unsigned long long __res =
2812 #ifdef __LITTLE_ENDIAN__
2813     vec_cnttz((vector unsigned long long)__tmp2);
2814 #else
2815     vec_cntlz((vector unsigned long long)__tmp2);
2816 #endif
2817   if (__res[0] == 64) {
2818     return (__res[1] + 64) >> 5;
2819   }
2820   return __res[0] >> 5;
2821 }
2822
2823 /* vec_first_mismatch_index */
2824
2825 static __inline__ unsigned __ATTRS_o_ai
2826 vec_first_mismatch_index(vector signed char __a, vector signed char __b) {
2827   vector unsigned long long __res =
2828 #ifdef __LITTLE_ENDIAN__
2829     vec_cnttz((vector unsigned long long)vec_cmpne(__a, __b));
2830 #else
2831     vec_cntlz((vector unsigned long long)vec_cmpne(__a, __b));
2832 #endif
2833   if (__res[0] == 64) {
2834     return (__res[1] + 64) >> 3;
2835   }
2836   return __res[0] >> 3;
2837 }
2838
2839 static __inline__ unsigned __ATTRS_o_ai
2840 vec_first_mismatch_index(vector unsigned char __a, vector unsigned char __b) {
2841   vector unsigned long long __res =
2842 #ifdef __LITTLE_ENDIAN__
2843     vec_cnttz((vector unsigned long long)vec_cmpne(__a, __b));
2844 #else
2845     vec_cntlz((vector unsigned long long)vec_cmpne(__a, __b));
2846 #endif
2847   if (__res[0] == 64) {
2848     return (__res[1] + 64) >> 3;
2849   }
2850   return __res[0] >> 3;
2851 }
2852
2853 static __inline__ unsigned __ATTRS_o_ai
2854 vec_first_mismatch_index(vector signed short __a, vector signed short __b) {
2855   vector unsigned long long __res =
2856 #ifdef __LITTLE_ENDIAN__
2857     vec_cnttz((vector unsigned long long)vec_cmpne(__a, __b));
2858 #else
2859     vec_cntlz((vector unsigned long long)vec_cmpne(__a, __b));
2860 #endif
2861   if (__res[0] == 64) {
2862     return (__res[1] + 64) >> 4;
2863   }
2864   return __res[0] >> 4;
2865 }
2866
2867 static __inline__ unsigned __ATTRS_o_ai
2868 vec_first_mismatch_index(vector unsigned short __a, vector unsigned short __b) {
2869   vector unsigned long long __res =
2870 #ifdef __LITTLE_ENDIAN__
2871     vec_cnttz((vector unsigned long long)vec_cmpne(__a, __b));
2872 #else
2873     vec_cntlz((vector unsigned long long)vec_cmpne(__a, __b));
2874 #endif
2875   if (__res[0] == 64) {
2876     return (__res[1] + 64) >> 4;
2877   }
2878   return __res[0] >> 4;
2879 }
2880
2881 static __inline__ unsigned __ATTRS_o_ai
2882 vec_first_mismatch_index(vector signed int __a, vector signed int __b) {
2883   vector unsigned long long __res =
2884 #ifdef __LITTLE_ENDIAN__
2885     vec_cnttz((vector unsigned long long)vec_cmpne(__a, __b));
2886 #else
2887     vec_cntlz((vector unsigned long long)vec_cmpne(__a, __b));
2888 #endif
2889   if (__res[0] == 64) {
2890     return (__res[1] + 64) >> 5;
2891   }
2892   return __res[0] >> 5;
2893 }
2894
2895 static __inline__ unsigned __ATTRS_o_ai
2896 vec_first_mismatch_index(vector unsigned int __a, vector unsigned int __b) {
2897   vector unsigned long long __res =
2898 #ifdef __LITTLE_ENDIAN__
2899     vec_cnttz((vector unsigned long long)vec_cmpne(__a, __b));
2900 #else
2901     vec_cntlz((vector unsigned long long)vec_cmpne(__a, __b));
2902 #endif
2903   if (__res[0] == 64) {
2904     return (__res[1] + 64) >> 5;
2905   }
2906   return __res[0] >> 5;
2907 }
2908
2909 /* vec_first_mismatch_or_eos_index */
2910
2911 static __inline__ unsigned __ATTRS_o_ai
2912 vec_first_mismatch_or_eos_index(vector signed char __a,
2913                                 vector signed char __b) {
2914   vector unsigned long long __res =
2915 #ifdef __LITTLE_ENDIAN__
2916     vec_cnttz((vector unsigned long long)vec_cmpnez(__a, __b));
2917 #else
2918     vec_cntlz((vector unsigned long long)vec_cmpnez(__a, __b));
2919 #endif
2920   if (__res[0] == 64) {
2921     return (__res[1] + 64) >> 3;
2922   }
2923   return __res[0] >> 3;
2924 }
2925
2926 static __inline__ unsigned __ATTRS_o_ai
2927 vec_first_mismatch_or_eos_index(vector unsigned char __a,
2928                                 vector unsigned char __b) {
2929   vector unsigned long long __res =
2930 #ifdef __LITTLE_ENDIAN__
2931     vec_cnttz((vector unsigned long long)vec_cmpnez(__a, __b));
2932 #else
2933     vec_cntlz((vector unsigned long long)vec_cmpnez(__a, __b));
2934 #endif
2935   if (__res[0] == 64) {
2936     return (__res[1] + 64) >> 3;
2937   }
2938   return __res[0] >> 3;
2939 }
2940
2941 static __inline__ unsigned __ATTRS_o_ai
2942 vec_first_mismatch_or_eos_index(vector signed short __a,
2943                                 vector signed short __b) {
2944   vector unsigned long long __res =
2945 #ifdef __LITTLE_ENDIAN__
2946     vec_cnttz((vector unsigned long long)vec_cmpnez(__a, __b));
2947 #else
2948     vec_cntlz((vector unsigned long long)vec_cmpnez(__a, __b));
2949 #endif
2950   if (__res[0] == 64) {
2951     return (__res[1] + 64) >> 4;
2952   }
2953   return __res[0] >> 4;
2954 }
2955
2956 static __inline__ unsigned __ATTRS_o_ai
2957 vec_first_mismatch_or_eos_index(vector unsigned short __a,
2958                                 vector unsigned short __b) {
2959   vector unsigned long long __res =
2960 #ifdef __LITTLE_ENDIAN__
2961     vec_cnttz((vector unsigned long long)vec_cmpnez(__a, __b));
2962 #else
2963     vec_cntlz((vector unsigned long long)vec_cmpnez(__a, __b));
2964 #endif
2965   if (__res[0] == 64) {
2966     return (__res[1] + 64) >> 4;
2967   }
2968   return __res[0] >> 4;
2969 }
2970
2971 static __inline__ unsigned __ATTRS_o_ai
2972 vec_first_mismatch_or_eos_index(vector signed int __a, vector signed int __b) {
2973   vector unsigned long long __res =
2974 #ifdef __LITTLE_ENDIAN__
2975     vec_cnttz((vector unsigned long long)vec_cmpnez(__a, __b));
2976 #else
2977     vec_cntlz((vector unsigned long long)vec_cmpnez(__a, __b));
2978 #endif
2979   if (__res[0] == 64) {
2980     return (__res[1] + 64) >> 5;
2981   }
2982   return __res[0] >> 5;
2983 }
2984
2985 static __inline__ unsigned __ATTRS_o_ai
2986 vec_first_mismatch_or_eos_index(vector unsigned int __a,
2987                                 vector unsigned int __b) {
2988   vector unsigned long long __res =
2989 #ifdef __LITTLE_ENDIAN__
2990     vec_cnttz((vector unsigned long long)vec_cmpnez(__a, __b));
2991 #else
2992     vec_cntlz((vector unsigned long long)vec_cmpnez(__a, __b));
2993 #endif
2994   if (__res[0] == 64) {
2995     return (__res[1] + 64) >> 5;
2996   }
2997   return __res[0] >> 5;
2998 }
2999
3000 static __inline__ vector double  __ATTRS_o_ai
3001 vec_insert_exp(vector double __a, vector unsigned long long __b) {
3002   return __builtin_vsx_xviexpdp((vector unsigned long long)__a,__b);
3003 }
3004
3005 static __inline__ vector double  __ATTRS_o_ai
3006 vec_insert_exp(vector unsigned long long __a, vector unsigned long long __b) {
3007   return __builtin_vsx_xviexpdp(__a,__b);
3008 }
3009
3010 static __inline__ vector float  __ATTRS_o_ai
3011 vec_insert_exp(vector float __a, vector unsigned int __b) {
3012   return __builtin_vsx_xviexpsp((vector unsigned int)__a,__b);
3013 }
3014
3015 static __inline__ vector float  __ATTRS_o_ai
3016 vec_insert_exp(vector unsigned int __a, vector unsigned int __b) {
3017   return __builtin_vsx_xviexpsp(__a,__b);
3018 }
3019
3020 #if defined(__powerpc64__)
3021 static __inline__ vector signed char __ATTRS_o_ai vec_xl_len(const signed char *__a,
3022                                                              size_t __b) {
3023   return (vector signed char)__builtin_vsx_lxvl(__a, (__b << 56));
3024 }
3025
3026 static __inline__ vector unsigned char __ATTRS_o_ai
3027 vec_xl_len(const unsigned char *__a, size_t __b) {
3028   return (vector unsigned char)__builtin_vsx_lxvl(__a, (__b << 56));
3029 }
3030
3031 static __inline__ vector signed short __ATTRS_o_ai vec_xl_len(const signed short *__a,
3032                                                               size_t __b) {
3033   return (vector signed short)__builtin_vsx_lxvl(__a, (__b << 56));
3034 }
3035
3036 static __inline__ vector unsigned short __ATTRS_o_ai
3037 vec_xl_len(const unsigned short *__a, size_t __b) {
3038   return (vector unsigned short)__builtin_vsx_lxvl(__a, (__b << 56));
3039 }
3040
3041 static __inline__ vector signed int __ATTRS_o_ai vec_xl_len(const signed int *__a,
3042                                                             size_t __b) {
3043   return (vector signed int)__builtin_vsx_lxvl(__a, (__b << 56));
3044 }
3045
3046 static __inline__ vector unsigned int __ATTRS_o_ai vec_xl_len(const unsigned int *__a,
3047                                                               size_t __b) {
3048   return (vector unsigned int)__builtin_vsx_lxvl(__a, (__b << 56));
3049 }
3050
3051 static __inline__ vector float __ATTRS_o_ai vec_xl_len(const float *__a, size_t __b) {
3052   return (vector float)__builtin_vsx_lxvl(__a, (__b << 56));
3053 }
3054
3055 #ifdef __SIZEOF_INT128__
3056 static __inline__ vector signed __int128 __ATTRS_o_ai
3057 vec_xl_len(const signed __int128 *__a, size_t __b) {
3058   return (vector signed __int128)__builtin_vsx_lxvl(__a, (__b << 56));
3059 }
3060
3061 static __inline__ vector unsigned __int128 __ATTRS_o_ai
3062 vec_xl_len(const unsigned __int128 *__a, size_t __b) {
3063   return (vector unsigned __int128)__builtin_vsx_lxvl(__a, (__b << 56));
3064 }
3065 #endif
3066
3067 static __inline__ vector signed long long __ATTRS_o_ai
3068 vec_xl_len(const signed long long *__a, size_t __b) {
3069   return (vector signed long long)__builtin_vsx_lxvl(__a, (__b << 56));
3070 }
3071
3072 static __inline__ vector unsigned long long __ATTRS_o_ai
3073 vec_xl_len(const unsigned long long *__a, size_t __b) {
3074   return (vector unsigned long long)__builtin_vsx_lxvl(__a, (__b << 56));
3075 }
3076
3077 static __inline__ vector double __ATTRS_o_ai vec_xl_len(const double *__a,
3078                                                         size_t __b) {
3079   return (vector double)__builtin_vsx_lxvl(__a, (__b << 56));
3080 }
3081
3082 static __inline__ vector unsigned char __ATTRS_o_ai
3083 vec_xl_len_r(const unsigned char *__a, size_t __b) {
3084   vector unsigned char __res =
3085       (vector unsigned char)__builtin_vsx_lxvll(__a, (__b << 56));
3086   vector unsigned char __mask =
3087       (vector unsigned char)__builtin_altivec_lvsr(16 - __b, (int *)NULL);
3088   return (vector unsigned char)__builtin_altivec_vperm_4si(
3089       (vector int)__res, (vector int)__res, __mask);
3090 }
3091
3092 // vec_xst_len
3093 static __inline__ void __ATTRS_o_ai vec_xst_len(vector unsigned char __a,
3094                                                 unsigned char *__b,
3095                                                 size_t __c) {
3096   return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
3097 }
3098
3099 static __inline__ void __ATTRS_o_ai vec_xst_len(vector signed char __a,
3100                                                 signed char *__b, size_t __c) {
3101   return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
3102 }
3103
3104 static __inline__ void __ATTRS_o_ai vec_xst_len(vector signed short __a,
3105                                                 signed short *__b, size_t __c) {
3106   return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
3107 }
3108
3109 static __inline__ void __ATTRS_o_ai vec_xst_len(vector unsigned short __a,
3110                                                 unsigned short *__b,
3111                                                 size_t __c) {
3112   return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
3113 }
3114
3115 static __inline__ void __ATTRS_o_ai vec_xst_len(vector signed int __a,
3116                                                 signed int *__b, size_t __c) {
3117   return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
3118 }
3119
3120 static __inline__ void __ATTRS_o_ai vec_xst_len(vector unsigned int __a,
3121                                                 unsigned int *__b, 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 float __a, float *__b,
3126                                                 size_t __c) {
3127   return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
3128 }
3129
3130 #ifdef __SIZEOF_INT128__
3131 static __inline__ void __ATTRS_o_ai vec_xst_len(vector signed __int128 __a,
3132                                                 signed __int128 *__b,
3133                                                 size_t __c) {
3134   return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
3135 }
3136
3137 static __inline__ void __ATTRS_o_ai vec_xst_len(vector unsigned __int128 __a,
3138                                                 unsigned __int128 *__b,
3139                                                 size_t __c) {
3140   return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
3141 }
3142 #endif
3143
3144 static __inline__ void __ATTRS_o_ai vec_xst_len(vector signed long long __a,
3145                                                 signed long long *__b,
3146                                                 size_t __c) {
3147   return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
3148 }
3149
3150 static __inline__ void __ATTRS_o_ai vec_xst_len(vector unsigned long long __a,
3151                                                 unsigned long long *__b,
3152                                                 size_t __c) {
3153   return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
3154 }
3155
3156 static __inline__ void __ATTRS_o_ai vec_xst_len(vector double __a, double *__b,
3157                                                 size_t __c) {
3158   return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
3159 }
3160
3161 static __inline__ void __ATTRS_o_ai vec_xst_len_r(vector unsigned char __a,
3162                                                   unsigned char *__b,
3163                                                   size_t __c) {
3164   vector unsigned char __mask =
3165       (vector unsigned char)__builtin_altivec_lvsl(16 - __c, (int *)NULL);
3166   vector unsigned char __res =
3167       (vector unsigned char)__builtin_altivec_vperm_4si(
3168           (vector int)__a, (vector int)__a, __mask);
3169   return __builtin_vsx_stxvll((vector int)__res, __b, (__c << 56));
3170 }
3171 #endif
3172 #endif
3173
3174 #if defined(__POWER9_VECTOR__) && defined(__powerpc64__)
3175 #define __vec_ldrmb(PTR, CNT) vec_xl_len_r((const unsigned char *)(PTR), (CNT))
3176 #define __vec_strmb(PTR, CNT, VAL)                                             \
3177   vec_xst_len_r((VAL), (unsigned char *)(PTR), (CNT))
3178 #else
3179 #define __vec_ldrmb __builtin_vsx_ldrmb
3180 #define __vec_strmb __builtin_vsx_strmb
3181 #endif
3182
3183 /* vec_cpsgn */
3184
3185 #ifdef __VSX__
3186 static __inline__ vector float __ATTRS_o_ai vec_cpsgn(vector float __a,
3187                                                       vector float __b) {
3188   return __builtin_vsx_xvcpsgnsp(__b, __a);
3189 }
3190
3191 static __inline__ vector double __ATTRS_o_ai vec_cpsgn(vector double __a,
3192                                                        vector double __b) {
3193   return __builtin_vsx_xvcpsgndp(__b, __a);
3194 }
3195 #endif
3196
3197 /* vec_ctf */
3198
3199 #ifdef __VSX__
3200 // There are some functions that have different signatures with the XL compiler
3201 // from those in Clang/GCC and documented in the PVIPR. This macro ensures that
3202 // the XL-compatible signatures are used for those functions.
3203 #ifdef __XL_COMPAT_ALTIVEC__
3204 #define vec_ctf(__a, __b)                                                      \
3205   _Generic(                                                                    \
3206       (__a), vector int                                                        \
3207       : (vector float)__builtin_altivec_vcfsx((vector int)(__a), (__b)),       \
3208         vector unsigned int                                                    \
3209       : (vector float)__builtin_altivec_vcfux((vector unsigned int)(__a),      \
3210                                               (__b)),                          \
3211         vector unsigned long long                                              \
3212       : (vector float)(__builtin_vsx_xvcvuxdsp(                                \
3213                            (vector unsigned long long)(__a)) *                 \
3214                        (vector float)(vector unsigned)((0x7f - (__b)) << 23)), \
3215         vector signed long long                                                \
3216       : (vector float)(__builtin_vsx_xvcvsxdsp(                                \
3217                            (vector signed long long)(__a)) *                   \
3218                        (vector float)(vector unsigned)((0x7f - (__b)) << 23)))
3219 #else // __XL_COMPAT_ALTIVEC__
3220 #define vec_ctf(__a, __b)                                                      \
3221   _Generic(                                                                    \
3222       (__a), vector int                                                        \
3223       : (vector float)__builtin_altivec_vcfsx((vector int)(__a), (__b)),       \
3224         vector unsigned int                                                    \
3225       : (vector float)__builtin_altivec_vcfux((vector unsigned int)(__a),      \
3226                                               (__b)),                          \
3227         vector unsigned long long                                              \
3228       : (vector float)(__builtin_convertvector(                                \
3229                            (vector unsigned long long)(__a), vector double) *  \
3230                        (vector double)(vector unsigned long long)((0x3ffULL -  \
3231                                                                    (__b))      \
3232                                                                   << 52)),     \
3233         vector signed long long                                                \
3234       : (vector float)(__builtin_convertvector((vector signed long long)(__a), \
3235                                                vector double) *                \
3236                        (vector double)(vector unsigned long long)((0x3ffULL -  \
3237                                                                    (__b))      \
3238                                                                   << 52)))
3239 #endif // __XL_COMPAT_ALTIVEC__
3240 #else
3241 #define vec_ctf(__a, __b)                                                      \
3242   _Generic((__a), vector int                                                   \
3243            : (vector float)__builtin_altivec_vcfsx((vector int)(__a), (__b)),  \
3244              vector unsigned int                                               \
3245            : (vector float)__builtin_altivec_vcfux((vector unsigned int)(__a), \
3246                                                    (__b)))
3247 #endif
3248
3249 /* vec_ctd */
3250 #ifdef __VSX__
3251 #define vec_ctd(__a, __b)                                                      \
3252   _Generic((__a), vector signed int                                            \
3253            : (vec_doublee((vector signed int)(__a)) *                          \
3254               (vector double)(vector unsigned long long)((0x3ffULL - (__b))    \
3255                                                          << 52)),              \
3256              vector unsigned int                                               \
3257            : (vec_doublee((vector unsigned int)(__a)) *                        \
3258               (vector double)(vector unsigned long long)((0x3ffULL - (__b))    \
3259                                                          << 52)),              \
3260              vector unsigned long long                                         \
3261            : (__builtin_convertvector((vector unsigned long long)(__a),        \
3262                                       vector double) *                         \
3263               (vector double)(vector unsigned long long)((0x3ffULL - (__b))    \
3264                                                          << 52)),              \
3265              vector signed long long                                           \
3266            : (__builtin_convertvector((vector signed long long)(__a),          \
3267                                       vector double) *                         \
3268               (vector double)(vector unsigned long long)((0x3ffULL - (__b))    \
3269                                                          << 52)))
3270 #endif // __VSX__
3271
3272 /* vec_vcfsx */
3273
3274 #define vec_vcfux __builtin_altivec_vcfux
3275 /* vec_vcfux */
3276
3277 #define vec_vcfsx(__a, __b) __builtin_altivec_vcfsx((vector int)(__a), (__b))
3278
3279 /* vec_cts */
3280
3281 #ifdef __VSX__
3282 #ifdef __XL_COMPAT_ALTIVEC__
3283 #define vec_cts(__a, __b)                                                      \
3284   _Generic((__a), vector float                                                 \
3285            : (vector signed int)__builtin_altivec_vctsxs((vector float)(__a),  \
3286                                                          (__b)),               \
3287              vector double                                                     \
3288            : __extension__({                                                   \
3289              vector double __ret =                                             \
3290                  (vector double)(__a) *                                        \
3291                  (vector double)(vector unsigned long long)((0x3ffULL + (__b)) \
3292                                                             << 52);            \
3293              (vector signed long long)__builtin_vsx_xvcvdpsxws(__ret);         \
3294            }))
3295 #else // __XL_COMPAT_ALTIVEC__
3296 #define vec_cts(__a, __b)                                                      \
3297   _Generic((__a), vector float                                                 \
3298            : (vector signed int)__builtin_altivec_vctsxs((vector float)(__a),  \
3299                                                          (__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              (vector signed long long)__builtin_convertvector(                 \
3307                  __ret, vector signed long long);                              \
3308            }))
3309 #endif // __XL_COMPAT_ALTIVEC__
3310 #else
3311 #define vec_cts __builtin_altivec_vctsxs
3312 #endif
3313
3314 /* vec_vctsxs */
3315
3316 #define vec_vctsxs __builtin_altivec_vctsxs
3317
3318 /* vec_ctu */
3319
3320 #ifdef __VSX__
3321 #ifdef __XL_COMPAT_ALTIVEC__
3322 #define vec_ctu(__a, __b)                                                      \
3323   _Generic((__a), vector float                                                 \
3324            : (vector unsigned int)__builtin_altivec_vctuxs(                    \
3325                  (vector float)(__a), (__b)),                                  \
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              (vector unsigned long long)__builtin_vsx_xvcvdpuxws(__ret);       \
3333            }))
3334 #else // __XL_COMPAT_ALTIVEC__
3335 #define vec_ctu(__a, __b)                                                      \
3336   _Generic((__a), vector float                                                 \
3337            : (vector unsigned int)__builtin_altivec_vctuxs(                    \
3338                  (vector float)(__a), (__b)),                                  \
3339              vector double                                                     \
3340            : __extension__({                                                   \
3341              vector double __ret =                                             \
3342                  (vector double)(__a) *                                        \
3343                  (vector double)(vector unsigned long long)((0x3ffULL + __b)   \
3344                                                             << 52);            \
3345              (vector unsigned long long)__builtin_convertvector(               \
3346                  __ret, vector unsigned long long);                            \
3347            }))
3348 #endif // __XL_COMPAT_ALTIVEC__
3349 #else
3350 #define vec_ctu __builtin_altivec_vctuxs
3351 #endif
3352
3353 #ifdef __LITTLE_ENDIAN__
3354 /* vec_ctsl */
3355
3356 #ifdef __VSX__
3357 #define vec_ctsl(__a, __b)                                                     \
3358   _Generic((__a), vector float                                                 \
3359            : __extension__({                                                   \
3360                vector float __ret =                                            \
3361                    (vector float)(__a) *                                       \
3362                    (vector float)(vector unsigned)((0x7f + (__b)) << 23);      \
3363                __builtin_vsx_xvcvspsxds(                                       \
3364                    __builtin_vsx_xxsldwi(__ret, __ret, 1));                    \
3365              }),                                                               \
3366              vector double                                                     \
3367            : __extension__({                                                   \
3368              vector double __ret =                                             \
3369                  (vector double)(__a) *                                        \
3370                  (vector double)(vector unsigned long long)((0x3ffULL + __b)   \
3371                                                             << 52);            \
3372              __builtin_convertvector(__ret, vector signed long long);          \
3373            }))
3374
3375 /* vec_ctul */
3376
3377 #define vec_ctul(__a, __b)                                                     \
3378   _Generic((__a), vector float                                                 \
3379            : __extension__({                                                   \
3380                vector float __ret =                                            \
3381                    (vector float)(__a) *                                       \
3382                    (vector float)(vector unsigned)((0x7f + (__b)) << 23);      \
3383                __builtin_vsx_xvcvspuxds(                                       \
3384                    __builtin_vsx_xxsldwi(__ret, __ret, 1));                    \
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 #else // __LITTLE_ENDIAN__
3396 /* vec_ctsl */
3397
3398 #ifdef __VSX__
3399 #define vec_ctsl(__a, __b)                                                     \
3400   _Generic((__a), vector float                                                 \
3401            : __extension__({                                                   \
3402                vector float __ret =                                            \
3403                    (vector float)(__a) *                                       \
3404                    (vector float)(vector unsigned)((0x7f + (__b)) << 23);      \
3405                __builtin_vsx_xvcvspsxds(__ret);                                \
3406              }),                                                               \
3407              vector double                                                     \
3408            : __extension__({                                                   \
3409              vector double __ret =                                             \
3410                  (vector double)(__a) *                                        \
3411                  (vector double)(vector unsigned long long)((0x3ffULL + __b)   \
3412                                                             << 52);            \
3413              __builtin_convertvector(__ret, vector signed long long);          \
3414            }))
3415
3416 /* vec_ctul */
3417
3418 #define vec_ctul(__a, __b)                                                     \
3419   _Generic((__a), vector float                                                 \
3420            : __extension__({                                                   \
3421                vector float __ret =                                            \
3422                    (vector float)(__a) *                                       \
3423                    (vector float)(vector unsigned)((0x7f + (__b)) << 23);      \
3424                __builtin_vsx_xvcvspuxds(__ret);                                \
3425              }),                                                               \
3426              vector double                                                     \
3427            : __extension__({                                                   \
3428              vector double __ret =                                             \
3429                  (vector double)(__a) *                                        \
3430                  (vector double)(vector unsigned long long)((0x3ffULL + __b)   \
3431                                                             << 52);            \
3432              __builtin_convertvector(__ret, vector unsigned long long);        \
3433            }))
3434 #endif
3435 #endif // __LITTLE_ENDIAN__
3436
3437 /* vec_vctuxs */
3438
3439 #define vec_vctuxs __builtin_altivec_vctuxs
3440
3441 /* vec_signext */
3442
3443 #ifdef __POWER9_VECTOR__
3444 static __inline__ vector signed int __ATTRS_o_ai
3445 vec_signexti(vector signed char __a) {
3446   return __builtin_altivec_vextsb2w(__a);
3447 }
3448
3449 static __inline__ vector signed int __ATTRS_o_ai
3450 vec_signexti(vector signed short __a) {
3451   return __builtin_altivec_vextsh2w(__a);
3452 }
3453
3454 static __inline__ vector signed long long __ATTRS_o_ai
3455 vec_signextll(vector signed char __a) {
3456   return __builtin_altivec_vextsb2d(__a);
3457 }
3458
3459 static __inline__ vector signed long long __ATTRS_o_ai
3460 vec_signextll(vector signed short __a) {
3461   return __builtin_altivec_vextsh2d(__a);
3462 }
3463
3464 static __inline__ vector signed long long __ATTRS_o_ai
3465 vec_signextll(vector signed int __a) {
3466   return __builtin_altivec_vextsw2d(__a);
3467 }
3468 #endif
3469
3470 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
3471 static __inline__ vector signed __int128 __ATTRS_o_ai
3472 vec_signextq(vector signed long long __a) {
3473   return __builtin_altivec_vextsd2q(__a);
3474 }
3475 #endif
3476
3477 /* vec_signed */
3478
3479 static __inline__ vector signed int __ATTRS_o_ai
3480 vec_sld(vector signed int, vector signed int, unsigned const int __c);
3481
3482 static __inline__ vector signed int __ATTRS_o_ai
3483 vec_signed(vector float __a) {
3484   return __builtin_convertvector(__a, vector signed int);
3485 }
3486
3487 #ifdef __VSX__
3488 static __inline__ vector signed long long __ATTRS_o_ai
3489 vec_signed(vector double __a) {
3490   return __builtin_convertvector(__a, vector signed long long);
3491 }
3492
3493 static __inline__ vector signed int __attribute__((__always_inline__))
3494 vec_signed2(vector double __a, vector double __b) {
3495   return (vector signed int) { __a[0], __a[1], __b[0], __b[1] };
3496 }
3497
3498 static __inline__ vector signed int __ATTRS_o_ai
3499 vec_signede(vector double __a) {
3500 #ifdef __LITTLE_ENDIAN__
3501   vector signed int __ret = __builtin_vsx_xvcvdpsxws(__a);
3502   return vec_sld(__ret, __ret, 12);
3503 #else
3504   return __builtin_vsx_xvcvdpsxws(__a);
3505 #endif
3506 }
3507
3508 static __inline__ vector signed int __ATTRS_o_ai
3509 vec_signedo(vector double __a) {
3510 #ifdef __LITTLE_ENDIAN__
3511   return __builtin_vsx_xvcvdpsxws(__a);
3512 #else
3513   vector signed int __ret = __builtin_vsx_xvcvdpsxws(__a);
3514   return vec_sld(__ret, __ret, 12);
3515 #endif
3516 }
3517 #endif
3518
3519 /* vec_unsigned */
3520
3521 static __inline__ vector unsigned int __ATTRS_o_ai
3522 vec_sld(vector unsigned int, vector unsigned int, unsigned const int __c);
3523
3524 static __inline__ vector unsigned int __ATTRS_o_ai
3525 vec_unsigned(vector float __a) {
3526   return __builtin_convertvector(__a, vector unsigned int);
3527 }
3528
3529 #ifdef __VSX__
3530 static __inline__ vector unsigned long long __ATTRS_o_ai
3531 vec_unsigned(vector double __a) {
3532   return __builtin_convertvector(__a, vector unsigned long long);
3533 }
3534
3535 static __inline__ vector unsigned int __attribute__((__always_inline__))
3536 vec_unsigned2(vector double __a, vector double __b) {
3537   return (vector unsigned int) { __a[0], __a[1], __b[0], __b[1] };
3538 }
3539
3540 static __inline__ vector unsigned int __ATTRS_o_ai
3541 vec_unsignede(vector double __a) {
3542 #ifdef __LITTLE_ENDIAN__
3543   vector unsigned int __ret = __builtin_vsx_xvcvdpuxws(__a);
3544   return vec_sld(__ret, __ret, 12);
3545 #else
3546   return __builtin_vsx_xvcvdpuxws(__a);
3547 #endif
3548 }
3549
3550 static __inline__ vector unsigned int __ATTRS_o_ai
3551 vec_unsignedo(vector double __a) {
3552 #ifdef __LITTLE_ENDIAN__
3553   return __builtin_vsx_xvcvdpuxws(__a);
3554 #else
3555   vector unsigned int __ret = __builtin_vsx_xvcvdpuxws(__a);
3556   return vec_sld(__ret, __ret, 12);
3557 #endif
3558 }
3559 #endif
3560
3561 /* vec_float */
3562
3563 static __inline__ vector float __ATTRS_o_ai
3564 vec_sld(vector float, vector float, unsigned const int __c);
3565
3566 static __inline__ vector float __ATTRS_o_ai
3567 vec_float(vector signed int __a) {
3568   return __builtin_convertvector(__a, vector float);
3569 }
3570
3571 static __inline__ vector float __ATTRS_o_ai
3572 vec_float(vector unsigned int __a) {
3573   return __builtin_convertvector(__a, vector float);
3574 }
3575
3576 #ifdef __VSX__
3577 static __inline__ vector float __ATTRS_o_ai
3578 vec_float2(vector signed long long __a, vector signed long long __b) {
3579   return (vector float) { __a[0], __a[1], __b[0], __b[1] };
3580 }
3581
3582 static __inline__ vector float __ATTRS_o_ai
3583 vec_float2(vector unsigned long long __a, vector unsigned long long __b) {
3584   return (vector float) { __a[0], __a[1], __b[0], __b[1] };
3585 }
3586
3587 static __inline__ vector float __ATTRS_o_ai
3588 vec_float2(vector double __a, vector double __b) {
3589   return (vector float) { __a[0], __a[1], __b[0], __b[1] };
3590 }
3591
3592 static __inline__ vector float __ATTRS_o_ai
3593 vec_floate(vector signed long long __a) {
3594 #ifdef __LITTLE_ENDIAN__
3595   vector float __ret = __builtin_vsx_xvcvsxdsp(__a);
3596   return vec_sld(__ret, __ret, 12);
3597 #else
3598   return __builtin_vsx_xvcvsxdsp(__a);
3599 #endif
3600 }
3601
3602 static __inline__ vector float __ATTRS_o_ai
3603 vec_floate(vector unsigned long long __a) {
3604 #ifdef __LITTLE_ENDIAN__
3605   vector float __ret = __builtin_vsx_xvcvuxdsp(__a);
3606   return vec_sld(__ret, __ret, 12);
3607 #else
3608   return __builtin_vsx_xvcvuxdsp(__a);
3609 #endif
3610 }
3611
3612 static __inline__ vector float __ATTRS_o_ai
3613 vec_floate(vector double __a) {
3614 #ifdef __LITTLE_ENDIAN__
3615   vector float __ret = __builtin_vsx_xvcvdpsp(__a);
3616   return vec_sld(__ret, __ret, 12);
3617 #else
3618   return __builtin_vsx_xvcvdpsp(__a);
3619 #endif
3620 }
3621
3622 static __inline__ vector float __ATTRS_o_ai
3623 vec_floato(vector signed long long __a) {
3624 #ifdef __LITTLE_ENDIAN__
3625   return __builtin_vsx_xvcvsxdsp(__a);
3626 #else
3627   vector float __ret = __builtin_vsx_xvcvsxdsp(__a);
3628   return vec_sld(__ret, __ret, 12);
3629 #endif
3630 }
3631
3632 static __inline__ vector float __ATTRS_o_ai
3633 vec_floato(vector unsigned long long __a) {
3634 #ifdef __LITTLE_ENDIAN__
3635   return __builtin_vsx_xvcvuxdsp(__a);
3636 #else
3637   vector float __ret = __builtin_vsx_xvcvuxdsp(__a);
3638   return vec_sld(__ret, __ret, 12);
3639 #endif
3640 }
3641
3642 static __inline__ vector float __ATTRS_o_ai
3643 vec_floato(vector double __a) {
3644 #ifdef __LITTLE_ENDIAN__
3645   return __builtin_vsx_xvcvdpsp(__a);
3646 #else
3647   vector float __ret = __builtin_vsx_xvcvdpsp(__a);
3648   return vec_sld(__ret, __ret, 12);
3649 #endif
3650 }
3651 #endif
3652
3653 /* vec_double */
3654
3655 #ifdef __VSX__
3656 static __inline__ vector double __ATTRS_o_ai
3657 vec_double(vector signed long long __a) {
3658   return __builtin_convertvector(__a, vector double);
3659 }
3660
3661 static __inline__ vector double __ATTRS_o_ai
3662 vec_double(vector unsigned long long __a) {
3663   return __builtin_convertvector(__a, vector double);
3664 }
3665
3666 static __inline__ vector double __ATTRS_o_ai
3667 vec_doublee(vector signed int __a) {
3668 #ifdef __LITTLE_ENDIAN__
3669   return __builtin_vsx_xvcvsxwdp(vec_sld(__a, __a, 4));
3670 #else
3671   return __builtin_vsx_xvcvsxwdp(__a);
3672 #endif
3673 }
3674
3675 static __inline__ vector double __ATTRS_o_ai
3676 vec_doublee(vector unsigned int __a) {
3677 #ifdef __LITTLE_ENDIAN__
3678   return __builtin_vsx_xvcvuxwdp(vec_sld(__a, __a, 4));
3679 #else
3680   return __builtin_vsx_xvcvuxwdp(__a);
3681 #endif
3682 }
3683
3684 static __inline__ vector double __ATTRS_o_ai
3685 vec_doublee(vector float __a) {
3686 #ifdef __LITTLE_ENDIAN__
3687   return __builtin_vsx_xvcvspdp(vec_sld(__a, __a, 4));
3688 #else
3689   return __builtin_vsx_xvcvspdp(__a);
3690 #endif
3691 }
3692
3693 static __inline__ vector double __ATTRS_o_ai
3694 vec_doubleh(vector signed int __a) {
3695   vector double __ret = {__a[0], __a[1]};
3696   return __ret;
3697 }
3698
3699 static __inline__ vector double __ATTRS_o_ai
3700 vec_doubleh(vector unsigned int __a) {
3701   vector double __ret = {__a[0], __a[1]};
3702   return __ret;
3703 }
3704
3705 static __inline__ vector double __ATTRS_o_ai
3706 vec_doubleh(vector float __a) {
3707   vector double __ret = {__a[0], __a[1]};
3708   return __ret;
3709 }
3710
3711 static __inline__ vector double __ATTRS_o_ai
3712 vec_doublel(vector signed int __a) {
3713   vector double __ret = {__a[2], __a[3]};
3714   return __ret;
3715 }
3716
3717 static __inline__ vector double __ATTRS_o_ai
3718 vec_doublel(vector unsigned int __a) {
3719   vector double __ret = {__a[2], __a[3]};
3720   return __ret;
3721 }
3722
3723 static __inline__ vector double __ATTRS_o_ai
3724 vec_doublel(vector float __a) {
3725   vector double __ret = {__a[2], __a[3]};
3726   return __ret;
3727 }
3728
3729 static __inline__ vector double __ATTRS_o_ai
3730 vec_doubleo(vector signed int __a) {
3731 #ifdef __LITTLE_ENDIAN__
3732   return __builtin_vsx_xvcvsxwdp(__a);
3733 #else
3734   return __builtin_vsx_xvcvsxwdp(vec_sld(__a, __a, 4));
3735 #endif
3736 }
3737
3738 static __inline__ vector double __ATTRS_o_ai
3739 vec_doubleo(vector unsigned int __a) {
3740 #ifdef __LITTLE_ENDIAN__
3741   return __builtin_vsx_xvcvuxwdp(__a);
3742 #else
3743   return __builtin_vsx_xvcvuxwdp(vec_sld(__a, __a, 4));
3744 #endif
3745 }
3746
3747 static __inline__ vector double __ATTRS_o_ai
3748 vec_doubleo(vector float __a) {
3749 #ifdef __LITTLE_ENDIAN__
3750   return __builtin_vsx_xvcvspdp(__a);
3751 #else
3752   return __builtin_vsx_xvcvspdp(vec_sld(__a, __a, 4));
3753 #endif
3754 }
3755
3756 /* vec_cvf */
3757 static __inline__ vector double __ATTRS_o_ai vec_cvf(vector float __a) {
3758   return vec_doublee(__a);
3759 }
3760
3761 static __inline__ vector float __ATTRS_o_ai vec_cvf(vector double __a) {
3762   return vec_floate(__a);
3763 }
3764 #endif
3765
3766 /* vec_div */
3767
3768 /* Integer vector divides (vectors are scalarized, elements divided
3769    and the vectors reassembled).
3770 */
3771 static __inline__ vector signed char __ATTRS_o_ai
3772 vec_div(vector signed char __a, vector signed char __b) {
3773   return __a / __b;
3774 }
3775
3776 static __inline__ vector unsigned char __ATTRS_o_ai
3777 vec_div(vector unsigned char __a, vector unsigned char __b) {
3778   return __a / __b;
3779 }
3780
3781 static __inline__ vector signed short __ATTRS_o_ai
3782 vec_div(vector signed short __a, vector signed short __b) {
3783   return __a / __b;
3784 }
3785
3786 static __inline__ vector unsigned short __ATTRS_o_ai
3787 vec_div(vector unsigned short __a, vector unsigned short __b) {
3788   return __a / __b;
3789 }
3790
3791 static __inline__ vector signed int __ATTRS_o_ai
3792 vec_div(vector signed int __a, vector signed int __b) {
3793   return __a / __b;
3794 }
3795
3796 static __inline__ vector unsigned int __ATTRS_o_ai
3797 vec_div(vector unsigned int __a, vector unsigned int __b) {
3798   return __a / __b;
3799 }
3800
3801 #ifdef __VSX__
3802 static __inline__ vector signed long long __ATTRS_o_ai
3803 vec_div(vector signed long long __a, vector signed long long __b) {
3804   return __a / __b;
3805 }
3806
3807 static __inline__ vector unsigned long long __ATTRS_o_ai
3808 vec_div(vector unsigned long long __a, vector unsigned long long __b) {
3809   return __a / __b;
3810 }
3811
3812 static __inline__ vector float __ATTRS_o_ai vec_div(vector float __a,
3813                                                     vector float __b) {
3814   return __a / __b;
3815 }
3816
3817 static __inline__ vector double __ATTRS_o_ai vec_div(vector double __a,
3818                                                      vector double __b) {
3819   return __a / __b;
3820 }
3821 #endif
3822
3823 /* vec_dive */
3824
3825 #ifdef __POWER10_VECTOR__
3826 static __inline__ vector signed int __ATTRS_o_ai
3827 vec_dive(vector signed int __a, vector signed int __b) {
3828   return __builtin_altivec_vdivesw(__a, __b);
3829 }
3830
3831 static __inline__ vector unsigned int __ATTRS_o_ai
3832 vec_dive(vector unsigned int __a, vector unsigned int __b) {
3833   return __builtin_altivec_vdiveuw(__a, __b);
3834 }
3835
3836 static __inline__ vector signed long long __ATTRS_o_ai
3837 vec_dive(vector signed long long __a, vector signed long long __b) {
3838   return __builtin_altivec_vdivesd(__a, __b);
3839 }
3840
3841 static __inline__ vector unsigned long long __ATTRS_o_ai
3842 vec_dive(vector unsigned long long __a, vector unsigned long long __b) {
3843   return __builtin_altivec_vdiveud(__a, __b);
3844 }
3845
3846 #ifdef __SIZEOF_INT128__
3847 static __inline__ vector unsigned __int128 __ATTRS_o_ai
3848 vec_dive(vector unsigned __int128 __a, vector unsigned __int128 __b) {
3849   return __builtin_altivec_vdiveuq(__a, __b);
3850 }
3851
3852 static __inline__ vector signed __int128 __ATTRS_o_ai
3853 vec_dive(vector signed __int128 __a, vector signed __int128 __b) {
3854   return __builtin_altivec_vdivesq(__a, __b);
3855 }
3856 #endif
3857 #endif
3858
3859 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
3860 static __inline__ vector unsigned __int128 __ATTRS_o_ai
3861 vec_div(vector unsigned __int128 __a, vector unsigned __int128 __b) {
3862   return __a / __b;
3863 }
3864
3865 static __inline__ vector signed __int128 __ATTRS_o_ai
3866 vec_div(vector signed __int128 __a, vector signed __int128 __b) {
3867   return __a / __b;
3868 }
3869 #endif /* __POWER10_VECTOR__ */
3870
3871 /* vec_xvtdiv */
3872
3873 #ifdef __VSX__
3874 static __inline__ int __ATTRS_o_ai vec_test_swdiv(vector double __a,
3875                                                   vector double __b) {
3876   return __builtin_vsx_xvtdivdp(__a, __b);
3877 }
3878
3879 static __inline__ int __ATTRS_o_ai vec_test_swdivs(vector float __a,
3880                                                    vector float __b) {
3881   return __builtin_vsx_xvtdivsp(__a, __b);
3882 }
3883 #endif
3884
3885 /* vec_dss */
3886
3887 #define vec_dss __builtin_altivec_dss
3888
3889 /* vec_dssall */
3890
3891 static __inline__ void __attribute__((__always_inline__)) vec_dssall(void) {
3892   __builtin_altivec_dssall();
3893 }
3894
3895 /* vec_dst */
3896 #define vec_dst(__PTR, __CW, __STR) \
3897   __builtin_altivec_dst((const void *)(__PTR), (__CW), (__STR))
3898
3899 /* vec_dstst */
3900 #define vec_dstst(__PTR, __CW, __STR) \
3901   __builtin_altivec_dstst((const void *)(__PTR), (__CW), (__STR))
3902
3903 /* vec_dststt */
3904 #define vec_dststt(__PTR, __CW, __STR) \
3905   __builtin_altivec_dststt((const void *)(__PTR), (__CW), (__STR))
3906
3907 /* vec_dstt */
3908 #define vec_dstt(__PTR, __CW, __STR) \
3909   __builtin_altivec_dstt((const void *)(__PTR), (__CW), (__STR))
3910
3911 /* vec_eqv */
3912
3913 #ifdef __POWER8_VECTOR__
3914 static __inline__ vector signed char __ATTRS_o_ai
3915 vec_eqv(vector signed char __a, vector signed char __b) {
3916   return (vector signed char)__builtin_vsx_xxleqv((vector unsigned int)__a,
3917                                                   (vector unsigned int)__b);
3918 }
3919
3920 static __inline__ vector unsigned char __ATTRS_o_ai
3921 vec_eqv(vector unsigned char __a, vector unsigned char __b) {
3922   return (vector unsigned char)__builtin_vsx_xxleqv((vector unsigned int)__a,
3923                                                     (vector unsigned int)__b);
3924 }
3925
3926 static __inline__ vector bool char __ATTRS_o_ai vec_eqv(vector bool char __a,
3927                                                         vector bool char __b) {
3928   return (vector bool char)__builtin_vsx_xxleqv((vector unsigned int)__a,
3929                                                 (vector unsigned int)__b);
3930 }
3931
3932 static __inline__ vector signed short __ATTRS_o_ai
3933 vec_eqv(vector signed short __a, vector signed short __b) {
3934   return (vector signed short)__builtin_vsx_xxleqv((vector unsigned int)__a,
3935                                                    (vector unsigned int)__b);
3936 }
3937
3938 static __inline__ vector unsigned short __ATTRS_o_ai
3939 vec_eqv(vector unsigned short __a, vector unsigned short __b) {
3940   return (vector unsigned short)__builtin_vsx_xxleqv((vector unsigned int)__a,
3941                                                      (vector unsigned int)__b);
3942 }
3943
3944 static __inline__ vector bool short __ATTRS_o_ai
3945 vec_eqv(vector bool short __a, vector bool short __b) {
3946   return (vector bool short)__builtin_vsx_xxleqv((vector unsigned int)__a,
3947                                                  (vector unsigned int)__b);
3948 }
3949
3950 static __inline__ vector signed int __ATTRS_o_ai
3951 vec_eqv(vector signed int __a, vector signed int __b) {
3952   return (vector signed int)__builtin_vsx_xxleqv((vector unsigned int)__a,
3953                                                  (vector unsigned int)__b);
3954 }
3955
3956 static __inline__ vector unsigned int __ATTRS_o_ai
3957 vec_eqv(vector unsigned int __a, vector unsigned int __b) {
3958   return __builtin_vsx_xxleqv(__a, __b);
3959 }
3960
3961 static __inline__ vector bool int __ATTRS_o_ai vec_eqv(vector bool int __a,
3962                                                        vector bool int __b) {
3963   return (vector bool int)__builtin_vsx_xxleqv((vector unsigned int)__a,
3964                                                (vector unsigned int)__b);
3965 }
3966
3967 static __inline__ vector signed long long __ATTRS_o_ai
3968 vec_eqv(vector signed long long __a, vector signed long long __b) {
3969   return (vector signed long long)__builtin_vsx_xxleqv(
3970       (vector unsigned int)__a, (vector unsigned int)__b);
3971 }
3972
3973 static __inline__ vector unsigned long long __ATTRS_o_ai
3974 vec_eqv(vector unsigned long long __a, vector unsigned long long __b) {
3975   return (vector unsigned long long)__builtin_vsx_xxleqv(
3976       (vector unsigned int)__a, (vector unsigned int)__b);
3977 }
3978
3979 static __inline__ vector bool long long __ATTRS_o_ai
3980 vec_eqv(vector bool long long __a, vector bool long long __b) {
3981   return (vector bool long long)__builtin_vsx_xxleqv((vector unsigned int)__a,
3982                                                      (vector unsigned int)__b);
3983 }
3984
3985 static __inline__ vector float __ATTRS_o_ai vec_eqv(vector float __a,
3986                                                     vector float __b) {
3987   return (vector float)__builtin_vsx_xxleqv((vector unsigned int)__a,
3988                                             (vector unsigned int)__b);
3989 }
3990
3991 static __inline__ vector double __ATTRS_o_ai vec_eqv(vector double __a,
3992                                                      vector double __b) {
3993   return (vector double)__builtin_vsx_xxleqv((vector unsigned int)__a,
3994                                              (vector unsigned int)__b);
3995 }
3996 #endif
3997
3998 /* vec_expte */
3999
4000 static __inline__ vector float __attribute__((__always_inline__))
4001 vec_expte(vector float __a) {
4002   return __builtin_altivec_vexptefp(__a);
4003 }
4004
4005 /* vec_vexptefp */
4006
4007 static __inline__ vector float __attribute__((__always_inline__))
4008 vec_vexptefp(vector float __a) {
4009   return __builtin_altivec_vexptefp(__a);
4010 }
4011
4012 /* vec_floor */
4013
4014 static __inline__ vector float __ATTRS_o_ai vec_floor(vector float __a) {
4015 #ifdef __VSX__
4016   return __builtin_vsx_xvrspim(__a);
4017 #else
4018   return __builtin_altivec_vrfim(__a);
4019 #endif
4020 }
4021
4022 #ifdef __VSX__
4023 static __inline__ vector double __ATTRS_o_ai vec_floor(vector double __a) {
4024   return __builtin_vsx_xvrdpim(__a);
4025 }
4026 #endif
4027
4028 /* vec_roundm */
4029 static __inline__ vector float __ATTRS_o_ai vec_roundm(vector float __a) {
4030   return vec_floor(__a);
4031 }
4032
4033 #ifdef __VSX__
4034 static __inline__ vector double __ATTRS_o_ai vec_roundm(vector double __a) {
4035   return vec_floor(__a);
4036 }
4037 #endif
4038
4039 /* vec_vrfim */
4040
4041 static __inline__ vector float __attribute__((__always_inline__))
4042 vec_vrfim(vector float __a) {
4043   return __builtin_altivec_vrfim(__a);
4044 }
4045
4046 /* vec_ld */
4047
4048 static __inline__ vector signed char __ATTRS_o_ai
4049 vec_ld(long __a, const vector signed char *__b) {
4050   return (vector signed char)__builtin_altivec_lvx(__a, __b);
4051 }
4052
4053 static __inline__ vector signed char __ATTRS_o_ai
4054 vec_ld(long __a, const signed char *__b) {
4055   return (vector signed char)__builtin_altivec_lvx(__a, __b);
4056 }
4057
4058 static __inline__ vector unsigned char __ATTRS_o_ai
4059 vec_ld(long __a, const vector unsigned char *__b) {
4060   return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
4061 }
4062
4063 static __inline__ vector unsigned char __ATTRS_o_ai
4064 vec_ld(long __a, const unsigned char *__b) {
4065   return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
4066 }
4067
4068 static __inline__ vector bool char __ATTRS_o_ai
4069 vec_ld(long __a, const vector bool char *__b) {
4070   return (vector bool char)__builtin_altivec_lvx(__a, __b);
4071 }
4072
4073 static __inline__ vector short __ATTRS_o_ai vec_ld(long __a,
4074                                                    const vector short *__b) {
4075   return (vector short)__builtin_altivec_lvx(__a, __b);
4076 }
4077
4078 static __inline__ vector short __ATTRS_o_ai vec_ld(long __a, const short *__b) {
4079   return (vector short)__builtin_altivec_lvx(__a, __b);
4080 }
4081
4082 static __inline__ vector unsigned short __ATTRS_o_ai
4083 vec_ld(long __a, const vector unsigned short *__b) {
4084   return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
4085 }
4086
4087 static __inline__ vector unsigned short __ATTRS_o_ai
4088 vec_ld(long __a, const unsigned short *__b) {
4089   return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
4090 }
4091
4092 static __inline__ vector bool short __ATTRS_o_ai
4093 vec_ld(long __a, const vector bool short *__b) {
4094   return (vector bool short)__builtin_altivec_lvx(__a, __b);
4095 }
4096
4097 static __inline__ vector pixel __ATTRS_o_ai vec_ld(long __a,
4098                                                    const vector pixel *__b) {
4099   return (vector pixel)__builtin_altivec_lvx(__a, __b);
4100 }
4101
4102 static __inline__ vector int __ATTRS_o_ai vec_ld(long __a,
4103                                                  const vector int *__b) {
4104   return (vector int)__builtin_altivec_lvx(__a, __b);
4105 }
4106
4107 static __inline__ vector int __ATTRS_o_ai vec_ld(long __a, const int *__b) {
4108   return (vector int)__builtin_altivec_lvx(__a, __b);
4109 }
4110
4111 static __inline__ vector unsigned int __ATTRS_o_ai
4112 vec_ld(long __a, const vector unsigned int *__b) {
4113   return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
4114 }
4115
4116 static __inline__ vector unsigned int __ATTRS_o_ai
4117 vec_ld(long __a, const unsigned int *__b) {
4118   return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
4119 }
4120
4121 static __inline__ vector bool int __ATTRS_o_ai
4122 vec_ld(long __a, const vector bool int *__b) {
4123   return (vector bool int)__builtin_altivec_lvx(__a, __b);
4124 }
4125
4126 static __inline__ vector float __ATTRS_o_ai vec_ld(long __a,
4127                                                    const vector float *__b) {
4128   return (vector float)__builtin_altivec_lvx(__a, __b);
4129 }
4130
4131 static __inline__ vector float __ATTRS_o_ai vec_ld(long __a, const float *__b) {
4132   return (vector float)__builtin_altivec_lvx(__a, __b);
4133 }
4134
4135 /* vec_lvx */
4136
4137 static __inline__ vector signed char __ATTRS_o_ai
4138 vec_lvx(long __a, const vector signed char *__b) {
4139   return (vector signed char)__builtin_altivec_lvx(__a, __b);
4140 }
4141
4142 static __inline__ vector signed char __ATTRS_o_ai
4143 vec_lvx(long __a, const signed char *__b) {
4144   return (vector signed char)__builtin_altivec_lvx(__a, __b);
4145 }
4146
4147 static __inline__ vector unsigned char __ATTRS_o_ai
4148 vec_lvx(long __a, const vector unsigned char *__b) {
4149   return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
4150 }
4151
4152 static __inline__ vector unsigned char __ATTRS_o_ai
4153 vec_lvx(long __a, const unsigned char *__b) {
4154   return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
4155 }
4156
4157 static __inline__ vector bool char __ATTRS_o_ai
4158 vec_lvx(long __a, const vector bool char *__b) {
4159   return (vector bool char)__builtin_altivec_lvx(__a, __b);
4160 }
4161
4162 static __inline__ vector short __ATTRS_o_ai vec_lvx(long __a,
4163                                                     const vector short *__b) {
4164   return (vector short)__builtin_altivec_lvx(__a, __b);
4165 }
4166
4167 static __inline__ vector short __ATTRS_o_ai vec_lvx(long __a, const short *__b) {
4168   return (vector short)__builtin_altivec_lvx(__a, __b);
4169 }
4170
4171 static __inline__ vector unsigned short __ATTRS_o_ai
4172 vec_lvx(long __a, const vector unsigned short *__b) {
4173   return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
4174 }
4175
4176 static __inline__ vector unsigned short __ATTRS_o_ai
4177 vec_lvx(long __a, const unsigned short *__b) {
4178   return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
4179 }
4180
4181 static __inline__ vector bool short __ATTRS_o_ai
4182 vec_lvx(long __a, const vector bool short *__b) {
4183   return (vector bool short)__builtin_altivec_lvx(__a, __b);
4184 }
4185
4186 static __inline__ vector pixel __ATTRS_o_ai vec_lvx(long __a,
4187                                                     const vector pixel *__b) {
4188   return (vector pixel)__builtin_altivec_lvx(__a, __b);
4189 }
4190
4191 static __inline__ vector int __ATTRS_o_ai vec_lvx(long __a,
4192                                                   const vector int *__b) {
4193   return (vector int)__builtin_altivec_lvx(__a, __b);
4194 }
4195
4196 static __inline__ vector int __ATTRS_o_ai vec_lvx(long __a, const int *__b) {
4197   return (vector int)__builtin_altivec_lvx(__a, __b);
4198 }
4199
4200 static __inline__ vector unsigned int __ATTRS_o_ai
4201 vec_lvx(long __a, const vector unsigned int *__b) {
4202   return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
4203 }
4204
4205 static __inline__ vector unsigned int __ATTRS_o_ai
4206 vec_lvx(long __a, const unsigned int *__b) {
4207   return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
4208 }
4209
4210 static __inline__ vector bool int __ATTRS_o_ai
4211 vec_lvx(long __a, const vector bool int *__b) {
4212   return (vector bool int)__builtin_altivec_lvx(__a, __b);
4213 }
4214
4215 static __inline__ vector float __ATTRS_o_ai vec_lvx(long __a,
4216                                                     const vector float *__b) {
4217   return (vector float)__builtin_altivec_lvx(__a, __b);
4218 }
4219
4220 static __inline__ vector float __ATTRS_o_ai vec_lvx(long __a, const float *__b) {
4221   return (vector float)__builtin_altivec_lvx(__a, __b);
4222 }
4223
4224 /* vec_lde */
4225
4226 static __inline__ vector signed char __ATTRS_o_ai
4227 vec_lde(long __a, const signed char *__b) {
4228   return (vector signed char)__builtin_altivec_lvebx(__a, __b);
4229 }
4230
4231 static __inline__ vector unsigned char __ATTRS_o_ai
4232 vec_lde(long __a, const unsigned char *__b) {
4233   return (vector unsigned char)__builtin_altivec_lvebx(__a, __b);
4234 }
4235
4236 static __inline__ vector short __ATTRS_o_ai vec_lde(long __a, const short *__b) {
4237   return (vector short)__builtin_altivec_lvehx(__a, __b);
4238 }
4239
4240 static __inline__ vector unsigned short __ATTRS_o_ai
4241 vec_lde(long __a, const unsigned short *__b) {
4242   return (vector unsigned short)__builtin_altivec_lvehx(__a, __b);
4243 }
4244
4245 static __inline__ vector int __ATTRS_o_ai vec_lde(long __a, const int *__b) {
4246   return (vector int)__builtin_altivec_lvewx(__a, __b);
4247 }
4248
4249 static __inline__ vector unsigned int __ATTRS_o_ai
4250 vec_lde(long __a, const unsigned int *__b) {
4251   return (vector unsigned int)__builtin_altivec_lvewx(__a, __b);
4252 }
4253
4254 static __inline__ vector float __ATTRS_o_ai vec_lde(long __a, const float *__b) {
4255   return (vector float)__builtin_altivec_lvewx(__a, __b);
4256 }
4257
4258 /* vec_lvebx */
4259
4260 static __inline__ vector signed char __ATTRS_o_ai
4261 vec_lvebx(long __a, const signed char *__b) {
4262   return (vector signed char)__builtin_altivec_lvebx(__a, __b);
4263 }
4264
4265 static __inline__ vector unsigned char __ATTRS_o_ai
4266 vec_lvebx(long __a, const unsigned char *__b) {
4267   return (vector unsigned char)__builtin_altivec_lvebx(__a, __b);
4268 }
4269
4270 /* vec_lvehx */
4271
4272 static __inline__ vector short __ATTRS_o_ai vec_lvehx(long __a,
4273                                                       const short *__b) {
4274   return (vector short)__builtin_altivec_lvehx(__a, __b);
4275 }
4276
4277 static __inline__ vector unsigned short __ATTRS_o_ai
4278 vec_lvehx(long __a, const unsigned short *__b) {
4279   return (vector unsigned short)__builtin_altivec_lvehx(__a, __b);
4280 }
4281
4282 /* vec_lvewx */
4283
4284 static __inline__ vector int __ATTRS_o_ai vec_lvewx(long __a, const int *__b) {
4285   return (vector int)__builtin_altivec_lvewx(__a, __b);
4286 }
4287
4288 static __inline__ vector unsigned int __ATTRS_o_ai
4289 vec_lvewx(long __a, const unsigned int *__b) {
4290   return (vector unsigned int)__builtin_altivec_lvewx(__a, __b);
4291 }
4292
4293 static __inline__ vector float __ATTRS_o_ai vec_lvewx(long __a,
4294                                                       const float *__b) {
4295   return (vector float)__builtin_altivec_lvewx(__a, __b);
4296 }
4297
4298 /* vec_ldl */
4299
4300 static __inline__ vector signed char __ATTRS_o_ai
4301 vec_ldl(long __a, const vector signed char *__b) {
4302   return (vector signed char)__builtin_altivec_lvxl(__a, __b);
4303 }
4304
4305 static __inline__ vector signed char __ATTRS_o_ai
4306 vec_ldl(long __a, const signed char *__b) {
4307   return (vector signed char)__builtin_altivec_lvxl(__a, __b);
4308 }
4309
4310 static __inline__ vector unsigned char __ATTRS_o_ai
4311 vec_ldl(long __a, const vector unsigned char *__b) {
4312   return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
4313 }
4314
4315 static __inline__ vector unsigned char __ATTRS_o_ai
4316 vec_ldl(long __a, const unsigned char *__b) {
4317   return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
4318 }
4319
4320 static __inline__ vector bool char __ATTRS_o_ai
4321 vec_ldl(long __a, const vector bool char *__b) {
4322   return (vector bool char)__builtin_altivec_lvxl(__a, __b);
4323 }
4324
4325 static __inline__ vector short __ATTRS_o_ai vec_ldl(long __a,
4326                                                     const vector short *__b) {
4327   return (vector short)__builtin_altivec_lvxl(__a, __b);
4328 }
4329
4330 static __inline__ vector short __ATTRS_o_ai vec_ldl(long __a, const short *__b) {
4331   return (vector short)__builtin_altivec_lvxl(__a, __b);
4332 }
4333
4334 static __inline__ vector unsigned short __ATTRS_o_ai
4335 vec_ldl(long __a, const vector unsigned short *__b) {
4336   return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
4337 }
4338
4339 static __inline__ vector unsigned short __ATTRS_o_ai
4340 vec_ldl(long __a, const unsigned short *__b) {
4341   return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
4342 }
4343
4344 static __inline__ vector bool short __ATTRS_o_ai
4345 vec_ldl(long __a, const vector bool short *__b) {
4346   return (vector bool short)__builtin_altivec_lvxl(__a, __b);
4347 }
4348
4349 static __inline__ vector pixel __ATTRS_o_ai vec_ldl(long __a,
4350                                                     const vector pixel *__b) {
4351   return (vector pixel short)__builtin_altivec_lvxl(__a, __b);
4352 }
4353
4354 static __inline__ vector int __ATTRS_o_ai vec_ldl(long __a,
4355                                                   const vector int *__b) {
4356   return (vector int)__builtin_altivec_lvxl(__a, __b);
4357 }
4358
4359 static __inline__ vector int __ATTRS_o_ai vec_ldl(long __a, const int *__b) {
4360   return (vector int)__builtin_altivec_lvxl(__a, __b);
4361 }
4362
4363 static __inline__ vector unsigned int __ATTRS_o_ai
4364 vec_ldl(long __a, const vector unsigned int *__b) {
4365   return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
4366 }
4367
4368 static __inline__ vector unsigned int __ATTRS_o_ai
4369 vec_ldl(long __a, const unsigned int *__b) {
4370   return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
4371 }
4372
4373 static __inline__ vector bool int __ATTRS_o_ai
4374 vec_ldl(long __a, const vector bool int *__b) {
4375   return (vector bool int)__builtin_altivec_lvxl(__a, __b);
4376 }
4377
4378 static __inline__ vector float __ATTRS_o_ai vec_ldl(long __a,
4379                                                     const vector float *__b) {
4380   return (vector float)__builtin_altivec_lvxl(__a, __b);
4381 }
4382
4383 static __inline__ vector float __ATTRS_o_ai vec_ldl(long __a, const float *__b) {
4384   return (vector float)__builtin_altivec_lvxl(__a, __b);
4385 }
4386
4387 /* vec_lvxl */
4388
4389 static __inline__ vector signed char __ATTRS_o_ai
4390 vec_lvxl(long __a, const vector signed char *__b) {
4391   return (vector signed char)__builtin_altivec_lvxl(__a, __b);
4392 }
4393
4394 static __inline__ vector signed char __ATTRS_o_ai
4395 vec_lvxl(long __a, const signed char *__b) {
4396   return (vector signed char)__builtin_altivec_lvxl(__a, __b);
4397 }
4398
4399 static __inline__ vector unsigned char __ATTRS_o_ai
4400 vec_lvxl(long __a, const vector unsigned char *__b) {
4401   return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
4402 }
4403
4404 static __inline__ vector unsigned char __ATTRS_o_ai
4405 vec_lvxl(long __a, const unsigned char *__b) {
4406   return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
4407 }
4408
4409 static __inline__ vector bool char __ATTRS_o_ai
4410 vec_lvxl(long __a, const vector bool char *__b) {
4411   return (vector bool char)__builtin_altivec_lvxl(__a, __b);
4412 }
4413
4414 static __inline__ vector short __ATTRS_o_ai vec_lvxl(long __a,
4415                                                      const vector short *__b) {
4416   return (vector short)__builtin_altivec_lvxl(__a, __b);
4417 }
4418
4419 static __inline__ vector short __ATTRS_o_ai vec_lvxl(long __a,
4420                                                      const short *__b) {
4421   return (vector short)__builtin_altivec_lvxl(__a, __b);
4422 }
4423
4424 static __inline__ vector unsigned short __ATTRS_o_ai
4425 vec_lvxl(long __a, const vector unsigned short *__b) {
4426   return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
4427 }
4428
4429 static __inline__ vector unsigned short __ATTRS_o_ai
4430 vec_lvxl(long __a, const unsigned short *__b) {
4431   return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
4432 }
4433
4434 static __inline__ vector bool short __ATTRS_o_ai
4435 vec_lvxl(long __a, const vector bool short *__b) {
4436   return (vector bool short)__builtin_altivec_lvxl(__a, __b);
4437 }
4438
4439 static __inline__ vector pixel __ATTRS_o_ai vec_lvxl(long __a,
4440                                                      const vector pixel *__b) {
4441   return (vector pixel)__builtin_altivec_lvxl(__a, __b);
4442 }
4443
4444 static __inline__ vector int __ATTRS_o_ai vec_lvxl(long __a,
4445                                                    const vector int *__b) {
4446   return (vector int)__builtin_altivec_lvxl(__a, __b);
4447 }
4448
4449 static __inline__ vector int __ATTRS_o_ai vec_lvxl(long __a, const int *__b) {
4450   return (vector int)__builtin_altivec_lvxl(__a, __b);
4451 }
4452
4453 static __inline__ vector unsigned int __ATTRS_o_ai
4454 vec_lvxl(long __a, const vector unsigned int *__b) {
4455   return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
4456 }
4457
4458 static __inline__ vector unsigned int __ATTRS_o_ai
4459 vec_lvxl(long __a, const unsigned int *__b) {
4460   return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
4461 }
4462
4463 static __inline__ vector bool int __ATTRS_o_ai
4464 vec_lvxl(long __a, const vector bool int *__b) {
4465   return (vector bool int)__builtin_altivec_lvxl(__a, __b);
4466 }
4467
4468 static __inline__ vector float __ATTRS_o_ai vec_lvxl(long __a,
4469                                                      const vector float *__b) {
4470   return (vector float)__builtin_altivec_lvxl(__a, __b);
4471 }
4472
4473 static __inline__ vector float __ATTRS_o_ai vec_lvxl(long __a,
4474                                                      const float *__b) {
4475   return (vector float)__builtin_altivec_lvxl(__a, __b);
4476 }
4477
4478 /* vec_loge */
4479
4480 static __inline__ vector float __attribute__((__always_inline__))
4481 vec_loge(vector float __a) {
4482   return __builtin_altivec_vlogefp(__a);
4483 }
4484
4485 /* vec_vlogefp */
4486
4487 static __inline__ vector float __attribute__((__always_inline__))
4488 vec_vlogefp(vector float __a) {
4489   return __builtin_altivec_vlogefp(__a);
4490 }
4491
4492 /* vec_lvsl */
4493
4494 #ifdef __LITTLE_ENDIAN__
4495 static __inline__ vector unsigned char __ATTRS_o_ai
4496     __attribute__((__deprecated__("use assignment for unaligned little endian \
4497 loads/stores"))) vec_lvsl(int __a, const signed char *__b) {
4498   vector unsigned char mask =
4499       (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4500   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4501                                   7,  6,  5,  4,  3,  2,  1, 0};
4502   return vec_perm(mask, mask, reverse);
4503 }
4504 #else
4505 static __inline__ vector unsigned char __ATTRS_o_ai
4506 vec_lvsl(int __a, const signed char *__b) {
4507   return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4508 }
4509 #endif
4510
4511 #ifdef __LITTLE_ENDIAN__
4512 static __inline__ vector unsigned char __ATTRS_o_ai
4513     __attribute__((__deprecated__("use assignment for unaligned little endian \
4514 loads/stores"))) vec_lvsl(int __a, const unsigned char *__b) {
4515   vector unsigned char mask =
4516       (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4517   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4518                                   7,  6,  5,  4,  3,  2,  1, 0};
4519   return vec_perm(mask, mask, reverse);
4520 }
4521 #else
4522 static __inline__ vector unsigned char __ATTRS_o_ai
4523 vec_lvsl(int __a, const unsigned char *__b) {
4524   return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4525 }
4526 #endif
4527
4528 #ifdef __LITTLE_ENDIAN__
4529 static __inline__ vector unsigned char __ATTRS_o_ai
4530     __attribute__((__deprecated__("use assignment for unaligned little endian \
4531 loads/stores"))) vec_lvsl(int __a, const short *__b) {
4532   vector unsigned char mask =
4533       (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4534   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4535                                   7,  6,  5,  4,  3,  2,  1, 0};
4536   return vec_perm(mask, mask, reverse);
4537 }
4538 #else
4539 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsl(int __a,
4540                                                              const short *__b) {
4541   return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4542 }
4543 #endif
4544
4545 #ifdef __LITTLE_ENDIAN__
4546 static __inline__ vector unsigned char __ATTRS_o_ai
4547     __attribute__((__deprecated__("use assignment for unaligned little endian \
4548 loads/stores"))) vec_lvsl(int __a, const unsigned short *__b) {
4549   vector unsigned char mask =
4550       (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4551   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4552                                   7,  6,  5,  4,  3,  2,  1, 0};
4553   return vec_perm(mask, mask, reverse);
4554 }
4555 #else
4556 static __inline__ vector unsigned char __ATTRS_o_ai
4557 vec_lvsl(int __a, const unsigned short *__b) {
4558   return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4559 }
4560 #endif
4561
4562 #ifdef __LITTLE_ENDIAN__
4563 static __inline__ vector unsigned char __ATTRS_o_ai
4564     __attribute__((__deprecated__("use assignment for unaligned little endian \
4565 loads/stores"))) vec_lvsl(int __a, const int *__b) {
4566   vector unsigned char mask =
4567       (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4568   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4569                                   7,  6,  5,  4,  3,  2,  1, 0};
4570   return vec_perm(mask, mask, reverse);
4571 }
4572 #else
4573 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsl(int __a,
4574                                                              const int *__b) {
4575   return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4576 }
4577 #endif
4578
4579 #ifdef __LITTLE_ENDIAN__
4580 static __inline__ vector unsigned char __ATTRS_o_ai
4581     __attribute__((__deprecated__("use assignment for unaligned little endian \
4582 loads/stores"))) vec_lvsl(int __a, const unsigned int *__b) {
4583   vector unsigned char mask =
4584       (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4585   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4586                                   7,  6,  5,  4,  3,  2,  1, 0};
4587   return vec_perm(mask, mask, reverse);
4588 }
4589 #else
4590 static __inline__ vector unsigned char __ATTRS_o_ai
4591 vec_lvsl(int __a, const unsigned int *__b) {
4592   return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4593 }
4594 #endif
4595
4596 #ifdef __LITTLE_ENDIAN__
4597 static __inline__ vector unsigned char __ATTRS_o_ai
4598     __attribute__((__deprecated__("use assignment for unaligned little endian \
4599 loads/stores"))) vec_lvsl(int __a, const float *__b) {
4600   vector unsigned char mask =
4601       (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4602   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4603                                   7,  6,  5,  4,  3,  2,  1, 0};
4604   return vec_perm(mask, mask, reverse);
4605 }
4606 #else
4607 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsl(int __a,
4608                                                              const float *__b) {
4609   return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4610 }
4611 #endif
4612
4613 /* vec_lvsr */
4614
4615 #ifdef __LITTLE_ENDIAN__
4616 static __inline__ vector unsigned char __ATTRS_o_ai
4617     __attribute__((__deprecated__("use assignment for unaligned little endian \
4618 loads/stores"))) vec_lvsr(int __a, const signed char *__b) {
4619   vector unsigned char mask =
4620       (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4621   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4622                                   7,  6,  5,  4,  3,  2,  1, 0};
4623   return vec_perm(mask, mask, reverse);
4624 }
4625 #else
4626 static __inline__ vector unsigned char __ATTRS_o_ai
4627 vec_lvsr(int __a, const signed char *__b) {
4628   return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4629 }
4630 #endif
4631
4632 #ifdef __LITTLE_ENDIAN__
4633 static __inline__ vector unsigned char __ATTRS_o_ai
4634     __attribute__((__deprecated__("use assignment for unaligned little endian \
4635 loads/stores"))) vec_lvsr(int __a, const unsigned char *__b) {
4636   vector unsigned char mask =
4637       (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4638   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4639                                   7,  6,  5,  4,  3,  2,  1, 0};
4640   return vec_perm(mask, mask, reverse);
4641 }
4642 #else
4643 static __inline__ vector unsigned char __ATTRS_o_ai
4644 vec_lvsr(int __a, const unsigned char *__b) {
4645   return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4646 }
4647 #endif
4648
4649 #ifdef __LITTLE_ENDIAN__
4650 static __inline__ vector unsigned char __ATTRS_o_ai
4651     __attribute__((__deprecated__("use assignment for unaligned little endian \
4652 loads/stores"))) vec_lvsr(int __a, const short *__b) {
4653   vector unsigned char mask =
4654       (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4655   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4656                                   7,  6,  5,  4,  3,  2,  1, 0};
4657   return vec_perm(mask, mask, reverse);
4658 }
4659 #else
4660 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsr(int __a,
4661                                                              const short *__b) {
4662   return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4663 }
4664 #endif
4665
4666 #ifdef __LITTLE_ENDIAN__
4667 static __inline__ vector unsigned char __ATTRS_o_ai
4668     __attribute__((__deprecated__("use assignment for unaligned little endian \
4669 loads/stores"))) vec_lvsr(int __a, const unsigned short *__b) {
4670   vector unsigned char mask =
4671       (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4672   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4673                                   7,  6,  5,  4,  3,  2,  1, 0};
4674   return vec_perm(mask, mask, reverse);
4675 }
4676 #else
4677 static __inline__ vector unsigned char __ATTRS_o_ai
4678 vec_lvsr(int __a, const unsigned short *__b) {
4679   return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4680 }
4681 #endif
4682
4683 #ifdef __LITTLE_ENDIAN__
4684 static __inline__ vector unsigned char __ATTRS_o_ai
4685     __attribute__((__deprecated__("use assignment for unaligned little endian \
4686 loads/stores"))) vec_lvsr(int __a, const int *__b) {
4687   vector unsigned char mask =
4688       (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4689   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4690                                   7,  6,  5,  4,  3,  2,  1, 0};
4691   return vec_perm(mask, mask, reverse);
4692 }
4693 #else
4694 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsr(int __a,
4695                                                              const int *__b) {
4696   return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4697 }
4698 #endif
4699
4700 #ifdef __LITTLE_ENDIAN__
4701 static __inline__ vector unsigned char __ATTRS_o_ai
4702     __attribute__((__deprecated__("use assignment for unaligned little endian \
4703 loads/stores"))) vec_lvsr(int __a, const unsigned int *__b) {
4704   vector unsigned char mask =
4705       (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4706   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4707                                   7,  6,  5,  4,  3,  2,  1, 0};
4708   return vec_perm(mask, mask, reverse);
4709 }
4710 #else
4711 static __inline__ vector unsigned char __ATTRS_o_ai
4712 vec_lvsr(int __a, const unsigned int *__b) {
4713   return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4714 }
4715 #endif
4716
4717 #ifdef __LITTLE_ENDIAN__
4718 static __inline__ vector unsigned char __ATTRS_o_ai
4719     __attribute__((__deprecated__("use assignment for unaligned little endian \
4720 loads/stores"))) vec_lvsr(int __a, const float *__b) {
4721   vector unsigned char mask =
4722       (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4723   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4724                                   7,  6,  5,  4,  3,  2,  1, 0};
4725   return vec_perm(mask, mask, reverse);
4726 }
4727 #else
4728 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsr(int __a,
4729                                                              const float *__b) {
4730   return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4731 }
4732 #endif
4733
4734 /* vec_madd */
4735 static __inline__ vector signed short __ATTRS_o_ai
4736 vec_mladd(vector signed short, vector signed short, vector signed short);
4737 static __inline__ vector signed short __ATTRS_o_ai
4738 vec_mladd(vector signed short, vector unsigned short, vector unsigned short);
4739 static __inline__ vector signed short __ATTRS_o_ai
4740 vec_mladd(vector unsigned short, vector signed short, vector signed short);
4741 static __inline__ vector unsigned short __ATTRS_o_ai
4742 vec_mladd(vector unsigned short, vector unsigned short, vector unsigned short);
4743
4744 static __inline__ vector signed short __ATTRS_o_ai vec_madd(
4745     vector signed short __a, vector signed short __b, vector signed short __c) {
4746   return vec_mladd(__a, __b, __c);
4747 }
4748
4749 static __inline__ vector signed short __ATTRS_o_ai
4750 vec_madd(vector signed short __a, vector unsigned short __b,
4751          vector unsigned short __c) {
4752   return vec_mladd(__a, __b, __c);
4753 }
4754
4755 static __inline__ vector signed short __ATTRS_o_ai
4756 vec_madd(vector unsigned short __a, vector signed short __b,
4757          vector signed short __c) {
4758   return vec_mladd(__a, __b, __c);
4759 }
4760
4761 static __inline__ vector unsigned short __ATTRS_o_ai
4762 vec_madd(vector unsigned short __a, vector unsigned short __b,
4763          vector unsigned short __c) {
4764   return vec_mladd(__a, __b, __c);
4765 }
4766
4767 static __inline__ vector float __ATTRS_o_ai vec_madd(vector float __a,
4768                                                      vector float __b,
4769                                                      vector float __c) {
4770 #ifdef __VSX__
4771   return __builtin_vsx_xvmaddasp(__a, __b, __c);
4772 #else
4773   return __builtin_altivec_vmaddfp(__a, __b, __c);
4774 #endif
4775 }
4776
4777 #ifdef __VSX__
4778 static __inline__ vector double __ATTRS_o_ai vec_madd(vector double __a,
4779                                                       vector double __b,
4780                                                       vector double __c) {
4781   return __builtin_vsx_xvmaddadp(__a, __b, __c);
4782 }
4783 #endif
4784
4785 /* vec_vmaddfp */
4786
4787 static __inline__ vector float __attribute__((__always_inline__))
4788 vec_vmaddfp(vector float __a, vector float __b, vector float __c) {
4789   return __builtin_altivec_vmaddfp(__a, __b, __c);
4790 }
4791
4792 /* vec_madds */
4793
4794 static __inline__ vector signed short __attribute__((__always_inline__))
4795 vec_madds(vector signed short __a, vector signed short __b,
4796           vector signed short __c) {
4797   return __builtin_altivec_vmhaddshs(__a, __b, __c);
4798 }
4799
4800 /* vec_vmhaddshs */
4801 static __inline__ vector signed short __attribute__((__always_inline__))
4802 vec_vmhaddshs(vector signed short __a, vector signed short __b,
4803               vector signed short __c) {
4804   return __builtin_altivec_vmhaddshs(__a, __b, __c);
4805 }
4806
4807 /* vec_msub */
4808
4809 #ifdef __VSX__
4810 static __inline__ vector float __ATTRS_o_ai vec_msub(vector float __a,
4811                                                      vector float __b,
4812                                                      vector float __c) {
4813   return __builtin_vsx_xvmsubasp(__a, __b, __c);
4814 }
4815
4816 static __inline__ vector double __ATTRS_o_ai vec_msub(vector double __a,
4817                                                       vector double __b,
4818                                                       vector double __c) {
4819   return __builtin_vsx_xvmsubadp(__a, __b, __c);
4820 }
4821 #endif
4822
4823 /* vec_max */
4824
4825 static __inline__ vector signed char __ATTRS_o_ai
4826 vec_max(vector signed char __a, vector signed char __b) {
4827   return __builtin_altivec_vmaxsb(__a, __b);
4828 }
4829
4830 static __inline__ vector signed char __ATTRS_o_ai
4831 vec_max(vector bool char __a, vector signed char __b) {
4832   return __builtin_altivec_vmaxsb((vector signed char)__a, __b);
4833 }
4834
4835 static __inline__ vector signed char __ATTRS_o_ai
4836 vec_max(vector signed char __a, vector bool char __b) {
4837   return __builtin_altivec_vmaxsb(__a, (vector signed char)__b);
4838 }
4839
4840 static __inline__ vector unsigned char __ATTRS_o_ai
4841 vec_max(vector unsigned char __a, vector unsigned char __b) {
4842   return __builtin_altivec_vmaxub(__a, __b);
4843 }
4844
4845 static __inline__ vector unsigned char __ATTRS_o_ai
4846 vec_max(vector bool char __a, vector unsigned char __b) {
4847   return __builtin_altivec_vmaxub((vector unsigned char)__a, __b);
4848 }
4849
4850 static __inline__ vector unsigned char __ATTRS_o_ai
4851 vec_max(vector unsigned char __a, vector bool char __b) {
4852   return __builtin_altivec_vmaxub(__a, (vector unsigned char)__b);
4853 }
4854
4855 static __inline__ vector short __ATTRS_o_ai vec_max(vector short __a,
4856                                                     vector short __b) {
4857   return __builtin_altivec_vmaxsh(__a, __b);
4858 }
4859
4860 static __inline__ vector short __ATTRS_o_ai vec_max(vector bool short __a,
4861                                                     vector short __b) {
4862   return __builtin_altivec_vmaxsh((vector short)__a, __b);
4863 }
4864
4865 static __inline__ vector short __ATTRS_o_ai vec_max(vector short __a,
4866                                                     vector bool short __b) {
4867   return __builtin_altivec_vmaxsh(__a, (vector short)__b);
4868 }
4869
4870 static __inline__ vector unsigned short __ATTRS_o_ai
4871 vec_max(vector unsigned short __a, vector unsigned short __b) {
4872   return __builtin_altivec_vmaxuh(__a, __b);
4873 }
4874
4875 static __inline__ vector unsigned short __ATTRS_o_ai
4876 vec_max(vector bool short __a, vector unsigned short __b) {
4877   return __builtin_altivec_vmaxuh((vector unsigned short)__a, __b);
4878 }
4879
4880 static __inline__ vector unsigned short __ATTRS_o_ai
4881 vec_max(vector unsigned short __a, vector bool short __b) {
4882   return __builtin_altivec_vmaxuh(__a, (vector unsigned short)__b);
4883 }
4884
4885 static __inline__ vector int __ATTRS_o_ai vec_max(vector int __a,
4886                                                   vector int __b) {
4887   return __builtin_altivec_vmaxsw(__a, __b);
4888 }
4889
4890 static __inline__ vector int __ATTRS_o_ai vec_max(vector bool int __a,
4891                                                   vector int __b) {
4892   return __builtin_altivec_vmaxsw((vector int)__a, __b);
4893 }
4894
4895 static __inline__ vector int __ATTRS_o_ai vec_max(vector int __a,
4896                                                   vector bool int __b) {
4897   return __builtin_altivec_vmaxsw(__a, (vector int)__b);
4898 }
4899
4900 static __inline__ vector unsigned int __ATTRS_o_ai
4901 vec_max(vector unsigned int __a, vector unsigned int __b) {
4902   return __builtin_altivec_vmaxuw(__a, __b);
4903 }
4904
4905 static __inline__ vector unsigned int __ATTRS_o_ai
4906 vec_max(vector bool int __a, vector unsigned int __b) {
4907   return __builtin_altivec_vmaxuw((vector unsigned int)__a, __b);
4908 }
4909
4910 static __inline__ vector unsigned int __ATTRS_o_ai
4911 vec_max(vector unsigned int __a, vector bool int __b) {
4912   return __builtin_altivec_vmaxuw(__a, (vector unsigned int)__b);
4913 }
4914
4915 #ifdef __POWER8_VECTOR__
4916 static __inline__ vector signed long long __ATTRS_o_ai
4917 vec_max(vector signed long long __a, vector signed long long __b) {
4918   return __builtin_altivec_vmaxsd(__a, __b);
4919 }
4920
4921 static __inline__ vector signed long long __ATTRS_o_ai
4922 vec_max(vector bool long long __a, vector signed long long __b) {
4923   return __builtin_altivec_vmaxsd((vector signed long long)__a, __b);
4924 }
4925
4926 static __inline__ vector signed long long __ATTRS_o_ai
4927 vec_max(vector signed long long __a, vector bool long long __b) {
4928   return __builtin_altivec_vmaxsd(__a, (vector signed long long)__b);
4929 }
4930
4931 static __inline__ vector unsigned long long __ATTRS_o_ai
4932 vec_max(vector unsigned long long __a, vector unsigned long long __b) {
4933   return __builtin_altivec_vmaxud(__a, __b);
4934 }
4935
4936 static __inline__ vector unsigned long long __ATTRS_o_ai
4937 vec_max(vector bool long long __a, vector unsigned long long __b) {
4938   return __builtin_altivec_vmaxud((vector unsigned long long)__a, __b);
4939 }
4940
4941 static __inline__ vector unsigned long long __ATTRS_o_ai
4942 vec_max(vector unsigned long long __a, vector bool long long __b) {
4943   return __builtin_altivec_vmaxud(__a, (vector unsigned long long)__b);
4944 }
4945 #endif
4946
4947 static __inline__ vector float __ATTRS_o_ai vec_max(vector float __a,
4948                                                     vector float __b) {
4949 #ifdef __VSX__
4950   return __builtin_vsx_xvmaxsp(__a, __b);
4951 #else
4952   return __builtin_altivec_vmaxfp(__a, __b);
4953 #endif
4954 }
4955
4956 #ifdef __VSX__
4957 static __inline__ vector double __ATTRS_o_ai vec_max(vector double __a,
4958                                                      vector double __b) {
4959   return __builtin_vsx_xvmaxdp(__a, __b);
4960 }
4961 #endif
4962
4963 /* vec_vmaxsb */
4964
4965 static __inline__ vector signed char __ATTRS_o_ai
4966 vec_vmaxsb(vector signed char __a, vector signed char __b) {
4967   return __builtin_altivec_vmaxsb(__a, __b);
4968 }
4969
4970 static __inline__ vector signed char __ATTRS_o_ai
4971 vec_vmaxsb(vector bool char __a, vector signed char __b) {
4972   return __builtin_altivec_vmaxsb((vector signed char)__a, __b);
4973 }
4974
4975 static __inline__ vector signed char __ATTRS_o_ai
4976 vec_vmaxsb(vector signed char __a, vector bool char __b) {
4977   return __builtin_altivec_vmaxsb(__a, (vector signed char)__b);
4978 }
4979
4980 /* vec_vmaxub */
4981
4982 static __inline__ vector unsigned char __ATTRS_o_ai
4983 vec_vmaxub(vector unsigned char __a, vector unsigned char __b) {
4984   return __builtin_altivec_vmaxub(__a, __b);
4985 }
4986
4987 static __inline__ vector unsigned char __ATTRS_o_ai
4988 vec_vmaxub(vector bool char __a, vector unsigned char __b) {
4989   return __builtin_altivec_vmaxub((vector unsigned char)__a, __b);
4990 }
4991
4992 static __inline__ vector unsigned char __ATTRS_o_ai
4993 vec_vmaxub(vector unsigned char __a, vector bool char __b) {
4994   return __builtin_altivec_vmaxub(__a, (vector unsigned char)__b);
4995 }
4996
4997 /* vec_vmaxsh */
4998
4999 static __inline__ vector short __ATTRS_o_ai vec_vmaxsh(vector short __a,
5000                                                        vector short __b) {
5001   return __builtin_altivec_vmaxsh(__a, __b);
5002 }
5003
5004 static __inline__ vector short __ATTRS_o_ai vec_vmaxsh(vector bool short __a,
5005                                                        vector short __b) {
5006   return __builtin_altivec_vmaxsh((vector short)__a, __b);
5007 }
5008
5009 static __inline__ vector short __ATTRS_o_ai vec_vmaxsh(vector short __a,
5010                                                        vector bool short __b) {
5011   return __builtin_altivec_vmaxsh(__a, (vector short)__b);
5012 }
5013
5014 /* vec_vmaxuh */
5015
5016 static __inline__ vector unsigned short __ATTRS_o_ai
5017 vec_vmaxuh(vector unsigned short __a, vector unsigned short __b) {
5018   return __builtin_altivec_vmaxuh(__a, __b);
5019 }
5020
5021 static __inline__ vector unsigned short __ATTRS_o_ai
5022 vec_vmaxuh(vector bool short __a, vector unsigned short __b) {
5023   return __builtin_altivec_vmaxuh((vector unsigned short)__a, __b);
5024 }
5025
5026 static __inline__ vector unsigned short __ATTRS_o_ai
5027 vec_vmaxuh(vector unsigned short __a, vector bool short __b) {
5028   return __builtin_altivec_vmaxuh(__a, (vector unsigned short)__b);
5029 }
5030
5031 /* vec_vmaxsw */
5032
5033 static __inline__ vector int __ATTRS_o_ai vec_vmaxsw(vector int __a,
5034                                                      vector int __b) {
5035   return __builtin_altivec_vmaxsw(__a, __b);
5036 }
5037
5038 static __inline__ vector int __ATTRS_o_ai vec_vmaxsw(vector bool int __a,
5039                                                      vector int __b) {
5040   return __builtin_altivec_vmaxsw((vector int)__a, __b);
5041 }
5042
5043 static __inline__ vector int __ATTRS_o_ai vec_vmaxsw(vector int __a,
5044                                                      vector bool int __b) {
5045   return __builtin_altivec_vmaxsw(__a, (vector int)__b);
5046 }
5047
5048 /* vec_vmaxuw */
5049
5050 static __inline__ vector unsigned int __ATTRS_o_ai
5051 vec_vmaxuw(vector unsigned int __a, vector unsigned int __b) {
5052   return __builtin_altivec_vmaxuw(__a, __b);
5053 }
5054
5055 static __inline__ vector unsigned int __ATTRS_o_ai
5056 vec_vmaxuw(vector bool int __a, vector unsigned int __b) {
5057   return __builtin_altivec_vmaxuw((vector unsigned int)__a, __b);
5058 }
5059
5060 static __inline__ vector unsigned int __ATTRS_o_ai
5061 vec_vmaxuw(vector unsigned int __a, vector bool int __b) {
5062   return __builtin_altivec_vmaxuw(__a, (vector unsigned int)__b);
5063 }
5064
5065 /* vec_vmaxfp */
5066
5067 static __inline__ vector float __attribute__((__always_inline__))
5068 vec_vmaxfp(vector float __a, vector float __b) {
5069 #ifdef __VSX__
5070   return __builtin_vsx_xvmaxsp(__a, __b);
5071 #else
5072   return __builtin_altivec_vmaxfp(__a, __b);
5073 #endif
5074 }
5075
5076 /* vec_mergeh */
5077
5078 static __inline__ vector signed char __ATTRS_o_ai
5079 vec_mergeh(vector signed char __a, vector signed char __b) {
5080   return vec_perm(__a, __b,
5081                   (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
5082                                          0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
5083                                          0x06, 0x16, 0x07, 0x17));
5084 }
5085
5086 static __inline__ vector unsigned char __ATTRS_o_ai
5087 vec_mergeh(vector unsigned char __a, vector unsigned char __b) {
5088   return vec_perm(__a, __b,
5089                   (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
5090                                          0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
5091                                          0x06, 0x16, 0x07, 0x17));
5092 }
5093
5094 static __inline__ vector bool char __ATTRS_o_ai
5095 vec_mergeh(vector bool char __a, vector bool char __b) {
5096   return vec_perm(__a, __b,
5097                   (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
5098                                          0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
5099                                          0x06, 0x16, 0x07, 0x17));
5100 }
5101
5102 static __inline__ vector short __ATTRS_o_ai vec_mergeh(vector short __a,
5103                                                        vector short __b) {
5104   return vec_perm(__a, __b,
5105                   (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
5106                                          0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
5107                                          0x06, 0x07, 0x16, 0x17));
5108 }
5109
5110 static __inline__ vector unsigned short __ATTRS_o_ai
5111 vec_mergeh(vector unsigned short __a, vector unsigned short __b) {
5112   return vec_perm(__a, __b,
5113                   (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
5114                                          0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
5115                                          0x06, 0x07, 0x16, 0x17));
5116 }
5117
5118 static __inline__ vector bool short __ATTRS_o_ai
5119 vec_mergeh(vector bool short __a, vector bool short __b) {
5120   return vec_perm(__a, __b,
5121                   (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
5122                                          0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
5123                                          0x06, 0x07, 0x16, 0x17));
5124 }
5125
5126 static __inline__ vector pixel __ATTRS_o_ai vec_mergeh(vector pixel __a,
5127                                                        vector pixel __b) {
5128   return vec_perm(__a, __b,
5129                   (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
5130                                          0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
5131                                          0x06, 0x07, 0x16, 0x17));
5132 }
5133
5134 static __inline__ vector int __ATTRS_o_ai vec_mergeh(vector int __a,
5135                                                      vector int __b) {
5136   return vec_perm(__a, __b,
5137                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5138                                          0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
5139                                          0x14, 0x15, 0x16, 0x17));
5140 }
5141
5142 static __inline__ vector unsigned int __ATTRS_o_ai
5143 vec_mergeh(vector unsigned int __a, vector unsigned int __b) {
5144   return vec_perm(__a, __b,
5145                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5146                                          0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
5147                                          0x14, 0x15, 0x16, 0x17));
5148 }
5149
5150 static __inline__ vector bool int __ATTRS_o_ai vec_mergeh(vector bool int __a,
5151                                                           vector bool int __b) {
5152   return vec_perm(__a, __b,
5153                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5154                                          0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
5155                                          0x14, 0x15, 0x16, 0x17));
5156 }
5157
5158 static __inline__ vector float __ATTRS_o_ai vec_mergeh(vector float __a,
5159                                                        vector float __b) {
5160   return vec_perm(__a, __b,
5161                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5162                                          0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
5163                                          0x14, 0x15, 0x16, 0x17));
5164 }
5165
5166 #ifdef __VSX__
5167 static __inline__ vector signed long long __ATTRS_o_ai
5168 vec_mergeh(vector signed long long __a, vector signed long long __b) {
5169   return vec_perm(__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 signed long long __ATTRS_o_ai
5176 vec_mergeh(vector signed long long __a, vector bool long long __b) {
5177   return vec_perm(__a, (vector signed long long)__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 signed long long __ATTRS_o_ai
5184 vec_mergeh(vector bool long long __a, vector signed long long __b) {
5185   return vec_perm((vector signed long long)__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
5191 static __inline__ vector unsigned long long __ATTRS_o_ai
5192 vec_mergeh(vector unsigned long long __a, vector unsigned long long __b) {
5193   return vec_perm(__a, __b,
5194                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
5195                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
5196                                          0x14, 0x15, 0x16, 0x17));
5197 }
5198
5199 static __inline__ vector unsigned long long __ATTRS_o_ai
5200 vec_mergeh(vector unsigned long long __a, vector bool long long __b) {
5201   return vec_perm(__a, (vector unsigned long long)__b,
5202                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
5203                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
5204                                          0x14, 0x15, 0x16, 0x17));
5205 }
5206
5207 static __inline__ vector unsigned long long __ATTRS_o_ai
5208 vec_mergeh(vector bool long long __a, vector unsigned long long __b) {
5209   return vec_perm((vector unsigned long long)__a, __b,
5210                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
5211                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
5212                                          0x14, 0x15, 0x16, 0x17));
5213 }
5214
5215 static __inline__ vector bool long long __ATTRS_o_ai
5216 vec_mergeh(vector bool long long __a, vector bool long long __b) {
5217   return vec_perm(__a, __b,
5218                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
5219                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
5220                                          0x14, 0x15, 0x16, 0x17));
5221 }
5222
5223 static __inline__ vector double __ATTRS_o_ai vec_mergeh(vector double __a,
5224                                                         vector double __b) {
5225   return vec_perm(__a, __b,
5226                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
5227                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
5228                                          0x14, 0x15, 0x16, 0x17));
5229 }
5230 static __inline__ vector double __ATTRS_o_ai
5231 vec_mergeh(vector double __a, vector bool long long __b) {
5232   return vec_perm(__a, (vector double)__b,
5233                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
5234                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
5235                                          0x14, 0x15, 0x16, 0x17));
5236 }
5237 static __inline__ vector double __ATTRS_o_ai
5238 vec_mergeh(vector bool long long __a, vector double __b) {
5239   return vec_perm((vector double)__a, __b,
5240                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
5241                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
5242                                          0x14, 0x15, 0x16, 0x17));
5243 }
5244 #endif
5245
5246 /* vec_vmrghb */
5247
5248 #define __builtin_altivec_vmrghb vec_vmrghb
5249
5250 static __inline__ vector signed char __ATTRS_o_ai
5251 vec_vmrghb(vector signed char __a, vector signed char __b) {
5252   return vec_perm(__a, __b,
5253                   (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
5254                                          0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
5255                                          0x06, 0x16, 0x07, 0x17));
5256 }
5257
5258 static __inline__ vector unsigned char __ATTRS_o_ai
5259 vec_vmrghb(vector unsigned char __a, vector unsigned char __b) {
5260   return vec_perm(__a, __b,
5261                   (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
5262                                          0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
5263                                          0x06, 0x16, 0x07, 0x17));
5264 }
5265
5266 static __inline__ vector bool char __ATTRS_o_ai
5267 vec_vmrghb(vector bool char __a, vector bool char __b) {
5268   return vec_perm(__a, __b,
5269                   (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
5270                                          0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
5271                                          0x06, 0x16, 0x07, 0x17));
5272 }
5273
5274 /* vec_vmrghh */
5275
5276 #define __builtin_altivec_vmrghh vec_vmrghh
5277
5278 static __inline__ vector short __ATTRS_o_ai vec_vmrghh(vector short __a,
5279                                                        vector short __b) {
5280   return vec_perm(__a, __b,
5281                   (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
5282                                          0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
5283                                          0x06, 0x07, 0x16, 0x17));
5284 }
5285
5286 static __inline__ vector unsigned short __ATTRS_o_ai
5287 vec_vmrghh(vector unsigned short __a, vector unsigned short __b) {
5288   return vec_perm(__a, __b,
5289                   (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
5290                                          0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
5291                                          0x06, 0x07, 0x16, 0x17));
5292 }
5293
5294 static __inline__ vector bool short __ATTRS_o_ai
5295 vec_vmrghh(vector bool short __a, vector bool short __b) {
5296   return vec_perm(__a, __b,
5297                   (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
5298                                          0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
5299                                          0x06, 0x07, 0x16, 0x17));
5300 }
5301
5302 static __inline__ vector pixel __ATTRS_o_ai vec_vmrghh(vector pixel __a,
5303                                                        vector pixel __b) {
5304   return vec_perm(__a, __b,
5305                   (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
5306                                          0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
5307                                          0x06, 0x07, 0x16, 0x17));
5308 }
5309
5310 /* vec_vmrghw */
5311
5312 #define __builtin_altivec_vmrghw vec_vmrghw
5313
5314 static __inline__ vector int __ATTRS_o_ai vec_vmrghw(vector int __a,
5315                                                      vector int __b) {
5316   return vec_perm(__a, __b,
5317                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5318                                          0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
5319                                          0x14, 0x15, 0x16, 0x17));
5320 }
5321
5322 static __inline__ vector unsigned int __ATTRS_o_ai
5323 vec_vmrghw(vector unsigned int __a, vector unsigned int __b) {
5324   return vec_perm(__a, __b,
5325                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5326                                          0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
5327                                          0x14, 0x15, 0x16, 0x17));
5328 }
5329
5330 static __inline__ vector bool int __ATTRS_o_ai vec_vmrghw(vector bool int __a,
5331                                                           vector bool int __b) {
5332   return vec_perm(__a, __b,
5333                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5334                                          0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
5335                                          0x14, 0x15, 0x16, 0x17));
5336 }
5337
5338 static __inline__ vector float __ATTRS_o_ai vec_vmrghw(vector float __a,
5339                                                        vector float __b) {
5340   return vec_perm(__a, __b,
5341                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5342                                          0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
5343                                          0x14, 0x15, 0x16, 0x17));
5344 }
5345
5346 /* vec_mergel */
5347
5348 static __inline__ vector signed char __ATTRS_o_ai
5349 vec_mergel(vector signed char __a, vector signed char __b) {
5350   return vec_perm(__a, __b,
5351                   (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
5352                                          0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
5353                                          0x0E, 0x1E, 0x0F, 0x1F));
5354 }
5355
5356 static __inline__ vector unsigned char __ATTRS_o_ai
5357 vec_mergel(vector unsigned char __a, vector unsigned char __b) {
5358   return vec_perm(__a, __b,
5359                   (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
5360                                          0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
5361                                          0x0E, 0x1E, 0x0F, 0x1F));
5362 }
5363
5364 static __inline__ vector bool char __ATTRS_o_ai
5365 vec_mergel(vector bool char __a, vector bool char __b) {
5366   return vec_perm(__a, __b,
5367                   (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
5368                                          0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
5369                                          0x0E, 0x1E, 0x0F, 0x1F));
5370 }
5371
5372 static __inline__ vector short __ATTRS_o_ai vec_mergel(vector short __a,
5373                                                        vector short __b) {
5374   return vec_perm(__a, __b,
5375                   (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
5376                                          0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
5377                                          0x0E, 0x0F, 0x1E, 0x1F));
5378 }
5379
5380 static __inline__ vector unsigned short __ATTRS_o_ai
5381 vec_mergel(vector unsigned short __a, vector unsigned short __b) {
5382   return vec_perm(__a, __b,
5383                   (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
5384                                          0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
5385                                          0x0E, 0x0F, 0x1E, 0x1F));
5386 }
5387
5388 static __inline__ vector bool short __ATTRS_o_ai
5389 vec_mergel(vector bool short __a, vector bool short __b) {
5390   return vec_perm(__a, __b,
5391                   (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
5392                                          0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
5393                                          0x0E, 0x0F, 0x1E, 0x1F));
5394 }
5395
5396 static __inline__ vector pixel __ATTRS_o_ai vec_mergel(vector pixel __a,
5397                                                        vector pixel __b) {
5398   return vec_perm(__a, __b,
5399                   (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
5400                                          0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
5401                                          0x0E, 0x0F, 0x1E, 0x1F));
5402 }
5403
5404 static __inline__ vector int __ATTRS_o_ai vec_mergel(vector int __a,
5405                                                      vector int __b) {
5406   return vec_perm(__a, __b,
5407                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
5408                                          0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
5409                                          0x1C, 0x1D, 0x1E, 0x1F));
5410 }
5411
5412 static __inline__ vector unsigned int __ATTRS_o_ai
5413 vec_mergel(vector unsigned int __a, vector unsigned int __b) {
5414   return vec_perm(__a, __b,
5415                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
5416                                          0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
5417                                          0x1C, 0x1D, 0x1E, 0x1F));
5418 }
5419
5420 static __inline__ vector bool int __ATTRS_o_ai vec_mergel(vector bool int __a,
5421                                                           vector bool int __b) {
5422   return vec_perm(__a, __b,
5423                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
5424                                          0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
5425                                          0x1C, 0x1D, 0x1E, 0x1F));
5426 }
5427
5428 static __inline__ vector float __ATTRS_o_ai vec_mergel(vector float __a,
5429                                                        vector float __b) {
5430   return vec_perm(__a, __b,
5431                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
5432                                          0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
5433                                          0x1C, 0x1D, 0x1E, 0x1F));
5434 }
5435
5436 #ifdef __VSX__
5437 static __inline__ vector signed long long __ATTRS_o_ai
5438 vec_mergel(vector signed long long __a, vector signed long long __b) {
5439   return vec_perm(__a, __b,
5440                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
5441                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
5442                                          0x1C, 0x1D, 0x1E, 0x1F));
5443 }
5444 static __inline__ vector signed long long __ATTRS_o_ai
5445 vec_mergel(vector signed long long __a, vector bool long long __b) {
5446   return vec_perm(__a, (vector signed long long)__b,
5447                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
5448                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
5449                                          0x1C, 0x1D, 0x1E, 0x1F));
5450 }
5451 static __inline__ vector signed long long __ATTRS_o_ai
5452 vec_mergel(vector bool long long __a, vector signed long long __b) {
5453   return vec_perm((vector signed long long)__a, __b,
5454                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
5455                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
5456                                          0x1C, 0x1D, 0x1E, 0x1F));
5457 }
5458 static __inline__ vector unsigned long long __ATTRS_o_ai
5459 vec_mergel(vector unsigned long long __a, vector unsigned long long __b) {
5460   return vec_perm(__a, __b,
5461                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
5462                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
5463                                          0x1C, 0x1D, 0x1E, 0x1F));
5464 }
5465 static __inline__ vector unsigned long long __ATTRS_o_ai
5466 vec_mergel(vector unsigned long long __a, vector bool long long __b) {
5467   return vec_perm(__a, (vector unsigned long long)__b,
5468                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
5469                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
5470                                          0x1C, 0x1D, 0x1E, 0x1F));
5471 }
5472 static __inline__ vector unsigned long long __ATTRS_o_ai
5473 vec_mergel(vector bool long long __a, vector unsigned long long __b) {
5474   return vec_perm((vector unsigned long long)__a, __b,
5475                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
5476                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
5477                                          0x1C, 0x1D, 0x1E, 0x1F));
5478 }
5479 static __inline__ vector bool long long __ATTRS_o_ai
5480 vec_mergel(vector bool long long __a, vector bool long long __b) {
5481   return vec_perm(__a, __b,
5482                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
5483                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
5484                                          0x1C, 0x1D, 0x1E, 0x1F));
5485 }
5486 static __inline__ vector double __ATTRS_o_ai vec_mergel(vector double __a,
5487                                                         vector double __b) {
5488   return vec_perm(__a, __b,
5489                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
5490                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
5491                                          0x1C, 0x1D, 0x1E, 0x1F));
5492 }
5493 static __inline__ vector double __ATTRS_o_ai
5494 vec_mergel(vector double __a, vector bool long long __b) {
5495   return vec_perm(__a, (vector double)__b,
5496                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
5497                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
5498                                          0x1C, 0x1D, 0x1E, 0x1F));
5499 }
5500 static __inline__ vector double __ATTRS_o_ai
5501 vec_mergel(vector bool long long __a, vector double __b) {
5502   return vec_perm((vector double)__a, __b,
5503                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
5504                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
5505                                          0x1C, 0x1D, 0x1E, 0x1F));
5506 }
5507 #endif
5508
5509 /* vec_vmrglb */
5510
5511 #define __builtin_altivec_vmrglb vec_vmrglb
5512
5513 static __inline__ vector signed char __ATTRS_o_ai
5514 vec_vmrglb(vector signed char __a, vector signed char __b) {
5515   return vec_perm(__a, __b,
5516                   (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
5517                                          0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
5518                                          0x0E, 0x1E, 0x0F, 0x1F));
5519 }
5520
5521 static __inline__ vector unsigned char __ATTRS_o_ai
5522 vec_vmrglb(vector unsigned char __a, vector unsigned char __b) {
5523   return vec_perm(__a, __b,
5524                   (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
5525                                          0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
5526                                          0x0E, 0x1E, 0x0F, 0x1F));
5527 }
5528
5529 static __inline__ vector bool char __ATTRS_o_ai
5530 vec_vmrglb(vector bool char __a, vector bool char __b) {
5531   return vec_perm(__a, __b,
5532                   (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
5533                                          0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
5534                                          0x0E, 0x1E, 0x0F, 0x1F));
5535 }
5536
5537 /* vec_vmrglh */
5538
5539 #define __builtin_altivec_vmrglh vec_vmrglh
5540
5541 static __inline__ vector short __ATTRS_o_ai vec_vmrglh(vector short __a,
5542                                                        vector short __b) {
5543   return vec_perm(__a, __b,
5544                   (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
5545                                          0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
5546                                          0x0E, 0x0F, 0x1E, 0x1F));
5547 }
5548
5549 static __inline__ vector unsigned short __ATTRS_o_ai
5550 vec_vmrglh(vector unsigned short __a, vector unsigned short __b) {
5551   return vec_perm(__a, __b,
5552                   (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
5553                                          0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
5554                                          0x0E, 0x0F, 0x1E, 0x1F));
5555 }
5556
5557 static __inline__ vector bool short __ATTRS_o_ai
5558 vec_vmrglh(vector bool short __a, vector bool short __b) {
5559   return vec_perm(__a, __b,
5560                   (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
5561                                          0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
5562                                          0x0E, 0x0F, 0x1E, 0x1F));
5563 }
5564
5565 static __inline__ vector pixel __ATTRS_o_ai vec_vmrglh(vector pixel __a,
5566                                                        vector pixel __b) {
5567   return vec_perm(__a, __b,
5568                   (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
5569                                          0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
5570                                          0x0E, 0x0F, 0x1E, 0x1F));
5571 }
5572
5573 /* vec_vmrglw */
5574
5575 #define __builtin_altivec_vmrglw vec_vmrglw
5576
5577 static __inline__ vector int __ATTRS_o_ai vec_vmrglw(vector int __a,
5578                                                      vector int __b) {
5579   return vec_perm(__a, __b,
5580                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
5581                                          0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
5582                                          0x1C, 0x1D, 0x1E, 0x1F));
5583 }
5584
5585 static __inline__ vector unsigned int __ATTRS_o_ai
5586 vec_vmrglw(vector unsigned int __a, vector unsigned int __b) {
5587   return vec_perm(__a, __b,
5588                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
5589                                          0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
5590                                          0x1C, 0x1D, 0x1E, 0x1F));
5591 }
5592
5593 static __inline__ vector bool int __ATTRS_o_ai vec_vmrglw(vector bool int __a,
5594                                                           vector bool int __b) {
5595   return vec_perm(__a, __b,
5596                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
5597                                          0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
5598                                          0x1C, 0x1D, 0x1E, 0x1F));
5599 }
5600
5601 static __inline__ vector float __ATTRS_o_ai vec_vmrglw(vector float __a,
5602                                                        vector float __b) {
5603   return vec_perm(__a, __b,
5604                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
5605                                          0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
5606                                          0x1C, 0x1D, 0x1E, 0x1F));
5607 }
5608
5609 #ifdef __POWER8_VECTOR__
5610 /* vec_mergee */
5611
5612 static __inline__ vector bool int __ATTRS_o_ai vec_mergee(vector bool int __a,
5613                                                           vector bool int __b) {
5614   return vec_perm(__a, __b,
5615                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5616                                          0x12, 0x13, 0x08, 0x09, 0x0A, 0x0B,
5617                                          0x18, 0x19, 0x1A, 0x1B));
5618 }
5619
5620 static __inline__ vector signed int __ATTRS_o_ai
5621 vec_mergee(vector signed int __a, vector signed int __b) {
5622   return vec_perm(__a, __b,
5623                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5624                                          0x12, 0x13, 0x08, 0x09, 0x0A, 0x0B,
5625                                          0x18, 0x19, 0x1A, 0x1B));
5626 }
5627
5628 static __inline__ vector unsigned int __ATTRS_o_ai
5629 vec_mergee(vector unsigned int __a, vector unsigned int __b) {
5630   return vec_perm(__a, __b,
5631                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5632                                          0x12, 0x13, 0x08, 0x09, 0x0A, 0x0B,
5633                                          0x18, 0x19, 0x1A, 0x1B));
5634 }
5635
5636 static __inline__ vector bool long long __ATTRS_o_ai
5637 vec_mergee(vector bool long long __a, vector bool long long __b) {
5638   return vec_mergeh(__a, __b);
5639 }
5640
5641 static __inline__ vector signed long long __ATTRS_o_ai
5642 vec_mergee(vector signed long long __a, vector signed long long __b) {
5643   return vec_mergeh(__a, __b);
5644 }
5645
5646 static __inline__ vector unsigned long long __ATTRS_o_ai
5647 vec_mergee(vector unsigned long long __a, vector unsigned long long __b) {
5648   return vec_mergeh(__a, __b);
5649 }
5650
5651 static __inline__ vector float __ATTRS_o_ai
5652 vec_mergee(vector float __a, vector float __b) {
5653   return vec_perm(__a, __b,
5654                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5655                                          0x12, 0x13, 0x08, 0x09, 0x0A, 0x0B,
5656                                          0x18, 0x19, 0x1A, 0x1B));
5657 }
5658
5659 static __inline__ vector double __ATTRS_o_ai
5660 vec_mergee(vector double __a, vector double __b) {
5661   return vec_mergeh(__a, __b);
5662 }
5663
5664 /* vec_mergeo */
5665
5666 static __inline__ vector bool int __ATTRS_o_ai vec_mergeo(vector bool int __a,
5667                                                           vector bool int __b) {
5668   return vec_perm(__a, __b,
5669                   (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x14, 0x15,
5670                                          0x16, 0x17, 0x0C, 0x0D, 0x0E, 0x0F,
5671                                          0x1C, 0x1D, 0x1E, 0x1F));
5672 }
5673
5674 static __inline__ vector signed int __ATTRS_o_ai
5675 vec_mergeo(vector signed int __a, vector signed int __b) {
5676   return vec_perm(__a, __b,
5677                   (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x14, 0x15,
5678                                          0x16, 0x17, 0x0C, 0x0D, 0x0E, 0x0F,
5679                                          0x1C, 0x1D, 0x1E, 0x1F));
5680 }
5681
5682 static __inline__ vector unsigned int __ATTRS_o_ai
5683 vec_mergeo(vector unsigned int __a, vector unsigned int __b) {
5684   return vec_perm(__a, __b,
5685                   (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x14, 0x15,
5686                                          0x16, 0x17, 0x0C, 0x0D, 0x0E, 0x0F,
5687                                          0x1C, 0x1D, 0x1E, 0x1F));
5688 }
5689
5690 static __inline__ vector bool long long __ATTRS_o_ai
5691 vec_mergeo(vector bool long long __a, vector bool long long __b) {
5692   return vec_mergel(__a, __b);
5693 }
5694
5695 static __inline__ vector signed long long __ATTRS_o_ai
5696 vec_mergeo(vector signed long long __a, vector signed long long __b) {
5697   return vec_mergel(__a, __b);
5698 }
5699
5700 static __inline__ vector unsigned long long __ATTRS_o_ai
5701 vec_mergeo(vector unsigned long long __a, vector unsigned long long __b) {
5702   return vec_mergel(__a, __b);
5703 }
5704
5705 static __inline__ vector float __ATTRS_o_ai
5706 vec_mergeo(vector float __a, vector float __b) {
5707   return vec_perm(__a, __b,
5708                   (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x14, 0x15,
5709                                          0x16, 0x17, 0x0C, 0x0D, 0x0E, 0x0F,
5710                                          0x1C, 0x1D, 0x1E, 0x1F));
5711 }
5712
5713 static __inline__ vector double __ATTRS_o_ai
5714 vec_mergeo(vector double __a, vector double __b) {
5715   return vec_mergel(__a, __b);
5716 }
5717
5718 #endif
5719
5720 /* vec_mfvscr */
5721
5722 static __inline__ vector unsigned short __attribute__((__always_inline__))
5723 vec_mfvscr(void) {
5724   return __builtin_altivec_mfvscr();
5725 }
5726
5727 /* vec_min */
5728
5729 static __inline__ vector signed char __ATTRS_o_ai
5730 vec_min(vector signed char __a, vector signed char __b) {
5731   return __builtin_altivec_vminsb(__a, __b);
5732 }
5733
5734 static __inline__ vector signed char __ATTRS_o_ai
5735 vec_min(vector bool char __a, vector signed char __b) {
5736   return __builtin_altivec_vminsb((vector signed char)__a, __b);
5737 }
5738
5739 static __inline__ vector signed char __ATTRS_o_ai
5740 vec_min(vector signed char __a, vector bool char __b) {
5741   return __builtin_altivec_vminsb(__a, (vector signed char)__b);
5742 }
5743
5744 static __inline__ vector unsigned char __ATTRS_o_ai
5745 vec_min(vector unsigned char __a, vector unsigned char __b) {
5746   return __builtin_altivec_vminub(__a, __b);
5747 }
5748
5749 static __inline__ vector unsigned char __ATTRS_o_ai
5750 vec_min(vector bool char __a, vector unsigned char __b) {
5751   return __builtin_altivec_vminub((vector unsigned char)__a, __b);
5752 }
5753
5754 static __inline__ vector unsigned char __ATTRS_o_ai
5755 vec_min(vector unsigned char __a, vector bool char __b) {
5756   return __builtin_altivec_vminub(__a, (vector unsigned char)__b);
5757 }
5758
5759 static __inline__ vector short __ATTRS_o_ai vec_min(vector short __a,
5760                                                     vector short __b) {
5761   return __builtin_altivec_vminsh(__a, __b);
5762 }
5763
5764 static __inline__ vector short __ATTRS_o_ai vec_min(vector bool short __a,
5765                                                     vector short __b) {
5766   return __builtin_altivec_vminsh((vector short)__a, __b);
5767 }
5768
5769 static __inline__ vector short __ATTRS_o_ai vec_min(vector short __a,
5770                                                     vector bool short __b) {
5771   return __builtin_altivec_vminsh(__a, (vector short)__b);
5772 }
5773
5774 static __inline__ vector unsigned short __ATTRS_o_ai
5775 vec_min(vector unsigned short __a, vector unsigned short __b) {
5776   return __builtin_altivec_vminuh(__a, __b);
5777 }
5778
5779 static __inline__ vector unsigned short __ATTRS_o_ai
5780 vec_min(vector bool short __a, vector unsigned short __b) {
5781   return __builtin_altivec_vminuh((vector unsigned short)__a, __b);
5782 }
5783
5784 static __inline__ vector unsigned short __ATTRS_o_ai
5785 vec_min(vector unsigned short __a, vector bool short __b) {
5786   return __builtin_altivec_vminuh(__a, (vector unsigned short)__b);
5787 }
5788
5789 static __inline__ vector int __ATTRS_o_ai vec_min(vector int __a,
5790                                                   vector int __b) {
5791   return __builtin_altivec_vminsw(__a, __b);
5792 }
5793
5794 static __inline__ vector int __ATTRS_o_ai vec_min(vector bool int __a,
5795                                                   vector int __b) {
5796   return __builtin_altivec_vminsw((vector int)__a, __b);
5797 }
5798
5799 static __inline__ vector int __ATTRS_o_ai vec_min(vector int __a,
5800                                                   vector bool int __b) {
5801   return __builtin_altivec_vminsw(__a, (vector int)__b);
5802 }
5803
5804 static __inline__ vector unsigned int __ATTRS_o_ai
5805 vec_min(vector unsigned int __a, vector unsigned int __b) {
5806   return __builtin_altivec_vminuw(__a, __b);
5807 }
5808
5809 static __inline__ vector unsigned int __ATTRS_o_ai
5810 vec_min(vector bool int __a, vector unsigned int __b) {
5811   return __builtin_altivec_vminuw((vector unsigned int)__a, __b);
5812 }
5813
5814 static __inline__ vector unsigned int __ATTRS_o_ai
5815 vec_min(vector unsigned int __a, vector bool int __b) {
5816   return __builtin_altivec_vminuw(__a, (vector unsigned int)__b);
5817 }
5818
5819 #ifdef __POWER8_VECTOR__
5820 static __inline__ vector signed long long __ATTRS_o_ai
5821 vec_min(vector signed long long __a, vector signed long long __b) {
5822   return __builtin_altivec_vminsd(__a, __b);
5823 }
5824
5825 static __inline__ vector signed long long __ATTRS_o_ai
5826 vec_min(vector bool long long __a, vector signed long long __b) {
5827   return __builtin_altivec_vminsd((vector signed long long)__a, __b);
5828 }
5829
5830 static __inline__ vector signed long long __ATTRS_o_ai
5831 vec_min(vector signed long long __a, vector bool long long __b) {
5832   return __builtin_altivec_vminsd(__a, (vector signed long long)__b);
5833 }
5834
5835 static __inline__ vector unsigned long long __ATTRS_o_ai
5836 vec_min(vector unsigned long long __a, vector unsigned long long __b) {
5837   return __builtin_altivec_vminud(__a, __b);
5838 }
5839
5840 static __inline__ vector unsigned long long __ATTRS_o_ai
5841 vec_min(vector bool long long __a, vector unsigned long long __b) {
5842   return __builtin_altivec_vminud((vector unsigned long long)__a, __b);
5843 }
5844
5845 static __inline__ vector unsigned long long __ATTRS_o_ai
5846 vec_min(vector unsigned long long __a, vector bool long long __b) {
5847   return __builtin_altivec_vminud(__a, (vector unsigned long long)__b);
5848 }
5849 #endif
5850
5851 static __inline__ vector float __ATTRS_o_ai vec_min(vector float __a,
5852                                                     vector float __b) {
5853 #ifdef __VSX__
5854   return __builtin_vsx_xvminsp(__a, __b);
5855 #else
5856   return __builtin_altivec_vminfp(__a, __b);
5857 #endif
5858 }
5859
5860 #ifdef __VSX__
5861 static __inline__ vector double __ATTRS_o_ai vec_min(vector double __a,
5862                                                      vector double __b) {
5863   return __builtin_vsx_xvmindp(__a, __b);
5864 }
5865 #endif
5866
5867 /* vec_vminsb */
5868
5869 static __inline__ vector signed char __ATTRS_o_ai
5870 vec_vminsb(vector signed char __a, vector signed char __b) {
5871   return __builtin_altivec_vminsb(__a, __b);
5872 }
5873
5874 static __inline__ vector signed char __ATTRS_o_ai
5875 vec_vminsb(vector bool char __a, vector signed char __b) {
5876   return __builtin_altivec_vminsb((vector signed char)__a, __b);
5877 }
5878
5879 static __inline__ vector signed char __ATTRS_o_ai
5880 vec_vminsb(vector signed char __a, vector bool char __b) {
5881   return __builtin_altivec_vminsb(__a, (vector signed char)__b);
5882 }
5883
5884 /* vec_vminub */
5885
5886 static __inline__ vector unsigned char __ATTRS_o_ai
5887 vec_vminub(vector unsigned char __a, vector unsigned char __b) {
5888   return __builtin_altivec_vminub(__a, __b);
5889 }
5890
5891 static __inline__ vector unsigned char __ATTRS_o_ai
5892 vec_vminub(vector bool char __a, vector unsigned char __b) {
5893   return __builtin_altivec_vminub((vector unsigned char)__a, __b);
5894 }
5895
5896 static __inline__ vector unsigned char __ATTRS_o_ai
5897 vec_vminub(vector unsigned char __a, vector bool char __b) {
5898   return __builtin_altivec_vminub(__a, (vector unsigned char)__b);
5899 }
5900
5901 /* vec_vminsh */
5902
5903 static __inline__ vector short __ATTRS_o_ai vec_vminsh(vector short __a,
5904                                                        vector short __b) {
5905   return __builtin_altivec_vminsh(__a, __b);
5906 }
5907
5908 static __inline__ vector short __ATTRS_o_ai vec_vminsh(vector bool short __a,
5909                                                        vector short __b) {
5910   return __builtin_altivec_vminsh((vector short)__a, __b);
5911 }
5912
5913 static __inline__ vector short __ATTRS_o_ai vec_vminsh(vector short __a,
5914                                                        vector bool short __b) {
5915   return __builtin_altivec_vminsh(__a, (vector short)__b);
5916 }
5917
5918 /* vec_vminuh */
5919
5920 static __inline__ vector unsigned short __ATTRS_o_ai
5921 vec_vminuh(vector unsigned short __a, vector unsigned short __b) {
5922   return __builtin_altivec_vminuh(__a, __b);
5923 }
5924
5925 static __inline__ vector unsigned short __ATTRS_o_ai
5926 vec_vminuh(vector bool short __a, vector unsigned short __b) {
5927   return __builtin_altivec_vminuh((vector unsigned short)__a, __b);
5928 }
5929
5930 static __inline__ vector unsigned short __ATTRS_o_ai
5931 vec_vminuh(vector unsigned short __a, vector bool short __b) {
5932   return __builtin_altivec_vminuh(__a, (vector unsigned short)__b);
5933 }
5934
5935 /* vec_vminsw */
5936
5937 static __inline__ vector int __ATTRS_o_ai vec_vminsw(vector int __a,
5938                                                      vector int __b) {
5939   return __builtin_altivec_vminsw(__a, __b);
5940 }
5941
5942 static __inline__ vector int __ATTRS_o_ai vec_vminsw(vector bool int __a,
5943                                                      vector int __b) {
5944   return __builtin_altivec_vminsw((vector int)__a, __b);
5945 }
5946
5947 static __inline__ vector int __ATTRS_o_ai vec_vminsw(vector int __a,
5948                                                      vector bool int __b) {
5949   return __builtin_altivec_vminsw(__a, (vector int)__b);
5950 }
5951
5952 /* vec_vminuw */
5953
5954 static __inline__ vector unsigned int __ATTRS_o_ai
5955 vec_vminuw(vector unsigned int __a, vector unsigned int __b) {
5956   return __builtin_altivec_vminuw(__a, __b);
5957 }
5958
5959 static __inline__ vector unsigned int __ATTRS_o_ai
5960 vec_vminuw(vector bool int __a, vector unsigned int __b) {
5961   return __builtin_altivec_vminuw((vector unsigned int)__a, __b);
5962 }
5963
5964 static __inline__ vector unsigned int __ATTRS_o_ai
5965 vec_vminuw(vector unsigned int __a, vector bool int __b) {
5966   return __builtin_altivec_vminuw(__a, (vector unsigned int)__b);
5967 }
5968
5969 /* vec_vminfp */
5970
5971 static __inline__ vector float __attribute__((__always_inline__))
5972 vec_vminfp(vector float __a, vector float __b) {
5973 #ifdef __VSX__
5974   return __builtin_vsx_xvminsp(__a, __b);
5975 #else
5976   return __builtin_altivec_vminfp(__a, __b);
5977 #endif
5978 }
5979
5980 /* vec_mladd */
5981
5982 #define __builtin_altivec_vmladduhm vec_mladd
5983
5984 static __inline__ vector short __ATTRS_o_ai vec_mladd(vector short __a,
5985                                                       vector short __b,
5986                                                       vector short __c) {
5987   return __a * __b + __c;
5988 }
5989
5990 static __inline__ vector short __ATTRS_o_ai vec_mladd(
5991     vector short __a, vector unsigned short __b, vector unsigned short __c) {
5992   return __a * (vector short)__b + (vector short)__c;
5993 }
5994
5995 static __inline__ vector short __ATTRS_o_ai vec_mladd(vector unsigned short __a,
5996                                                       vector short __b,
5997                                                       vector short __c) {
5998   return (vector short)__a * __b + __c;
5999 }
6000
6001 static __inline__ vector unsigned short __ATTRS_o_ai
6002 vec_mladd(vector unsigned short __a, vector unsigned short __b,
6003           vector unsigned short __c) {
6004   return __a * __b + __c;
6005 }
6006
6007 /* vec_vmladduhm */
6008
6009 static __inline__ vector short __ATTRS_o_ai vec_vmladduhm(vector short __a,
6010                                                           vector short __b,
6011                                                           vector short __c) {
6012   return __a * __b + __c;
6013 }
6014
6015 static __inline__ vector short __ATTRS_o_ai vec_vmladduhm(
6016     vector short __a, vector unsigned short __b, vector unsigned short __c) {
6017   return __a * (vector short)__b + (vector short)__c;
6018 }
6019
6020 static __inline__ vector short __ATTRS_o_ai
6021 vec_vmladduhm(vector unsigned short __a, vector short __b, vector short __c) {
6022   return (vector short)__a * __b + __c;
6023 }
6024
6025 static __inline__ vector unsigned short __ATTRS_o_ai
6026 vec_vmladduhm(vector unsigned short __a, vector unsigned short __b,
6027               vector unsigned short __c) {
6028   return __a * __b + __c;
6029 }
6030
6031 /* vec_mradds */
6032
6033 static __inline__ vector short __attribute__((__always_inline__))
6034 vec_mradds(vector short __a, vector short __b, vector short __c) {
6035   return __builtin_altivec_vmhraddshs(__a, __b, __c);
6036 }
6037
6038 /* vec_vmhraddshs */
6039
6040 static __inline__ vector short __attribute__((__always_inline__))
6041 vec_vmhraddshs(vector short __a, vector short __b, vector short __c) {
6042   return __builtin_altivec_vmhraddshs(__a, __b, __c);
6043 }
6044
6045 /* vec_msum */
6046
6047 static __inline__ vector int __ATTRS_o_ai vec_msum(vector signed char __a,
6048                                                    vector unsigned char __b,
6049                                                    vector int __c) {
6050   return __builtin_altivec_vmsummbm(__a, __b, __c);
6051 }
6052
6053 static __inline__ vector unsigned int __ATTRS_o_ai
6054 vec_msum(vector unsigned char __a, vector unsigned char __b,
6055          vector unsigned int __c) {
6056   return __builtin_altivec_vmsumubm(__a, __b, __c);
6057 }
6058
6059 static __inline__ vector int __ATTRS_o_ai vec_msum(vector short __a,
6060                                                    vector short __b,
6061                                                    vector int __c) {
6062   return __builtin_altivec_vmsumshm(__a, __b, __c);
6063 }
6064
6065 static __inline__ vector unsigned int __ATTRS_o_ai
6066 vec_msum(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_msumc */
6072
6073 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
6074 static __inline__ vector unsigned __int128 __ATTRS_o_ai
6075 vec_msumc(vector unsigned long long __a, vector unsigned long long __b,
6076           vector unsigned __int128 __c) {
6077   return __builtin_altivec_vmsumcud(__a, __b, __c);
6078 }
6079 #endif
6080
6081 /* vec_vmsummbm */
6082
6083 static __inline__ vector int __attribute__((__always_inline__))
6084 vec_vmsummbm(vector signed char __a, vector unsigned char __b, vector int __c) {
6085   return __builtin_altivec_vmsummbm(__a, __b, __c);
6086 }
6087
6088 /* vec_vmsumubm */
6089
6090 static __inline__ vector unsigned int __attribute__((__always_inline__))
6091 vec_vmsumubm(vector unsigned char __a, vector unsigned char __b,
6092              vector unsigned int __c) {
6093   return __builtin_altivec_vmsumubm(__a, __b, __c);
6094 }
6095
6096 /* vec_vmsumshm */
6097
6098 static __inline__ vector int __attribute__((__always_inline__))
6099 vec_vmsumshm(vector short __a, vector short __b, vector int __c) {
6100   return __builtin_altivec_vmsumshm(__a, __b, __c);
6101 }
6102
6103 /* vec_vmsumuhm */
6104
6105 static __inline__ vector unsigned int __attribute__((__always_inline__))
6106 vec_vmsumuhm(vector unsigned short __a, vector unsigned short __b,
6107              vector unsigned int __c) {
6108   return __builtin_altivec_vmsumuhm(__a, __b, __c);
6109 }
6110
6111 /* vec_msums */
6112
6113 static __inline__ vector int __ATTRS_o_ai vec_msums(vector short __a,
6114                                                     vector short __b,
6115                                                     vector int __c) {
6116   return __builtin_altivec_vmsumshs(__a, __b, __c);
6117 }
6118
6119 static __inline__ vector unsigned int __ATTRS_o_ai
6120 vec_msums(vector unsigned short __a, vector unsigned short __b,
6121           vector unsigned int __c) {
6122   return __builtin_altivec_vmsumuhs(__a, __b, __c);
6123 }
6124
6125 /* vec_vmsumshs */
6126
6127 static __inline__ vector int __attribute__((__always_inline__))
6128 vec_vmsumshs(vector short __a, vector short __b, vector int __c) {
6129   return __builtin_altivec_vmsumshs(__a, __b, __c);
6130 }
6131
6132 /* vec_vmsumuhs */
6133
6134 static __inline__ vector unsigned int __attribute__((__always_inline__))
6135 vec_vmsumuhs(vector unsigned short __a, vector unsigned short __b,
6136              vector unsigned int __c) {
6137   return __builtin_altivec_vmsumuhs(__a, __b, __c);
6138 }
6139
6140 /* vec_mtvscr */
6141
6142 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector signed char __a) {
6143   __builtin_altivec_mtvscr((vector int)__a);
6144 }
6145
6146 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector unsigned char __a) {
6147   __builtin_altivec_mtvscr((vector int)__a);
6148 }
6149
6150 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector bool char __a) {
6151   __builtin_altivec_mtvscr((vector int)__a);
6152 }
6153
6154 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector short __a) {
6155   __builtin_altivec_mtvscr((vector int)__a);
6156 }
6157
6158 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector unsigned short __a) {
6159   __builtin_altivec_mtvscr((vector int)__a);
6160 }
6161
6162 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector bool short __a) {
6163   __builtin_altivec_mtvscr((vector int)__a);
6164 }
6165
6166 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector pixel __a) {
6167   __builtin_altivec_mtvscr((vector int)__a);
6168 }
6169
6170 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector int __a) {
6171   __builtin_altivec_mtvscr((vector int)__a);
6172 }
6173
6174 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector unsigned int __a) {
6175   __builtin_altivec_mtvscr((vector int)__a);
6176 }
6177
6178 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector bool int __a) {
6179   __builtin_altivec_mtvscr((vector int)__a);
6180 }
6181
6182 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector float __a) {
6183   __builtin_altivec_mtvscr((vector int)__a);
6184 }
6185
6186 /* vec_mul */
6187
6188 /* Integer vector multiplication will involve multiplication of the odd/even
6189    elements separately, then truncating the results and moving to the
6190    result vector.
6191 */
6192 static __inline__ vector signed char __ATTRS_o_ai
6193 vec_mul(vector signed char __a, vector signed char __b) {
6194   return __a * __b;
6195 }
6196
6197 static __inline__ vector unsigned char __ATTRS_o_ai
6198 vec_mul(vector unsigned char __a, vector unsigned char __b) {
6199   return __a * __b;
6200 }
6201
6202 static __inline__ vector signed short __ATTRS_o_ai
6203 vec_mul(vector signed short __a, vector signed short __b) {
6204   return __a * __b;
6205 }
6206
6207 static __inline__ vector unsigned short __ATTRS_o_ai
6208 vec_mul(vector unsigned short __a, vector unsigned short __b) {
6209   return __a * __b;
6210 }
6211
6212 static __inline__ vector signed int __ATTRS_o_ai
6213 vec_mul(vector signed int __a, vector signed int __b) {
6214   return __a * __b;
6215 }
6216
6217 static __inline__ vector unsigned int __ATTRS_o_ai
6218 vec_mul(vector unsigned int __a, vector unsigned int __b) {
6219   return __a * __b;
6220 }
6221
6222 #ifdef __VSX__
6223 static __inline__ vector signed long long __ATTRS_o_ai
6224 vec_mul(vector signed long long __a, vector signed long long __b) {
6225   return __a * __b;
6226 }
6227
6228 static __inline__ vector unsigned long long __ATTRS_o_ai
6229 vec_mul(vector unsigned long long __a, vector unsigned long long __b) {
6230   return __a * __b;
6231 }
6232 #endif
6233
6234 static __inline__ vector float __ATTRS_o_ai vec_mul(vector float __a,
6235                                                     vector float __b) {
6236   return __a * __b;
6237 }
6238
6239 #ifdef __VSX__
6240 static __inline__ vector double __ATTRS_o_ai vec_mul(vector double __a,
6241                                                      vector double __b) {
6242   return __a * __b;
6243 }
6244 #endif
6245
6246 /* The vmulos* and vmules* instructions have a big endian bias, so
6247    we must reverse the meaning of "even" and "odd" for little endian.  */
6248
6249 /* vec_mule */
6250
6251 static __inline__ vector short __ATTRS_o_ai vec_mule(vector signed char __a,
6252                                                      vector signed char __b) {
6253 #ifdef __LITTLE_ENDIAN__
6254   return __builtin_altivec_vmulosb(__a, __b);
6255 #else
6256   return __builtin_altivec_vmulesb(__a, __b);
6257 #endif
6258 }
6259
6260 static __inline__ vector unsigned short __ATTRS_o_ai
6261 vec_mule(vector unsigned char __a, vector unsigned char __b) {
6262 #ifdef __LITTLE_ENDIAN__
6263   return __builtin_altivec_vmuloub(__a, __b);
6264 #else
6265   return __builtin_altivec_vmuleub(__a, __b);
6266 #endif
6267 }
6268
6269 static __inline__ vector int __ATTRS_o_ai vec_mule(vector short __a,
6270                                                    vector short __b) {
6271 #ifdef __LITTLE_ENDIAN__
6272   return __builtin_altivec_vmulosh(__a, __b);
6273 #else
6274   return __builtin_altivec_vmulesh(__a, __b);
6275 #endif
6276 }
6277
6278 static __inline__ vector unsigned int __ATTRS_o_ai
6279 vec_mule(vector unsigned short __a, vector unsigned short __b) {
6280 #ifdef __LITTLE_ENDIAN__
6281   return __builtin_altivec_vmulouh(__a, __b);
6282 #else
6283   return __builtin_altivec_vmuleuh(__a, __b);
6284 #endif
6285 }
6286
6287 #ifdef __POWER8_VECTOR__
6288 static __inline__ vector signed long long __ATTRS_o_ai
6289 vec_mule(vector signed int __a, vector signed int __b) {
6290 #ifdef __LITTLE_ENDIAN__
6291   return __builtin_altivec_vmulosw(__a, __b);
6292 #else
6293   return __builtin_altivec_vmulesw(__a, __b);
6294 #endif
6295 }
6296
6297 static __inline__ vector unsigned long long __ATTRS_o_ai
6298 vec_mule(vector unsigned int __a, vector unsigned int __b) {
6299 #ifdef __LITTLE_ENDIAN__
6300   return __builtin_altivec_vmulouw(__a, __b);
6301 #else
6302   return __builtin_altivec_vmuleuw(__a, __b);
6303 #endif
6304 }
6305 #endif
6306
6307 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
6308 static __inline__ vector signed __int128 __ATTRS_o_ai
6309 vec_mule(vector signed long long __a, vector signed long long __b) {
6310 #ifdef __LITTLE_ENDIAN__
6311   return __builtin_altivec_vmulosd(__a, __b);
6312 #else
6313   return __builtin_altivec_vmulesd(__a, __b);
6314 #endif
6315 }
6316
6317 static __inline__ vector unsigned __int128 __ATTRS_o_ai
6318 vec_mule(vector unsigned long long __a, vector unsigned long long __b) {
6319 #ifdef __LITTLE_ENDIAN__
6320   return __builtin_altivec_vmuloud(__a, __b);
6321 #else
6322   return __builtin_altivec_vmuleud(__a, __b);
6323 #endif
6324 }
6325 #endif
6326
6327 /* vec_vmulesb */
6328
6329 static __inline__ vector short __attribute__((__always_inline__))
6330 vec_vmulesb(vector signed char __a, vector signed char __b) {
6331 #ifdef __LITTLE_ENDIAN__
6332   return __builtin_altivec_vmulosb(__a, __b);
6333 #else
6334   return __builtin_altivec_vmulesb(__a, __b);
6335 #endif
6336 }
6337
6338 /* vec_vmuleub */
6339
6340 static __inline__ vector unsigned short __attribute__((__always_inline__))
6341 vec_vmuleub(vector unsigned char __a, vector unsigned char __b) {
6342 #ifdef __LITTLE_ENDIAN__
6343   return __builtin_altivec_vmuloub(__a, __b);
6344 #else
6345   return __builtin_altivec_vmuleub(__a, __b);
6346 #endif
6347 }
6348
6349 /* vec_vmulesh */
6350
6351 static __inline__ vector int __attribute__((__always_inline__))
6352 vec_vmulesh(vector short __a, vector short __b) {
6353 #ifdef __LITTLE_ENDIAN__
6354   return __builtin_altivec_vmulosh(__a, __b);
6355 #else
6356   return __builtin_altivec_vmulesh(__a, __b);
6357 #endif
6358 }
6359
6360 /* vec_vmuleuh */
6361
6362 static __inline__ vector unsigned int __attribute__((__always_inline__))
6363 vec_vmuleuh(vector unsigned short __a, vector unsigned short __b) {
6364 #ifdef __LITTLE_ENDIAN__
6365   return __builtin_altivec_vmulouh(__a, __b);
6366 #else
6367   return __builtin_altivec_vmuleuh(__a, __b);
6368 #endif
6369 }
6370
6371 /* vec_mulh */
6372
6373 #ifdef __POWER10_VECTOR__
6374 static __inline__ vector signed int __ATTRS_o_ai
6375 vec_mulh(vector signed int __a, vector signed int __b) {
6376   return __builtin_altivec_vmulhsw(__a, __b);
6377 }
6378
6379 static __inline__ vector unsigned int __ATTRS_o_ai
6380 vec_mulh(vector unsigned int __a, vector unsigned int __b) {
6381   return __builtin_altivec_vmulhuw(__a, __b);
6382 }
6383
6384 static __inline__ vector signed long long __ATTRS_o_ai
6385 vec_mulh(vector signed long long __a, vector signed long long __b) {
6386   return __builtin_altivec_vmulhsd(__a, __b);
6387 }
6388
6389 static __inline__ vector unsigned long long __ATTRS_o_ai
6390 vec_mulh(vector unsigned long long __a, vector unsigned long long __b) {
6391   return __builtin_altivec_vmulhud(__a, __b);
6392 }
6393 #endif
6394
6395 /* vec_mulo */
6396
6397 static __inline__ vector short __ATTRS_o_ai vec_mulo(vector signed char __a,
6398                                                      vector signed char __b) {
6399 #ifdef __LITTLE_ENDIAN__
6400   return __builtin_altivec_vmulesb(__a, __b);
6401 #else
6402   return __builtin_altivec_vmulosb(__a, __b);
6403 #endif
6404 }
6405
6406 static __inline__ vector unsigned short __ATTRS_o_ai
6407 vec_mulo(vector unsigned char __a, vector unsigned char __b) {
6408 #ifdef __LITTLE_ENDIAN__
6409   return __builtin_altivec_vmuleub(__a, __b);
6410 #else
6411   return __builtin_altivec_vmuloub(__a, __b);
6412 #endif
6413 }
6414
6415 static __inline__ vector int __ATTRS_o_ai vec_mulo(vector short __a,
6416                                                    vector short __b) {
6417 #ifdef __LITTLE_ENDIAN__
6418   return __builtin_altivec_vmulesh(__a, __b);
6419 #else
6420   return __builtin_altivec_vmulosh(__a, __b);
6421 #endif
6422 }
6423
6424 static __inline__ vector unsigned int __ATTRS_o_ai
6425 vec_mulo(vector unsigned short __a, vector unsigned short __b) {
6426 #ifdef __LITTLE_ENDIAN__
6427   return __builtin_altivec_vmuleuh(__a, __b);
6428 #else
6429   return __builtin_altivec_vmulouh(__a, __b);
6430 #endif
6431 }
6432
6433 #ifdef __POWER8_VECTOR__
6434 static __inline__ vector signed long long __ATTRS_o_ai
6435 vec_mulo(vector signed int __a, vector signed int __b) {
6436 #ifdef __LITTLE_ENDIAN__
6437   return __builtin_altivec_vmulesw(__a, __b);
6438 #else
6439   return __builtin_altivec_vmulosw(__a, __b);
6440 #endif
6441 }
6442
6443 static __inline__ vector unsigned long long __ATTRS_o_ai
6444 vec_mulo(vector unsigned int __a, vector unsigned int __b) {
6445 #ifdef __LITTLE_ENDIAN__
6446   return __builtin_altivec_vmuleuw(__a, __b);
6447 #else
6448   return __builtin_altivec_vmulouw(__a, __b);
6449 #endif
6450 }
6451 #endif
6452
6453 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
6454 static __inline__ vector signed __int128 __ATTRS_o_ai
6455 vec_mulo(vector signed long long __a, vector signed long long __b) {
6456 #ifdef __LITTLE_ENDIAN__
6457   return __builtin_altivec_vmulesd(__a, __b);
6458 #else
6459   return __builtin_altivec_vmulosd(__a, __b);
6460 #endif
6461 }
6462
6463 static __inline__ vector unsigned __int128 __ATTRS_o_ai
6464 vec_mulo(vector unsigned long long __a, vector unsigned long long __b) {
6465 #ifdef __LITTLE_ENDIAN__
6466   return __builtin_altivec_vmuleud(__a, __b);
6467 #else
6468   return __builtin_altivec_vmuloud(__a, __b);
6469 #endif
6470 }
6471 #endif
6472
6473 /* vec_vmulosb */
6474
6475 static __inline__ vector short __attribute__((__always_inline__))
6476 vec_vmulosb(vector signed char __a, vector signed char __b) {
6477 #ifdef __LITTLE_ENDIAN__
6478   return __builtin_altivec_vmulesb(__a, __b);
6479 #else
6480   return __builtin_altivec_vmulosb(__a, __b);
6481 #endif
6482 }
6483
6484 /* vec_vmuloub */
6485
6486 static __inline__ vector unsigned short __attribute__((__always_inline__))
6487 vec_vmuloub(vector unsigned char __a, vector unsigned char __b) {
6488 #ifdef __LITTLE_ENDIAN__
6489   return __builtin_altivec_vmuleub(__a, __b);
6490 #else
6491   return __builtin_altivec_vmuloub(__a, __b);
6492 #endif
6493 }
6494
6495 /* vec_vmulosh */
6496
6497 static __inline__ vector int __attribute__((__always_inline__))
6498 vec_vmulosh(vector short __a, vector short __b) {
6499 #ifdef __LITTLE_ENDIAN__
6500   return __builtin_altivec_vmulesh(__a, __b);
6501 #else
6502   return __builtin_altivec_vmulosh(__a, __b);
6503 #endif
6504 }
6505
6506 /* vec_vmulouh */
6507
6508 static __inline__ vector unsigned int __attribute__((__always_inline__))
6509 vec_vmulouh(vector unsigned short __a, vector unsigned short __b) {
6510 #ifdef __LITTLE_ENDIAN__
6511   return __builtin_altivec_vmuleuh(__a, __b);
6512 #else
6513   return __builtin_altivec_vmulouh(__a, __b);
6514 #endif
6515 }
6516
6517 /*  vec_nand */
6518
6519 #ifdef __POWER8_VECTOR__
6520 static __inline__ vector signed char __ATTRS_o_ai
6521 vec_nand(vector signed char __a, vector signed char __b) {
6522   return ~(__a & __b);
6523 }
6524
6525 static __inline__ vector signed char __ATTRS_o_ai
6526 vec_nand(vector signed char __a, vector bool char __b) {
6527   return ~(__a & (vector signed char)__b);
6528 }
6529
6530 static __inline__ vector signed char __ATTRS_o_ai
6531 vec_nand(vector bool char __a, vector signed char __b) {
6532   return (vector signed char)~(__a & (vector bool char)__b);
6533 }
6534
6535 static __inline__ vector unsigned char __ATTRS_o_ai
6536 vec_nand(vector unsigned char __a, vector unsigned char __b) {
6537   return ~(__a & __b);
6538 }
6539
6540 static __inline__ vector unsigned char __ATTRS_o_ai
6541 vec_nand(vector unsigned char __a, vector bool char __b) {
6542   return ~(__a & (vector unsigned char)__b);
6543 }
6544
6545 static __inline__ vector unsigned char __ATTRS_o_ai
6546 vec_nand(vector bool char __a, vector unsigned char __b) {
6547   return (vector unsigned char)~(__a & (vector bool char)__b);
6548 }
6549
6550 static __inline__ vector bool char __ATTRS_o_ai vec_nand(vector bool char __a,
6551                                                          vector bool char __b) {
6552   return ~(__a & __b);
6553 }
6554
6555 static __inline__ vector signed short __ATTRS_o_ai
6556 vec_nand(vector signed short __a, vector signed short __b) {
6557   return ~(__a & __b);
6558 }
6559
6560 static __inline__ vector signed short __ATTRS_o_ai
6561 vec_nand(vector signed short __a, vector bool short __b) {
6562   return ~(__a & (vector signed short)__b);
6563 }
6564
6565 static __inline__ vector signed short __ATTRS_o_ai
6566 vec_nand(vector bool short __a, vector signed short __b) {
6567   return (vector signed short)~(__a & (vector bool short)__b);
6568 }
6569
6570 static __inline__ vector unsigned short __ATTRS_o_ai
6571 vec_nand(vector unsigned short __a, vector unsigned short __b) {
6572   return ~(__a & __b);
6573 }
6574
6575 static __inline__ vector unsigned short __ATTRS_o_ai
6576 vec_nand(vector unsigned short __a, vector bool short __b) {
6577   return ~(__a & (vector unsigned short)__b);
6578 }
6579
6580 static __inline__ vector bool short __ATTRS_o_ai
6581 vec_nand(vector bool short __a, vector bool short __b) {
6582   return ~(__a & __b);
6583 }
6584
6585 static __inline__ vector signed int __ATTRS_o_ai
6586 vec_nand(vector signed int __a, vector signed int __b) {
6587   return ~(__a & __b);
6588 }
6589
6590 static __inline__ vector signed int __ATTRS_o_ai vec_nand(vector signed int __a,
6591                                                           vector bool int __b) {
6592   return ~(__a & (vector signed int)__b);
6593 }
6594
6595 static __inline__ vector signed int __ATTRS_o_ai
6596 vec_nand(vector bool int __a, vector signed int __b) {
6597   return (vector signed int)~(__a & (vector bool int)__b);
6598 }
6599
6600 static __inline__ vector unsigned int __ATTRS_o_ai
6601 vec_nand(vector unsigned int __a, vector unsigned int __b) {
6602   return ~(__a & __b);
6603 }
6604
6605 static __inline__ vector unsigned int __ATTRS_o_ai
6606 vec_nand(vector unsigned int __a, vector bool int __b) {
6607   return ~(__a & (vector unsigned int)__b);
6608 }
6609
6610 static __inline__ vector unsigned int __ATTRS_o_ai
6611 vec_nand(vector bool int __a, vector unsigned int __b) {
6612   return (vector unsigned int)~(__a & (vector bool int)__b);
6613 }
6614
6615 static __inline__ vector bool int __ATTRS_o_ai vec_nand(vector bool int __a,
6616                                                         vector bool int __b) {
6617   return ~(__a & __b);
6618 }
6619
6620 static __inline__ vector float __ATTRS_o_ai
6621 vec_nand(vector float __a, vector float __b) {
6622   return (vector float)(~((vector unsigned int)__a &
6623                           (vector unsigned int)__b));
6624 }
6625
6626 static __inline__ vector signed long long __ATTRS_o_ai
6627 vec_nand(vector signed long long __a, vector signed long long __b) {
6628   return ~(__a & __b);
6629 }
6630
6631 static __inline__ vector signed long long __ATTRS_o_ai
6632 vec_nand(vector signed long long __a, vector bool long long __b) {
6633   return ~(__a & (vector signed long long)__b);
6634 }
6635
6636 static __inline__ vector signed long long __ATTRS_o_ai
6637 vec_nand(vector bool long long __a, vector signed long long __b) {
6638   return (vector signed long long)~(__a & (vector bool long long)__b);
6639 }
6640
6641 static __inline__ vector unsigned long long __ATTRS_o_ai
6642 vec_nand(vector unsigned long long __a, vector unsigned long long __b) {
6643   return ~(__a & __b);
6644 }
6645
6646 static __inline__ vector unsigned long long __ATTRS_o_ai
6647 vec_nand(vector unsigned long long __a, vector bool long long __b) {
6648   return ~(__a & (vector unsigned long long)__b);
6649 }
6650
6651 static __inline__ vector unsigned long long __ATTRS_o_ai
6652 vec_nand(vector bool long long __a, vector unsigned long long __b) {
6653   return (vector unsigned long long)~(__a & (vector bool long long)__b);
6654 }
6655
6656 static __inline__ vector bool long long __ATTRS_o_ai
6657 vec_nand(vector bool long long __a, vector bool long long __b) {
6658   return ~(__a & __b);
6659 }
6660
6661 static __inline__ vector double __ATTRS_o_ai
6662 vec_nand(vector double __a, vector double __b) {
6663   return (vector double)(~((vector unsigned long long)__a &
6664                            (vector unsigned long long)__b));
6665 }
6666
6667 #endif
6668
6669 /* vec_nmadd */
6670
6671 #ifdef __VSX__
6672 static __inline__ vector float __ATTRS_o_ai vec_nmadd(vector float __a,
6673                                                       vector float __b,
6674                                                       vector float __c) {
6675   return __builtin_vsx_xvnmaddasp(__a, __b, __c);
6676 }
6677
6678 static __inline__ vector double __ATTRS_o_ai vec_nmadd(vector double __a,
6679                                                        vector double __b,
6680                                                        vector double __c) {
6681   return __builtin_vsx_xvnmaddadp(__a, __b, __c);
6682 }
6683 #endif
6684
6685 /* vec_nmsub */
6686
6687 static __inline__ vector float __ATTRS_o_ai vec_nmsub(vector float __a,
6688                                                       vector float __b,
6689                                                       vector float __c) {
6690 #ifdef __VSX__
6691   return __builtin_vsx_xvnmsubasp(__a, __b, __c);
6692 #else
6693   return __builtin_altivec_vnmsubfp(__a, __b, __c);
6694 #endif
6695 }
6696
6697 #ifdef __VSX__
6698 static __inline__ vector double __ATTRS_o_ai vec_nmsub(vector double __a,
6699                                                        vector double __b,
6700                                                        vector double __c) {
6701   return __builtin_vsx_xvnmsubadp(__a, __b, __c);
6702 }
6703 #endif
6704
6705 /* vec_vnmsubfp */
6706
6707 static __inline__ vector float __attribute__((__always_inline__))
6708 vec_vnmsubfp(vector float __a, vector float __b, vector float __c) {
6709   return __builtin_altivec_vnmsubfp(__a, __b, __c);
6710 }
6711
6712 /* vec_nor */
6713
6714 #define __builtin_altivec_vnor vec_nor
6715
6716 static __inline__ vector signed char __ATTRS_o_ai
6717 vec_nor(vector signed char __a, vector signed char __b) {
6718   return ~(__a | __b);
6719 }
6720
6721 static __inline__ vector unsigned char __ATTRS_o_ai
6722 vec_nor(vector unsigned char __a, vector unsigned char __b) {
6723   return ~(__a | __b);
6724 }
6725
6726 static __inline__ vector bool char __ATTRS_o_ai vec_nor(vector bool char __a,
6727                                                         vector bool char __b) {
6728   return ~(__a | __b);
6729 }
6730
6731 static __inline__ vector short __ATTRS_o_ai vec_nor(vector short __a,
6732                                                     vector short __b) {
6733   return ~(__a | __b);
6734 }
6735
6736 static __inline__ vector unsigned short __ATTRS_o_ai
6737 vec_nor(vector unsigned short __a, vector unsigned short __b) {
6738   return ~(__a | __b);
6739 }
6740
6741 static __inline__ vector bool short __ATTRS_o_ai
6742 vec_nor(vector bool short __a, vector bool short __b) {
6743   return ~(__a | __b);
6744 }
6745
6746 static __inline__ vector int __ATTRS_o_ai vec_nor(vector int __a,
6747                                                   vector int __b) {
6748   return ~(__a | __b);
6749 }
6750
6751 static __inline__ vector unsigned int __ATTRS_o_ai
6752 vec_nor(vector unsigned int __a, vector unsigned int __b) {
6753   return ~(__a | __b);
6754 }
6755
6756 static __inline__ vector bool int __ATTRS_o_ai vec_nor(vector bool int __a,
6757                                                        vector bool int __b) {
6758   return ~(__a | __b);
6759 }
6760
6761 static __inline__ vector float __ATTRS_o_ai vec_nor(vector float __a,
6762                                                     vector float __b) {
6763   vector unsigned int __res =
6764       ~((vector unsigned int)__a | (vector unsigned int)__b);
6765   return (vector float)__res;
6766 }
6767
6768 #ifdef __VSX__
6769 static __inline__ vector double __ATTRS_o_ai vec_nor(vector double __a,
6770                                                      vector double __b) {
6771   vector unsigned long long __res =
6772       ~((vector unsigned long long)__a | (vector unsigned long long)__b);
6773   return (vector double)__res;
6774 }
6775 #endif
6776
6777 /* vec_vnor */
6778
6779 static __inline__ vector signed char __ATTRS_o_ai
6780 vec_vnor(vector signed char __a, vector signed char __b) {
6781   return ~(__a | __b);
6782 }
6783
6784 static __inline__ vector unsigned char __ATTRS_o_ai
6785 vec_vnor(vector unsigned char __a, vector unsigned char __b) {
6786   return ~(__a | __b);
6787 }
6788
6789 static __inline__ vector bool char __ATTRS_o_ai vec_vnor(vector bool char __a,
6790                                                          vector bool char __b) {
6791   return ~(__a | __b);
6792 }
6793
6794 static __inline__ vector short __ATTRS_o_ai vec_vnor(vector short __a,
6795                                                      vector short __b) {
6796   return ~(__a | __b);
6797 }
6798
6799 static __inline__ vector unsigned short __ATTRS_o_ai
6800 vec_vnor(vector unsigned short __a, vector unsigned short __b) {
6801   return ~(__a | __b);
6802 }
6803
6804 static __inline__ vector bool short __ATTRS_o_ai
6805 vec_vnor(vector bool short __a, vector bool short __b) {
6806   return ~(__a | __b);
6807 }
6808
6809 static __inline__ vector int __ATTRS_o_ai vec_vnor(vector int __a,
6810                                                    vector int __b) {
6811   return ~(__a | __b);
6812 }
6813
6814 static __inline__ vector unsigned int __ATTRS_o_ai
6815 vec_vnor(vector unsigned int __a, vector unsigned int __b) {
6816   return ~(__a | __b);
6817 }
6818
6819 static __inline__ vector bool int __ATTRS_o_ai vec_vnor(vector bool int __a,
6820                                                         vector bool int __b) {
6821   return ~(__a | __b);
6822 }
6823
6824 static __inline__ vector float __ATTRS_o_ai vec_vnor(vector float __a,
6825                                                      vector float __b) {
6826   vector unsigned int __res =
6827       ~((vector unsigned int)__a | (vector unsigned int)__b);
6828   return (vector float)__res;
6829 }
6830
6831 #ifdef __VSX__
6832 static __inline__ vector signed long long __ATTRS_o_ai
6833 vec_nor(vector signed long long __a, vector signed long long __b) {
6834   return ~(__a | __b);
6835 }
6836
6837 static __inline__ vector unsigned long long __ATTRS_o_ai
6838 vec_nor(vector unsigned long long __a, vector unsigned long long __b) {
6839   return ~(__a | __b);
6840 }
6841
6842 static __inline__ vector bool long long __ATTRS_o_ai
6843 vec_nor(vector bool long long __a, vector bool long long __b) {
6844   return ~(__a | __b);
6845 }
6846 #endif
6847
6848 /* vec_or */
6849
6850 #define __builtin_altivec_vor vec_or
6851
6852 static __inline__ vector signed char __ATTRS_o_ai
6853 vec_or(vector signed char __a, vector signed char __b) {
6854   return __a | __b;
6855 }
6856
6857 static __inline__ vector signed char __ATTRS_o_ai
6858 vec_or(vector bool char __a, vector signed char __b) {
6859   return (vector signed char)__a | __b;
6860 }
6861
6862 static __inline__ vector signed char __ATTRS_o_ai vec_or(vector signed char __a,
6863                                                          vector bool char __b) {
6864   return __a | (vector signed char)__b;
6865 }
6866
6867 static __inline__ vector unsigned char __ATTRS_o_ai
6868 vec_or(vector unsigned char __a, vector unsigned char __b) {
6869   return __a | __b;
6870 }
6871
6872 static __inline__ vector unsigned char __ATTRS_o_ai
6873 vec_or(vector bool char __a, vector unsigned char __b) {
6874   return (vector unsigned char)__a | __b;
6875 }
6876
6877 static __inline__ vector unsigned char __ATTRS_o_ai
6878 vec_or(vector unsigned char __a, vector bool char __b) {
6879   return __a | (vector unsigned char)__b;
6880 }
6881
6882 static __inline__ vector bool char __ATTRS_o_ai vec_or(vector bool char __a,
6883                                                        vector bool char __b) {
6884   return __a | __b;
6885 }
6886
6887 static __inline__ vector short __ATTRS_o_ai vec_or(vector short __a,
6888                                                    vector short __b) {
6889   return __a | __b;
6890 }
6891
6892 static __inline__ vector short __ATTRS_o_ai vec_or(vector bool short __a,
6893                                                    vector short __b) {
6894   return (vector short)__a | __b;
6895 }
6896
6897 static __inline__ vector short __ATTRS_o_ai vec_or(vector short __a,
6898                                                    vector bool short __b) {
6899   return __a | (vector short)__b;
6900 }
6901
6902 static __inline__ vector unsigned short __ATTRS_o_ai
6903 vec_or(vector unsigned short __a, vector unsigned short __b) {
6904   return __a | __b;
6905 }
6906
6907 static __inline__ vector unsigned short __ATTRS_o_ai
6908 vec_or(vector bool short __a, vector unsigned short __b) {
6909   return (vector unsigned short)__a | __b;
6910 }
6911
6912 static __inline__ vector unsigned short __ATTRS_o_ai
6913 vec_or(vector unsigned short __a, vector bool short __b) {
6914   return __a | (vector unsigned short)__b;
6915 }
6916
6917 static __inline__ vector bool short __ATTRS_o_ai vec_or(vector bool short __a,
6918                                                         vector bool short __b) {
6919   return __a | __b;
6920 }
6921
6922 static __inline__ vector int __ATTRS_o_ai vec_or(vector int __a,
6923                                                  vector int __b) {
6924   return __a | __b;
6925 }
6926
6927 static __inline__ vector int __ATTRS_o_ai vec_or(vector bool int __a,
6928                                                  vector int __b) {
6929   return (vector int)__a | __b;
6930 }
6931
6932 static __inline__ vector int __ATTRS_o_ai vec_or(vector int __a,
6933                                                  vector bool int __b) {
6934   return __a | (vector int)__b;
6935 }
6936
6937 static __inline__ vector unsigned int __ATTRS_o_ai
6938 vec_or(vector unsigned int __a, vector unsigned int __b) {
6939   return __a | __b;
6940 }
6941
6942 static __inline__ vector unsigned int __ATTRS_o_ai
6943 vec_or(vector bool int __a, vector unsigned int __b) {
6944   return (vector unsigned int)__a | __b;
6945 }
6946
6947 static __inline__ vector unsigned int __ATTRS_o_ai
6948 vec_or(vector unsigned int __a, vector bool int __b) {
6949   return __a | (vector unsigned int)__b;
6950 }
6951
6952 static __inline__ vector bool int __ATTRS_o_ai vec_or(vector bool int __a,
6953                                                       vector bool int __b) {
6954   return __a | __b;
6955 }
6956
6957 static __inline__ vector float __ATTRS_o_ai vec_or(vector float __a,
6958                                                    vector float __b) {
6959   vector unsigned int __res =
6960       (vector unsigned int)__a | (vector unsigned int)__b;
6961   return (vector float)__res;
6962 }
6963
6964 static __inline__ vector float __ATTRS_o_ai vec_or(vector bool int __a,
6965                                                    vector float __b) {
6966   vector unsigned int __res =
6967       (vector unsigned int)__a | (vector unsigned int)__b;
6968   return (vector float)__res;
6969 }
6970
6971 static __inline__ vector float __ATTRS_o_ai vec_or(vector float __a,
6972                                                    vector bool int __b) {
6973   vector unsigned int __res =
6974       (vector unsigned int)__a | (vector unsigned int)__b;
6975   return (vector float)__res;
6976 }
6977
6978 #ifdef __VSX__
6979 static __inline__ vector double __ATTRS_o_ai vec_or(vector bool long long __a,
6980                                                     vector double __b) {
6981   return (vector double)((vector unsigned long long)__a |
6982                          (vector unsigned long long)__b);
6983 }
6984
6985 static __inline__ vector double __ATTRS_o_ai vec_or(vector double __a,
6986                                                     vector bool long long __b) {
6987   return (vector double)((vector unsigned long long)__a |
6988                          (vector unsigned long long)__b);
6989 }
6990
6991 static __inline__ vector double __ATTRS_o_ai vec_or(vector double __a,
6992                                                     vector double __b) {
6993   return (vector double)((vector unsigned long long)__a |
6994                          (vector unsigned long long)__b);
6995 }
6996
6997 static __inline__ vector signed long long __ATTRS_o_ai
6998 vec_or(vector signed long long __a, vector signed long long __b) {
6999   return __a | __b;
7000 }
7001
7002 static __inline__ vector signed long long __ATTRS_o_ai
7003 vec_or(vector bool long long __a, vector signed long long __b) {
7004   return (vector signed long long)__a | __b;
7005 }
7006
7007 static __inline__ vector signed long long __ATTRS_o_ai
7008 vec_or(vector signed long long __a, vector bool long long __b) {
7009   return __a | (vector signed long long)__b;
7010 }
7011
7012 static __inline__ vector unsigned long long __ATTRS_o_ai
7013 vec_or(vector unsigned long long __a, vector unsigned long long __b) {
7014   return __a | __b;
7015 }
7016
7017 static __inline__ vector unsigned long long __ATTRS_o_ai
7018 vec_or(vector bool long long __a, vector unsigned long long __b) {
7019   return (vector unsigned long long)__a | __b;
7020 }
7021
7022 static __inline__ vector unsigned long long __ATTRS_o_ai
7023 vec_or(vector unsigned long long __a, vector bool long long __b) {
7024   return __a | (vector unsigned long long)__b;
7025 }
7026
7027 static __inline__ vector bool long long __ATTRS_o_ai
7028 vec_or(vector bool long long __a, vector bool long long __b) {
7029   return __a | __b;
7030 }
7031 #endif
7032
7033 #ifdef __POWER8_VECTOR__
7034 static __inline__ vector signed char __ATTRS_o_ai
7035 vec_orc(vector signed char __a, vector signed char __b) {
7036   return __a | ~__b;
7037 }
7038
7039 static __inline__ vector signed char __ATTRS_o_ai
7040 vec_orc(vector signed char __a, vector bool char __b) {
7041   return __a | (vector signed char)~__b;
7042 }
7043
7044 static __inline__ vector signed char __ATTRS_o_ai
7045 vec_orc(vector bool char __a, vector signed char __b) {
7046   return (vector signed char)(__a | (vector bool char)~__b);
7047 }
7048
7049 static __inline__ vector unsigned char __ATTRS_o_ai
7050 vec_orc(vector unsigned char __a, vector unsigned char __b) {
7051   return __a | ~__b;
7052 }
7053
7054 static __inline__ vector unsigned char __ATTRS_o_ai
7055 vec_orc(vector unsigned char __a, vector bool char __b) {
7056   return __a | (vector unsigned char)~__b;
7057 }
7058
7059 static __inline__ vector unsigned char __ATTRS_o_ai
7060 vec_orc(vector bool char __a, vector unsigned char __b) {
7061   return (vector unsigned char)(__a | (vector bool char)~__b);
7062 }
7063
7064 static __inline__ vector bool char __ATTRS_o_ai vec_orc(vector bool char __a,
7065                                                         vector bool char __b) {
7066   return __a | ~__b;
7067 }
7068
7069 static __inline__ vector signed short __ATTRS_o_ai
7070 vec_orc(vector signed short __a, vector signed short __b) {
7071   return __a | ~__b;
7072 }
7073
7074 static __inline__ vector signed short __ATTRS_o_ai
7075 vec_orc(vector signed short __a, vector bool short __b) {
7076   return __a | (vector signed short)~__b;
7077 }
7078
7079 static __inline__ vector signed short __ATTRS_o_ai
7080 vec_orc(vector bool short __a, vector signed short __b) {
7081   return (vector signed short)(__a | (vector bool short)~__b);
7082 }
7083
7084 static __inline__ vector unsigned short __ATTRS_o_ai
7085 vec_orc(vector unsigned short __a, vector unsigned short __b) {
7086   return __a | ~__b;
7087 }
7088
7089 static __inline__ vector unsigned short __ATTRS_o_ai
7090 vec_orc(vector unsigned short __a, vector bool short __b) {
7091   return __a | (vector unsigned short)~__b;
7092 }
7093
7094 static __inline__ vector unsigned short __ATTRS_o_ai
7095 vec_orc(vector bool short __a, vector unsigned short __b) {
7096   return (vector unsigned short)(__a | (vector bool short)~__b);
7097 }
7098
7099 static __inline__ vector bool short __ATTRS_o_ai
7100 vec_orc(vector bool short __a, vector bool short __b) {
7101   return __a | ~__b;
7102 }
7103
7104 static __inline__ vector signed int __ATTRS_o_ai
7105 vec_orc(vector signed int __a, vector signed int __b) {
7106   return __a | ~__b;
7107 }
7108
7109 static __inline__ vector signed int __ATTRS_o_ai vec_orc(vector signed int __a,
7110                                                          vector bool int __b) {
7111   return __a | (vector signed int)~__b;
7112 }
7113
7114 static __inline__ vector signed int __ATTRS_o_ai
7115 vec_orc(vector bool int __a, vector signed int __b) {
7116   return (vector signed int)(__a | (vector bool int)~__b);
7117 }
7118
7119 static __inline__ vector unsigned int __ATTRS_o_ai
7120 vec_orc(vector unsigned int __a, vector unsigned int __b) {
7121   return __a | ~__b;
7122 }
7123
7124 static __inline__ vector unsigned int __ATTRS_o_ai
7125 vec_orc(vector unsigned int __a, vector bool int __b) {
7126   return __a | (vector unsigned int)~__b;
7127 }
7128
7129 static __inline__ vector unsigned int __ATTRS_o_ai
7130 vec_orc(vector bool int __a, vector unsigned int __b) {
7131   return (vector unsigned int)(__a | (vector bool int)~__b);
7132 }
7133
7134 static __inline__ vector bool int __ATTRS_o_ai vec_orc(vector bool int __a,
7135                                                        vector bool int __b) {
7136   return __a | ~__b;
7137 }
7138
7139 static __inline__ vector float __ATTRS_o_ai
7140 vec_orc(vector bool int __a, vector float __b) {
7141   return (vector float)(__a | ~(vector bool int)__b);
7142 }
7143
7144 static __inline__ vector float __ATTRS_o_ai
7145 vec_orc(vector float __a, vector bool int __b) {
7146   return (vector float)((vector bool int)__a | ~__b);
7147 }
7148
7149 static __inline__ vector float __ATTRS_o_ai vec_orc(vector float __a,
7150                                                     vector float __b) {
7151   return (vector float)((vector unsigned int)__a | ~(vector unsigned int)__b);
7152 }
7153
7154 static __inline__ vector signed long long __ATTRS_o_ai
7155 vec_orc(vector signed long long __a, vector signed long long __b) {
7156   return __a | ~__b;
7157 }
7158
7159 static __inline__ vector signed long long __ATTRS_o_ai
7160 vec_orc(vector signed long long __a, vector bool long long __b) {
7161   return __a | (vector signed long long)~__b;
7162 }
7163
7164 static __inline__ vector signed long long __ATTRS_o_ai
7165 vec_orc(vector bool long long __a, vector signed long long __b) {
7166   return (vector signed long long)(__a | (vector bool long long)~__b);
7167 }
7168
7169 static __inline__ vector unsigned long long __ATTRS_o_ai
7170 vec_orc(vector unsigned long long __a, vector unsigned long long __b) {
7171   return __a | ~__b;
7172 }
7173
7174 static __inline__ vector unsigned long long __ATTRS_o_ai
7175 vec_orc(vector unsigned long long __a, vector bool long long __b) {
7176   return __a | (vector unsigned long long)~__b;
7177 }
7178
7179 static __inline__ vector unsigned long long __ATTRS_o_ai
7180 vec_orc(vector bool long long __a, vector unsigned long long __b) {
7181   return (vector unsigned long long)(__a | (vector bool long long)~__b);
7182 }
7183
7184 static __inline__ vector bool long long __ATTRS_o_ai
7185 vec_orc(vector bool long long __a, vector bool long long __b) {
7186   return __a | ~__b;
7187 }
7188
7189 static __inline__ vector double __ATTRS_o_ai
7190 vec_orc(vector double __a, vector bool long long __b) {
7191   return (vector double)((vector bool long long)__a | ~__b);
7192 }
7193
7194 static __inline__ vector double __ATTRS_o_ai
7195 vec_orc(vector bool long long __a, vector double __b) {
7196   return (vector double)(__a | ~(vector bool long long)__b);
7197 }
7198
7199 static __inline__ vector double __ATTRS_o_ai vec_orc(vector double __a,
7200                                                      vector double __b) {
7201   return (vector double)((vector unsigned long long)__a |
7202                          ~(vector unsigned long long)__b);
7203 }
7204 #endif
7205
7206 /* vec_vor */
7207
7208 static __inline__ vector signed char __ATTRS_o_ai
7209 vec_vor(vector signed char __a, vector signed char __b) {
7210   return __a | __b;
7211 }
7212
7213 static __inline__ vector signed char __ATTRS_o_ai
7214 vec_vor(vector bool char __a, vector signed char __b) {
7215   return (vector signed char)__a | __b;
7216 }
7217
7218 static __inline__ vector signed char __ATTRS_o_ai
7219 vec_vor(vector signed char __a, vector bool char __b) {
7220   return __a | (vector signed char)__b;
7221 }
7222
7223 static __inline__ vector unsigned char __ATTRS_o_ai
7224 vec_vor(vector unsigned char __a, vector unsigned char __b) {
7225   return __a | __b;
7226 }
7227
7228 static __inline__ vector unsigned char __ATTRS_o_ai
7229 vec_vor(vector bool char __a, vector unsigned char __b) {
7230   return (vector unsigned char)__a | __b;
7231 }
7232
7233 static __inline__ vector unsigned char __ATTRS_o_ai
7234 vec_vor(vector unsigned char __a, vector bool char __b) {
7235   return __a | (vector unsigned char)__b;
7236 }
7237
7238 static __inline__ vector bool char __ATTRS_o_ai vec_vor(vector bool char __a,
7239                                                         vector bool char __b) {
7240   return __a | __b;
7241 }
7242
7243 static __inline__ vector short __ATTRS_o_ai vec_vor(vector short __a,
7244                                                     vector short __b) {
7245   return __a | __b;
7246 }
7247
7248 static __inline__ vector short __ATTRS_o_ai vec_vor(vector bool short __a,
7249                                                     vector short __b) {
7250   return (vector short)__a | __b;
7251 }
7252
7253 static __inline__ vector short __ATTRS_o_ai vec_vor(vector short __a,
7254                                                     vector bool short __b) {
7255   return __a | (vector short)__b;
7256 }
7257
7258 static __inline__ vector unsigned short __ATTRS_o_ai
7259 vec_vor(vector unsigned short __a, vector unsigned short __b) {
7260   return __a | __b;
7261 }
7262
7263 static __inline__ vector unsigned short __ATTRS_o_ai
7264 vec_vor(vector bool short __a, vector unsigned short __b) {
7265   return (vector unsigned short)__a | __b;
7266 }
7267
7268 static __inline__ vector unsigned short __ATTRS_o_ai
7269 vec_vor(vector unsigned short __a, vector bool short __b) {
7270   return __a | (vector unsigned short)__b;
7271 }
7272
7273 static __inline__ vector bool short __ATTRS_o_ai
7274 vec_vor(vector bool short __a, vector bool short __b) {
7275   return __a | __b;
7276 }
7277
7278 static __inline__ vector int __ATTRS_o_ai vec_vor(vector int __a,
7279                                                   vector int __b) {
7280   return __a | __b;
7281 }
7282
7283 static __inline__ vector int __ATTRS_o_ai vec_vor(vector bool int __a,
7284                                                   vector int __b) {
7285   return (vector int)__a | __b;
7286 }
7287
7288 static __inline__ vector int __ATTRS_o_ai vec_vor(vector int __a,
7289                                                   vector bool int __b) {
7290   return __a | (vector int)__b;
7291 }
7292
7293 static __inline__ vector unsigned int __ATTRS_o_ai
7294 vec_vor(vector unsigned int __a, vector unsigned int __b) {
7295   return __a | __b;
7296 }
7297
7298 static __inline__ vector unsigned int __ATTRS_o_ai
7299 vec_vor(vector bool int __a, vector unsigned int __b) {
7300   return (vector unsigned int)__a | __b;
7301 }
7302
7303 static __inline__ vector unsigned int __ATTRS_o_ai
7304 vec_vor(vector unsigned int __a, vector bool int __b) {
7305   return __a | (vector unsigned int)__b;
7306 }
7307
7308 static __inline__ vector bool int __ATTRS_o_ai vec_vor(vector bool int __a,
7309                                                        vector bool int __b) {
7310   return __a | __b;
7311 }
7312
7313 static __inline__ vector float __ATTRS_o_ai vec_vor(vector float __a,
7314                                                     vector float __b) {
7315   vector unsigned int __res =
7316       (vector unsigned int)__a | (vector unsigned int)__b;
7317   return (vector float)__res;
7318 }
7319
7320 static __inline__ vector float __ATTRS_o_ai vec_vor(vector bool int __a,
7321                                                     vector float __b) {
7322   vector unsigned int __res =
7323       (vector unsigned int)__a | (vector unsigned int)__b;
7324   return (vector float)__res;
7325 }
7326
7327 static __inline__ vector float __ATTRS_o_ai vec_vor(vector float __a,
7328                                                     vector bool int __b) {
7329   vector unsigned int __res =
7330       (vector unsigned int)__a | (vector unsigned int)__b;
7331   return (vector float)__res;
7332 }
7333
7334 #ifdef __VSX__
7335 static __inline__ vector signed long long __ATTRS_o_ai
7336 vec_vor(vector signed long long __a, vector signed long long __b) {
7337   return __a | __b;
7338 }
7339
7340 static __inline__ vector signed long long __ATTRS_o_ai
7341 vec_vor(vector bool long long __a, vector signed long long __b) {
7342   return (vector signed long long)__a | __b;
7343 }
7344
7345 static __inline__ vector signed long long __ATTRS_o_ai
7346 vec_vor(vector signed long long __a, vector bool long long __b) {
7347   return __a | (vector signed long long)__b;
7348 }
7349
7350 static __inline__ vector unsigned long long __ATTRS_o_ai
7351 vec_vor(vector unsigned long long __a, vector unsigned long long __b) {
7352   return __a | __b;
7353 }
7354
7355 static __inline__ vector unsigned long long __ATTRS_o_ai
7356 vec_vor(vector bool long long __a, vector unsigned long long __b) {
7357   return (vector unsigned long long)__a | __b;
7358 }
7359
7360 static __inline__ vector unsigned long long __ATTRS_o_ai
7361 vec_vor(vector unsigned long long __a, vector bool long long __b) {
7362   return __a | (vector unsigned long long)__b;
7363 }
7364
7365 static __inline__ vector bool long long __ATTRS_o_ai
7366 vec_vor(vector bool long long __a, vector bool long long __b) {
7367   return __a | __b;
7368 }
7369 #endif
7370
7371 /* vec_pack */
7372
7373 /* The various vector pack instructions have a big-endian bias, so for
7374    little endian we must handle reversed element numbering.  */
7375
7376 static __inline__ vector signed char __ATTRS_o_ai
7377 vec_pack(vector signed short __a, vector signed short __b) {
7378 #ifdef __LITTLE_ENDIAN__
7379   return (vector signed char)vec_perm(
7380       __a, __b,
7381       (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
7382                              0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
7383 #else
7384   return (vector signed char)vec_perm(
7385       __a, __b,
7386       (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
7387                              0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
7388 #endif
7389 }
7390
7391 static __inline__ vector unsigned char __ATTRS_o_ai
7392 vec_pack(vector unsigned short __a, vector unsigned short __b) {
7393 #ifdef __LITTLE_ENDIAN__
7394   return (vector unsigned char)vec_perm(
7395       __a, __b,
7396       (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
7397                              0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
7398 #else
7399   return (vector unsigned char)vec_perm(
7400       __a, __b,
7401       (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
7402                              0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
7403 #endif
7404 }
7405
7406 static __inline__ vector bool char __ATTRS_o_ai
7407 vec_pack(vector bool short __a, vector bool short __b) {
7408 #ifdef __LITTLE_ENDIAN__
7409   return (vector bool char)vec_perm(
7410       __a, __b,
7411       (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
7412                              0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
7413 #else
7414   return (vector bool char)vec_perm(
7415       __a, __b,
7416       (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
7417                              0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
7418 #endif
7419 }
7420
7421 static __inline__ vector short __ATTRS_o_ai vec_pack(vector int __a,
7422                                                      vector int __b) {
7423 #ifdef __LITTLE_ENDIAN__
7424   return (vector short)vec_perm(
7425       __a, __b,
7426       (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
7427                              0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
7428 #else
7429   return (vector short)vec_perm(
7430       __a, __b,
7431       (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
7432                              0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
7433 #endif
7434 }
7435
7436 static __inline__ vector unsigned short __ATTRS_o_ai
7437 vec_pack(vector unsigned int __a, vector unsigned int __b) {
7438 #ifdef __LITTLE_ENDIAN__
7439   return (vector unsigned short)vec_perm(
7440       __a, __b,
7441       (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
7442                              0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
7443 #else
7444   return (vector unsigned short)vec_perm(
7445       __a, __b,
7446       (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
7447                              0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
7448 #endif
7449 }
7450
7451 static __inline__ vector bool short __ATTRS_o_ai vec_pack(vector bool int __a,
7452                                                           vector bool int __b) {
7453 #ifdef __LITTLE_ENDIAN__
7454   return (vector bool short)vec_perm(
7455       __a, __b,
7456       (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
7457                              0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
7458 #else
7459   return (vector bool short)vec_perm(
7460       __a, __b,
7461       (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
7462                              0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
7463 #endif
7464 }
7465
7466 #ifdef __VSX__
7467 static __inline__ vector signed int __ATTRS_o_ai
7468 vec_pack(vector signed long long __a, vector signed long long __b) {
7469 #ifdef __LITTLE_ENDIAN__
7470   return (vector signed int)vec_perm(
7471       __a, __b,
7472       (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
7473                              0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
7474 #else
7475   return (vector signed int)vec_perm(
7476       __a, __b,
7477       (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
7478                              0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
7479 #endif
7480 }
7481 static __inline__ vector unsigned int __ATTRS_o_ai
7482 vec_pack(vector unsigned long long __a, vector unsigned long long __b) {
7483 #ifdef __LITTLE_ENDIAN__
7484   return (vector unsigned int)vec_perm(
7485       __a, __b,
7486       (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
7487                              0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
7488 #else
7489   return (vector unsigned int)vec_perm(
7490       __a, __b,
7491       (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
7492                              0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
7493 #endif
7494 }
7495
7496 static __inline__ vector bool int __ATTRS_o_ai
7497 vec_pack(vector bool long long __a, vector bool long long __b) {
7498 #ifdef __LITTLE_ENDIAN__
7499   return (vector bool int)vec_perm(
7500       __a, __b,
7501       (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
7502                              0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
7503 #else
7504   return (vector bool int)vec_perm(
7505       __a, __b,
7506       (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
7507                              0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
7508 #endif
7509 }
7510
7511 static __inline__ vector float __ATTRS_o_ai
7512 vec_pack(vector double __a, vector double __b) {
7513   return (vector float) (__a[0], __a[1], __b[0], __b[1]);
7514 }
7515 #endif
7516
7517 #ifdef __POWER9_VECTOR__
7518 static __inline__ vector unsigned short __ATTRS_o_ai
7519 vec_pack_to_short_fp32(vector float __a, vector float __b) {
7520   vector float __resa = __builtin_vsx_xvcvsphp(__a);
7521   vector float __resb = __builtin_vsx_xvcvsphp(__b);
7522 #ifdef __LITTLE_ENDIAN__
7523   return (vector unsigned short)vec_mergee(__resa, __resb);
7524 #else
7525   return (vector unsigned short)vec_mergeo(__resa, __resb);
7526 #endif
7527 }
7528
7529 #endif
7530 /* vec_vpkuhum */
7531
7532 #define __builtin_altivec_vpkuhum vec_vpkuhum
7533
7534 static __inline__ vector signed char __ATTRS_o_ai
7535 vec_vpkuhum(vector signed short __a, vector signed short __b) {
7536 #ifdef __LITTLE_ENDIAN__
7537   return (vector signed char)vec_perm(
7538       __a, __b,
7539       (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
7540                              0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
7541 #else
7542   return (vector signed char)vec_perm(
7543       __a, __b,
7544       (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
7545                              0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
7546 #endif
7547 }
7548
7549 static __inline__ vector unsigned char __ATTRS_o_ai
7550 vec_vpkuhum(vector unsigned short __a, vector unsigned short __b) {
7551 #ifdef __LITTLE_ENDIAN__
7552   return (vector unsigned char)vec_perm(
7553       __a, __b,
7554       (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
7555                              0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
7556 #else
7557   return (vector unsigned char)vec_perm(
7558       __a, __b,
7559       (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
7560                              0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
7561 #endif
7562 }
7563
7564 static __inline__ vector bool char __ATTRS_o_ai
7565 vec_vpkuhum(vector bool short __a, vector bool short __b) {
7566 #ifdef __LITTLE_ENDIAN__
7567   return (vector bool char)vec_perm(
7568       __a, __b,
7569       (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
7570                              0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
7571 #else
7572   return (vector bool char)vec_perm(
7573       __a, __b,
7574       (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
7575                              0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
7576 #endif
7577 }
7578
7579 /* vec_vpkuwum */
7580
7581 #define __builtin_altivec_vpkuwum vec_vpkuwum
7582
7583 static __inline__ vector short __ATTRS_o_ai vec_vpkuwum(vector int __a,
7584                                                         vector int __b) {
7585 #ifdef __LITTLE_ENDIAN__
7586   return (vector short)vec_perm(
7587       __a, __b,
7588       (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
7589                              0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
7590 #else
7591   return (vector short)vec_perm(
7592       __a, __b,
7593       (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
7594                              0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
7595 #endif
7596 }
7597
7598 static __inline__ vector unsigned short __ATTRS_o_ai
7599 vec_vpkuwum(vector unsigned int __a, vector unsigned int __b) {
7600 #ifdef __LITTLE_ENDIAN__
7601   return (vector unsigned short)vec_perm(
7602       __a, __b,
7603       (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
7604                              0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
7605 #else
7606   return (vector unsigned short)vec_perm(
7607       __a, __b,
7608       (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
7609                              0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
7610 #endif
7611 }
7612
7613 static __inline__ vector bool short __ATTRS_o_ai
7614 vec_vpkuwum(vector bool int __a, vector bool int __b) {
7615 #ifdef __LITTLE_ENDIAN__
7616   return (vector bool short)vec_perm(
7617       __a, __b,
7618       (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
7619                              0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
7620 #else
7621   return (vector bool short)vec_perm(
7622       __a, __b,
7623       (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
7624                              0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
7625 #endif
7626 }
7627
7628 /* vec_vpkudum */
7629
7630 #ifdef __POWER8_VECTOR__
7631 #define __builtin_altivec_vpkudum vec_vpkudum
7632
7633 static __inline__ vector int __ATTRS_o_ai vec_vpkudum(vector long long __a,
7634                                                       vector long long __b) {
7635 #ifdef __LITTLE_ENDIAN__
7636   return (vector int)vec_perm(
7637       __a, __b,
7638       (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
7639                              0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
7640 #else
7641   return (vector int)vec_perm(
7642       __a, __b,
7643       (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
7644                              0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
7645 #endif
7646 }
7647
7648 static __inline__ vector unsigned int __ATTRS_o_ai
7649 vec_vpkudum(vector unsigned long long __a, vector unsigned long long __b) {
7650 #ifdef __LITTLE_ENDIAN__
7651   return (vector unsigned int)vec_perm(
7652       __a, __b,
7653       (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
7654                              0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
7655 #else
7656   return (vector unsigned int)vec_perm(
7657       __a, __b,
7658       (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
7659                              0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
7660 #endif
7661 }
7662
7663 static __inline__ vector bool int __ATTRS_o_ai
7664 vec_vpkudum(vector bool long long __a, vector bool long long __b) {
7665 #ifdef __LITTLE_ENDIAN__
7666   return (vector bool int)vec_perm(
7667       (vector long long)__a, (vector long long)__b,
7668       (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
7669                              0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
7670 #else
7671   return (vector bool int)vec_perm(
7672       (vector long long)__a, (vector long long)__b,
7673       (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
7674                              0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
7675 #endif
7676 }
7677 #endif
7678
7679 /* vec_packpx */
7680
7681 static __inline__ vector pixel __attribute__((__always_inline__))
7682 vec_packpx(vector unsigned int __a, vector unsigned int __b) {
7683 #ifdef __LITTLE_ENDIAN__
7684   return (vector pixel)__builtin_altivec_vpkpx(__b, __a);
7685 #else
7686   return (vector pixel)__builtin_altivec_vpkpx(__a, __b);
7687 #endif
7688 }
7689
7690 /* vec_vpkpx */
7691
7692 static __inline__ vector pixel __attribute__((__always_inline__))
7693 vec_vpkpx(vector unsigned int __a, vector unsigned int __b) {
7694 #ifdef __LITTLE_ENDIAN__
7695   return (vector pixel)__builtin_altivec_vpkpx(__b, __a);
7696 #else
7697   return (vector pixel)__builtin_altivec_vpkpx(__a, __b);
7698 #endif
7699 }
7700
7701 /* vec_packs */
7702
7703 static __inline__ vector signed char __ATTRS_o_ai vec_packs(vector short __a,
7704                                                             vector short __b) {
7705 #ifdef __LITTLE_ENDIAN__
7706   return __builtin_altivec_vpkshss(__b, __a);
7707 #else
7708   return __builtin_altivec_vpkshss(__a, __b);
7709 #endif
7710 }
7711
7712 static __inline__ vector unsigned char __ATTRS_o_ai
7713 vec_packs(vector unsigned short __a, vector unsigned short __b) {
7714 #ifdef __LITTLE_ENDIAN__
7715   return __builtin_altivec_vpkuhus(__b, __a);
7716 #else
7717   return __builtin_altivec_vpkuhus(__a, __b);
7718 #endif
7719 }
7720
7721 static __inline__ vector signed short __ATTRS_o_ai vec_packs(vector int __a,
7722                                                              vector int __b) {
7723 #ifdef __LITTLE_ENDIAN__
7724   return __builtin_altivec_vpkswss(__b, __a);
7725 #else
7726   return __builtin_altivec_vpkswss(__a, __b);
7727 #endif
7728 }
7729
7730 static __inline__ vector unsigned short __ATTRS_o_ai
7731 vec_packs(vector unsigned int __a, vector unsigned int __b) {
7732 #ifdef __LITTLE_ENDIAN__
7733   return __builtin_altivec_vpkuwus(__b, __a);
7734 #else
7735   return __builtin_altivec_vpkuwus(__a, __b);
7736 #endif
7737 }
7738
7739 #ifdef __POWER8_VECTOR__
7740 static __inline__ vector int __ATTRS_o_ai vec_packs(vector long long __a,
7741                                                     vector long long __b) {
7742 #ifdef __LITTLE_ENDIAN__
7743   return __builtin_altivec_vpksdss(__b, __a);
7744 #else
7745   return __builtin_altivec_vpksdss(__a, __b);
7746 #endif
7747 }
7748
7749 static __inline__ vector unsigned int __ATTRS_o_ai
7750 vec_packs(vector unsigned long long __a, vector unsigned long long __b) {
7751 #ifdef __LITTLE_ENDIAN__
7752   return __builtin_altivec_vpkudus(__b, __a);
7753 #else
7754   return __builtin_altivec_vpkudus(__a, __b);
7755 #endif
7756 }
7757 #endif
7758
7759 /* vec_vpkshss */
7760
7761 static __inline__ vector signed char __attribute__((__always_inline__))
7762 vec_vpkshss(vector short __a, vector short __b) {
7763 #ifdef __LITTLE_ENDIAN__
7764   return __builtin_altivec_vpkshss(__b, __a);
7765 #else
7766   return __builtin_altivec_vpkshss(__a, __b);
7767 #endif
7768 }
7769
7770 /* vec_vpksdss */
7771
7772 #ifdef __POWER8_VECTOR__
7773 static __inline__ vector int __ATTRS_o_ai vec_vpksdss(vector long long __a,
7774                                                       vector long long __b) {
7775 #ifdef __LITTLE_ENDIAN__
7776   return __builtin_altivec_vpksdss(__b, __a);
7777 #else
7778   return __builtin_altivec_vpksdss(__a, __b);
7779 #endif
7780 }
7781 #endif
7782
7783 /* vec_vpkuhus */
7784
7785 static __inline__ vector unsigned char __attribute__((__always_inline__))
7786 vec_vpkuhus(vector unsigned short __a, vector unsigned short __b) {
7787 #ifdef __LITTLE_ENDIAN__
7788   return __builtin_altivec_vpkuhus(__b, __a);
7789 #else
7790   return __builtin_altivec_vpkuhus(__a, __b);
7791 #endif
7792 }
7793
7794 /* vec_vpkudus */
7795
7796 #ifdef __POWER8_VECTOR__
7797 static __inline__ vector unsigned int __attribute__((__always_inline__))
7798 vec_vpkudus(vector unsigned long long __a, vector unsigned long long __b) {
7799 #ifdef __LITTLE_ENDIAN__
7800   return __builtin_altivec_vpkudus(__b, __a);
7801 #else
7802   return __builtin_altivec_vpkudus(__a, __b);
7803 #endif
7804 }
7805 #endif
7806
7807 /* vec_vpkswss */
7808
7809 static __inline__ vector signed short __attribute__((__always_inline__))
7810 vec_vpkswss(vector int __a, vector int __b) {
7811 #ifdef __LITTLE_ENDIAN__
7812   return __builtin_altivec_vpkswss(__b, __a);
7813 #else
7814   return __builtin_altivec_vpkswss(__a, __b);
7815 #endif
7816 }
7817
7818 /* vec_vpkuwus */
7819
7820 static __inline__ vector unsigned short __attribute__((__always_inline__))
7821 vec_vpkuwus(vector unsigned int __a, vector unsigned int __b) {
7822 #ifdef __LITTLE_ENDIAN__
7823   return __builtin_altivec_vpkuwus(__b, __a);
7824 #else
7825   return __builtin_altivec_vpkuwus(__a, __b);
7826 #endif
7827 }
7828
7829 /* vec_packsu */
7830
7831 static __inline__ vector unsigned char __ATTRS_o_ai
7832 vec_packsu(vector short __a, vector short __b) {
7833 #ifdef __LITTLE_ENDIAN__
7834   return __builtin_altivec_vpkshus(__b, __a);
7835 #else
7836   return __builtin_altivec_vpkshus(__a, __b);
7837 #endif
7838 }
7839
7840 static __inline__ vector unsigned char __ATTRS_o_ai
7841 vec_packsu(vector unsigned short __a, vector unsigned short __b) {
7842 #ifdef __LITTLE_ENDIAN__
7843   return __builtin_altivec_vpkuhus(__b, __a);
7844 #else
7845   return __builtin_altivec_vpkuhus(__a, __b);
7846 #endif
7847 }
7848
7849 static __inline__ vector unsigned short __ATTRS_o_ai
7850 vec_packsu(vector int __a, vector int __b) {
7851 #ifdef __LITTLE_ENDIAN__
7852   return __builtin_altivec_vpkswus(__b, __a);
7853 #else
7854   return __builtin_altivec_vpkswus(__a, __b);
7855 #endif
7856 }
7857
7858 static __inline__ vector unsigned short __ATTRS_o_ai
7859 vec_packsu(vector unsigned int __a, vector unsigned int __b) {
7860 #ifdef __LITTLE_ENDIAN__
7861   return __builtin_altivec_vpkuwus(__b, __a);
7862 #else
7863   return __builtin_altivec_vpkuwus(__a, __b);
7864 #endif
7865 }
7866
7867 #ifdef __POWER8_VECTOR__
7868 static __inline__ vector unsigned int __ATTRS_o_ai
7869 vec_packsu(vector long long __a, vector long long __b) {
7870 #ifdef __LITTLE_ENDIAN__
7871   return __builtin_altivec_vpksdus(__b, __a);
7872 #else
7873   return __builtin_altivec_vpksdus(__a, __b);
7874 #endif
7875 }
7876
7877 static __inline__ vector unsigned int __ATTRS_o_ai
7878 vec_packsu(vector unsigned long long __a, vector unsigned long long __b) {
7879 #ifdef __LITTLE_ENDIAN__
7880   return __builtin_altivec_vpkudus(__b, __a);
7881 #else
7882   return __builtin_altivec_vpkudus(__a, __b);
7883 #endif
7884 }
7885 #endif
7886
7887 /* vec_vpkshus */
7888
7889 static __inline__ vector unsigned char __ATTRS_o_ai
7890 vec_vpkshus(vector short __a, vector short __b) {
7891 #ifdef __LITTLE_ENDIAN__
7892   return __builtin_altivec_vpkshus(__b, __a);
7893 #else
7894   return __builtin_altivec_vpkshus(__a, __b);
7895 #endif
7896 }
7897
7898 static __inline__ vector unsigned char __ATTRS_o_ai
7899 vec_vpkshus(vector unsigned short __a, vector unsigned short __b) {
7900 #ifdef __LITTLE_ENDIAN__
7901   return __builtin_altivec_vpkuhus(__b, __a);
7902 #else
7903   return __builtin_altivec_vpkuhus(__a, __b);
7904 #endif
7905 }
7906
7907 /* vec_vpkswus */
7908
7909 static __inline__ vector unsigned short __ATTRS_o_ai
7910 vec_vpkswus(vector int __a, vector int __b) {
7911 #ifdef __LITTLE_ENDIAN__
7912   return __builtin_altivec_vpkswus(__b, __a);
7913 #else
7914   return __builtin_altivec_vpkswus(__a, __b);
7915 #endif
7916 }
7917
7918 static __inline__ vector unsigned short __ATTRS_o_ai
7919 vec_vpkswus(vector unsigned int __a, vector unsigned int __b) {
7920 #ifdef __LITTLE_ENDIAN__
7921   return __builtin_altivec_vpkuwus(__b, __a);
7922 #else
7923   return __builtin_altivec_vpkuwus(__a, __b);
7924 #endif
7925 }
7926
7927 /* vec_vpksdus */
7928
7929 #ifdef __POWER8_VECTOR__
7930 static __inline__ vector unsigned int __ATTRS_o_ai
7931 vec_vpksdus(vector long long __a, vector long long __b) {
7932 #ifdef __LITTLE_ENDIAN__
7933   return __builtin_altivec_vpksdus(__b, __a);
7934 #else
7935   return __builtin_altivec_vpksdus(__a, __b);
7936 #endif
7937 }
7938 #endif
7939
7940 /* vec_perm */
7941
7942 // The vperm instruction is defined architecturally with a big-endian bias.
7943 // For little endian, we swap the input operands and invert the permute
7944 // control vector.  Only the rightmost 5 bits matter, so we could use
7945 // a vector of all 31s instead of all 255s to perform the inversion.
7946 // However, when the PCV is not a constant, using 255 has an advantage
7947 // in that the vec_xor can be recognized as a vec_nor (and for P8 and
7948 // later, possibly a vec_nand).
7949
7950 static __inline__ vector signed char __ATTRS_o_ai vec_perm(
7951     vector signed char __a, vector signed char __b, vector unsigned char __c) {
7952 #ifdef __LITTLE_ENDIAN__
7953   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7954                               255, 255, 255, 255, 255, 255, 255, 255};
7955   __d = vec_xor(__c, __d);
7956   return (vector signed char)__builtin_altivec_vperm_4si((vector int)__b,
7957                                                          (vector int)__a, __d);
7958 #else
7959   return (vector signed char)__builtin_altivec_vperm_4si((vector int)__a,
7960                                                          (vector int)__b, __c);
7961 #endif
7962 }
7963
7964 static __inline__ vector unsigned char __ATTRS_o_ai
7965 vec_perm(vector unsigned char __a, vector unsigned char __b,
7966          vector unsigned char __c) {
7967 #ifdef __LITTLE_ENDIAN__
7968   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7969                               255, 255, 255, 255, 255, 255, 255, 255};
7970   __d = vec_xor(__c, __d);
7971   return (vector unsigned char)__builtin_altivec_vperm_4si(
7972       (vector int)__b, (vector int)__a, __d);
7973 #else
7974   return (vector unsigned char)__builtin_altivec_vperm_4si(
7975       (vector int)__a, (vector int)__b, __c);
7976 #endif
7977 }
7978
7979 static __inline__ vector bool char __ATTRS_o_ai
7980 vec_perm(vector bool char __a, vector bool char __b, vector unsigned char __c) {
7981 #ifdef __LITTLE_ENDIAN__
7982   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7983                               255, 255, 255, 255, 255, 255, 255, 255};
7984   __d = vec_xor(__c, __d);
7985   return (vector bool char)__builtin_altivec_vperm_4si((vector int)__b,
7986                                                        (vector int)__a, __d);
7987 #else
7988   return (vector bool char)__builtin_altivec_vperm_4si((vector int)__a,
7989                                                        (vector int)__b, __c);
7990 #endif
7991 }
7992
7993 static __inline__ vector short __ATTRS_o_ai vec_perm(vector signed short __a,
7994                                                      vector signed short __b,
7995                                                      vector unsigned char __c) {
7996 #ifdef __LITTLE_ENDIAN__
7997   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7998                               255, 255, 255, 255, 255, 255, 255, 255};
7999   __d = vec_xor(__c, __d);
8000   return (vector signed short)__builtin_altivec_vperm_4si((vector int)__b,
8001                                                           (vector int)__a, __d);
8002 #else
8003   return (vector signed short)__builtin_altivec_vperm_4si((vector int)__a,
8004                                                           (vector int)__b, __c);
8005 #endif
8006 }
8007
8008 static __inline__ vector unsigned short __ATTRS_o_ai
8009 vec_perm(vector unsigned short __a, vector unsigned short __b,
8010          vector unsigned char __c) {
8011 #ifdef __LITTLE_ENDIAN__
8012   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
8013                               255, 255, 255, 255, 255, 255, 255, 255};
8014   __d = vec_xor(__c, __d);
8015   return (vector unsigned short)__builtin_altivec_vperm_4si(
8016       (vector int)__b, (vector int)__a, __d);
8017 #else
8018   return (vector unsigned short)__builtin_altivec_vperm_4si(
8019       (vector int)__a, (vector int)__b, __c);
8020 #endif
8021 }
8022
8023 static __inline__ vector bool short __ATTRS_o_ai vec_perm(
8024     vector bool short __a, vector bool short __b, vector unsigned char __c) {
8025 #ifdef __LITTLE_ENDIAN__
8026   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
8027                               255, 255, 255, 255, 255, 255, 255, 255};
8028   __d = vec_xor(__c, __d);
8029   return (vector bool short)__builtin_altivec_vperm_4si((vector int)__b,
8030                                                         (vector int)__a, __d);
8031 #else
8032   return (vector bool short)__builtin_altivec_vperm_4si((vector int)__a,
8033                                                         (vector int)__b, __c);
8034 #endif
8035 }
8036
8037 static __inline__ vector pixel __ATTRS_o_ai vec_perm(vector pixel __a,
8038                                                      vector pixel __b,
8039                                                      vector unsigned char __c) {
8040 #ifdef __LITTLE_ENDIAN__
8041   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
8042                               255, 255, 255, 255, 255, 255, 255, 255};
8043   __d = vec_xor(__c, __d);
8044   return (vector pixel)__builtin_altivec_vperm_4si((vector int)__b,
8045                                                    (vector int)__a, __d);
8046 #else
8047   return (vector pixel)__builtin_altivec_vperm_4si((vector int)__a,
8048                                                    (vector int)__b, __c);
8049 #endif
8050 }
8051
8052 static __inline__ vector int __ATTRS_o_ai vec_perm(vector signed int __a,
8053                                                    vector signed int __b,
8054                                                    vector unsigned char __c) {
8055 #ifdef __LITTLE_ENDIAN__
8056   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
8057                               255, 255, 255, 255, 255, 255, 255, 255};
8058   __d = vec_xor(__c, __d);
8059   return (vector signed int)__builtin_altivec_vperm_4si(__b, __a, __d);
8060 #else
8061   return (vector signed int)__builtin_altivec_vperm_4si(__a, __b, __c);
8062 #endif
8063 }
8064
8065 static __inline__ vector unsigned int __ATTRS_o_ai
8066 vec_perm(vector unsigned int __a, vector unsigned int __b,
8067          vector unsigned char __c) {
8068 #ifdef __LITTLE_ENDIAN__
8069   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
8070                               255, 255, 255, 255, 255, 255, 255, 255};
8071   __d = vec_xor(__c, __d);
8072   return (vector unsigned int)__builtin_altivec_vperm_4si((vector int)__b,
8073                                                           (vector int)__a, __d);
8074 #else
8075   return (vector unsigned int)__builtin_altivec_vperm_4si((vector int)__a,
8076                                                           (vector int)__b, __c);
8077 #endif
8078 }
8079
8080 static __inline__ vector bool int __ATTRS_o_ai
8081 vec_perm(vector bool int __a, vector bool int __b, vector unsigned char __c) {
8082 #ifdef __LITTLE_ENDIAN__
8083   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
8084                               255, 255, 255, 255, 255, 255, 255, 255};
8085   __d = vec_xor(__c, __d);
8086   return (vector bool int)__builtin_altivec_vperm_4si((vector int)__b,
8087                                                       (vector int)__a, __d);
8088 #else
8089   return (vector bool int)__builtin_altivec_vperm_4si((vector int)__a,
8090                                                       (vector int)__b, __c);
8091 #endif
8092 }
8093
8094 static __inline__ vector float __ATTRS_o_ai vec_perm(vector float __a,
8095                                                      vector float __b,
8096                                                      vector unsigned char __c) {
8097 #ifdef __LITTLE_ENDIAN__
8098   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
8099                               255, 255, 255, 255, 255, 255, 255, 255};
8100   __d = vec_xor(__c, __d);
8101   return (vector float)__builtin_altivec_vperm_4si((vector int)__b,
8102                                                    (vector int)__a, __d);
8103 #else
8104   return (vector float)__builtin_altivec_vperm_4si((vector int)__a,
8105                                                    (vector int)__b, __c);
8106 #endif
8107 }
8108
8109 #ifdef __VSX__
8110 static __inline__ vector long long __ATTRS_o_ai
8111 vec_perm(vector signed long long __a, vector signed long long __b,
8112          vector unsigned char __c) {
8113 #ifdef __LITTLE_ENDIAN__
8114   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
8115                               255, 255, 255, 255, 255, 255, 255, 255};
8116   __d = vec_xor(__c, __d);
8117   return (vector signed long long)__builtin_altivec_vperm_4si(
8118       (vector int)__b, (vector int)__a, __d);
8119 #else
8120   return (vector signed long long)__builtin_altivec_vperm_4si(
8121       (vector int)__a, (vector int)__b, __c);
8122 #endif
8123 }
8124
8125 static __inline__ vector unsigned long long __ATTRS_o_ai
8126 vec_perm(vector unsigned long long __a, vector unsigned long long __b,
8127          vector unsigned char __c) {
8128 #ifdef __LITTLE_ENDIAN__
8129   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
8130                               255, 255, 255, 255, 255, 255, 255, 255};
8131   __d = vec_xor(__c, __d);
8132   return (vector unsigned long long)__builtin_altivec_vperm_4si(
8133       (vector int)__b, (vector int)__a, __d);
8134 #else
8135   return (vector unsigned long long)__builtin_altivec_vperm_4si(
8136       (vector int)__a, (vector int)__b, __c);
8137 #endif
8138 }
8139
8140 static __inline__ vector bool long long __ATTRS_o_ai
8141 vec_perm(vector bool long long __a, vector bool long long __b,
8142          vector unsigned char __c) {
8143 #ifdef __LITTLE_ENDIAN__
8144   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
8145                               255, 255, 255, 255, 255, 255, 255, 255};
8146   __d = vec_xor(__c, __d);
8147   return (vector bool long long)__builtin_altivec_vperm_4si(
8148       (vector int)__b, (vector int)__a, __d);
8149 #else
8150   return (vector bool long long)__builtin_altivec_vperm_4si(
8151       (vector int)__a, (vector int)__b, __c);
8152 #endif
8153 }
8154
8155 static __inline__ vector double __ATTRS_o_ai
8156 vec_perm(vector double __a, vector double __b, vector unsigned char __c) {
8157 #ifdef __LITTLE_ENDIAN__
8158   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
8159                               255, 255, 255, 255, 255, 255, 255, 255};
8160   __d = vec_xor(__c, __d);
8161   return (vector double)__builtin_altivec_vperm_4si((vector int)__b,
8162                                                     (vector int)__a, __d);
8163 #else
8164   return (vector double)__builtin_altivec_vperm_4si((vector int)__a,
8165                                                     (vector int)__b, __c);
8166 #endif
8167 }
8168 #endif
8169
8170 /* vec_vperm */
8171
8172 static __inline__ vector signed char __ATTRS_o_ai vec_vperm(
8173     vector signed char __a, vector signed char __b, vector unsigned char __c) {
8174   return vec_perm(__a, __b, __c);
8175 }
8176
8177 static __inline__ vector unsigned char __ATTRS_o_ai
8178 vec_vperm(vector unsigned char __a, vector unsigned char __b,
8179           vector unsigned char __c) {
8180   return vec_perm(__a, __b, __c);
8181 }
8182
8183 static __inline__ vector bool char __ATTRS_o_ai vec_vperm(
8184     vector bool char __a, vector bool char __b, vector unsigned char __c) {
8185   return vec_perm(__a, __b, __c);
8186 }
8187
8188 static __inline__ vector short __ATTRS_o_ai
8189 vec_vperm(vector short __a, vector short __b, vector unsigned char __c) {
8190   return vec_perm(__a, __b, __c);
8191 }
8192
8193 static __inline__ vector unsigned short __ATTRS_o_ai
8194 vec_vperm(vector unsigned short __a, vector unsigned short __b,
8195           vector unsigned char __c) {
8196   return vec_perm(__a, __b, __c);
8197 }
8198
8199 static __inline__ vector bool short __ATTRS_o_ai vec_vperm(
8200     vector bool short __a, vector bool short __b, vector unsigned char __c) {
8201   return vec_perm(__a, __b, __c);
8202 }
8203
8204 static __inline__ vector pixel __ATTRS_o_ai
8205 vec_vperm(vector pixel __a, vector pixel __b, vector unsigned char __c) {
8206   return vec_perm(__a, __b, __c);
8207 }
8208
8209 static __inline__ vector int __ATTRS_o_ai vec_vperm(vector int __a,
8210                                                     vector int __b,
8211                                                     vector unsigned char __c) {
8212   return vec_perm(__a, __b, __c);
8213 }
8214
8215 static __inline__ vector unsigned int __ATTRS_o_ai
8216 vec_vperm(vector unsigned int __a, vector unsigned int __b,
8217           vector unsigned char __c) {
8218   return vec_perm(__a, __b, __c);
8219 }
8220
8221 static __inline__ vector bool int __ATTRS_o_ai
8222 vec_vperm(vector bool int __a, vector bool int __b, vector unsigned char __c) {
8223   return vec_perm(__a, __b, __c);
8224 }
8225
8226 static __inline__ vector float __ATTRS_o_ai
8227 vec_vperm(vector float __a, vector float __b, vector unsigned char __c) {
8228   return vec_perm(__a, __b, __c);
8229 }
8230
8231 #ifdef __VSX__
8232 static __inline__ vector long long __ATTRS_o_ai vec_vperm(
8233     vector long long __a, vector long long __b, vector unsigned char __c) {
8234   return vec_perm(__a, __b, __c);
8235 }
8236
8237 static __inline__ vector unsigned long long __ATTRS_o_ai
8238 vec_vperm(vector unsigned long long __a, vector unsigned long long __b,
8239           vector unsigned char __c) {
8240   return vec_perm(__a, __b, __c);
8241 }
8242
8243 static __inline__ vector double __ATTRS_o_ai
8244 vec_vperm(vector double __a, vector double __b, vector unsigned char __c) {
8245   return vec_perm(__a, __b, __c);
8246 }
8247 #endif
8248
8249 /* vec_re */
8250
8251 static __inline__ vector float __ATTRS_o_ai vec_re(vector float __a) {
8252 #ifdef __VSX__
8253   return __builtin_vsx_xvresp(__a);
8254 #else
8255   return __builtin_altivec_vrefp(__a);
8256 #endif
8257 }
8258
8259 #ifdef __VSX__
8260 static __inline__ vector double __ATTRS_o_ai vec_re(vector double __a) {
8261   return __builtin_vsx_xvredp(__a);
8262 }
8263 #endif
8264
8265 /* vec_vrefp */
8266
8267 static __inline__ vector float __attribute__((__always_inline__))
8268 vec_vrefp(vector float __a) {
8269   return __builtin_altivec_vrefp(__a);
8270 }
8271
8272 /* vec_rl */
8273
8274 static __inline__ vector signed char __ATTRS_o_ai
8275 vec_rl(vector signed char __a, vector unsigned char __b) {
8276   return (vector signed char)__builtin_altivec_vrlb((vector char)__a, __b);
8277 }
8278
8279 static __inline__ vector unsigned char __ATTRS_o_ai
8280 vec_rl(vector unsigned char __a, vector unsigned char __b) {
8281   return (vector unsigned char)__builtin_altivec_vrlb((vector char)__a, __b);
8282 }
8283
8284 static __inline__ vector short __ATTRS_o_ai vec_rl(vector short __a,
8285                                                    vector unsigned short __b) {
8286   return __builtin_altivec_vrlh(__a, __b);
8287 }
8288
8289 static __inline__ vector unsigned short __ATTRS_o_ai
8290 vec_rl(vector unsigned short __a, vector unsigned short __b) {
8291   return (vector unsigned short)__builtin_altivec_vrlh((vector short)__a, __b);
8292 }
8293
8294 static __inline__ vector int __ATTRS_o_ai vec_rl(vector int __a,
8295                                                  vector unsigned int __b) {
8296   return __builtin_altivec_vrlw(__a, __b);
8297 }
8298
8299 static __inline__ vector unsigned int __ATTRS_o_ai
8300 vec_rl(vector unsigned int __a, vector unsigned int __b) {
8301   return (vector unsigned int)__builtin_altivec_vrlw((vector int)__a, __b);
8302 }
8303
8304 #ifdef __POWER8_VECTOR__
8305 static __inline__ vector signed long long __ATTRS_o_ai
8306 vec_rl(vector signed long long __a, vector unsigned long long __b) {
8307   return __builtin_altivec_vrld(__a, __b);
8308 }
8309
8310 static __inline__ vector unsigned long long __ATTRS_o_ai
8311 vec_rl(vector unsigned long long __a, vector unsigned long long __b) {
8312   return (vector unsigned long long)__builtin_altivec_vrld(
8313       (vector long long)__a, __b);
8314 }
8315 #endif
8316
8317 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
8318 static __inline__ vector signed __int128 __ATTRS_o_ai
8319 vec_rl(vector signed __int128 __a, vector unsigned __int128 __b) {
8320   return (vector signed __int128)(((vector unsigned __int128)__b
8321                                    << (vector unsigned __int128)__a) |
8322                                   ((vector unsigned __int128)__b >>
8323                                    ((__CHAR_BIT__ *
8324                                      sizeof(vector unsigned __int128)) -
8325                                     (vector unsigned __int128)__a)));
8326 }
8327
8328 static __inline__ vector unsigned __int128 __ATTRS_o_ai
8329 vec_rl(vector unsigned __int128 __a, vector unsigned __int128 __b) {
8330   return (__b << __a)|(__b >> ((__CHAR_BIT__ * sizeof(vector unsigned __int128)) - __a));
8331 }
8332 #endif
8333
8334 /* vec_rlmi */
8335 #ifdef __POWER9_VECTOR__
8336 static __inline__ vector unsigned int __ATTRS_o_ai
8337 vec_rlmi(vector unsigned int __a, vector unsigned int __b,
8338          vector unsigned int __c) {
8339   return __builtin_altivec_vrlwmi(__a, __c, __b);
8340 }
8341
8342 static __inline__ vector unsigned long long __ATTRS_o_ai
8343 vec_rlmi(vector unsigned long long __a, vector unsigned long long __b,
8344          vector unsigned long long __c) {
8345   return __builtin_altivec_vrldmi(__a, __c, __b);
8346 }
8347 #endif
8348
8349 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
8350 static __inline__ vector unsigned __int128 __ATTRS_o_ai
8351 vec_rlmi(vector unsigned __int128 __a, vector unsigned __int128 __b,
8352          vector unsigned __int128 __c) {
8353   return __builtin_altivec_vrlqmi(__a, __c, __b);
8354 }
8355
8356 static __inline__ vector signed __int128 __ATTRS_o_ai
8357 vec_rlmi(vector signed __int128 __a, vector signed __int128 __b,
8358          vector signed __int128 __c) {
8359   return (vector signed __int128)__builtin_altivec_vrlqmi(
8360       (vector unsigned __int128)__a, (vector unsigned __int128)__c,
8361       (vector unsigned __int128)__b);
8362 }
8363 #endif
8364
8365 /* vec_rlnm */
8366 #ifdef __POWER9_VECTOR__
8367 static __inline__ vector unsigned int __ATTRS_o_ai
8368 vec_rlnm(vector unsigned int __a, vector unsigned int __b,
8369          vector unsigned int __c) {
8370   vector unsigned int OneByte = { 0x8, 0x8, 0x8, 0x8 };
8371   return __builtin_altivec_vrlwnm(__a, ((__c << OneByte) | __b));
8372 }
8373
8374 static __inline__ vector unsigned long long __ATTRS_o_ai
8375 vec_rlnm(vector unsigned long long __a, vector unsigned long long __b,
8376          vector unsigned long long __c) {
8377   vector unsigned long long OneByte = { 0x8, 0x8 };
8378   return __builtin_altivec_vrldnm(__a, ((__c << OneByte) | __b));
8379 }
8380 #endif
8381
8382 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
8383 static __inline__ vector unsigned __int128 __ATTRS_o_ai
8384 vec_rlnm(vector unsigned __int128 __a, vector unsigned __int128 __b,
8385          vector unsigned __int128 __c) {
8386   // Merge __b and __c using an appropriate shuffle.
8387   vector unsigned char TmpB = (vector unsigned char)__b;
8388   vector unsigned char TmpC = (vector unsigned char)__c;
8389   vector unsigned char MaskAndShift =
8390 #ifdef __LITTLE_ENDIAN__
8391       __builtin_shufflevector(TmpB, TmpC, -1, -1, -1, -1, -1, -1, -1, -1, 16, 0,
8392                               1, -1, -1, -1, -1, -1);
8393 #else
8394       __builtin_shufflevector(TmpB, TmpC, -1, -1, -1, -1, -1, 31, 30, 15, -1,
8395                               -1, -1, -1, -1, -1, -1, -1);
8396 #endif
8397    return __builtin_altivec_vrlqnm(__a, (vector unsigned __int128) MaskAndShift);
8398 }
8399
8400 static __inline__ vector signed __int128 __ATTRS_o_ai
8401 vec_rlnm(vector signed __int128 __a, vector signed __int128 __b,
8402          vector signed __int128 __c) {
8403   // Merge __b and __c using an appropriate shuffle.
8404   vector unsigned char TmpB = (vector unsigned char)__b;
8405   vector unsigned char TmpC = (vector unsigned char)__c;
8406   vector unsigned char MaskAndShift =
8407 #ifdef __LITTLE_ENDIAN__
8408       __builtin_shufflevector(TmpB, TmpC, -1, -1, -1, -1, -1, -1, -1, -1, 16, 0,
8409                               1, -1, -1, -1, -1, -1);
8410 #else
8411       __builtin_shufflevector(TmpB, TmpC, -1, -1, -1, -1, -1, 31, 30, 15, -1,
8412                               -1, -1, -1, -1, -1, -1, -1);
8413 #endif
8414   return (vector signed __int128)__builtin_altivec_vrlqnm(
8415       (vector unsigned __int128)__a, (vector unsigned __int128)MaskAndShift);
8416 }
8417 #endif
8418
8419 /* vec_vrlb */
8420
8421 static __inline__ vector signed char __ATTRS_o_ai
8422 vec_vrlb(vector signed char __a, vector unsigned char __b) {
8423   return (vector signed char)__builtin_altivec_vrlb((vector char)__a, __b);
8424 }
8425
8426 static __inline__ vector unsigned char __ATTRS_o_ai
8427 vec_vrlb(vector unsigned char __a, vector unsigned char __b) {
8428   return (vector unsigned char)__builtin_altivec_vrlb((vector char)__a, __b);
8429 }
8430
8431 /* vec_vrlh */
8432
8433 static __inline__ vector short __ATTRS_o_ai
8434 vec_vrlh(vector short __a, vector unsigned short __b) {
8435   return __builtin_altivec_vrlh(__a, __b);
8436 }
8437
8438 static __inline__ vector unsigned short __ATTRS_o_ai
8439 vec_vrlh(vector unsigned short __a, vector unsigned short __b) {
8440   return (vector unsigned short)__builtin_altivec_vrlh((vector short)__a, __b);
8441 }
8442
8443 /* vec_vrlw */
8444
8445 static __inline__ vector int __ATTRS_o_ai vec_vrlw(vector int __a,
8446                                                    vector unsigned int __b) {
8447   return __builtin_altivec_vrlw(__a, __b);
8448 }
8449
8450 static __inline__ vector unsigned int __ATTRS_o_ai
8451 vec_vrlw(vector unsigned int __a, vector unsigned int __b) {
8452   return (vector unsigned int)__builtin_altivec_vrlw((vector int)__a, __b);
8453 }
8454
8455 /* vec_round */
8456
8457 static __inline__ vector float __ATTRS_o_ai vec_round(vector float __a) {
8458   return __builtin_altivec_vrfin(__a);
8459 }
8460
8461 #ifdef __VSX__
8462 #ifdef __XL_COMPAT_ALTIVEC__
8463 static __inline__ vector double __ATTRS_o_ai vec_rint(vector double __a);
8464 static __inline__ vector double __ATTRS_o_ai vec_round(vector double __a) {
8465   double __fpscr = __builtin_readflm();
8466   __builtin_setrnd(0);
8467   vector double __rounded = vec_rint(__a);
8468   __builtin_setflm(__fpscr);
8469   return __rounded;
8470 }
8471 #else
8472 static __inline__ vector double __ATTRS_o_ai vec_round(vector double __a) {
8473   return __builtin_vsx_xvrdpi(__a);
8474 }
8475 #endif
8476
8477 /* vec_rint */
8478
8479 static __inline__ vector float __ATTRS_o_ai vec_rint(vector float __a) {
8480   return __builtin_vsx_xvrspic(__a);
8481 }
8482
8483 static __inline__ vector double __ATTRS_o_ai vec_rint(vector double __a) {
8484   return __builtin_vsx_xvrdpic(__a);
8485 }
8486
8487 /* vec_roundc */
8488
8489 static __inline__ vector float __ATTRS_o_ai vec_roundc(vector float __a) {
8490   return __builtin_vsx_xvrspic(__a);
8491 }
8492
8493 static __inline__ vector double __ATTRS_o_ai vec_roundc(vector double __a) {
8494   return __builtin_vsx_xvrdpic(__a);
8495 }
8496
8497 /* vec_nearbyint */
8498
8499 static __inline__ vector float __ATTRS_o_ai vec_nearbyint(vector float __a) {
8500   return __builtin_vsx_xvrspi(__a);
8501 }
8502
8503 static __inline__ vector double __ATTRS_o_ai vec_nearbyint(vector double __a) {
8504   return __builtin_vsx_xvrdpi(__a);
8505 }
8506 #endif
8507
8508 /* vec_vrfin */
8509
8510 static __inline__ vector float __attribute__((__always_inline__))
8511 vec_vrfin(vector float __a) {
8512   return __builtin_altivec_vrfin(__a);
8513 }
8514
8515 /* vec_sqrt */
8516
8517 #ifdef __VSX__
8518 static __inline__ vector float __ATTRS_o_ai vec_sqrt(vector float __a) {
8519   return __builtin_vsx_xvsqrtsp(__a);
8520 }
8521
8522 static __inline__ vector double __ATTRS_o_ai vec_sqrt(vector double __a) {
8523   return __builtin_vsx_xvsqrtdp(__a);
8524 }
8525 #endif
8526
8527 /* vec_rsqrte */
8528
8529 static __inline__ vector float __ATTRS_o_ai vec_rsqrte(vector float __a) {
8530 #ifdef __VSX__
8531   return __builtin_vsx_xvrsqrtesp(__a);
8532 #else
8533   return __builtin_altivec_vrsqrtefp(__a);
8534 #endif
8535 }
8536
8537 #ifdef __VSX__
8538 static __inline__ vector double __ATTRS_o_ai vec_rsqrte(vector double __a) {
8539   return __builtin_vsx_xvrsqrtedp(__a);
8540 }
8541 #endif
8542
8543 static vector float __ATTRS_o_ai vec_rsqrt(vector float __a) {
8544   return __builtin_ppc_rsqrtf(__a);
8545 }
8546
8547 #ifdef __VSX__
8548 static vector double __ATTRS_o_ai vec_rsqrt(vector double __a) {
8549   return __builtin_ppc_rsqrtd(__a);
8550 }
8551 #endif
8552
8553 /* vec_vrsqrtefp */
8554
8555 static __inline__ __vector float __attribute__((__always_inline__))
8556 vec_vrsqrtefp(vector float __a) {
8557   return __builtin_altivec_vrsqrtefp(__a);
8558 }
8559
8560 /* vec_xvtsqrt */
8561
8562 #ifdef __VSX__
8563 static __inline__ int __ATTRS_o_ai vec_test_swsqrt(vector double __a) {
8564   return __builtin_vsx_xvtsqrtdp(__a);
8565 }
8566
8567 static __inline__ int __ATTRS_o_ai vec_test_swsqrts(vector float __a) {
8568   return __builtin_vsx_xvtsqrtsp(__a);
8569 }
8570 #endif
8571
8572 /* vec_sel */
8573
8574 #define __builtin_altivec_vsel_4si vec_sel
8575
8576 static __inline__ vector signed char __ATTRS_o_ai vec_sel(
8577     vector signed char __a, vector signed char __b, vector unsigned char __c) {
8578   return (__a & ~(vector signed char)__c) | (__b & (vector signed char)__c);
8579 }
8580
8581 static __inline__ vector signed char __ATTRS_o_ai
8582 vec_sel(vector signed char __a, vector signed char __b, vector bool char __c) {
8583   return (__a & ~(vector signed char)__c) | (__b & (vector signed char)__c);
8584 }
8585
8586 static __inline__ vector unsigned char __ATTRS_o_ai
8587 vec_sel(vector unsigned char __a, vector unsigned char __b,
8588         vector unsigned char __c) {
8589   return (__a & ~__c) | (__b & __c);
8590 }
8591
8592 static __inline__ vector unsigned char __ATTRS_o_ai vec_sel(
8593     vector unsigned char __a, vector unsigned char __b, vector bool char __c) {
8594   return (__a & ~(vector unsigned char)__c) | (__b & (vector unsigned char)__c);
8595 }
8596
8597 static __inline__ vector bool char __ATTRS_o_ai
8598 vec_sel(vector bool char __a, vector bool char __b, vector unsigned char __c) {
8599   return (__a & ~(vector bool char)__c) | (__b & (vector bool char)__c);
8600 }
8601
8602 static __inline__ vector bool char __ATTRS_o_ai vec_sel(vector bool char __a,
8603                                                         vector bool char __b,
8604                                                         vector bool char __c) {
8605   return (__a & ~__c) | (__b & __c);
8606 }
8607
8608 static __inline__ vector short __ATTRS_o_ai vec_sel(vector short __a,
8609                                                     vector short __b,
8610                                                     vector unsigned short __c) {
8611   return (__a & ~(vector short)__c) | (__b & (vector short)__c);
8612 }
8613
8614 static __inline__ vector short __ATTRS_o_ai vec_sel(vector short __a,
8615                                                     vector short __b,
8616                                                     vector bool short __c) {
8617   return (__a & ~(vector short)__c) | (__b & (vector short)__c);
8618 }
8619
8620 static __inline__ vector unsigned short __ATTRS_o_ai
8621 vec_sel(vector unsigned short __a, vector unsigned short __b,
8622         vector unsigned short __c) {
8623   return (__a & ~__c) | (__b & __c);
8624 }
8625
8626 static __inline__ vector unsigned short __ATTRS_o_ai
8627 vec_sel(vector unsigned short __a, vector unsigned short __b,
8628         vector bool short __c) {
8629   return (__a & ~(vector unsigned short)__c) |
8630          (__b & (vector unsigned short)__c);
8631 }
8632
8633 static __inline__ vector bool short __ATTRS_o_ai vec_sel(
8634     vector bool short __a, vector bool short __b, vector unsigned short __c) {
8635   return (__a & ~(vector bool short)__c) | (__b & (vector bool short)__c);
8636 }
8637
8638 static __inline__ vector bool short __ATTRS_o_ai
8639 vec_sel(vector bool short __a, vector bool short __b, vector bool short __c) {
8640   return (__a & ~__c) | (__b & __c);
8641 }
8642
8643 static __inline__ vector int __ATTRS_o_ai vec_sel(vector int __a,
8644                                                   vector int __b,
8645                                                   vector unsigned int __c) {
8646   return (__a & ~(vector int)__c) | (__b & (vector int)__c);
8647 }
8648
8649 static __inline__ vector int __ATTRS_o_ai vec_sel(vector int __a,
8650                                                   vector int __b,
8651                                                   vector bool int __c) {
8652   return (__a & ~(vector int)__c) | (__b & (vector int)__c);
8653 }
8654
8655 static __inline__ vector unsigned int __ATTRS_o_ai vec_sel(
8656     vector unsigned int __a, vector unsigned int __b, vector unsigned int __c) {
8657   return (__a & ~__c) | (__b & __c);
8658 }
8659
8660 static __inline__ vector unsigned int __ATTRS_o_ai
8661 vec_sel(vector unsigned int __a, vector unsigned int __b, vector bool int __c) {
8662   return (__a & ~(vector unsigned int)__c) | (__b & (vector unsigned int)__c);
8663 }
8664
8665 static __inline__ vector bool int __ATTRS_o_ai
8666 vec_sel(vector bool int __a, vector bool int __b, vector unsigned int __c) {
8667   return (__a & ~(vector bool int)__c) | (__b & (vector bool int)__c);
8668 }
8669
8670 static __inline__ vector bool int __ATTRS_o_ai vec_sel(vector bool int __a,
8671                                                        vector bool int __b,
8672                                                        vector bool int __c) {
8673   return (__a & ~__c) | (__b & __c);
8674 }
8675
8676 static __inline__ vector float __ATTRS_o_ai vec_sel(vector float __a,
8677                                                     vector float __b,
8678                                                     vector unsigned int __c) {
8679   vector int __res = ((vector int)__a & ~(vector int)__c) |
8680                      ((vector int)__b & (vector int)__c);
8681   return (vector float)__res;
8682 }
8683
8684 static __inline__ vector float __ATTRS_o_ai vec_sel(vector float __a,
8685                                                     vector float __b,
8686                                                     vector bool int __c) {
8687   vector int __res = ((vector int)__a & ~(vector int)__c) |
8688                      ((vector int)__b & (vector int)__c);
8689   return (vector float)__res;
8690 }
8691
8692 #ifdef __VSX__
8693 static __inline__ vector double __ATTRS_o_ai
8694 vec_sel(vector double __a, vector double __b, vector bool long long __c) {
8695   vector long long __res = ((vector long long)__a & ~(vector long long)__c) |
8696                            ((vector long long)__b & (vector long long)__c);
8697   return (vector double)__res;
8698 }
8699
8700 static __inline__ vector double __ATTRS_o_ai
8701 vec_sel(vector double __a, vector double __b, vector unsigned long long __c) {
8702   vector long long __res = ((vector long long)__a & ~(vector long long)__c) |
8703                            ((vector long long)__b & (vector long long)__c);
8704   return (vector double)__res;
8705 }
8706
8707 static __inline__ vector bool long long __ATTRS_o_ai
8708 vec_sel(vector bool long long __a, vector bool long long __b,
8709         vector bool long long __c) {
8710   return (__a & ~__c) | (__b & __c);
8711 }
8712
8713 static __inline__ vector bool long long __ATTRS_o_ai
8714 vec_sel(vector bool long long __a, vector bool long long __b,
8715         vector unsigned long long __c) {
8716   return (__a & ~(vector bool long long)__c) |
8717          (__b & (vector bool long long)__c);
8718 }
8719
8720 static __inline__ vector signed long long __ATTRS_o_ai
8721 vec_sel(vector signed long long __a, vector signed long long __b,
8722         vector bool long long __c) {
8723   return (__a & ~(vector signed long long)__c) |
8724          (__b & (vector signed long long)__c);
8725 }
8726
8727 static __inline__ vector signed long long __ATTRS_o_ai
8728 vec_sel(vector signed long long __a, vector signed long long __b,
8729         vector unsigned long long __c) {
8730   return (__a & ~(vector signed long long)__c) |
8731          (__b & (vector signed long long)__c);
8732 }
8733
8734 static __inline__ vector unsigned long long __ATTRS_o_ai
8735 vec_sel(vector unsigned long long __a, vector unsigned long long __b,
8736         vector bool long long __c) {
8737   return (__a & ~(vector unsigned long long)__c) |
8738          (__b & (vector unsigned long long)__c);
8739 }
8740
8741 static __inline__ vector unsigned long long __ATTRS_o_ai
8742 vec_sel(vector unsigned long long __a, vector unsigned long long __b,
8743         vector unsigned long long __c) {
8744   return (__a & ~__c) | (__b & __c);
8745 }
8746 #endif
8747
8748 /* vec_vsel */
8749
8750 static __inline__ vector signed char __ATTRS_o_ai vec_vsel(
8751     vector signed char __a, vector signed char __b, vector unsigned char __c) {
8752   return (__a & ~(vector signed char)__c) | (__b & (vector signed char)__c);
8753 }
8754
8755 static __inline__ vector signed char __ATTRS_o_ai
8756 vec_vsel(vector signed char __a, vector signed char __b, vector bool char __c) {
8757   return (__a & ~(vector signed char)__c) | (__b & (vector signed char)__c);
8758 }
8759
8760 static __inline__ vector unsigned char __ATTRS_o_ai
8761 vec_vsel(vector unsigned char __a, vector unsigned char __b,
8762          vector unsigned char __c) {
8763   return (__a & ~__c) | (__b & __c);
8764 }
8765
8766 static __inline__ vector unsigned char __ATTRS_o_ai vec_vsel(
8767     vector unsigned char __a, vector unsigned char __b, vector bool char __c) {
8768   return (__a & ~(vector unsigned char)__c) | (__b & (vector unsigned char)__c);
8769 }
8770
8771 static __inline__ vector bool char __ATTRS_o_ai
8772 vec_vsel(vector bool char __a, vector bool char __b, vector unsigned char __c) {
8773   return (__a & ~(vector bool char)__c) | (__b & (vector bool char)__c);
8774 }
8775
8776 static __inline__ vector bool char __ATTRS_o_ai vec_vsel(vector bool char __a,
8777                                                          vector bool char __b,
8778                                                          vector bool char __c) {
8779   return (__a & ~__c) | (__b & __c);
8780 }
8781
8782 static __inline__ vector short __ATTRS_o_ai
8783 vec_vsel(vector short __a, vector short __b, vector unsigned short __c) {
8784   return (__a & ~(vector short)__c) | (__b & (vector short)__c);
8785 }
8786
8787 static __inline__ vector short __ATTRS_o_ai vec_vsel(vector short __a,
8788                                                      vector short __b,
8789                                                      vector bool short __c) {
8790   return (__a & ~(vector short)__c) | (__b & (vector short)__c);
8791 }
8792
8793 static __inline__ vector unsigned short __ATTRS_o_ai
8794 vec_vsel(vector unsigned short __a, vector unsigned short __b,
8795          vector unsigned short __c) {
8796   return (__a & ~__c) | (__b & __c);
8797 }
8798
8799 static __inline__ vector unsigned short __ATTRS_o_ai
8800 vec_vsel(vector unsigned short __a, vector unsigned short __b,
8801          vector bool short __c) {
8802   return (__a & ~(vector unsigned short)__c) |
8803          (__b & (vector unsigned short)__c);
8804 }
8805
8806 static __inline__ vector bool short __ATTRS_o_ai vec_vsel(
8807     vector bool short __a, vector bool short __b, vector unsigned short __c) {
8808   return (__a & ~(vector bool short)__c) | (__b & (vector bool short)__c);
8809 }
8810
8811 static __inline__ vector bool short __ATTRS_o_ai
8812 vec_vsel(vector bool short __a, vector bool short __b, vector bool short __c) {
8813   return (__a & ~__c) | (__b & __c);
8814 }
8815
8816 static __inline__ vector int __ATTRS_o_ai vec_vsel(vector int __a,
8817                                                    vector int __b,
8818                                                    vector unsigned int __c) {
8819   return (__a & ~(vector int)__c) | (__b & (vector int)__c);
8820 }
8821
8822 static __inline__ vector int __ATTRS_o_ai vec_vsel(vector int __a,
8823                                                    vector int __b,
8824                                                    vector bool int __c) {
8825   return (__a & ~(vector int)__c) | (__b & (vector int)__c);
8826 }
8827
8828 static __inline__ vector unsigned int __ATTRS_o_ai vec_vsel(
8829     vector unsigned int __a, vector unsigned int __b, vector unsigned int __c) {
8830   return (__a & ~__c) | (__b & __c);
8831 }
8832
8833 static __inline__ vector unsigned int __ATTRS_o_ai vec_vsel(
8834     vector unsigned int __a, vector unsigned int __b, vector bool int __c) {
8835   return (__a & ~(vector unsigned int)__c) | (__b & (vector unsigned int)__c);
8836 }
8837
8838 static __inline__ vector bool int __ATTRS_o_ai
8839 vec_vsel(vector bool int __a, vector bool int __b, vector unsigned int __c) {
8840   return (__a & ~(vector bool int)__c) | (__b & (vector bool int)__c);
8841 }
8842
8843 static __inline__ vector bool int __ATTRS_o_ai vec_vsel(vector bool int __a,
8844                                                         vector bool int __b,
8845                                                         vector bool int __c) {
8846   return (__a & ~__c) | (__b & __c);
8847 }
8848
8849 static __inline__ vector float __ATTRS_o_ai vec_vsel(vector float __a,
8850                                                      vector float __b,
8851                                                      vector unsigned int __c) {
8852   vector int __res = ((vector int)__a & ~(vector int)__c) |
8853                      ((vector int)__b & (vector int)__c);
8854   return (vector float)__res;
8855 }
8856
8857 static __inline__ vector float __ATTRS_o_ai vec_vsel(vector float __a,
8858                                                      vector float __b,
8859                                                      vector bool int __c) {
8860   vector int __res = ((vector int)__a & ~(vector int)__c) |
8861                      ((vector int)__b & (vector int)__c);
8862   return (vector float)__res;
8863 }
8864
8865 /* vec_sl */
8866
8867 // vec_sl does modulo arithmetic on __b first, so __b is allowed to be more
8868 // than the length of __a.
8869 static __inline__ vector unsigned char __ATTRS_o_ai
8870 vec_sl(vector unsigned char __a, vector unsigned char __b) {
8871   return __a << (__b %
8872                  (vector unsigned char)(sizeof(unsigned char) * __CHAR_BIT__));
8873 }
8874
8875 static __inline__ vector signed char __ATTRS_o_ai
8876 vec_sl(vector signed char __a, vector unsigned char __b) {
8877   return (vector signed char)vec_sl((vector unsigned char)__a, __b);
8878 }
8879
8880 static __inline__ vector unsigned short __ATTRS_o_ai
8881 vec_sl(vector unsigned short __a, vector unsigned short __b) {
8882   return __a << (__b % (vector unsigned short)(sizeof(unsigned short) *
8883                                                __CHAR_BIT__));
8884 }
8885
8886 static __inline__ vector short __ATTRS_o_ai vec_sl(vector short __a,
8887                                                    vector unsigned short __b) {
8888   return (vector short)vec_sl((vector unsigned short)__a, __b);
8889 }
8890
8891 static __inline__ vector unsigned int __ATTRS_o_ai
8892 vec_sl(vector unsigned int __a, vector unsigned int __b) {
8893   return __a << (__b %
8894                  (vector unsigned int)(sizeof(unsigned int) * __CHAR_BIT__));
8895 }
8896
8897 static __inline__ vector int __ATTRS_o_ai vec_sl(vector int __a,
8898                                                  vector unsigned int __b) {
8899   return (vector int)vec_sl((vector unsigned int)__a, __b);
8900 }
8901
8902 #ifdef __POWER8_VECTOR__
8903 static __inline__ vector unsigned long long __ATTRS_o_ai
8904 vec_sl(vector unsigned long long __a, vector unsigned long long __b) {
8905   return __a << (__b % (vector unsigned long long)(sizeof(unsigned long long) *
8906                                                    __CHAR_BIT__));
8907 }
8908
8909 static __inline__ vector long long __ATTRS_o_ai
8910 vec_sl(vector long long __a, vector unsigned long long __b) {
8911   return (vector long long)vec_sl((vector unsigned long long)__a, __b);
8912 }
8913 #elif defined(__VSX__)
8914 static __inline__ vector unsigned char __ATTRS_o_ai
8915 vec_vspltb(vector unsigned char __a, unsigned char __b);
8916 static __inline__ vector unsigned long long __ATTRS_o_ai
8917 vec_sl(vector unsigned long long __a, vector unsigned long long __b) {
8918   __b %= (vector unsigned long long)(sizeof(unsigned long long) * __CHAR_BIT__);
8919
8920   // Big endian element one (the right doubleword) can be left shifted as-is.
8921   // The other element needs to be swapped into the right doubleword and
8922   // shifted. Then the right doublewords of the two result vectors are merged.
8923   vector signed long long __rightelt =
8924       (vector signed long long)__builtin_altivec_vslo((vector signed int)__a,
8925                                                       (vector signed int)__b);
8926 #ifdef __LITTLE_ENDIAN__
8927   __rightelt = (vector signed long long)__builtin_altivec_vsl(
8928       (vector signed int)__rightelt,
8929       (vector signed int)vec_vspltb((vector unsigned char)__b, 0));
8930 #else
8931   __rightelt = (vector signed long long)__builtin_altivec_vsl(
8932       (vector signed int)__rightelt,
8933       (vector signed int)vec_vspltb((vector unsigned char)__b, 15));
8934 #endif
8935   __a = __builtin_shufflevector(__a, __a, 1, 0);
8936   __b = __builtin_shufflevector(__b, __b, 1, 0);
8937   vector signed long long __leftelt =
8938       (vector signed long long)__builtin_altivec_vslo((vector signed int)__a,
8939                                                       (vector signed int)__b);
8940 #ifdef __LITTLE_ENDIAN__
8941   __leftelt = (vector signed long long)__builtin_altivec_vsl(
8942       (vector signed int)__leftelt,
8943       (vector signed int)vec_vspltb((vector unsigned char)__b, 0));
8944   return (vector unsigned long long)__builtin_shufflevector(__rightelt,
8945                                                             __leftelt, 0, 2);
8946 #else
8947   __leftelt = (vector signed long long)__builtin_altivec_vsl(
8948       (vector signed int)__leftelt,
8949       (vector signed int)vec_vspltb((vector unsigned char)__b, 15));
8950   return (vector unsigned long long)__builtin_shufflevector(__leftelt,
8951                                                             __rightelt, 1, 3);
8952 #endif
8953 }
8954
8955 static __inline__ vector long long __ATTRS_o_ai
8956 vec_sl(vector long long __a, vector unsigned long long __b) {
8957   return (vector long long)vec_sl((vector unsigned long long)__a, __b);
8958 }
8959 #endif /* __VSX__ */
8960
8961 /* vec_vslb */
8962
8963 #define __builtin_altivec_vslb vec_vslb
8964
8965 static __inline__ vector signed char __ATTRS_o_ai
8966 vec_vslb(vector signed char __a, vector unsigned char __b) {
8967   return vec_sl(__a, __b);
8968 }
8969
8970 static __inline__ vector unsigned char __ATTRS_o_ai
8971 vec_vslb(vector unsigned char __a, vector unsigned char __b) {
8972   return vec_sl(__a, __b);
8973 }
8974
8975 /* vec_vslh */
8976
8977 #define __builtin_altivec_vslh vec_vslh
8978
8979 static __inline__ vector short __ATTRS_o_ai
8980 vec_vslh(vector short __a, vector unsigned short __b) {
8981   return vec_sl(__a, __b);
8982 }
8983
8984 static __inline__ vector unsigned short __ATTRS_o_ai
8985 vec_vslh(vector unsigned short __a, vector unsigned short __b) {
8986   return vec_sl(__a, __b);
8987 }
8988
8989 /* vec_vslw */
8990
8991 #define __builtin_altivec_vslw vec_vslw
8992
8993 static __inline__ vector int __ATTRS_o_ai vec_vslw(vector int __a,
8994                                                    vector unsigned int __b) {
8995   return vec_sl(__a, __b);
8996 }
8997
8998 static __inline__ vector unsigned int __ATTRS_o_ai
8999 vec_vslw(vector unsigned int __a, vector unsigned int __b) {
9000   return vec_sl(__a, __b);
9001 }
9002
9003 /* vec_sld */
9004
9005 #define __builtin_altivec_vsldoi_4si vec_sld
9006
9007 static __inline__ vector signed char __ATTRS_o_ai vec_sld(
9008     vector signed char __a, vector signed char __b, unsigned const int __c) {
9009   unsigned char __d = __c & 0x0F;
9010 #ifdef __LITTLE_ENDIAN__
9011   return vec_perm(
9012       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9013                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9014                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9015                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9016 #else
9017   return vec_perm(
9018       __a, __b,
9019       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9020                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9021                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9022 #endif
9023 }
9024
9025 static __inline__ vector unsigned char __ATTRS_o_ai
9026 vec_sld(vector unsigned char __a, vector unsigned char __b,
9027         unsigned const int __c) {
9028   unsigned char __d = __c & 0x0F;
9029 #ifdef __LITTLE_ENDIAN__
9030   return vec_perm(
9031       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9032                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9033                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9034                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9035 #else
9036   return vec_perm(
9037       __a, __b,
9038       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9039                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9040                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9041 #endif
9042 }
9043
9044 static __inline__ vector bool char __ATTRS_o_ai
9045 vec_sld(vector bool char __a, vector bool char __b, unsigned const int __c) {
9046   unsigned char __d = __c & 0x0F;
9047 #ifdef __LITTLE_ENDIAN__
9048   return vec_perm(
9049       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9050                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9051                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9052                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9053 #else
9054   return vec_perm(
9055       __a, __b,
9056       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9057                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9058                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9059 #endif
9060 }
9061
9062 static __inline__ vector signed short __ATTRS_o_ai vec_sld(
9063     vector signed short __a, vector signed short __b, unsigned const int __c) {
9064   unsigned char __d = __c & 0x0F;
9065 #ifdef __LITTLE_ENDIAN__
9066   return vec_perm(
9067       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9068                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9069                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9070                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9071 #else
9072   return vec_perm(
9073       __a, __b,
9074       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9075                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9076                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9077 #endif
9078 }
9079
9080 static __inline__ vector unsigned short __ATTRS_o_ai
9081 vec_sld(vector unsigned short __a, vector unsigned short __b,
9082         unsigned const int __c) {
9083   unsigned char __d = __c & 0x0F;
9084 #ifdef __LITTLE_ENDIAN__
9085   return vec_perm(
9086       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9087                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9088                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9089                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9090 #else
9091   return vec_perm(
9092       __a, __b,
9093       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9094                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9095                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9096 #endif
9097 }
9098
9099 static __inline__ vector bool short __ATTRS_o_ai
9100 vec_sld(vector bool short __a, vector bool short __b, unsigned const int __c) {
9101   unsigned char __d = __c & 0x0F;
9102 #ifdef __LITTLE_ENDIAN__
9103   return vec_perm(
9104       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9105                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9106                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9107                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9108 #else
9109   return vec_perm(
9110       __a, __b,
9111       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9112                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9113                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9114 #endif
9115 }
9116
9117 static __inline__ vector pixel __ATTRS_o_ai vec_sld(vector pixel __a,
9118                                                     vector pixel __b,
9119                                                     unsigned const int __c) {
9120   unsigned char __d = __c & 0x0F;
9121 #ifdef __LITTLE_ENDIAN__
9122   return vec_perm(
9123       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9124                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9125                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9126                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9127 #else
9128   return vec_perm(
9129       __a, __b,
9130       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9131                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9132                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9133 #endif
9134 }
9135
9136 static __inline__ vector signed int __ATTRS_o_ai
9137 vec_sld(vector signed int __a, vector signed int __b, unsigned const int __c) {
9138   unsigned char __d = __c & 0x0F;
9139 #ifdef __LITTLE_ENDIAN__
9140   return vec_perm(
9141       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9142                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9143                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9144                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9145 #else
9146   return vec_perm(
9147       __a, __b,
9148       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9149                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9150                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9151 #endif
9152 }
9153
9154 static __inline__ vector unsigned int __ATTRS_o_ai vec_sld(
9155     vector unsigned int __a, vector unsigned int __b, unsigned const int __c) {
9156   unsigned char __d = __c & 0x0F;
9157 #ifdef __LITTLE_ENDIAN__
9158   return vec_perm(
9159       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9160                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9161                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9162                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9163 #else
9164   return vec_perm(
9165       __a, __b,
9166       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9167                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9168                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9169 #endif
9170 }
9171
9172 static __inline__ vector bool int __ATTRS_o_ai vec_sld(vector bool int __a,
9173                                                        vector bool int __b,
9174                                                        unsigned const int __c) {
9175   unsigned char __d = __c & 0x0F;
9176 #ifdef __LITTLE_ENDIAN__
9177   return vec_perm(
9178       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9179                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9180                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9181                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9182 #else
9183   return vec_perm(
9184       __a, __b,
9185       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9186                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9187                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9188 #endif
9189 }
9190
9191 static __inline__ vector float __ATTRS_o_ai vec_sld(vector float __a,
9192                                                     vector float __b,
9193                                                     unsigned const int __c) {
9194   unsigned char __d = __c & 0x0F;
9195 #ifdef __LITTLE_ENDIAN__
9196   return vec_perm(
9197       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9198                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9199                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9200                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9201 #else
9202   return vec_perm(
9203       __a, __b,
9204       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9205                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9206                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9207 #endif
9208 }
9209
9210 #ifdef __VSX__
9211 static __inline__ vector bool long long __ATTRS_o_ai
9212 vec_sld(vector bool long long __a, vector bool long long __b,
9213         unsigned const int __c) {
9214   unsigned char __d = __c & 0x0F;
9215 #ifdef __LITTLE_ENDIAN__
9216   return vec_perm(
9217       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9218                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9219                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9220                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9221 #else
9222   return vec_perm(
9223       __a, __b,
9224       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9225                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9226                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9227 #endif
9228 }
9229
9230 static __inline__ vector signed long long __ATTRS_o_ai
9231 vec_sld(vector signed long long __a, vector signed long long __b,
9232         unsigned const int __c) {
9233   unsigned char __d = __c & 0x0F;
9234 #ifdef __LITTLE_ENDIAN__
9235   return vec_perm(
9236       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9237                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9238                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9239                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9240 #else
9241   return vec_perm(
9242       __a, __b,
9243       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9244                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9245                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9246 #endif
9247 }
9248
9249 static __inline__ vector unsigned long long __ATTRS_o_ai
9250 vec_sld(vector unsigned long long __a, vector unsigned long long __b,
9251         unsigned const int __c) {
9252   unsigned char __d = __c & 0x0F;
9253 #ifdef __LITTLE_ENDIAN__
9254   return vec_perm(
9255       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9256                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9257                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9258                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9259 #else
9260   return vec_perm(
9261       __a, __b,
9262       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9263                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9264                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9265 #endif
9266 }
9267
9268 static __inline__ vector double __ATTRS_o_ai vec_sld(vector double __a,
9269                                                      vector double __b,
9270                                                      unsigned const int __c) {
9271   unsigned char __d = __c & 0x0F;
9272 #ifdef __LITTLE_ENDIAN__
9273   return vec_perm(
9274       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9275                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9276                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9277                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9278 #else
9279   return vec_perm(
9280       __a, __b,
9281       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9282                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9283                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9284 #endif
9285 }
9286 #endif
9287
9288 /* vec_sldw */
9289 static __inline__ vector signed char __ATTRS_o_ai vec_sldw(
9290     vector signed char __a, vector signed char __b, unsigned const int __c) {
9291   return vec_sld(__a, __b, ((__c << 2) & 0x0F));
9292 }
9293
9294 static __inline__ vector unsigned char __ATTRS_o_ai
9295 vec_sldw(vector unsigned char __a, vector unsigned char __b,
9296          unsigned const int __c) {
9297   return vec_sld(__a, __b, ((__c << 2) & 0x0F));
9298 }
9299
9300 static __inline__ vector signed short __ATTRS_o_ai vec_sldw(
9301     vector signed short __a, vector signed short __b, unsigned const int __c) {
9302   return vec_sld(__a, __b, ((__c << 2) & 0x0F));
9303 }
9304
9305 static __inline__ vector unsigned short __ATTRS_o_ai
9306 vec_sldw(vector unsigned short __a, vector unsigned short __b,
9307          unsigned const int __c) {
9308   return vec_sld(__a, __b, ((__c << 2) & 0x0F));
9309 }
9310
9311 static __inline__ vector signed int __ATTRS_o_ai
9312 vec_sldw(vector signed int __a, vector signed int __b, unsigned const int __c) {
9313   return vec_sld(__a, __b, ((__c << 2) & 0x0F));
9314 }
9315
9316 static __inline__ vector unsigned int __ATTRS_o_ai vec_sldw(
9317     vector unsigned int __a, vector unsigned int __b, unsigned const int __c) {
9318   return vec_sld(__a, __b, ((__c << 2) & 0x0F));
9319 }
9320
9321 static __inline__ vector float __ATTRS_o_ai vec_sldw(
9322     vector float __a, vector float __b, unsigned const int __c) {
9323   return vec_sld(__a, __b, ((__c << 2) & 0x0F));
9324 }
9325
9326 #ifdef __VSX__
9327 static __inline__ vector signed long long __ATTRS_o_ai
9328 vec_sldw(vector signed long long __a, vector signed long long __b,
9329          unsigned const int __c) {
9330   return vec_sld(__a, __b, ((__c << 2) & 0x0F));
9331 }
9332
9333 static __inline__ vector unsigned long long __ATTRS_o_ai
9334 vec_sldw(vector unsigned long long __a, vector unsigned long long __b,
9335          unsigned const int __c) {
9336   return vec_sld(__a, __b, ((__c << 2) & 0x0F));
9337 }
9338
9339 static __inline__ vector double __ATTRS_o_ai vec_sldw(
9340     vector double __a, vector double __b, unsigned const int __c) {
9341   return vec_sld(__a, __b, ((__c << 2) & 0x0F));
9342 }
9343 #endif
9344
9345 #ifdef __POWER9_VECTOR__
9346 /* vec_slv */
9347 static __inline__ vector unsigned char __ATTRS_o_ai
9348 vec_slv(vector unsigned char __a, vector unsigned char __b) {
9349   return __builtin_altivec_vslv(__a, __b);
9350 }
9351
9352 /* vec_srv */
9353 static __inline__ vector unsigned char __ATTRS_o_ai
9354 vec_srv(vector unsigned char __a, vector unsigned char __b) {
9355   return __builtin_altivec_vsrv(__a, __b);
9356 }
9357 #endif
9358
9359 /* vec_vsldoi */
9360
9361 static __inline__ vector signed char __ATTRS_o_ai
9362 vec_vsldoi(vector signed char __a, vector signed char __b, unsigned char __c) {
9363   unsigned char __d = __c & 0x0F;
9364 #ifdef __LITTLE_ENDIAN__
9365   return vec_perm(
9366       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9367                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9368                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9369                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9370 #else
9371   return vec_perm(
9372       __a, __b,
9373       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9374                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9375                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9376 #endif
9377 }
9378
9379 static __inline__ vector unsigned char __ATTRS_o_ai vec_vsldoi(
9380     vector unsigned char __a, vector unsigned char __b, unsigned char __c) {
9381   unsigned char __d = __c & 0x0F;
9382 #ifdef __LITTLE_ENDIAN__
9383   return vec_perm(
9384       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9385                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9386                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9387                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9388 #else
9389   return vec_perm(
9390       __a, __b,
9391       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9392                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9393                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9394 #endif
9395 }
9396
9397 static __inline__ vector short __ATTRS_o_ai vec_vsldoi(vector short __a,
9398                                                        vector short __b,
9399                                                        unsigned char __c) {
9400   unsigned char __d = __c & 0x0F;
9401 #ifdef __LITTLE_ENDIAN__
9402   return vec_perm(
9403       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9404                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9405                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9406                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9407 #else
9408   return vec_perm(
9409       __a, __b,
9410       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9411                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9412                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9413 #endif
9414 }
9415
9416 static __inline__ vector unsigned short __ATTRS_o_ai vec_vsldoi(
9417     vector unsigned short __a, vector unsigned short __b, unsigned char __c) {
9418   unsigned char __d = __c & 0x0F;
9419 #ifdef __LITTLE_ENDIAN__
9420   return vec_perm(
9421       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9422                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9423                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9424                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9425 #else
9426   return vec_perm(
9427       __a, __b,
9428       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9429                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9430                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9431 #endif
9432 }
9433
9434 static __inline__ vector pixel __ATTRS_o_ai vec_vsldoi(vector pixel __a,
9435                                                        vector pixel __b,
9436                                                        unsigned char __c) {
9437   unsigned char __d = __c & 0x0F;
9438 #ifdef __LITTLE_ENDIAN__
9439   return vec_perm(
9440       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9441                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9442                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9443                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9444 #else
9445   return vec_perm(
9446       __a, __b,
9447       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9448                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9449                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9450 #endif
9451 }
9452
9453 static __inline__ vector int __ATTRS_o_ai vec_vsldoi(vector int __a,
9454                                                      vector int __b,
9455                                                      unsigned char __c) {
9456   unsigned char __d = __c & 0x0F;
9457 #ifdef __LITTLE_ENDIAN__
9458   return vec_perm(
9459       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9460                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9461                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9462                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9463 #else
9464   return vec_perm(
9465       __a, __b,
9466       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9467                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9468                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9469 #endif
9470 }
9471
9472 static __inline__ vector unsigned int __ATTRS_o_ai vec_vsldoi(
9473     vector unsigned int __a, vector unsigned int __b, unsigned char __c) {
9474   unsigned char __d = __c & 0x0F;
9475 #ifdef __LITTLE_ENDIAN__
9476   return vec_perm(
9477       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9478                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9479                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9480                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9481 #else
9482   return vec_perm(
9483       __a, __b,
9484       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9485                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9486                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9487 #endif
9488 }
9489
9490 static __inline__ vector float __ATTRS_o_ai vec_vsldoi(vector float __a,
9491                                                        vector float __b,
9492                                                        unsigned char __c) {
9493   unsigned char __d = __c & 0x0F;
9494 #ifdef __LITTLE_ENDIAN__
9495   return vec_perm(
9496       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
9497                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
9498                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
9499                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
9500 #else
9501   return vec_perm(
9502       __a, __b,
9503       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
9504                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
9505                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
9506 #endif
9507 }
9508
9509 /* vec_sll */
9510
9511 static __inline__ vector signed char __ATTRS_o_ai
9512 vec_sll(vector signed char __a, vector unsigned char __b) {
9513   return (vector signed char)__builtin_altivec_vsl((vector int)__a,
9514                                                    (vector int)__b);
9515 }
9516
9517 static __inline__ vector signed char __ATTRS_o_ai
9518 vec_sll(vector signed char __a, vector unsigned short __b) {
9519   return (vector signed char)__builtin_altivec_vsl((vector int)__a,
9520                                                    (vector int)__b);
9521 }
9522
9523 static __inline__ vector signed char __ATTRS_o_ai
9524 vec_sll(vector signed char __a, vector unsigned int __b) {
9525   return (vector signed char)__builtin_altivec_vsl((vector int)__a,
9526                                                    (vector int)__b);
9527 }
9528
9529 static __inline__ vector unsigned char __ATTRS_o_ai
9530 vec_sll(vector unsigned char __a, vector unsigned char __b) {
9531   return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
9532                                                      (vector int)__b);
9533 }
9534
9535 static __inline__ vector unsigned char __ATTRS_o_ai
9536 vec_sll(vector unsigned char __a, vector unsigned short __b) {
9537   return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
9538                                                      (vector int)__b);
9539 }
9540
9541 static __inline__ vector unsigned char __ATTRS_o_ai
9542 vec_sll(vector unsigned char __a, vector unsigned int __b) {
9543   return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
9544                                                      (vector int)__b);
9545 }
9546
9547 static __inline__ vector bool char __ATTRS_o_ai
9548 vec_sll(vector bool char __a, vector unsigned char __b) {
9549   return (vector bool char)__builtin_altivec_vsl((vector int)__a,
9550                                                  (vector int)__b);
9551 }
9552
9553 static __inline__ vector bool char __ATTRS_o_ai
9554 vec_sll(vector bool char __a, vector unsigned short __b) {
9555   return (vector bool char)__builtin_altivec_vsl((vector int)__a,
9556                                                  (vector int)__b);
9557 }
9558
9559 static __inline__ vector bool char __ATTRS_o_ai
9560 vec_sll(vector bool char __a, vector unsigned int __b) {
9561   return (vector bool char)__builtin_altivec_vsl((vector int)__a,
9562                                                  (vector int)__b);
9563 }
9564
9565 static __inline__ vector short __ATTRS_o_ai vec_sll(vector short __a,
9566                                                     vector unsigned char __b) {
9567   return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
9568 }
9569
9570 static __inline__ vector short __ATTRS_o_ai vec_sll(vector short __a,
9571                                                     vector unsigned short __b) {
9572   return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
9573 }
9574
9575 static __inline__ vector short __ATTRS_o_ai vec_sll(vector short __a,
9576                                                     vector unsigned int __b) {
9577   return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
9578 }
9579
9580 static __inline__ vector unsigned short __ATTRS_o_ai
9581 vec_sll(vector unsigned short __a, vector unsigned char __b) {
9582   return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
9583                                                       (vector int)__b);
9584 }
9585
9586 static __inline__ vector unsigned short __ATTRS_o_ai
9587 vec_sll(vector unsigned short __a, vector unsigned short __b) {
9588   return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
9589                                                       (vector int)__b);
9590 }
9591
9592 static __inline__ vector unsigned short __ATTRS_o_ai
9593 vec_sll(vector unsigned short __a, vector unsigned int __b) {
9594   return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
9595                                                       (vector int)__b);
9596 }
9597
9598 static __inline__ vector bool short __ATTRS_o_ai
9599 vec_sll(vector bool short __a, vector unsigned char __b) {
9600   return (vector bool short)__builtin_altivec_vsl((vector int)__a,
9601                                                   (vector int)__b);
9602 }
9603
9604 static __inline__ vector bool short __ATTRS_o_ai
9605 vec_sll(vector bool short __a, vector unsigned short __b) {
9606   return (vector bool short)__builtin_altivec_vsl((vector int)__a,
9607                                                   (vector int)__b);
9608 }
9609
9610 static __inline__ vector bool short __ATTRS_o_ai
9611 vec_sll(vector bool short __a, vector unsigned int __b) {
9612   return (vector bool short)__builtin_altivec_vsl((vector int)__a,
9613                                                   (vector int)__b);
9614 }
9615
9616 static __inline__ vector pixel __ATTRS_o_ai vec_sll(vector pixel __a,
9617                                                     vector unsigned char __b) {
9618   return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
9619 }
9620
9621 static __inline__ vector pixel __ATTRS_o_ai vec_sll(vector pixel __a,
9622                                                     vector unsigned short __b) {
9623   return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
9624 }
9625
9626 static __inline__ vector pixel __ATTRS_o_ai vec_sll(vector pixel __a,
9627                                                     vector unsigned int __b) {
9628   return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
9629 }
9630
9631 static __inline__ vector int __ATTRS_o_ai vec_sll(vector int __a,
9632                                                   vector unsigned char __b) {
9633   return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
9634 }
9635
9636 static __inline__ vector int __ATTRS_o_ai vec_sll(vector int __a,
9637                                                   vector unsigned short __b) {
9638   return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
9639 }
9640
9641 static __inline__ vector int __ATTRS_o_ai vec_sll(vector int __a,
9642                                                   vector unsigned int __b) {
9643   return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
9644 }
9645
9646 static __inline__ vector unsigned int __ATTRS_o_ai
9647 vec_sll(vector unsigned int __a, vector unsigned char __b) {
9648   return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
9649                                                     (vector int)__b);
9650 }
9651
9652 static __inline__ vector unsigned int __ATTRS_o_ai
9653 vec_sll(vector unsigned int __a, vector unsigned short __b) {
9654   return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
9655                                                     (vector int)__b);
9656 }
9657
9658 static __inline__ vector unsigned int __ATTRS_o_ai
9659 vec_sll(vector unsigned int __a, vector unsigned int __b) {
9660   return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
9661                                                     (vector int)__b);
9662 }
9663
9664 static __inline__ vector bool int __ATTRS_o_ai
9665 vec_sll(vector bool int __a, vector unsigned char __b) {
9666   return (vector bool int)__builtin_altivec_vsl((vector int)__a,
9667                                                 (vector int)__b);
9668 }
9669
9670 static __inline__ vector bool int __ATTRS_o_ai
9671 vec_sll(vector bool int __a, vector unsigned short __b) {
9672   return (vector bool int)__builtin_altivec_vsl((vector int)__a,
9673                                                 (vector int)__b);
9674 }
9675
9676 static __inline__ vector bool int __ATTRS_o_ai
9677 vec_sll(vector bool int __a, vector unsigned int __b) {
9678   return (vector bool int)__builtin_altivec_vsl((vector int)__a,
9679                                                 (vector int)__b);
9680 }
9681
9682 #ifdef __VSX__
9683 static __inline__ vector signed long long __ATTRS_o_ai
9684 vec_sll(vector signed long long __a, vector unsigned char __b) {
9685   return (vector signed long long)__builtin_altivec_vsl((vector int)__a,
9686                                                         (vector int)__b);
9687 }
9688
9689 static __inline__ vector unsigned long long __ATTRS_o_ai
9690 vec_sll(vector unsigned long long __a, vector unsigned char __b) {
9691   return (vector unsigned long long)__builtin_altivec_vsl((vector int)__a,
9692                                                           (vector int)__b);
9693 }
9694 #endif
9695
9696 /* vec_vsl */
9697
9698 static __inline__ vector signed char __ATTRS_o_ai
9699 vec_vsl(vector signed char __a, vector unsigned char __b) {
9700   return (vector signed char)__builtin_altivec_vsl((vector int)__a,
9701                                                    (vector int)__b);
9702 }
9703
9704 static __inline__ vector signed char __ATTRS_o_ai
9705 vec_vsl(vector signed char __a, vector unsigned short __b) {
9706   return (vector signed char)__builtin_altivec_vsl((vector int)__a,
9707                                                    (vector int)__b);
9708 }
9709
9710 static __inline__ vector signed char __ATTRS_o_ai
9711 vec_vsl(vector signed char __a, vector unsigned int __b) {
9712   return (vector signed char)__builtin_altivec_vsl((vector int)__a,
9713                                                    (vector int)__b);
9714 }
9715
9716 static __inline__ vector unsigned char __ATTRS_o_ai
9717 vec_vsl(vector unsigned char __a, vector unsigned char __b) {
9718   return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
9719                                                      (vector int)__b);
9720 }
9721
9722 static __inline__ vector unsigned char __ATTRS_o_ai
9723 vec_vsl(vector unsigned char __a, vector unsigned short __b) {
9724   return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
9725                                                      (vector int)__b);
9726 }
9727
9728 static __inline__ vector unsigned char __ATTRS_o_ai
9729 vec_vsl(vector unsigned char __a, vector unsigned int __b) {
9730   return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
9731                                                      (vector int)__b);
9732 }
9733
9734 static __inline__ vector bool char __ATTRS_o_ai
9735 vec_vsl(vector bool char __a, vector unsigned char __b) {
9736   return (vector bool char)__builtin_altivec_vsl((vector int)__a,
9737                                                  (vector int)__b);
9738 }
9739
9740 static __inline__ vector bool char __ATTRS_o_ai
9741 vec_vsl(vector bool char __a, vector unsigned short __b) {
9742   return (vector bool char)__builtin_altivec_vsl((vector int)__a,
9743                                                  (vector int)__b);
9744 }
9745
9746 static __inline__ vector bool char __ATTRS_o_ai
9747 vec_vsl(vector bool char __a, vector unsigned int __b) {
9748   return (vector bool char)__builtin_altivec_vsl((vector int)__a,
9749                                                  (vector int)__b);
9750 }
9751
9752 static __inline__ vector short __ATTRS_o_ai vec_vsl(vector short __a,
9753                                                     vector unsigned char __b) {
9754   return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
9755 }
9756
9757 static __inline__ vector short __ATTRS_o_ai vec_vsl(vector short __a,
9758                                                     vector unsigned short __b) {
9759   return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
9760 }
9761
9762 static __inline__ vector short __ATTRS_o_ai vec_vsl(vector short __a,
9763                                                     vector unsigned int __b) {
9764   return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
9765 }
9766
9767 static __inline__ vector unsigned short __ATTRS_o_ai
9768 vec_vsl(vector unsigned short __a, vector unsigned char __b) {
9769   return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
9770                                                       (vector int)__b);
9771 }
9772
9773 static __inline__ vector unsigned short __ATTRS_o_ai
9774 vec_vsl(vector unsigned short __a, vector unsigned short __b) {
9775   return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
9776                                                       (vector int)__b);
9777 }
9778
9779 static __inline__ vector unsigned short __ATTRS_o_ai
9780 vec_vsl(vector unsigned short __a, vector unsigned int __b) {
9781   return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
9782                                                       (vector int)__b);
9783 }
9784
9785 static __inline__ vector bool short __ATTRS_o_ai
9786 vec_vsl(vector bool short __a, vector unsigned char __b) {
9787   return (vector bool short)__builtin_altivec_vsl((vector int)__a,
9788                                                   (vector int)__b);
9789 }
9790
9791 static __inline__ vector bool short __ATTRS_o_ai
9792 vec_vsl(vector bool short __a, vector unsigned short __b) {
9793   return (vector bool short)__builtin_altivec_vsl((vector int)__a,
9794                                                   (vector int)__b);
9795 }
9796
9797 static __inline__ vector bool short __ATTRS_o_ai
9798 vec_vsl(vector bool short __a, vector unsigned int __b) {
9799   return (vector bool short)__builtin_altivec_vsl((vector int)__a,
9800                                                   (vector int)__b);
9801 }
9802
9803 static __inline__ vector pixel __ATTRS_o_ai vec_vsl(vector pixel __a,
9804                                                     vector unsigned char __b) {
9805   return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
9806 }
9807
9808 static __inline__ vector pixel __ATTRS_o_ai vec_vsl(vector pixel __a,
9809                                                     vector unsigned short __b) {
9810   return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
9811 }
9812
9813 static __inline__ vector pixel __ATTRS_o_ai vec_vsl(vector pixel __a,
9814                                                     vector unsigned int __b) {
9815   return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
9816 }
9817
9818 static __inline__ vector int __ATTRS_o_ai vec_vsl(vector int __a,
9819                                                   vector unsigned char __b) {
9820   return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
9821 }
9822
9823 static __inline__ vector int __ATTRS_o_ai vec_vsl(vector int __a,
9824                                                   vector unsigned short __b) {
9825   return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
9826 }
9827
9828 static __inline__ vector int __ATTRS_o_ai vec_vsl(vector int __a,
9829                                                   vector unsigned int __b) {
9830   return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
9831 }
9832
9833 static __inline__ vector unsigned int __ATTRS_o_ai
9834 vec_vsl(vector unsigned int __a, vector unsigned char __b) {
9835   return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
9836                                                     (vector int)__b);
9837 }
9838
9839 static __inline__ vector unsigned int __ATTRS_o_ai
9840 vec_vsl(vector unsigned int __a, vector unsigned short __b) {
9841   return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
9842                                                     (vector int)__b);
9843 }
9844
9845 static __inline__ vector unsigned int __ATTRS_o_ai
9846 vec_vsl(vector unsigned int __a, vector unsigned int __b) {
9847   return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
9848                                                     (vector int)__b);
9849 }
9850
9851 static __inline__ vector bool int __ATTRS_o_ai
9852 vec_vsl(vector bool int __a, vector unsigned char __b) {
9853   return (vector bool int)__builtin_altivec_vsl((vector int)__a,
9854                                                 (vector int)__b);
9855 }
9856
9857 static __inline__ vector bool int __ATTRS_o_ai
9858 vec_vsl(vector bool int __a, vector unsigned short __b) {
9859   return (vector bool int)__builtin_altivec_vsl((vector int)__a,
9860                                                 (vector int)__b);
9861 }
9862
9863 static __inline__ vector bool int __ATTRS_o_ai
9864 vec_vsl(vector bool int __a, vector unsigned int __b) {
9865   return (vector bool int)__builtin_altivec_vsl((vector int)__a,
9866                                                 (vector int)__b);
9867 }
9868
9869 /* vec_slo */
9870
9871 static __inline__ vector signed char __ATTRS_o_ai
9872 vec_slo(vector signed char __a, vector signed char __b) {
9873   return (vector signed char)__builtin_altivec_vslo((vector int)__a,
9874                                                     (vector int)__b);
9875 }
9876
9877 static __inline__ vector signed char __ATTRS_o_ai
9878 vec_slo(vector signed char __a, vector unsigned char __b) {
9879   return (vector signed char)__builtin_altivec_vslo((vector int)__a,
9880                                                     (vector int)__b);
9881 }
9882
9883 static __inline__ vector unsigned char __ATTRS_o_ai
9884 vec_slo(vector unsigned char __a, vector signed char __b) {
9885   return (vector unsigned char)__builtin_altivec_vslo((vector int)__a,
9886                                                       (vector int)__b);
9887 }
9888
9889 static __inline__ vector unsigned char __ATTRS_o_ai
9890 vec_slo(vector unsigned char __a, vector unsigned char __b) {
9891   return (vector unsigned char)__builtin_altivec_vslo((vector int)__a,
9892                                                       (vector int)__b);
9893 }
9894
9895 static __inline__ vector short __ATTRS_o_ai vec_slo(vector short __a,
9896                                                     vector signed char __b) {
9897   return (vector short)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9898 }
9899
9900 static __inline__ vector short __ATTRS_o_ai vec_slo(vector short __a,
9901                                                     vector unsigned char __b) {
9902   return (vector short)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9903 }
9904
9905 static __inline__ vector unsigned short __ATTRS_o_ai
9906 vec_slo(vector unsigned short __a, vector signed char __b) {
9907   return (vector unsigned short)__builtin_altivec_vslo((vector int)__a,
9908                                                        (vector int)__b);
9909 }
9910
9911 static __inline__ vector unsigned short __ATTRS_o_ai
9912 vec_slo(vector unsigned short __a, vector unsigned char __b) {
9913   return (vector unsigned short)__builtin_altivec_vslo((vector int)__a,
9914                                                        (vector int)__b);
9915 }
9916
9917 static __inline__ vector pixel __ATTRS_o_ai vec_slo(vector pixel __a,
9918                                                     vector signed char __b) {
9919   return (vector pixel)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9920 }
9921
9922 static __inline__ vector pixel __ATTRS_o_ai vec_slo(vector pixel __a,
9923                                                     vector unsigned char __b) {
9924   return (vector pixel)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9925 }
9926
9927 static __inline__ vector int __ATTRS_o_ai vec_slo(vector int __a,
9928                                                   vector signed char __b) {
9929   return (vector int)__builtin_altivec_vslo(__a, (vector int)__b);
9930 }
9931
9932 static __inline__ vector int __ATTRS_o_ai vec_slo(vector int __a,
9933                                                   vector unsigned char __b) {
9934   return (vector int)__builtin_altivec_vslo(__a, (vector int)__b);
9935 }
9936
9937 static __inline__ vector unsigned int __ATTRS_o_ai
9938 vec_slo(vector unsigned int __a, vector signed char __b) {
9939   return (vector unsigned int)__builtin_altivec_vslo((vector int)__a,
9940                                                      (vector int)__b);
9941 }
9942
9943 static __inline__ vector unsigned int __ATTRS_o_ai
9944 vec_slo(vector unsigned int __a, vector unsigned char __b) {
9945   return (vector unsigned int)__builtin_altivec_vslo((vector int)__a,
9946                                                      (vector int)__b);
9947 }
9948
9949 static __inline__ vector float __ATTRS_o_ai vec_slo(vector float __a,
9950                                                     vector signed char __b) {
9951   return (vector float)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9952 }
9953
9954 static __inline__ vector float __ATTRS_o_ai vec_slo(vector float __a,
9955                                                     vector unsigned char __b) {
9956   return (vector float)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9957 }
9958
9959 #ifdef __VSX__
9960 static __inline__ vector signed long long __ATTRS_o_ai
9961 vec_slo(vector signed long long __a, vector signed char __b) {
9962   return (vector signed long long)__builtin_altivec_vslo((vector int)__a,
9963                                                          (vector int)__b);
9964 }
9965
9966 static __inline__ vector signed long long __ATTRS_o_ai
9967 vec_slo(vector signed long long __a, vector unsigned char __b) {
9968   return (vector signed long long)__builtin_altivec_vslo((vector int)__a,
9969                                                          (vector int)__b);
9970 }
9971
9972 static __inline__ vector unsigned long long __ATTRS_o_ai
9973 vec_slo(vector unsigned long long __a, vector signed char __b) {
9974   return (vector unsigned long long)__builtin_altivec_vslo((vector int)__a,
9975                                                            (vector int)__b);
9976 }
9977
9978 static __inline__ vector unsigned long long __ATTRS_o_ai
9979 vec_slo(vector unsigned long long __a, vector unsigned char __b) {
9980   return (vector unsigned long long)__builtin_altivec_vslo((vector int)__a,
9981                                                            (vector int)__b);
9982 }
9983 #endif
9984
9985 /* vec_vslo */
9986
9987 static __inline__ vector signed char __ATTRS_o_ai
9988 vec_vslo(vector signed char __a, vector signed char __b) {
9989   return (vector signed char)__builtin_altivec_vslo((vector int)__a,
9990                                                     (vector int)__b);
9991 }
9992
9993 static __inline__ vector signed char __ATTRS_o_ai
9994 vec_vslo(vector signed char __a, vector unsigned char __b) {
9995   return (vector signed char)__builtin_altivec_vslo((vector int)__a,
9996                                                     (vector int)__b);
9997 }
9998
9999 static __inline__ vector unsigned char __ATTRS_o_ai
10000 vec_vslo(vector unsigned char __a, vector signed char __b) {
10001   return (vector unsigned char)__builtin_altivec_vslo((vector int)__a,
10002                                                       (vector int)__b);
10003 }
10004
10005 static __inline__ vector unsigned char __ATTRS_o_ai
10006 vec_vslo(vector unsigned char __a, vector unsigned char __b) {
10007   return (vector unsigned char)__builtin_altivec_vslo((vector int)__a,
10008                                                       (vector int)__b);
10009 }
10010
10011 static __inline__ vector short __ATTRS_o_ai vec_vslo(vector short __a,
10012                                                      vector signed char __b) {
10013   return (vector short)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
10014 }
10015
10016 static __inline__ vector short __ATTRS_o_ai vec_vslo(vector short __a,
10017                                                      vector unsigned char __b) {
10018   return (vector short)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
10019 }
10020
10021 static __inline__ vector unsigned short __ATTRS_o_ai
10022 vec_vslo(vector unsigned short __a, vector signed char __b) {
10023   return (vector unsigned short)__builtin_altivec_vslo((vector int)__a,
10024                                                        (vector int)__b);
10025 }
10026
10027 static __inline__ vector unsigned short __ATTRS_o_ai
10028 vec_vslo(vector unsigned short __a, vector unsigned char __b) {
10029   return (vector unsigned short)__builtin_altivec_vslo((vector int)__a,
10030                                                        (vector int)__b);
10031 }
10032
10033 static __inline__ vector pixel __ATTRS_o_ai vec_vslo(vector pixel __a,
10034                                                      vector signed char __b) {
10035   return (vector pixel)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
10036 }
10037
10038 static __inline__ vector pixel __ATTRS_o_ai vec_vslo(vector pixel __a,
10039                                                      vector unsigned char __b) {
10040   return (vector pixel)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
10041 }
10042
10043 static __inline__ vector int __ATTRS_o_ai vec_vslo(vector int __a,
10044                                                    vector signed char __b) {
10045   return (vector int)__builtin_altivec_vslo(__a, (vector int)__b);
10046 }
10047
10048 static __inline__ vector int __ATTRS_o_ai vec_vslo(vector int __a,
10049                                                    vector unsigned char __b) {
10050   return (vector int)__builtin_altivec_vslo(__a, (vector int)__b);
10051 }
10052
10053 static __inline__ vector unsigned int __ATTRS_o_ai
10054 vec_vslo(vector unsigned int __a, vector signed char __b) {
10055   return (vector unsigned int)__builtin_altivec_vslo((vector int)__a,
10056                                                      (vector int)__b);
10057 }
10058
10059 static __inline__ vector unsigned int __ATTRS_o_ai
10060 vec_vslo(vector unsigned int __a, vector unsigned char __b) {
10061   return (vector unsigned int)__builtin_altivec_vslo((vector int)__a,
10062                                                      (vector int)__b);
10063 }
10064
10065 static __inline__ vector float __ATTRS_o_ai vec_vslo(vector float __a,
10066                                                      vector signed char __b) {
10067   return (vector float)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
10068 }
10069
10070 static __inline__ vector float __ATTRS_o_ai vec_vslo(vector float __a,
10071                                                      vector unsigned char __b) {
10072   return (vector float)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
10073 }
10074
10075 /* vec_splat */
10076
10077 static __inline__ vector signed char __ATTRS_o_ai
10078 vec_splat(vector signed char __a, unsigned const int __b) {
10079   return vec_perm(__a, __a, (vector unsigned char)(__b & 0x0F));
10080 }
10081
10082 static __inline__ vector unsigned char __ATTRS_o_ai
10083 vec_splat(vector unsigned char __a, unsigned const int __b) {
10084   return vec_perm(__a, __a, (vector unsigned char)(__b & 0x0F));
10085 }
10086
10087 static __inline__ vector bool char __ATTRS_o_ai
10088 vec_splat(vector bool char __a, unsigned const int __b) {
10089   return vec_perm(__a, __a, (vector unsigned char)(__b & 0x0F));
10090 }
10091
10092 static __inline__ vector signed short __ATTRS_o_ai
10093 vec_splat(vector signed short __a, unsigned const int __b) {
10094   unsigned char b0 = (__b & 0x07) * 2;
10095   unsigned char b1 = b0 + 1;
10096   return vec_perm(__a, __a,
10097                   (vector unsigned char)(b0, b1, b0, b1, b0, b1, b0, b1, b0, b1,
10098                                          b0, b1, b0, b1, b0, b1));
10099 }
10100
10101 static __inline__ vector unsigned short __ATTRS_o_ai
10102 vec_splat(vector unsigned short __a, unsigned const int __b) {
10103   unsigned char b0 = (__b & 0x07) * 2;
10104   unsigned char b1 = b0 + 1;
10105   return vec_perm(__a, __a,
10106                   (vector unsigned char)(b0, b1, b0, b1, b0, b1, b0, b1, b0, b1,
10107                                          b0, b1, b0, b1, b0, b1));
10108 }
10109
10110 static __inline__ vector bool short __ATTRS_o_ai
10111 vec_splat(vector bool short __a, unsigned const int __b) {
10112   unsigned char b0 = (__b & 0x07) * 2;
10113   unsigned char b1 = b0 + 1;
10114   return vec_perm(__a, __a,
10115                   (vector unsigned char)(b0, b1, b0, b1, b0, b1, b0, b1, b0, b1,
10116                                          b0, b1, b0, b1, b0, b1));
10117 }
10118
10119 static __inline__ vector pixel __ATTRS_o_ai vec_splat(vector pixel __a,
10120                                                       unsigned const int __b) {
10121   unsigned char b0 = (__b & 0x07) * 2;
10122   unsigned char b1 = b0 + 1;
10123   return vec_perm(__a, __a,
10124                   (vector unsigned char)(b0, b1, b0, b1, b0, b1, b0, b1, b0, b1,
10125                                          b0, b1, b0, b1, b0, b1));
10126 }
10127
10128 static __inline__ vector signed int __ATTRS_o_ai
10129 vec_splat(vector signed int __a, unsigned const int __b) {
10130   unsigned char b0 = (__b & 0x03) * 4;
10131   unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3;
10132   return vec_perm(__a, __a,
10133                   (vector unsigned char)(b0, b1, b2, b3, b0, b1, b2, b3, b0, b1,
10134                                          b2, b3, b0, b1, b2, b3));
10135 }
10136
10137 static __inline__ vector unsigned int __ATTRS_o_ai
10138 vec_splat(vector unsigned int __a, unsigned const int __b) {
10139   unsigned char b0 = (__b & 0x03) * 4;
10140   unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3;
10141   return vec_perm(__a, __a,
10142                   (vector unsigned char)(b0, b1, b2, b3, b0, b1, b2, b3, b0, b1,
10143                                          b2, b3, b0, b1, b2, b3));
10144 }
10145
10146 static __inline__ vector bool int __ATTRS_o_ai
10147 vec_splat(vector bool int __a, unsigned const int __b) {
10148   unsigned char b0 = (__b & 0x03) * 4;
10149   unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3;
10150   return vec_perm(__a, __a,
10151                   (vector unsigned char)(b0, b1, b2, b3, b0, b1, b2, b3, b0, b1,
10152                                          b2, b3, b0, b1, b2, b3));
10153 }
10154
10155 static __inline__ vector float __ATTRS_o_ai vec_splat(vector float __a,
10156                                                       unsigned const int __b) {
10157   unsigned char b0 = (__b & 0x03) * 4;
10158   unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3;
10159   return vec_perm(__a, __a,
10160                   (vector unsigned char)(b0, b1, b2, b3, b0, b1, b2, b3, b0, b1,
10161                                          b2, b3, b0, b1, b2, b3));
10162 }
10163
10164 #ifdef __VSX__
10165 static __inline__ vector double __ATTRS_o_ai vec_splat(vector double __a,
10166                                                        unsigned const int __b) {
10167   unsigned char b0 = (__b & 0x01) * 8;
10168   unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3, b4 = b0 + 4, b5 = b0 + 5,
10169                 b6 = b0 + 6, b7 = b0 + 7;
10170   return vec_perm(__a, __a,
10171                   (vector unsigned char)(b0, b1, b2, b3, b4, b5, b6, b7, b0, b1,
10172                                          b2, b3, b4, b5, b6, b7));
10173 }
10174 static __inline__ vector bool long long __ATTRS_o_ai
10175 vec_splat(vector bool long long __a, unsigned const int __b) {
10176   unsigned char b0 = (__b & 0x01) * 8;
10177   unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3, b4 = b0 + 4, b5 = b0 + 5,
10178                 b6 = b0 + 6, b7 = b0 + 7;
10179   return vec_perm(__a, __a,
10180                   (vector unsigned char)(b0, b1, b2, b3, b4, b5, b6, b7, b0, b1,
10181                                          b2, b3, b4, b5, b6, b7));
10182 }
10183 static __inline__ vector signed long long __ATTRS_o_ai
10184 vec_splat(vector signed long long __a, unsigned const int __b) {
10185   unsigned char b0 = (__b & 0x01) * 8;
10186   unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3, b4 = b0 + 4, b5 = b0 + 5,
10187                 b6 = b0 + 6, b7 = b0 + 7;
10188   return vec_perm(__a, __a,
10189                   (vector unsigned char)(b0, b1, b2, b3, b4, b5, b6, b7, b0, b1,
10190                                          b2, b3, b4, b5, b6, b7));
10191 }
10192 static __inline__ vector unsigned long long __ATTRS_o_ai
10193 vec_splat(vector unsigned long long __a, unsigned const int __b) {
10194   unsigned char b0 = (__b & 0x01) * 8;
10195   unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3, b4 = b0 + 4, b5 = b0 + 5,
10196                 b6 = b0 + 6, b7 = b0 + 7;
10197   return vec_perm(__a, __a,
10198                   (vector unsigned char)(b0, b1, b2, b3, b4, b5, b6, b7, b0, b1,
10199                                          b2, b3, b4, b5, b6, b7));
10200 }
10201 #endif
10202
10203 /* vec_vspltb */
10204
10205 #define __builtin_altivec_vspltb vec_vspltb
10206
10207 static __inline__ vector signed char __ATTRS_o_ai
10208 vec_vspltb(vector signed char __a, unsigned char __b) {
10209   return vec_perm(__a, __a, (vector unsigned char)(__b));
10210 }
10211
10212 static __inline__ vector unsigned char __ATTRS_o_ai
10213 vec_vspltb(vector unsigned char __a, unsigned char __b) {
10214   return vec_perm(__a, __a, (vector unsigned char)(__b));
10215 }
10216
10217 static __inline__ vector bool char __ATTRS_o_ai vec_vspltb(vector bool char __a,
10218                                                            unsigned char __b) {
10219   return vec_perm(__a, __a, (vector unsigned char)(__b));
10220 }
10221
10222 /* vec_vsplth */
10223
10224 #define __builtin_altivec_vsplth vec_vsplth
10225
10226 static __inline__ vector short __ATTRS_o_ai vec_vsplth(vector short __a,
10227                                                        unsigned char __b) {
10228   __b *= 2;
10229   unsigned char b1 = __b + 1;
10230   return vec_perm(__a, __a,
10231                   (vector unsigned char)(__b, b1, __b, b1, __b, b1, __b, b1,
10232                                          __b, b1, __b, b1, __b, b1, __b, b1));
10233 }
10234
10235 static __inline__ vector unsigned short __ATTRS_o_ai
10236 vec_vsplth(vector unsigned short __a, unsigned char __b) {
10237   __b *= 2;
10238   unsigned char b1 = __b + 1;
10239   return vec_perm(__a, __a,
10240                   (vector unsigned char)(__b, b1, __b, b1, __b, b1, __b, b1,
10241                                          __b, b1, __b, b1, __b, b1, __b, b1));
10242 }
10243
10244 static __inline__ vector bool short __ATTRS_o_ai
10245 vec_vsplth(vector bool short __a, unsigned char __b) {
10246   __b *= 2;
10247   unsigned char b1 = __b + 1;
10248   return vec_perm(__a, __a,
10249                   (vector unsigned char)(__b, b1, __b, b1, __b, b1, __b, b1,
10250                                          __b, b1, __b, b1, __b, b1, __b, b1));
10251 }
10252
10253 static __inline__ vector pixel __ATTRS_o_ai vec_vsplth(vector pixel __a,
10254                                                        unsigned char __b) {
10255   __b *= 2;
10256   unsigned char b1 = __b + 1;
10257   return vec_perm(__a, __a,
10258                   (vector unsigned char)(__b, b1, __b, b1, __b, b1, __b, b1,
10259                                          __b, b1, __b, b1, __b, b1, __b, b1));
10260 }
10261
10262 /* vec_vspltw */
10263
10264 #define __builtin_altivec_vspltw vec_vspltw
10265
10266 static __inline__ vector int __ATTRS_o_ai vec_vspltw(vector int __a,
10267                                                      unsigned char __b) {
10268   __b *= 4;
10269   unsigned char b1 = __b + 1, b2 = __b + 2, b3 = __b + 3;
10270   return vec_perm(__a, __a,
10271                   (vector unsigned char)(__b, b1, b2, b3, __b, b1, b2, b3, __b,
10272                                          b1, b2, b3, __b, b1, b2, b3));
10273 }
10274
10275 static __inline__ vector unsigned int __ATTRS_o_ai
10276 vec_vspltw(vector unsigned int __a, unsigned char __b) {
10277   __b *= 4;
10278   unsigned char b1 = __b + 1, b2 = __b + 2, b3 = __b + 3;
10279   return vec_perm(__a, __a,
10280                   (vector unsigned char)(__b, b1, b2, b3, __b, b1, b2, b3, __b,
10281                                          b1, b2, b3, __b, b1, b2, b3));
10282 }
10283
10284 static __inline__ vector bool int __ATTRS_o_ai vec_vspltw(vector bool int __a,
10285                                                           unsigned char __b) {
10286   __b *= 4;
10287   unsigned char b1 = __b + 1, b2 = __b + 2, b3 = __b + 3;
10288   return vec_perm(__a, __a,
10289                   (vector unsigned char)(__b, b1, b2, b3, __b, b1, b2, b3, __b,
10290                                          b1, b2, b3, __b, b1, b2, b3));
10291 }
10292
10293 static __inline__ vector float __ATTRS_o_ai vec_vspltw(vector float __a,
10294                                                        unsigned char __b) {
10295   __b *= 4;
10296   unsigned char b1 = __b + 1, b2 = __b + 2, b3 = __b + 3;
10297   return vec_perm(__a, __a,
10298                   (vector unsigned char)(__b, b1, b2, b3, __b, b1, b2, b3, __b,
10299                                          b1, b2, b3, __b, b1, b2, b3));
10300 }
10301
10302 /* vec_splat_s8 */
10303
10304 #define __builtin_altivec_vspltisb vec_splat_s8
10305
10306 // FIXME: parameter should be treated as 5-bit signed literal
10307 static __inline__ vector signed char __ATTRS_o_ai
10308 vec_splat_s8(signed char __a) {
10309   return (vector signed char)(__a);
10310 }
10311
10312 /* vec_vspltisb */
10313
10314 // FIXME: parameter should be treated as 5-bit signed literal
10315 static __inline__ vector signed char __ATTRS_o_ai
10316 vec_vspltisb(signed char __a) {
10317   return (vector signed char)(__a);
10318 }
10319
10320 /* vec_splat_s16 */
10321
10322 #define __builtin_altivec_vspltish vec_splat_s16
10323
10324 // FIXME: parameter should be treated as 5-bit signed literal
10325 static __inline__ vector short __ATTRS_o_ai vec_splat_s16(signed char __a) {
10326   return (vector short)(__a);
10327 }
10328
10329 /* vec_vspltish */
10330
10331 // FIXME: parameter should be treated as 5-bit signed literal
10332 static __inline__ vector short __ATTRS_o_ai vec_vspltish(signed char __a) {
10333   return (vector short)(__a);
10334 }
10335
10336 /* vec_splat_s32 */
10337
10338 #define __builtin_altivec_vspltisw vec_splat_s32
10339
10340 // FIXME: parameter should be treated as 5-bit signed literal
10341 static __inline__ vector int __ATTRS_o_ai vec_splat_s32(signed char __a) {
10342   return (vector int)(__a);
10343 }
10344
10345 /* vec_vspltisw */
10346
10347 // FIXME: parameter should be treated as 5-bit signed literal
10348 static __inline__ vector int __ATTRS_o_ai vec_vspltisw(signed char __a) {
10349   return (vector int)(__a);
10350 }
10351
10352 /* vec_splat_u8 */
10353
10354 // FIXME: parameter should be treated as 5-bit signed literal
10355 static __inline__ vector unsigned char __ATTRS_o_ai
10356 vec_splat_u8(unsigned char __a) {
10357   return (vector unsigned char)(__a);
10358 }
10359
10360 /* vec_splat_u16 */
10361
10362 // FIXME: parameter should be treated as 5-bit signed literal
10363 static __inline__ vector unsigned short __ATTRS_o_ai
10364 vec_splat_u16(signed char __a) {
10365   return (vector unsigned short)(__a);
10366 }
10367
10368 /* vec_splat_u32 */
10369
10370 // FIXME: parameter should be treated as 5-bit signed literal
10371 static __inline__ vector unsigned int __ATTRS_o_ai
10372 vec_splat_u32(signed char __a) {
10373   return (vector unsigned int)(__a);
10374 }
10375
10376 /* vec_sr */
10377
10378 // vec_sr does modulo arithmetic on __b first, so __b is allowed to be more
10379 // than the length of __a.
10380 static __inline__ vector unsigned char __ATTRS_o_ai
10381 vec_sr(vector unsigned char __a, vector unsigned char __b) {
10382   return __a >>
10383          (__b % (vector unsigned char)(sizeof(unsigned char) * __CHAR_BIT__));
10384 }
10385
10386 static __inline__ vector signed char __ATTRS_o_ai
10387 vec_sr(vector signed char __a, vector unsigned char __b) {
10388   return (vector signed char)vec_sr((vector unsigned char)__a, __b);
10389 }
10390
10391 static __inline__ vector unsigned short __ATTRS_o_ai
10392 vec_sr(vector unsigned short __a, vector unsigned short __b) {
10393   return __a >>
10394          (__b % (vector unsigned short)(sizeof(unsigned short) * __CHAR_BIT__));
10395 }
10396
10397 static __inline__ vector short __ATTRS_o_ai vec_sr(vector short __a,
10398                                                    vector unsigned short __b) {
10399   return (vector short)vec_sr((vector unsigned short)__a, __b);
10400 }
10401
10402 static __inline__ vector unsigned int __ATTRS_o_ai
10403 vec_sr(vector unsigned int __a, vector unsigned int __b) {
10404   return __a >>
10405          (__b % (vector unsigned int)(sizeof(unsigned int) * __CHAR_BIT__));
10406 }
10407
10408 static __inline__ vector int __ATTRS_o_ai vec_sr(vector int __a,
10409                                                  vector unsigned int __b) {
10410   return (vector int)vec_sr((vector unsigned int)__a, __b);
10411 }
10412
10413 #ifdef __POWER8_VECTOR__
10414 static __inline__ vector unsigned long long __ATTRS_o_ai
10415 vec_sr(vector unsigned long long __a, vector unsigned long long __b) {
10416   return __a >> (__b % (vector unsigned long long)(sizeof(unsigned long long) *
10417                                                    __CHAR_BIT__));
10418 }
10419
10420 static __inline__ vector long long __ATTRS_o_ai
10421 vec_sr(vector long long __a, vector unsigned long long __b) {
10422   return (vector long long)vec_sr((vector unsigned long long)__a, __b);
10423 }
10424 #elif defined(__VSX__)
10425 static __inline__ vector unsigned long long __ATTRS_o_ai
10426 vec_sr(vector unsigned long long __a, vector unsigned long long __b) {
10427   __b %= (vector unsigned long long)(sizeof(unsigned long long) * __CHAR_BIT__);
10428
10429   // Big endian element zero (the left doubleword) can be right shifted as-is.
10430   // However the shift amount must be in the right doubleword.
10431   // The other element needs to be swapped into the left doubleword and
10432   // shifted. Then the left doublewords of the two result vectors are merged.
10433   vector unsigned long long __swapshift =
10434       __builtin_shufflevector(__b, __b, 1, 0);
10435   vector unsigned long long __leftelt =
10436       (vector unsigned long long)__builtin_altivec_vsro(
10437           (vector signed int)__a, (vector signed int)__swapshift);
10438 #ifdef __LITTLE_ENDIAN__
10439   __leftelt = (vector unsigned long long)__builtin_altivec_vsr(
10440       (vector signed int)__leftelt,
10441       (vector signed int)vec_vspltb((vector unsigned char)__swapshift, 0));
10442 #else
10443   __leftelt = (vector unsigned long long)__builtin_altivec_vsr(
10444       (vector signed int)__leftelt,
10445       (vector signed int)vec_vspltb((vector unsigned char)__swapshift, 15));
10446 #endif
10447   __a = __builtin_shufflevector(__a, __a, 1, 0);
10448   vector unsigned long long __rightelt =
10449       (vector unsigned long long)__builtin_altivec_vsro((vector signed int)__a,
10450                                                         (vector signed int)__b);
10451 #ifdef __LITTLE_ENDIAN__
10452   __rightelt = (vector unsigned long long)__builtin_altivec_vsr(
10453       (vector signed int)__rightelt,
10454       (vector signed int)vec_vspltb((vector unsigned char)__b, 0));
10455   return __builtin_shufflevector(__rightelt, __leftelt, 1, 3);
10456 #else
10457   __rightelt = (vector unsigned long long)__builtin_altivec_vsr(
10458       (vector signed int)__rightelt,
10459       (vector signed int)vec_vspltb((vector unsigned char)__b, 15));
10460   return __builtin_shufflevector(__leftelt, __rightelt, 0, 2);
10461 #endif
10462 }
10463
10464 static __inline__ vector long long __ATTRS_o_ai
10465 vec_sr(vector long long __a, vector unsigned long long __b) {
10466   return (vector long long)vec_sr((vector unsigned long long)__a, __b);
10467 }
10468 #endif /* __VSX__ */
10469
10470 /* vec_vsrb */
10471
10472 #define __builtin_altivec_vsrb vec_vsrb
10473
10474 static __inline__ vector signed char __ATTRS_o_ai
10475 vec_vsrb(vector signed char __a, vector unsigned char __b) {
10476   return vec_sr(__a, __b);
10477 }
10478
10479 static __inline__ vector unsigned char __ATTRS_o_ai
10480 vec_vsrb(vector unsigned char __a, vector unsigned char __b) {
10481   return vec_sr(__a, __b);
10482 }
10483
10484 /* vec_vsrh */
10485
10486 #define __builtin_altivec_vsrh vec_vsrh
10487
10488 static __inline__ vector short __ATTRS_o_ai
10489 vec_vsrh(vector short __a, vector unsigned short __b) {
10490   return vec_sr(__a, __b);
10491 }
10492
10493 static __inline__ vector unsigned short __ATTRS_o_ai
10494 vec_vsrh(vector unsigned short __a, vector unsigned short __b) {
10495   return vec_sr(__a, __b);
10496 }
10497
10498 /* vec_vsrw */
10499
10500 #define __builtin_altivec_vsrw vec_vsrw
10501
10502 static __inline__ vector int __ATTRS_o_ai vec_vsrw(vector int __a,
10503                                                    vector unsigned int __b) {
10504   return vec_sr(__a, __b);
10505 }
10506
10507 static __inline__ vector unsigned int __ATTRS_o_ai
10508 vec_vsrw(vector unsigned int __a, vector unsigned int __b) {
10509   return vec_sr(__a, __b);
10510 }
10511
10512 /* vec_sra */
10513
10514 static __inline__ vector signed char __ATTRS_o_ai
10515 vec_sra(vector signed char __a, vector unsigned char __b) {
10516   return (vector signed char)__builtin_altivec_vsrab((vector char)__a, __b);
10517 }
10518
10519 static __inline__ vector unsigned char __ATTRS_o_ai
10520 vec_sra(vector unsigned char __a, vector unsigned char __b) {
10521   return (vector unsigned char)__builtin_altivec_vsrab((vector char)__a, __b);
10522 }
10523
10524 static __inline__ vector short __ATTRS_o_ai vec_sra(vector short __a,
10525                                                     vector unsigned short __b) {
10526   return __builtin_altivec_vsrah(__a, (vector unsigned short)__b);
10527 }
10528
10529 static __inline__ vector unsigned short __ATTRS_o_ai
10530 vec_sra(vector unsigned short __a, vector unsigned short __b) {
10531   return (vector unsigned short)__builtin_altivec_vsrah((vector short)__a, __b);
10532 }
10533
10534 static __inline__ vector int __ATTRS_o_ai vec_sra(vector int __a,
10535                                                   vector unsigned int __b) {
10536   return __builtin_altivec_vsraw(__a, __b);
10537 }
10538
10539 static __inline__ vector unsigned int __ATTRS_o_ai
10540 vec_sra(vector unsigned int __a, vector unsigned int __b) {
10541   return (vector unsigned int)__builtin_altivec_vsraw((vector int)__a, __b);
10542 }
10543
10544 #ifdef __POWER8_VECTOR__
10545 static __inline__ vector signed long long __ATTRS_o_ai
10546 vec_sra(vector signed long long __a, vector unsigned long long __b) {
10547   return __a >> __b;
10548 }
10549
10550 static __inline__ vector unsigned long long __ATTRS_o_ai
10551 vec_sra(vector unsigned long long __a, vector unsigned long long __b) {
10552   return (vector unsigned long long)((vector signed long long)__a >> __b);
10553 }
10554 #elif defined(__VSX__)
10555 static __inline__ vector signed long long __ATTRS_o_ai
10556 vec_sra(vector signed long long __a, vector unsigned long long __b) {
10557   __b %= (vector unsigned long long)(sizeof(unsigned long long) * __CHAR_BIT__);
10558   return __a >> __b;
10559 }
10560
10561 static __inline__ vector unsigned long long __ATTRS_o_ai
10562 vec_sra(vector unsigned long long __a, vector unsigned long long __b) {
10563   __b %= (vector unsigned long long)(sizeof(unsigned long long) * __CHAR_BIT__);
10564   return (vector unsigned long long)((vector signed long long)__a >> __b);
10565 }
10566 #endif /* __VSX__ */
10567
10568 /* vec_vsrab */
10569
10570 static __inline__ vector signed char __ATTRS_o_ai
10571 vec_vsrab(vector signed char __a, vector unsigned char __b) {
10572   return (vector signed char)__builtin_altivec_vsrab((vector char)__a, __b);
10573 }
10574
10575 static __inline__ vector unsigned char __ATTRS_o_ai
10576 vec_vsrab(vector unsigned char __a, vector unsigned char __b) {
10577   return (vector unsigned char)__builtin_altivec_vsrab((vector char)__a, __b);
10578 }
10579
10580 /* vec_vsrah */
10581
10582 static __inline__ vector short __ATTRS_o_ai
10583 vec_vsrah(vector short __a, vector unsigned short __b) {
10584   return __builtin_altivec_vsrah(__a, (vector unsigned short)__b);
10585 }
10586
10587 static __inline__ vector unsigned short __ATTRS_o_ai
10588 vec_vsrah(vector unsigned short __a, vector unsigned short __b) {
10589   return (vector unsigned short)__builtin_altivec_vsrah((vector short)__a, __b);
10590 }
10591
10592 /* vec_vsraw */
10593
10594 static __inline__ vector int __ATTRS_o_ai vec_vsraw(vector int __a,
10595                                                     vector unsigned int __b) {
10596   return __builtin_altivec_vsraw(__a, __b);
10597 }
10598
10599 static __inline__ vector unsigned int __ATTRS_o_ai
10600 vec_vsraw(vector unsigned int __a, vector unsigned int __b) {
10601   return (vector unsigned int)__builtin_altivec_vsraw((vector int)__a, __b);
10602 }
10603
10604 /* vec_srl */
10605
10606 static __inline__ vector signed char __ATTRS_o_ai
10607 vec_srl(vector signed char __a, vector unsigned char __b) {
10608   return (vector signed char)__builtin_altivec_vsr((vector int)__a,
10609                                                    (vector int)__b);
10610 }
10611
10612 static __inline__ vector signed char __ATTRS_o_ai
10613 vec_srl(vector signed char __a, vector unsigned short __b) {
10614   return (vector signed char)__builtin_altivec_vsr((vector int)__a,
10615                                                    (vector int)__b);
10616 }
10617
10618 static __inline__ vector signed char __ATTRS_o_ai
10619 vec_srl(vector signed char __a, vector unsigned int __b) {
10620   return (vector signed char)__builtin_altivec_vsr((vector int)__a,
10621                                                    (vector int)__b);
10622 }
10623
10624 static __inline__ vector unsigned char __ATTRS_o_ai
10625 vec_srl(vector unsigned char __a, vector unsigned char __b) {
10626   return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
10627                                                      (vector int)__b);
10628 }
10629
10630 static __inline__ vector unsigned char __ATTRS_o_ai
10631 vec_srl(vector unsigned char __a, vector unsigned short __b) {
10632   return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
10633                                                      (vector int)__b);
10634 }
10635
10636 static __inline__ vector unsigned char __ATTRS_o_ai
10637 vec_srl(vector unsigned char __a, vector unsigned int __b) {
10638   return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
10639                                                      (vector int)__b);
10640 }
10641
10642 static __inline__ vector bool char __ATTRS_o_ai
10643 vec_srl(vector bool char __a, vector unsigned char __b) {
10644   return (vector bool char)__builtin_altivec_vsr((vector int)__a,
10645                                                  (vector int)__b);
10646 }
10647
10648 static __inline__ vector bool char __ATTRS_o_ai
10649 vec_srl(vector bool char __a, vector unsigned short __b) {
10650   return (vector bool char)__builtin_altivec_vsr((vector int)__a,
10651                                                  (vector int)__b);
10652 }
10653
10654 static __inline__ vector bool char __ATTRS_o_ai
10655 vec_srl(vector bool char __a, vector unsigned int __b) {
10656   return (vector bool char)__builtin_altivec_vsr((vector int)__a,
10657                                                  (vector int)__b);
10658 }
10659
10660 static __inline__ vector short __ATTRS_o_ai vec_srl(vector short __a,
10661                                                     vector unsigned char __b) {
10662   return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
10663 }
10664
10665 static __inline__ vector short __ATTRS_o_ai vec_srl(vector short __a,
10666                                                     vector unsigned short __b) {
10667   return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
10668 }
10669
10670 static __inline__ vector short __ATTRS_o_ai vec_srl(vector short __a,
10671                                                     vector unsigned int __b) {
10672   return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
10673 }
10674
10675 static __inline__ vector unsigned short __ATTRS_o_ai
10676 vec_srl(vector unsigned short __a, vector unsigned char __b) {
10677   return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
10678                                                       (vector int)__b);
10679 }
10680
10681 static __inline__ vector unsigned short __ATTRS_o_ai
10682 vec_srl(vector unsigned short __a, vector unsigned short __b) {
10683   return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
10684                                                       (vector int)__b);
10685 }
10686
10687 static __inline__ vector unsigned short __ATTRS_o_ai
10688 vec_srl(vector unsigned short __a, vector unsigned int __b) {
10689   return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
10690                                                       (vector int)__b);
10691 }
10692
10693 static __inline__ vector bool short __ATTRS_o_ai
10694 vec_srl(vector bool short __a, vector unsigned char __b) {
10695   return (vector bool short)__builtin_altivec_vsr((vector int)__a,
10696                                                   (vector int)__b);
10697 }
10698
10699 static __inline__ vector bool short __ATTRS_o_ai
10700 vec_srl(vector bool short __a, vector unsigned short __b) {
10701   return (vector bool short)__builtin_altivec_vsr((vector int)__a,
10702                                                   (vector int)__b);
10703 }
10704
10705 static __inline__ vector bool short __ATTRS_o_ai
10706 vec_srl(vector bool short __a, vector unsigned int __b) {
10707   return (vector bool short)__builtin_altivec_vsr((vector int)__a,
10708                                                   (vector int)__b);
10709 }
10710
10711 static __inline__ vector pixel __ATTRS_o_ai vec_srl(vector pixel __a,
10712                                                     vector unsigned char __b) {
10713   return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
10714 }
10715
10716 static __inline__ vector pixel __ATTRS_o_ai vec_srl(vector pixel __a,
10717                                                     vector unsigned short __b) {
10718   return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
10719 }
10720
10721 static __inline__ vector pixel __ATTRS_o_ai vec_srl(vector pixel __a,
10722                                                     vector unsigned int __b) {
10723   return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
10724 }
10725
10726 static __inline__ vector int __ATTRS_o_ai vec_srl(vector int __a,
10727                                                   vector unsigned char __b) {
10728   return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
10729 }
10730
10731 static __inline__ vector int __ATTRS_o_ai vec_srl(vector int __a,
10732                                                   vector unsigned short __b) {
10733   return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
10734 }
10735
10736 static __inline__ vector int __ATTRS_o_ai vec_srl(vector int __a,
10737                                                   vector unsigned int __b) {
10738   return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
10739 }
10740
10741 static __inline__ vector unsigned int __ATTRS_o_ai
10742 vec_srl(vector unsigned int __a, vector unsigned char __b) {
10743   return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
10744                                                     (vector int)__b);
10745 }
10746
10747 static __inline__ vector unsigned int __ATTRS_o_ai
10748 vec_srl(vector unsigned int __a, vector unsigned short __b) {
10749   return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
10750                                                     (vector int)__b);
10751 }
10752
10753 static __inline__ vector unsigned int __ATTRS_o_ai
10754 vec_srl(vector unsigned int __a, vector unsigned int __b) {
10755   return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
10756                                                     (vector int)__b);
10757 }
10758
10759 static __inline__ vector bool int __ATTRS_o_ai
10760 vec_srl(vector bool int __a, vector unsigned char __b) {
10761   return (vector bool int)__builtin_altivec_vsr((vector int)__a,
10762                                                 (vector int)__b);
10763 }
10764
10765 static __inline__ vector bool int __ATTRS_o_ai
10766 vec_srl(vector bool int __a, vector unsigned short __b) {
10767   return (vector bool int)__builtin_altivec_vsr((vector int)__a,
10768                                                 (vector int)__b);
10769 }
10770
10771 static __inline__ vector bool int __ATTRS_o_ai
10772 vec_srl(vector bool int __a, vector unsigned int __b) {
10773   return (vector bool int)__builtin_altivec_vsr((vector int)__a,
10774                                                 (vector int)__b);
10775 }
10776
10777 #ifdef __VSX__
10778 static __inline__ vector signed long long __ATTRS_o_ai
10779 vec_srl(vector signed long long __a, vector unsigned char __b) {
10780   return (vector signed long long)__builtin_altivec_vsr((vector int)__a,
10781                                                         (vector int)__b);
10782 }
10783
10784 static __inline__ vector unsigned long long __ATTRS_o_ai
10785 vec_srl(vector unsigned long long __a, vector unsigned char __b) {
10786   return (vector unsigned long long)__builtin_altivec_vsr((vector int)__a,
10787                                                           (vector int)__b);
10788 }
10789 #endif
10790
10791 /* vec_vsr */
10792
10793 static __inline__ vector signed char __ATTRS_o_ai
10794 vec_vsr(vector signed char __a, vector unsigned char __b) {
10795   return (vector signed char)__builtin_altivec_vsr((vector int)__a,
10796                                                    (vector int)__b);
10797 }
10798
10799 static __inline__ vector signed char __ATTRS_o_ai
10800 vec_vsr(vector signed char __a, vector unsigned short __b) {
10801   return (vector signed char)__builtin_altivec_vsr((vector int)__a,
10802                                                    (vector int)__b);
10803 }
10804
10805 static __inline__ vector signed char __ATTRS_o_ai
10806 vec_vsr(vector signed char __a, vector unsigned int __b) {
10807   return (vector signed char)__builtin_altivec_vsr((vector int)__a,
10808                                                    (vector int)__b);
10809 }
10810
10811 static __inline__ vector unsigned char __ATTRS_o_ai
10812 vec_vsr(vector unsigned char __a, vector unsigned char __b) {
10813   return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
10814                                                      (vector int)__b);
10815 }
10816
10817 static __inline__ vector unsigned char __ATTRS_o_ai
10818 vec_vsr(vector unsigned char __a, vector unsigned short __b) {
10819   return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
10820                                                      (vector int)__b);
10821 }
10822
10823 static __inline__ vector unsigned char __ATTRS_o_ai
10824 vec_vsr(vector unsigned char __a, vector unsigned int __b) {
10825   return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
10826                                                      (vector int)__b);
10827 }
10828
10829 static __inline__ vector bool char __ATTRS_o_ai
10830 vec_vsr(vector bool char __a, vector unsigned char __b) {
10831   return (vector bool char)__builtin_altivec_vsr((vector int)__a,
10832                                                  (vector int)__b);
10833 }
10834
10835 static __inline__ vector bool char __ATTRS_o_ai
10836 vec_vsr(vector bool char __a, vector unsigned short __b) {
10837   return (vector bool char)__builtin_altivec_vsr((vector int)__a,
10838                                                  (vector int)__b);
10839 }
10840
10841 static __inline__ vector bool char __ATTRS_o_ai
10842 vec_vsr(vector bool char __a, vector unsigned int __b) {
10843   return (vector bool char)__builtin_altivec_vsr((vector int)__a,
10844                                                  (vector int)__b);
10845 }
10846
10847 static __inline__ vector short __ATTRS_o_ai vec_vsr(vector short __a,
10848                                                     vector unsigned char __b) {
10849   return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
10850 }
10851
10852 static __inline__ vector short __ATTRS_o_ai vec_vsr(vector short __a,
10853                                                     vector unsigned short __b) {
10854   return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
10855 }
10856
10857 static __inline__ vector short __ATTRS_o_ai vec_vsr(vector short __a,
10858                                                     vector unsigned int __b) {
10859   return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
10860 }
10861
10862 static __inline__ vector unsigned short __ATTRS_o_ai
10863 vec_vsr(vector unsigned short __a, vector unsigned char __b) {
10864   return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
10865                                                       (vector int)__b);
10866 }
10867
10868 static __inline__ vector unsigned short __ATTRS_o_ai
10869 vec_vsr(vector unsigned short __a, vector unsigned short __b) {
10870   return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
10871                                                       (vector int)__b);
10872 }
10873
10874 static __inline__ vector unsigned short __ATTRS_o_ai
10875 vec_vsr(vector unsigned short __a, vector unsigned int __b) {
10876   return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
10877                                                       (vector int)__b);
10878 }
10879
10880 static __inline__ vector bool short __ATTRS_o_ai
10881 vec_vsr(vector bool short __a, vector unsigned char __b) {
10882   return (vector bool short)__builtin_altivec_vsr((vector int)__a,
10883                                                   (vector int)__b);
10884 }
10885
10886 static __inline__ vector bool short __ATTRS_o_ai
10887 vec_vsr(vector bool short __a, vector unsigned short __b) {
10888   return (vector bool short)__builtin_altivec_vsr((vector int)__a,
10889                                                   (vector int)__b);
10890 }
10891
10892 static __inline__ vector bool short __ATTRS_o_ai
10893 vec_vsr(vector bool short __a, vector unsigned int __b) {
10894   return (vector bool short)__builtin_altivec_vsr((vector int)__a,
10895                                                   (vector int)__b);
10896 }
10897
10898 static __inline__ vector pixel __ATTRS_o_ai vec_vsr(vector pixel __a,
10899                                                     vector unsigned char __b) {
10900   return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
10901 }
10902
10903 static __inline__ vector pixel __ATTRS_o_ai vec_vsr(vector pixel __a,
10904                                                     vector unsigned short __b) {
10905   return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
10906 }
10907
10908 static __inline__ vector pixel __ATTRS_o_ai vec_vsr(vector pixel __a,
10909                                                     vector unsigned int __b) {
10910   return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
10911 }
10912
10913 static __inline__ vector int __ATTRS_o_ai vec_vsr(vector int __a,
10914                                                   vector unsigned char __b) {
10915   return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
10916 }
10917
10918 static __inline__ vector int __ATTRS_o_ai vec_vsr(vector int __a,
10919                                                   vector unsigned short __b) {
10920   return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
10921 }
10922
10923 static __inline__ vector int __ATTRS_o_ai vec_vsr(vector int __a,
10924                                                   vector unsigned int __b) {
10925   return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
10926 }
10927
10928 static __inline__ vector unsigned int __ATTRS_o_ai
10929 vec_vsr(vector unsigned int __a, vector unsigned char __b) {
10930   return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
10931                                                     (vector int)__b);
10932 }
10933
10934 static __inline__ vector unsigned int __ATTRS_o_ai
10935 vec_vsr(vector unsigned int __a, vector unsigned short __b) {
10936   return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
10937                                                     (vector int)__b);
10938 }
10939
10940 static __inline__ vector unsigned int __ATTRS_o_ai
10941 vec_vsr(vector unsigned int __a, vector unsigned int __b) {
10942   return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
10943                                                     (vector int)__b);
10944 }
10945
10946 static __inline__ vector bool int __ATTRS_o_ai
10947 vec_vsr(vector bool int __a, vector unsigned char __b) {
10948   return (vector bool int)__builtin_altivec_vsr((vector int)__a,
10949                                                 (vector int)__b);
10950 }
10951
10952 static __inline__ vector bool int __ATTRS_o_ai
10953 vec_vsr(vector bool int __a, vector unsigned short __b) {
10954   return (vector bool int)__builtin_altivec_vsr((vector int)__a,
10955                                                 (vector int)__b);
10956 }
10957
10958 static __inline__ vector bool int __ATTRS_o_ai
10959 vec_vsr(vector bool int __a, vector unsigned int __b) {
10960   return (vector bool int)__builtin_altivec_vsr((vector int)__a,
10961                                                 (vector int)__b);
10962 }
10963
10964 /* vec_sro */
10965
10966 static __inline__ vector signed char __ATTRS_o_ai
10967 vec_sro(vector signed char __a, vector signed char __b) {
10968   return (vector signed char)__builtin_altivec_vsro((vector int)__a,
10969                                                     (vector int)__b);
10970 }
10971
10972 static __inline__ vector signed char __ATTRS_o_ai
10973 vec_sro(vector signed char __a, vector unsigned char __b) {
10974   return (vector signed char)__builtin_altivec_vsro((vector int)__a,
10975                                                     (vector int)__b);
10976 }
10977
10978 static __inline__ vector unsigned char __ATTRS_o_ai
10979 vec_sro(vector unsigned char __a, vector signed char __b) {
10980   return (vector unsigned char)__builtin_altivec_vsro((vector int)__a,
10981                                                       (vector int)__b);
10982 }
10983
10984 static __inline__ vector unsigned char __ATTRS_o_ai
10985 vec_sro(vector unsigned char __a, vector unsigned char __b) {
10986   return (vector unsigned char)__builtin_altivec_vsro((vector int)__a,
10987                                                       (vector int)__b);
10988 }
10989
10990 static __inline__ vector short __ATTRS_o_ai vec_sro(vector short __a,
10991                                                     vector signed char __b) {
10992   return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10993 }
10994
10995 static __inline__ vector short __ATTRS_o_ai vec_sro(vector short __a,
10996                                                     vector unsigned char __b) {
10997   return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10998 }
10999
11000 static __inline__ vector unsigned short __ATTRS_o_ai
11001 vec_sro(vector unsigned short __a, vector signed char __b) {
11002   return (vector unsigned short)__builtin_altivec_vsro((vector int)__a,
11003                                                        (vector int)__b);
11004 }
11005
11006 static __inline__ vector unsigned short __ATTRS_o_ai
11007 vec_sro(vector unsigned short __a, vector unsigned char __b) {
11008   return (vector unsigned short)__builtin_altivec_vsro((vector int)__a,
11009                                                        (vector int)__b);
11010 }
11011
11012 static __inline__ vector pixel __ATTRS_o_ai vec_sro(vector pixel __a,
11013                                                     vector signed char __b) {
11014   return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
11015 }
11016
11017 static __inline__ vector pixel __ATTRS_o_ai vec_sro(vector pixel __a,
11018                                                     vector unsigned char __b) {
11019   return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
11020 }
11021
11022 static __inline__ vector int __ATTRS_o_ai vec_sro(vector int __a,
11023                                                   vector signed char __b) {
11024   return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
11025 }
11026
11027 static __inline__ vector int __ATTRS_o_ai vec_sro(vector int __a,
11028                                                   vector unsigned char __b) {
11029   return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
11030 }
11031
11032 static __inline__ vector unsigned int __ATTRS_o_ai
11033 vec_sro(vector unsigned int __a, vector signed char __b) {
11034   return (vector unsigned int)__builtin_altivec_vsro((vector int)__a,
11035                                                      (vector int)__b);
11036 }
11037
11038 static __inline__ vector unsigned int __ATTRS_o_ai
11039 vec_sro(vector unsigned int __a, vector unsigned char __b) {
11040   return (vector unsigned int)__builtin_altivec_vsro((vector int)__a,
11041                                                      (vector int)__b);
11042 }
11043
11044 static __inline__ vector float __ATTRS_o_ai vec_sro(vector float __a,
11045                                                     vector signed char __b) {
11046   return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
11047 }
11048
11049 static __inline__ vector float __ATTRS_o_ai vec_sro(vector float __a,
11050                                                     vector unsigned char __b) {
11051   return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
11052 }
11053
11054 #ifdef __VSX__
11055 static __inline__ vector signed long long __ATTRS_o_ai
11056 vec_sro(vector signed long long __a, vector signed char __b) {
11057   return (vector signed long long)__builtin_altivec_vsro((vector int)__a,
11058                                                          (vector int)__b);
11059 }
11060
11061 static __inline__ vector signed long long __ATTRS_o_ai
11062 vec_sro(vector signed long long __a, vector unsigned char __b) {
11063   return (vector signed long long)__builtin_altivec_vsro((vector int)__a,
11064                                                          (vector int)__b);
11065 }
11066
11067 static __inline__ vector unsigned long long __ATTRS_o_ai
11068 vec_sro(vector unsigned long long __a, vector signed char __b) {
11069   return (vector unsigned long long)__builtin_altivec_vsro((vector int)__a,
11070                                                            (vector int)__b);
11071 }
11072
11073 static __inline__ vector unsigned long long __ATTRS_o_ai
11074 vec_sro(vector unsigned long long __a, vector unsigned char __b) {
11075   return (vector unsigned long long)__builtin_altivec_vsro((vector int)__a,
11076                                                            (vector int)__b);
11077 }
11078 #endif
11079
11080 /* vec_vsro */
11081
11082 static __inline__ vector signed char __ATTRS_o_ai
11083 vec_vsro(vector signed char __a, vector signed char __b) {
11084   return (vector signed char)__builtin_altivec_vsro((vector int)__a,
11085                                                     (vector int)__b);
11086 }
11087
11088 static __inline__ vector signed char __ATTRS_o_ai
11089 vec_vsro(vector signed char __a, vector unsigned char __b) {
11090   return (vector signed char)__builtin_altivec_vsro((vector int)__a,
11091                                                     (vector int)__b);
11092 }
11093
11094 static __inline__ vector unsigned char __ATTRS_o_ai
11095 vec_vsro(vector unsigned char __a, vector signed char __b) {
11096   return (vector unsigned char)__builtin_altivec_vsro((vector int)__a,
11097                                                       (vector int)__b);
11098 }
11099
11100 static __inline__ vector unsigned char __ATTRS_o_ai
11101 vec_vsro(vector unsigned char __a, vector unsigned char __b) {
11102   return (vector unsigned char)__builtin_altivec_vsro((vector int)__a,
11103                                                       (vector int)__b);
11104 }
11105
11106 static __inline__ vector short __ATTRS_o_ai vec_vsro(vector short __a,
11107                                                      vector signed char __b) {
11108   return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
11109 }
11110
11111 static __inline__ vector short __ATTRS_o_ai vec_vsro(vector short __a,
11112                                                      vector unsigned char __b) {
11113   return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
11114 }
11115
11116 static __inline__ vector unsigned short __ATTRS_o_ai
11117 vec_vsro(vector unsigned short __a, vector signed char __b) {
11118   return (vector unsigned short)__builtin_altivec_vsro((vector int)__a,
11119                                                        (vector int)__b);
11120 }
11121
11122 static __inline__ vector unsigned short __ATTRS_o_ai
11123 vec_vsro(vector unsigned short __a, vector unsigned char __b) {
11124   return (vector unsigned short)__builtin_altivec_vsro((vector int)__a,
11125                                                        (vector int)__b);
11126 }
11127
11128 static __inline__ vector pixel __ATTRS_o_ai vec_vsro(vector pixel __a,
11129                                                      vector signed char __b) {
11130   return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
11131 }
11132
11133 static __inline__ vector pixel __ATTRS_o_ai vec_vsro(vector pixel __a,
11134                                                      vector unsigned char __b) {
11135   return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
11136 }
11137
11138 static __inline__ vector int __ATTRS_o_ai vec_vsro(vector int __a,
11139                                                    vector signed char __b) {
11140   return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
11141 }
11142
11143 static __inline__ vector int __ATTRS_o_ai vec_vsro(vector int __a,
11144                                                    vector unsigned char __b) {
11145   return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
11146 }
11147
11148 static __inline__ vector unsigned int __ATTRS_o_ai
11149 vec_vsro(vector unsigned int __a, vector signed char __b) {
11150   return (vector unsigned int)__builtin_altivec_vsro((vector int)__a,
11151                                                      (vector int)__b);
11152 }
11153
11154 static __inline__ vector unsigned int __ATTRS_o_ai
11155 vec_vsro(vector unsigned int __a, vector unsigned char __b) {
11156   return (vector unsigned int)__builtin_altivec_vsro((vector int)__a,
11157                                                      (vector int)__b);
11158 }
11159
11160 static __inline__ vector float __ATTRS_o_ai vec_vsro(vector float __a,
11161                                                      vector signed char __b) {
11162   return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
11163 }
11164
11165 static __inline__ vector float __ATTRS_o_ai vec_vsro(vector float __a,
11166                                                      vector unsigned char __b) {
11167   return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
11168 }
11169
11170 /* vec_st */
11171
11172 static __inline__ void __ATTRS_o_ai vec_st(vector signed char __a, long __b,
11173                                            vector signed char *__c) {
11174   __builtin_altivec_stvx((vector int)__a, __b, __c);
11175 }
11176
11177 static __inline__ void __ATTRS_o_ai vec_st(vector signed char __a, long __b,
11178                                            signed char *__c) {
11179   __builtin_altivec_stvx((vector int)__a, __b, __c);
11180 }
11181
11182 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned char __a, long __b,
11183                                            vector unsigned char *__c) {
11184   __builtin_altivec_stvx((vector int)__a, __b, __c);
11185 }
11186
11187 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned char __a, long __b,
11188                                            unsigned char *__c) {
11189   __builtin_altivec_stvx((vector int)__a, __b, __c);
11190 }
11191
11192 static __inline__ void __ATTRS_o_ai vec_st(vector bool char __a, long __b,
11193                                            signed char *__c) {
11194   __builtin_altivec_stvx((vector int)__a, __b, __c);
11195 }
11196
11197 static __inline__ void __ATTRS_o_ai vec_st(vector bool char __a, long __b,
11198                                            unsigned char *__c) {
11199   __builtin_altivec_stvx((vector int)__a, __b, __c);
11200 }
11201
11202 static __inline__ void __ATTRS_o_ai vec_st(vector bool char __a, long __b,
11203                                            vector bool char *__c) {
11204   __builtin_altivec_stvx((vector int)__a, __b, __c);
11205 }
11206
11207 static __inline__ void __ATTRS_o_ai vec_st(vector short __a, long __b,
11208                                            vector short *__c) {
11209   __builtin_altivec_stvx((vector int)__a, __b, __c);
11210 }
11211
11212 static __inline__ void __ATTRS_o_ai vec_st(vector short __a, long __b,
11213                                            short *__c) {
11214   __builtin_altivec_stvx((vector int)__a, __b, __c);
11215 }
11216
11217 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned short __a, long __b,
11218                                            vector unsigned short *__c) {
11219   __builtin_altivec_stvx((vector int)__a, __b, __c);
11220 }
11221
11222 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned short __a, long __b,
11223                                            unsigned short *__c) {
11224   __builtin_altivec_stvx((vector int)__a, __b, __c);
11225 }
11226
11227 static __inline__ void __ATTRS_o_ai vec_st(vector bool short __a, long __b,
11228                                            short *__c) {
11229   __builtin_altivec_stvx((vector int)__a, __b, __c);
11230 }
11231
11232 static __inline__ void __ATTRS_o_ai vec_st(vector bool short __a, long __b,
11233                                            unsigned short *__c) {
11234   __builtin_altivec_stvx((vector int)__a, __b, __c);
11235 }
11236
11237 static __inline__ void __ATTRS_o_ai vec_st(vector bool short __a, long __b,
11238                                            vector bool short *__c) {
11239   __builtin_altivec_stvx((vector int)__a, __b, __c);
11240 }
11241
11242 static __inline__ void __ATTRS_o_ai vec_st(vector pixel __a, long __b,
11243                                            short *__c) {
11244   __builtin_altivec_stvx((vector int)__a, __b, __c);
11245 }
11246
11247 static __inline__ void __ATTRS_o_ai vec_st(vector pixel __a, long __b,
11248                                            unsigned short *__c) {
11249   __builtin_altivec_stvx((vector int)__a, __b, __c);
11250 }
11251
11252 static __inline__ void __ATTRS_o_ai vec_st(vector pixel __a, long __b,
11253                                            vector pixel *__c) {
11254   __builtin_altivec_stvx((vector int)__a, __b, __c);
11255 }
11256
11257 static __inline__ void __ATTRS_o_ai vec_st(vector int __a, long __b,
11258                                            vector int *__c) {
11259   __builtin_altivec_stvx(__a, __b, __c);
11260 }
11261
11262 static __inline__ void __ATTRS_o_ai vec_st(vector int __a, long __b, int *__c) {
11263   __builtin_altivec_stvx(__a, __b, __c);
11264 }
11265
11266 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned int __a, long __b,
11267                                            vector unsigned int *__c) {
11268   __builtin_altivec_stvx((vector int)__a, __b, __c);
11269 }
11270
11271 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned int __a, long __b,
11272                                            unsigned int *__c) {
11273   __builtin_altivec_stvx((vector int)__a, __b, __c);
11274 }
11275
11276 static __inline__ void __ATTRS_o_ai vec_st(vector bool int __a, long __b,
11277                                            int *__c) {
11278   __builtin_altivec_stvx((vector int)__a, __b, __c);
11279 }
11280
11281 static __inline__ void __ATTRS_o_ai vec_st(vector bool int __a, long __b,
11282                                            unsigned int *__c) {
11283   __builtin_altivec_stvx((vector int)__a, __b, __c);
11284 }
11285
11286 static __inline__ void __ATTRS_o_ai vec_st(vector bool int __a, long __b,
11287                                            vector bool int *__c) {
11288   __builtin_altivec_stvx((vector int)__a, __b, __c);
11289 }
11290
11291 static __inline__ void __ATTRS_o_ai vec_st(vector float __a, long __b,
11292                                            vector float *__c) {
11293   __builtin_altivec_stvx((vector int)__a, __b, __c);
11294 }
11295
11296 static __inline__ void __ATTRS_o_ai vec_st(vector float __a, long __b,
11297                                            float *__c) {
11298   __builtin_altivec_stvx((vector int)__a, __b, __c);
11299 }
11300
11301 /* vec_stvx */
11302
11303 static __inline__ void __ATTRS_o_ai vec_stvx(vector signed char __a, long __b,
11304                                              vector signed char *__c) {
11305   __builtin_altivec_stvx((vector int)__a, __b, __c);
11306 }
11307
11308 static __inline__ void __ATTRS_o_ai vec_stvx(vector signed char __a, long __b,
11309                                              signed char *__c) {
11310   __builtin_altivec_stvx((vector int)__a, __b, __c);
11311 }
11312
11313 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned char __a, long __b,
11314                                              vector unsigned char *__c) {
11315   __builtin_altivec_stvx((vector int)__a, __b, __c);
11316 }
11317
11318 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned char __a, long __b,
11319                                              unsigned char *__c) {
11320   __builtin_altivec_stvx((vector int)__a, __b, __c);
11321 }
11322
11323 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool char __a, long __b,
11324                                              signed char *__c) {
11325   __builtin_altivec_stvx((vector int)__a, __b, __c);
11326 }
11327
11328 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool char __a, long __b,
11329                                              unsigned char *__c) {
11330   __builtin_altivec_stvx((vector int)__a, __b, __c);
11331 }
11332
11333 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool char __a, long __b,
11334                                              vector bool char *__c) {
11335   __builtin_altivec_stvx((vector int)__a, __b, __c);
11336 }
11337
11338 static __inline__ void __ATTRS_o_ai vec_stvx(vector short __a, long __b,
11339                                              vector short *__c) {
11340   __builtin_altivec_stvx((vector int)__a, __b, __c);
11341 }
11342
11343 static __inline__ void __ATTRS_o_ai vec_stvx(vector short __a, long __b,
11344                                              short *__c) {
11345   __builtin_altivec_stvx((vector int)__a, __b, __c);
11346 }
11347
11348 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned short __a, long __b,
11349                                              vector unsigned short *__c) {
11350   __builtin_altivec_stvx((vector int)__a, __b, __c);
11351 }
11352
11353 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned short __a, long __b,
11354                                              unsigned short *__c) {
11355   __builtin_altivec_stvx((vector int)__a, __b, __c);
11356 }
11357
11358 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool short __a, long __b,
11359                                              short *__c) {
11360   __builtin_altivec_stvx((vector int)__a, __b, __c);
11361 }
11362
11363 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool short __a, long __b,
11364                                              unsigned short *__c) {
11365   __builtin_altivec_stvx((vector int)__a, __b, __c);
11366 }
11367
11368 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool short __a, long __b,
11369                                              vector bool short *__c) {
11370   __builtin_altivec_stvx((vector int)__a, __b, __c);
11371 }
11372
11373 static __inline__ void __ATTRS_o_ai vec_stvx(vector pixel __a, long __b,
11374                                              short *__c) {
11375   __builtin_altivec_stvx((vector int)__a, __b, __c);
11376 }
11377
11378 static __inline__ void __ATTRS_o_ai vec_stvx(vector pixel __a, long __b,
11379                                              unsigned short *__c) {
11380   __builtin_altivec_stvx((vector int)__a, __b, __c);
11381 }
11382
11383 static __inline__ void __ATTRS_o_ai vec_stvx(vector pixel __a, long __b,
11384                                              vector pixel *__c) {
11385   __builtin_altivec_stvx((vector int)__a, __b, __c);
11386 }
11387
11388 static __inline__ void __ATTRS_o_ai vec_stvx(vector int __a, long __b,
11389                                              vector int *__c) {
11390   __builtin_altivec_stvx(__a, __b, __c);
11391 }
11392
11393 static __inline__ void __ATTRS_o_ai vec_stvx(vector int __a, long __b,
11394                                              int *__c) {
11395   __builtin_altivec_stvx(__a, __b, __c);
11396 }
11397
11398 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned int __a, long __b,
11399                                              vector unsigned int *__c) {
11400   __builtin_altivec_stvx((vector int)__a, __b, __c);
11401 }
11402
11403 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned int __a, long __b,
11404                                              unsigned int *__c) {
11405   __builtin_altivec_stvx((vector int)__a, __b, __c);
11406 }
11407
11408 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool int __a, long __b,
11409                                              int *__c) {
11410   __builtin_altivec_stvx((vector int)__a, __b, __c);
11411 }
11412
11413 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool int __a, long __b,
11414                                              unsigned int *__c) {
11415   __builtin_altivec_stvx((vector int)__a, __b, __c);
11416 }
11417
11418 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool int __a, long __b,
11419                                              vector bool int *__c) {
11420   __builtin_altivec_stvx((vector int)__a, __b, __c);
11421 }
11422
11423 static __inline__ void __ATTRS_o_ai vec_stvx(vector float __a, long __b,
11424                                              vector float *__c) {
11425   __builtin_altivec_stvx((vector int)__a, __b, __c);
11426 }
11427
11428 static __inline__ void __ATTRS_o_ai vec_stvx(vector float __a, long __b,
11429                                              float *__c) {
11430   __builtin_altivec_stvx((vector int)__a, __b, __c);
11431 }
11432
11433 /* vec_ste */
11434
11435 static __inline__ void __ATTRS_o_ai vec_ste(vector signed char __a, long __b,
11436                                             signed char *__c) {
11437   __builtin_altivec_stvebx((vector char)__a, __b, __c);
11438 }
11439
11440 static __inline__ void __ATTRS_o_ai vec_ste(vector unsigned char __a, long __b,
11441                                             unsigned char *__c) {
11442   __builtin_altivec_stvebx((vector char)__a, __b, __c);
11443 }
11444
11445 static __inline__ void __ATTRS_o_ai vec_ste(vector bool char __a, long __b,
11446                                             signed char *__c) {
11447   __builtin_altivec_stvebx((vector char)__a, __b, __c);
11448 }
11449
11450 static __inline__ void __ATTRS_o_ai vec_ste(vector bool char __a, long __b,
11451                                             unsigned char *__c) {
11452   __builtin_altivec_stvebx((vector char)__a, __b, __c);
11453 }
11454
11455 static __inline__ void __ATTRS_o_ai vec_ste(vector short __a, long __b,
11456                                             short *__c) {
11457   __builtin_altivec_stvehx(__a, __b, __c);
11458 }
11459
11460 static __inline__ void __ATTRS_o_ai vec_ste(vector unsigned short __a, long __b,
11461                                             unsigned short *__c) {
11462   __builtin_altivec_stvehx((vector short)__a, __b, __c);
11463 }
11464
11465 static __inline__ void __ATTRS_o_ai vec_ste(vector bool short __a, long __b,
11466                                             short *__c) {
11467   __builtin_altivec_stvehx((vector short)__a, __b, __c);
11468 }
11469
11470 static __inline__ void __ATTRS_o_ai vec_ste(vector bool short __a, long __b,
11471                                             unsigned short *__c) {
11472   __builtin_altivec_stvehx((vector short)__a, __b, __c);
11473 }
11474
11475 static __inline__ void __ATTRS_o_ai vec_ste(vector pixel __a, long __b,
11476                                             short *__c) {
11477   __builtin_altivec_stvehx((vector short)__a, __b, __c);
11478 }
11479
11480 static __inline__ void __ATTRS_o_ai vec_ste(vector pixel __a, long __b,
11481                                             unsigned short *__c) {
11482   __builtin_altivec_stvehx((vector short)__a, __b, __c);
11483 }
11484
11485 static __inline__ void __ATTRS_o_ai vec_ste(vector int __a, long __b, int *__c) {
11486   __builtin_altivec_stvewx(__a, __b, __c);
11487 }
11488
11489 static __inline__ void __ATTRS_o_ai vec_ste(vector unsigned int __a, long __b,
11490                                             unsigned int *__c) {
11491   __builtin_altivec_stvewx((vector int)__a, __b, __c);
11492 }
11493
11494 static __inline__ void __ATTRS_o_ai vec_ste(vector bool int __a, long __b,
11495                                             int *__c) {
11496   __builtin_altivec_stvewx((vector int)__a, __b, __c);
11497 }
11498
11499 static __inline__ void __ATTRS_o_ai vec_ste(vector bool 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_ste(vector float __a, long __b,
11505                                             float *__c) {
11506   __builtin_altivec_stvewx((vector int)__a, __b, __c);
11507 }
11508
11509 /* vec_stvebx */
11510
11511 static __inline__ void __ATTRS_o_ai vec_stvebx(vector signed char __a, long __b,
11512                                                signed char *__c) {
11513   __builtin_altivec_stvebx((vector char)__a, __b, __c);
11514 }
11515
11516 static __inline__ void __ATTRS_o_ai vec_stvebx(vector unsigned char __a,
11517                                                long __b, unsigned char *__c) {
11518   __builtin_altivec_stvebx((vector char)__a, __b, __c);
11519 }
11520
11521 static __inline__ void __ATTRS_o_ai vec_stvebx(vector bool char __a, long __b,
11522                                                signed char *__c) {
11523   __builtin_altivec_stvebx((vector char)__a, __b, __c);
11524 }
11525
11526 static __inline__ void __ATTRS_o_ai vec_stvebx(vector bool char __a, long __b,
11527                                                unsigned char *__c) {
11528   __builtin_altivec_stvebx((vector char)__a, __b, __c);
11529 }
11530
11531 /* vec_stvehx */
11532
11533 static __inline__ void __ATTRS_o_ai vec_stvehx(vector short __a, long __b,
11534                                                short *__c) {
11535   __builtin_altivec_stvehx(__a, __b, __c);
11536 }
11537
11538 static __inline__ void __ATTRS_o_ai vec_stvehx(vector unsigned short __a,
11539                                                long __b, unsigned short *__c) {
11540   __builtin_altivec_stvehx((vector short)__a, __b, __c);
11541 }
11542
11543 static __inline__ void __ATTRS_o_ai vec_stvehx(vector bool short __a, long __b,
11544                                                short *__c) {
11545   __builtin_altivec_stvehx((vector short)__a, __b, __c);
11546 }
11547
11548 static __inline__ void __ATTRS_o_ai vec_stvehx(vector bool short __a, long __b,
11549                                                unsigned short *__c) {
11550   __builtin_altivec_stvehx((vector short)__a, __b, __c);
11551 }
11552
11553 static __inline__ void __ATTRS_o_ai vec_stvehx(vector pixel __a, long __b,
11554                                                short *__c) {
11555   __builtin_altivec_stvehx((vector short)__a, __b, __c);
11556 }
11557
11558 static __inline__ void __ATTRS_o_ai vec_stvehx(vector pixel __a, long __b,
11559                                                unsigned short *__c) {
11560   __builtin_altivec_stvehx((vector short)__a, __b, __c);
11561 }
11562
11563 /* vec_stvewx */
11564
11565 static __inline__ void __ATTRS_o_ai vec_stvewx(vector int __a, long __b,
11566                                                int *__c) {
11567   __builtin_altivec_stvewx(__a, __b, __c);
11568 }
11569
11570 static __inline__ void __ATTRS_o_ai vec_stvewx(vector unsigned int __a, long __b,
11571                                                unsigned int *__c) {
11572   __builtin_altivec_stvewx((vector int)__a, __b, __c);
11573 }
11574
11575 static __inline__ void __ATTRS_o_ai vec_stvewx(vector bool int __a, long __b,
11576                                                int *__c) {
11577   __builtin_altivec_stvewx((vector int)__a, __b, __c);
11578 }
11579
11580 static __inline__ void __ATTRS_o_ai vec_stvewx(vector bool int __a, long __b,
11581                                                unsigned int *__c) {
11582   __builtin_altivec_stvewx((vector int)__a, __b, __c);
11583 }
11584
11585 static __inline__ void __ATTRS_o_ai vec_stvewx(vector float __a, long __b,
11586                                                float *__c) {
11587   __builtin_altivec_stvewx((vector int)__a, __b, __c);
11588 }
11589
11590 /* vec_stl */
11591
11592 static __inline__ void __ATTRS_o_ai vec_stl(vector signed char __a, int __b,
11593                                             vector signed char *__c) {
11594   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11595 }
11596
11597 static __inline__ void __ATTRS_o_ai vec_stl(vector signed char __a, int __b,
11598                                             signed char *__c) {
11599   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11600 }
11601
11602 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned char __a, int __b,
11603                                             vector unsigned char *__c) {
11604   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11605 }
11606
11607 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned char __a, int __b,
11608                                             unsigned char *__c) {
11609   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11610 }
11611
11612 static __inline__ void __ATTRS_o_ai vec_stl(vector bool char __a, int __b,
11613                                             signed char *__c) {
11614   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11615 }
11616
11617 static __inline__ void __ATTRS_o_ai vec_stl(vector bool char __a, int __b,
11618                                             unsigned char *__c) {
11619   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11620 }
11621
11622 static __inline__ void __ATTRS_o_ai vec_stl(vector bool char __a, int __b,
11623                                             vector bool char *__c) {
11624   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11625 }
11626
11627 static __inline__ void __ATTRS_o_ai vec_stl(vector short __a, int __b,
11628                                             vector short *__c) {
11629   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11630 }
11631
11632 static __inline__ void __ATTRS_o_ai vec_stl(vector short __a, int __b,
11633                                             short *__c) {
11634   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11635 }
11636
11637 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned short __a, int __b,
11638                                             vector unsigned short *__c) {
11639   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11640 }
11641
11642 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned short __a, int __b,
11643                                             unsigned short *__c) {
11644   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11645 }
11646
11647 static __inline__ void __ATTRS_o_ai vec_stl(vector bool short __a, int __b,
11648                                             short *__c) {
11649   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11650 }
11651
11652 static __inline__ void __ATTRS_o_ai vec_stl(vector bool short __a, int __b,
11653                                             unsigned short *__c) {
11654   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11655 }
11656
11657 static __inline__ void __ATTRS_o_ai vec_stl(vector bool short __a, int __b,
11658                                             vector bool short *__c) {
11659   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11660 }
11661
11662 static __inline__ void __ATTRS_o_ai vec_stl(vector pixel __a, int __b,
11663                                             short *__c) {
11664   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11665 }
11666
11667 static __inline__ void __ATTRS_o_ai vec_stl(vector pixel __a, int __b,
11668                                             unsigned short *__c) {
11669   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11670 }
11671
11672 static __inline__ void __ATTRS_o_ai vec_stl(vector pixel __a, int __b,
11673                                             vector pixel *__c) {
11674   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11675 }
11676
11677 static __inline__ void __ATTRS_o_ai vec_stl(vector int __a, int __b,
11678                                             vector int *__c) {
11679   __builtin_altivec_stvxl(__a, __b, __c);
11680 }
11681
11682 static __inline__ void __ATTRS_o_ai vec_stl(vector int __a, int __b, int *__c) {
11683   __builtin_altivec_stvxl(__a, __b, __c);
11684 }
11685
11686 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned int __a, int __b,
11687                                             vector unsigned int *__c) {
11688   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11689 }
11690
11691 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned int __a, int __b,
11692                                             unsigned int *__c) {
11693   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11694 }
11695
11696 static __inline__ void __ATTRS_o_ai vec_stl(vector bool int __a, int __b,
11697                                             int *__c) {
11698   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11699 }
11700
11701 static __inline__ void __ATTRS_o_ai vec_stl(vector bool int __a, int __b,
11702                                             unsigned int *__c) {
11703   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11704 }
11705
11706 static __inline__ void __ATTRS_o_ai vec_stl(vector bool int __a, int __b,
11707                                             vector bool int *__c) {
11708   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11709 }
11710
11711 static __inline__ void __ATTRS_o_ai vec_stl(vector float __a, int __b,
11712                                             vector float *__c) {
11713   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11714 }
11715
11716 static __inline__ void __ATTRS_o_ai vec_stl(vector float __a, int __b,
11717                                             float *__c) {
11718   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11719 }
11720
11721 /* vec_stvxl */
11722
11723 static __inline__ void __ATTRS_o_ai vec_stvxl(vector signed char __a, int __b,
11724                                               vector signed char *__c) {
11725   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11726 }
11727
11728 static __inline__ void __ATTRS_o_ai vec_stvxl(vector signed char __a, int __b,
11729                                               signed char *__c) {
11730   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11731 }
11732
11733 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned char __a, int __b,
11734                                               vector unsigned char *__c) {
11735   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11736 }
11737
11738 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned char __a, int __b,
11739                                               unsigned char *__c) {
11740   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11741 }
11742
11743 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool char __a, int __b,
11744                                               signed char *__c) {
11745   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11746 }
11747
11748 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool char __a, int __b,
11749                                               unsigned char *__c) {
11750   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11751 }
11752
11753 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool char __a, int __b,
11754                                               vector bool char *__c) {
11755   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11756 }
11757
11758 static __inline__ void __ATTRS_o_ai vec_stvxl(vector short __a, int __b,
11759                                               vector short *__c) {
11760   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11761 }
11762
11763 static __inline__ void __ATTRS_o_ai vec_stvxl(vector short __a, int __b,
11764                                               short *__c) {
11765   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11766 }
11767
11768 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned short __a,
11769                                               int __b,
11770                                               vector unsigned short *__c) {
11771   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11772 }
11773
11774 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned short __a,
11775                                               int __b, unsigned short *__c) {
11776   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11777 }
11778
11779 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool short __a, int __b,
11780                                               short *__c) {
11781   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11782 }
11783
11784 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool short __a, int __b,
11785                                               unsigned short *__c) {
11786   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11787 }
11788
11789 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool short __a, int __b,
11790                                               vector bool short *__c) {
11791   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11792 }
11793
11794 static __inline__ void __ATTRS_o_ai vec_stvxl(vector pixel __a, int __b,
11795                                               short *__c) {
11796   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11797 }
11798
11799 static __inline__ void __ATTRS_o_ai vec_stvxl(vector pixel __a, int __b,
11800                                               unsigned short *__c) {
11801   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11802 }
11803
11804 static __inline__ void __ATTRS_o_ai vec_stvxl(vector pixel __a, int __b,
11805                                               vector pixel *__c) {
11806   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11807 }
11808
11809 static __inline__ void __ATTRS_o_ai vec_stvxl(vector int __a, int __b,
11810                                               vector int *__c) {
11811   __builtin_altivec_stvxl(__a, __b, __c);
11812 }
11813
11814 static __inline__ void __ATTRS_o_ai vec_stvxl(vector int __a, int __b,
11815                                               int *__c) {
11816   __builtin_altivec_stvxl(__a, __b, __c);
11817 }
11818
11819 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned int __a, int __b,
11820                                               vector unsigned int *__c) {
11821   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11822 }
11823
11824 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned int __a, int __b,
11825                                               unsigned int *__c) {
11826   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11827 }
11828
11829 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool int __a, int __b,
11830                                               int *__c) {
11831   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11832 }
11833
11834 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool int __a, int __b,
11835                                               unsigned int *__c) {
11836   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11837 }
11838
11839 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool int __a, int __b,
11840                                               vector bool int *__c) {
11841   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11842 }
11843
11844 static __inline__ void __ATTRS_o_ai vec_stvxl(vector float __a, int __b,
11845                                               vector float *__c) {
11846   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11847 }
11848
11849 static __inline__ void __ATTRS_o_ai vec_stvxl(vector float __a, int __b,
11850                                               float *__c) {
11851   __builtin_altivec_stvxl((vector int)__a, __b, __c);
11852 }
11853
11854 /* vec_sub */
11855
11856 static __inline__ vector signed char __ATTRS_o_ai
11857 vec_sub(vector signed char __a, vector signed char __b) {
11858   return __a - __b;
11859 }
11860
11861 static __inline__ vector signed char __ATTRS_o_ai
11862 vec_sub(vector bool char __a, vector signed char __b) {
11863   return (vector signed char)__a - __b;
11864 }
11865
11866 static __inline__ vector signed char __ATTRS_o_ai
11867 vec_sub(vector signed char __a, vector bool char __b) {
11868   return __a - (vector signed char)__b;
11869 }
11870
11871 static __inline__ vector unsigned char __ATTRS_o_ai
11872 vec_sub(vector unsigned char __a, vector unsigned char __b) {
11873   return __a - __b;
11874 }
11875
11876 static __inline__ vector unsigned char __ATTRS_o_ai
11877 vec_sub(vector bool char __a, vector unsigned char __b) {
11878   return (vector unsigned char)__a - __b;
11879 }
11880
11881 static __inline__ vector unsigned char __ATTRS_o_ai
11882 vec_sub(vector unsigned char __a, vector bool char __b) {
11883   return __a - (vector unsigned char)__b;
11884 }
11885
11886 static __inline__ vector short __ATTRS_o_ai vec_sub(vector short __a,
11887                                                     vector short __b) {
11888   return __a - __b;
11889 }
11890
11891 static __inline__ vector short __ATTRS_o_ai vec_sub(vector bool short __a,
11892                                                     vector short __b) {
11893   return (vector short)__a - __b;
11894 }
11895
11896 static __inline__ vector short __ATTRS_o_ai vec_sub(vector short __a,
11897                                                     vector bool short __b) {
11898   return __a - (vector short)__b;
11899 }
11900
11901 static __inline__ vector unsigned short __ATTRS_o_ai
11902 vec_sub(vector unsigned short __a, vector unsigned short __b) {
11903   return __a - __b;
11904 }
11905
11906 static __inline__ vector unsigned short __ATTRS_o_ai
11907 vec_sub(vector bool short __a, vector unsigned short __b) {
11908   return (vector unsigned short)__a - __b;
11909 }
11910
11911 static __inline__ vector unsigned short __ATTRS_o_ai
11912 vec_sub(vector unsigned short __a, vector bool short __b) {
11913   return __a - (vector unsigned short)__b;
11914 }
11915
11916 static __inline__ vector int __ATTRS_o_ai vec_sub(vector int __a,
11917                                                   vector int __b) {
11918   return __a - __b;
11919 }
11920
11921 static __inline__ vector int __ATTRS_o_ai vec_sub(vector bool int __a,
11922                                                   vector int __b) {
11923   return (vector int)__a - __b;
11924 }
11925
11926 static __inline__ vector int __ATTRS_o_ai vec_sub(vector int __a,
11927                                                   vector bool int __b) {
11928   return __a - (vector int)__b;
11929 }
11930
11931 static __inline__ vector unsigned int __ATTRS_o_ai
11932 vec_sub(vector unsigned int __a, vector unsigned int __b) {
11933   return __a - __b;
11934 }
11935
11936 static __inline__ vector unsigned int __ATTRS_o_ai
11937 vec_sub(vector bool int __a, vector unsigned int __b) {
11938   return (vector unsigned int)__a - __b;
11939 }
11940
11941 static __inline__ vector unsigned int __ATTRS_o_ai
11942 vec_sub(vector unsigned int __a, vector bool int __b) {
11943   return __a - (vector unsigned int)__b;
11944 }
11945
11946 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__) &&                    \
11947     defined(__SIZEOF_INT128__)
11948 static __inline__ vector signed __int128 __ATTRS_o_ai
11949 vec_sub(vector signed __int128 __a, vector signed __int128 __b) {
11950   return __a - __b;
11951 }
11952
11953 static __inline__ vector unsigned __int128 __ATTRS_o_ai
11954 vec_sub(vector unsigned __int128 __a, vector unsigned __int128 __b) {
11955   return __a - __b;
11956 }
11957 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__) &&
11958        // defined(__SIZEOF_INT128__)
11959
11960 #ifdef __VSX__
11961 static __inline__ vector signed long long __ATTRS_o_ai
11962 vec_sub(vector signed long long __a, vector signed long long __b) {
11963   return __a - __b;
11964 }
11965
11966 static __inline__ vector unsigned long long __ATTRS_o_ai
11967 vec_sub(vector unsigned long long __a, vector unsigned long long __b) {
11968   return __a - __b;
11969 }
11970
11971 static __inline__ vector double __ATTRS_o_ai vec_sub(vector double __a,
11972                                                      vector double __b) {
11973   return __a - __b;
11974 }
11975 #endif
11976
11977 static __inline__ vector float __ATTRS_o_ai vec_sub(vector float __a,
11978                                                     vector float __b) {
11979   return __a - __b;
11980 }
11981
11982 /* vec_vsububm */
11983
11984 #define __builtin_altivec_vsububm vec_vsububm
11985
11986 static __inline__ vector signed char __ATTRS_o_ai
11987 vec_vsububm(vector signed char __a, vector signed char __b) {
11988   return __a - __b;
11989 }
11990
11991 static __inline__ vector signed char __ATTRS_o_ai
11992 vec_vsububm(vector bool char __a, vector signed char __b) {
11993   return (vector signed char)__a - __b;
11994 }
11995
11996 static __inline__ vector signed char __ATTRS_o_ai
11997 vec_vsububm(vector signed char __a, vector bool char __b) {
11998   return __a - (vector signed char)__b;
11999 }
12000
12001 static __inline__ vector unsigned char __ATTRS_o_ai
12002 vec_vsububm(vector unsigned char __a, vector unsigned char __b) {
12003   return __a - __b;
12004 }
12005
12006 static __inline__ vector unsigned char __ATTRS_o_ai
12007 vec_vsububm(vector bool char __a, vector unsigned char __b) {
12008   return (vector unsigned char)__a - __b;
12009 }
12010
12011 static __inline__ vector unsigned char __ATTRS_o_ai
12012 vec_vsububm(vector unsigned char __a, vector bool char __b) {
12013   return __a - (vector unsigned char)__b;
12014 }
12015
12016 /* vec_vsubuhm */
12017
12018 #define __builtin_altivec_vsubuhm vec_vsubuhm
12019
12020 static __inline__ vector short __ATTRS_o_ai vec_vsubuhm(vector short __a,
12021                                                         vector short __b) {
12022   return __a - __b;
12023 }
12024
12025 static __inline__ vector short __ATTRS_o_ai vec_vsubuhm(vector bool short __a,
12026                                                         vector short __b) {
12027   return (vector short)__a - __b;
12028 }
12029
12030 static __inline__ vector short __ATTRS_o_ai vec_vsubuhm(vector short __a,
12031                                                         vector bool short __b) {
12032   return __a - (vector short)__b;
12033 }
12034
12035 static __inline__ vector unsigned short __ATTRS_o_ai
12036 vec_vsubuhm(vector unsigned short __a, vector unsigned short __b) {
12037   return __a - __b;
12038 }
12039
12040 static __inline__ vector unsigned short __ATTRS_o_ai
12041 vec_vsubuhm(vector bool short __a, vector unsigned short __b) {
12042   return (vector unsigned short)__a - __b;
12043 }
12044
12045 static __inline__ vector unsigned short __ATTRS_o_ai
12046 vec_vsubuhm(vector unsigned short __a, vector bool short __b) {
12047   return __a - (vector unsigned short)__b;
12048 }
12049
12050 /* vec_vsubuwm */
12051
12052 #define __builtin_altivec_vsubuwm vec_vsubuwm
12053
12054 static __inline__ vector int __ATTRS_o_ai vec_vsubuwm(vector int __a,
12055                                                       vector int __b) {
12056   return __a - __b;
12057 }
12058
12059 static __inline__ vector int __ATTRS_o_ai vec_vsubuwm(vector bool int __a,
12060                                                       vector int __b) {
12061   return (vector int)__a - __b;
12062 }
12063
12064 static __inline__ vector int __ATTRS_o_ai vec_vsubuwm(vector int __a,
12065                                                       vector bool int __b) {
12066   return __a - (vector int)__b;
12067 }
12068
12069 static __inline__ vector unsigned int __ATTRS_o_ai
12070 vec_vsubuwm(vector unsigned int __a, vector unsigned int __b) {
12071   return __a - __b;
12072 }
12073
12074 static __inline__ vector unsigned int __ATTRS_o_ai
12075 vec_vsubuwm(vector bool int __a, vector unsigned int __b) {
12076   return (vector unsigned int)__a - __b;
12077 }
12078
12079 static __inline__ vector unsigned int __ATTRS_o_ai
12080 vec_vsubuwm(vector unsigned int __a, vector bool int __b) {
12081   return __a - (vector unsigned int)__b;
12082 }
12083
12084 /* vec_vsubfp */
12085
12086 #define __builtin_altivec_vsubfp vec_vsubfp
12087
12088 static __inline__ vector float __attribute__((__always_inline__))
12089 vec_vsubfp(vector float __a, vector float __b) {
12090   return __a - __b;
12091 }
12092
12093 /* vec_subc */
12094
12095 static __inline__ vector signed int __ATTRS_o_ai
12096 vec_subc(vector signed int __a, vector signed int __b) {
12097   return (vector signed int)__builtin_altivec_vsubcuw((vector unsigned int)__a,
12098                                                       (vector unsigned int) __b);
12099 }
12100
12101 static __inline__ vector unsigned int __ATTRS_o_ai
12102 vec_subc(vector unsigned int __a, vector unsigned int __b) {
12103   return __builtin_altivec_vsubcuw(__a, __b);
12104 }
12105
12106 #ifdef __POWER8_VECTOR__
12107 #ifdef __SIZEOF_INT128__
12108 static __inline__ vector unsigned __int128 __ATTRS_o_ai
12109 vec_subc(vector unsigned __int128 __a, vector unsigned __int128 __b) {
12110   return __builtin_altivec_vsubcuq(__a, __b);
12111 }
12112
12113 static __inline__ vector signed __int128 __ATTRS_o_ai
12114 vec_subc(vector signed __int128 __a, vector signed __int128 __b) {
12115   return (vector signed __int128)__builtin_altivec_vsubcuq(
12116       (vector unsigned __int128)__a, (vector unsigned __int128)__b);
12117 }
12118 #endif
12119
12120 static __inline__ vector unsigned char __attribute__((__always_inline__))
12121 vec_subc_u128(vector unsigned char __a, vector unsigned char __b) {
12122   return (vector unsigned char)__builtin_altivec_vsubcuq_c(
12123       (vector unsigned char)__a, (vector unsigned char)__b);
12124 }
12125 #endif // __POWER8_VECTOR__
12126
12127 /* vec_vsubcuw */
12128
12129 static __inline__ vector unsigned int __attribute__((__always_inline__))
12130 vec_vsubcuw(vector unsigned int __a, vector unsigned int __b) {
12131   return __builtin_altivec_vsubcuw(__a, __b);
12132 }
12133
12134 /* vec_subs */
12135
12136 static __inline__ vector signed char __ATTRS_o_ai
12137 vec_subs(vector signed char __a, vector signed char __b) {
12138   return __builtin_altivec_vsubsbs(__a, __b);
12139 }
12140
12141 static __inline__ vector signed char __ATTRS_o_ai
12142 vec_subs(vector bool char __a, vector signed char __b) {
12143   return __builtin_altivec_vsubsbs((vector signed char)__a, __b);
12144 }
12145
12146 static __inline__ vector signed char __ATTRS_o_ai
12147 vec_subs(vector signed char __a, vector bool char __b) {
12148   return __builtin_altivec_vsubsbs(__a, (vector signed char)__b);
12149 }
12150
12151 static __inline__ vector unsigned char __ATTRS_o_ai
12152 vec_subs(vector unsigned char __a, vector unsigned char __b) {
12153   return __builtin_altivec_vsububs(__a, __b);
12154 }
12155
12156 static __inline__ vector unsigned char __ATTRS_o_ai
12157 vec_subs(vector bool char __a, vector unsigned char __b) {
12158   return __builtin_altivec_vsububs((vector unsigned char)__a, __b);
12159 }
12160
12161 static __inline__ vector unsigned char __ATTRS_o_ai
12162 vec_subs(vector unsigned char __a, vector bool char __b) {
12163   return __builtin_altivec_vsububs(__a, (vector unsigned char)__b);
12164 }
12165
12166 static __inline__ vector short __ATTRS_o_ai vec_subs(vector short __a,
12167                                                      vector short __b) {
12168   return __builtin_altivec_vsubshs(__a, __b);
12169 }
12170
12171 static __inline__ vector short __ATTRS_o_ai vec_subs(vector bool short __a,
12172                                                      vector short __b) {
12173   return __builtin_altivec_vsubshs((vector short)__a, __b);
12174 }
12175
12176 static __inline__ vector short __ATTRS_o_ai vec_subs(vector short __a,
12177                                                      vector bool short __b) {
12178   return __builtin_altivec_vsubshs(__a, (vector short)__b);
12179 }
12180
12181 static __inline__ vector unsigned short __ATTRS_o_ai
12182 vec_subs(vector unsigned short __a, vector unsigned short __b) {
12183   return __builtin_altivec_vsubuhs(__a, __b);
12184 }
12185
12186 static __inline__ vector unsigned short __ATTRS_o_ai
12187 vec_subs(vector bool short __a, vector unsigned short __b) {
12188   return __builtin_altivec_vsubuhs((vector unsigned short)__a, __b);
12189 }
12190
12191 static __inline__ vector unsigned short __ATTRS_o_ai
12192 vec_subs(vector unsigned short __a, vector bool short __b) {
12193   return __builtin_altivec_vsubuhs(__a, (vector unsigned short)__b);
12194 }
12195
12196 static __inline__ vector int __ATTRS_o_ai vec_subs(vector int __a,
12197                                                    vector int __b) {
12198   return __builtin_altivec_vsubsws(__a, __b);
12199 }
12200
12201 static __inline__ vector int __ATTRS_o_ai vec_subs(vector bool int __a,
12202                                                    vector int __b) {
12203   return __builtin_altivec_vsubsws((vector int)__a, __b);
12204 }
12205
12206 static __inline__ vector int __ATTRS_o_ai vec_subs(vector int __a,
12207                                                    vector bool int __b) {
12208   return __builtin_altivec_vsubsws(__a, (vector int)__b);
12209 }
12210
12211 static __inline__ vector unsigned int __ATTRS_o_ai
12212 vec_subs(vector unsigned int __a, vector unsigned int __b) {
12213   return __builtin_altivec_vsubuws(__a, __b);
12214 }
12215
12216 static __inline__ vector unsigned int __ATTRS_o_ai
12217 vec_subs(vector bool int __a, vector unsigned int __b) {
12218   return __builtin_altivec_vsubuws((vector unsigned int)__a, __b);
12219 }
12220
12221 static __inline__ vector unsigned int __ATTRS_o_ai
12222 vec_subs(vector unsigned int __a, vector bool int __b) {
12223   return __builtin_altivec_vsubuws(__a, (vector unsigned int)__b);
12224 }
12225
12226 /* vec_vsubsbs */
12227
12228 static __inline__ vector signed char __ATTRS_o_ai
12229 vec_vsubsbs(vector signed char __a, vector signed char __b) {
12230   return __builtin_altivec_vsubsbs(__a, __b);
12231 }
12232
12233 static __inline__ vector signed char __ATTRS_o_ai
12234 vec_vsubsbs(vector bool char __a, vector signed char __b) {
12235   return __builtin_altivec_vsubsbs((vector signed char)__a, __b);
12236 }
12237
12238 static __inline__ vector signed char __ATTRS_o_ai
12239 vec_vsubsbs(vector signed char __a, vector bool char __b) {
12240   return __builtin_altivec_vsubsbs(__a, (vector signed char)__b);
12241 }
12242
12243 /* vec_vsububs */
12244
12245 static __inline__ vector unsigned char __ATTRS_o_ai
12246 vec_vsububs(vector unsigned char __a, vector unsigned char __b) {
12247   return __builtin_altivec_vsububs(__a, __b);
12248 }
12249
12250 static __inline__ vector unsigned char __ATTRS_o_ai
12251 vec_vsububs(vector bool char __a, vector unsigned char __b) {
12252   return __builtin_altivec_vsububs((vector unsigned char)__a, __b);
12253 }
12254
12255 static __inline__ vector unsigned char __ATTRS_o_ai
12256 vec_vsububs(vector unsigned char __a, vector bool char __b) {
12257   return __builtin_altivec_vsububs(__a, (vector unsigned char)__b);
12258 }
12259
12260 /* vec_vsubshs */
12261
12262 static __inline__ vector short __ATTRS_o_ai vec_vsubshs(vector short __a,
12263                                                         vector short __b) {
12264   return __builtin_altivec_vsubshs(__a, __b);
12265 }
12266
12267 static __inline__ vector short __ATTRS_o_ai vec_vsubshs(vector bool short __a,
12268                                                         vector short __b) {
12269   return __builtin_altivec_vsubshs((vector short)__a, __b);
12270 }
12271
12272 static __inline__ vector short __ATTRS_o_ai vec_vsubshs(vector short __a,
12273                                                         vector bool short __b) {
12274   return __builtin_altivec_vsubshs(__a, (vector short)__b);
12275 }
12276
12277 /* vec_vsubuhs */
12278
12279 static __inline__ vector unsigned short __ATTRS_o_ai
12280 vec_vsubuhs(vector unsigned short __a, vector unsigned short __b) {
12281   return __builtin_altivec_vsubuhs(__a, __b);
12282 }
12283
12284 static __inline__ vector unsigned short __ATTRS_o_ai
12285 vec_vsubuhs(vector bool short __a, vector unsigned short __b) {
12286   return __builtin_altivec_vsubuhs((vector unsigned short)__a, __b);
12287 }
12288
12289 static __inline__ vector unsigned short __ATTRS_o_ai
12290 vec_vsubuhs(vector unsigned short __a, vector bool short __b) {
12291   return __builtin_altivec_vsubuhs(__a, (vector unsigned short)__b);
12292 }
12293
12294 /* vec_vsubsws */
12295
12296 static __inline__ vector int __ATTRS_o_ai vec_vsubsws(vector int __a,
12297                                                       vector int __b) {
12298   return __builtin_altivec_vsubsws(__a, __b);
12299 }
12300
12301 static __inline__ vector int __ATTRS_o_ai vec_vsubsws(vector bool int __a,
12302                                                       vector int __b) {
12303   return __builtin_altivec_vsubsws((vector int)__a, __b);
12304 }
12305
12306 static __inline__ vector int __ATTRS_o_ai vec_vsubsws(vector int __a,
12307                                                       vector bool int __b) {
12308   return __builtin_altivec_vsubsws(__a, (vector int)__b);
12309 }
12310
12311 /* vec_vsubuws */
12312
12313 static __inline__ vector unsigned int __ATTRS_o_ai
12314 vec_vsubuws(vector unsigned int __a, vector unsigned int __b) {
12315   return __builtin_altivec_vsubuws(__a, __b);
12316 }
12317
12318 static __inline__ vector unsigned int __ATTRS_o_ai
12319 vec_vsubuws(vector bool int __a, vector unsigned int __b) {
12320   return __builtin_altivec_vsubuws((vector unsigned int)__a, __b);
12321 }
12322
12323 static __inline__ vector unsigned int __ATTRS_o_ai
12324 vec_vsubuws(vector unsigned int __a, vector bool int __b) {
12325   return __builtin_altivec_vsubuws(__a, (vector unsigned int)__b);
12326 }
12327
12328 #ifdef __POWER8_VECTOR__
12329 /* vec_vsubuqm */
12330
12331 #ifdef __SIZEOF_INT128__
12332 static __inline__ vector signed __int128 __ATTRS_o_ai
12333 vec_vsubuqm(vector signed __int128 __a, vector signed __int128 __b) {
12334   return __a - __b;
12335 }
12336
12337 static __inline__ vector unsigned __int128 __ATTRS_o_ai
12338 vec_vsubuqm(vector unsigned __int128 __a, vector unsigned __int128 __b) {
12339   return __a - __b;
12340 }
12341 #endif
12342
12343 static __inline__ vector unsigned char __attribute__((__always_inline__))
12344 vec_sub_u128(vector unsigned char __a, vector unsigned char __b) {
12345   return (vector unsigned char)__builtin_altivec_vsubuqm(__a, __b);
12346 }
12347
12348 /* vec_vsubeuqm */
12349
12350 #ifdef __SIZEOF_INT128__
12351 static __inline__ vector signed __int128 __ATTRS_o_ai
12352 vec_vsubeuqm(vector signed __int128 __a, vector signed __int128 __b,
12353              vector signed __int128 __c) {
12354   return (vector signed __int128)__builtin_altivec_vsubeuqm(
12355       (vector unsigned __int128)__a, (vector unsigned __int128)__b,
12356       (vector unsigned __int128)__c);
12357 }
12358
12359 static __inline__ vector unsigned __int128 __ATTRS_o_ai
12360 vec_vsubeuqm(vector unsigned __int128 __a, vector unsigned __int128 __b,
12361              vector unsigned __int128 __c) {
12362   return __builtin_altivec_vsubeuqm(__a, __b, __c);
12363 }
12364
12365 static __inline__ vector signed __int128 __ATTRS_o_ai
12366 vec_sube(vector signed __int128 __a, vector signed __int128 __b,
12367              vector signed __int128 __c) {
12368   return (vector signed __int128)__builtin_altivec_vsubeuqm(
12369       (vector unsigned __int128)__a, (vector unsigned __int128)__b,
12370       (vector unsigned __int128)__c);
12371 }
12372
12373 static __inline__ vector unsigned __int128 __ATTRS_o_ai
12374 vec_sube(vector unsigned __int128 __a, vector unsigned __int128 __b,
12375              vector unsigned __int128 __c) {
12376   return __builtin_altivec_vsubeuqm(__a, __b, __c);
12377 }
12378 #endif
12379
12380 static __inline__ vector unsigned char __attribute__((__always_inline__))
12381 vec_sube_u128(vector unsigned char __a, vector unsigned char __b,
12382               vector unsigned char __c) {
12383   return (vector unsigned char)__builtin_altivec_vsubeuqm_c(
12384       (vector unsigned char)__a, (vector unsigned char)__b,
12385       (vector unsigned char)__c);
12386 }
12387
12388 /* vec_vsubcuq */
12389
12390 #ifdef __SIZEOF_INT128__
12391 static __inline__ vector signed __int128 __ATTRS_o_ai
12392 vec_vsubcuq(vector signed __int128 __a, vector signed __int128 __b) {
12393   return (vector signed __int128)__builtin_altivec_vsubcuq(
12394       (vector unsigned __int128)__a, (vector unsigned __int128)__b);
12395 }
12396
12397 static __inline__ vector unsigned __int128 __ATTRS_o_ai
12398 vec_vsubcuq(vector unsigned __int128 __a, vector unsigned __int128 __b) {
12399   return __builtin_altivec_vsubcuq(__a, __b);
12400 }
12401
12402 /* vec_vsubecuq */
12403
12404 static __inline__ vector signed __int128 __ATTRS_o_ai
12405 vec_vsubecuq(vector signed __int128 __a, vector signed __int128 __b,
12406              vector signed __int128 __c) {
12407   return (vector signed __int128)__builtin_altivec_vsubecuq(
12408       (vector unsigned __int128)__a, (vector unsigned __int128)__b,
12409       (vector unsigned __int128)__c);
12410 }
12411
12412 static __inline__ vector unsigned __int128 __ATTRS_o_ai
12413 vec_vsubecuq(vector unsigned __int128 __a, vector unsigned __int128 __b,
12414              vector unsigned __int128 __c) {
12415   return __builtin_altivec_vsubecuq(__a, __b, __c);
12416 }
12417 #endif
12418
12419 #ifdef __powerpc64__
12420 static __inline__ vector signed int __ATTRS_o_ai
12421 vec_subec(vector signed int __a, vector signed int __b,
12422              vector signed int __c) {
12423   return vec_addec(__a, ~__b, __c);
12424 }
12425
12426 static __inline__ vector unsigned int __ATTRS_o_ai
12427 vec_subec(vector unsigned int __a, vector unsigned int __b,
12428              vector unsigned int __c) {
12429   return vec_addec(__a, ~__b, __c);
12430 }
12431 #endif
12432
12433 #ifdef __SIZEOF_INT128__
12434 static __inline__ vector signed __int128 __ATTRS_o_ai
12435 vec_subec(vector signed __int128 __a, vector signed __int128 __b,
12436              vector signed __int128 __c) {
12437   return (vector signed __int128)__builtin_altivec_vsubecuq(
12438       (vector unsigned __int128)__a, (vector unsigned __int128)__b,
12439       (vector unsigned __int128)__c);
12440 }
12441
12442 static __inline__ vector unsigned __int128 __ATTRS_o_ai
12443 vec_subec(vector unsigned __int128 __a, vector unsigned __int128 __b,
12444              vector unsigned __int128 __c) {
12445   return __builtin_altivec_vsubecuq(__a, __b, __c);
12446 }
12447 #endif
12448
12449 static __inline__ vector unsigned char __attribute__((__always_inline__))
12450 vec_subec_u128(vector unsigned char __a, vector unsigned char __b,
12451                vector unsigned char __c) {
12452   return (vector unsigned char)__builtin_altivec_vsubecuq_c(
12453       (vector unsigned char)__a, (vector unsigned char)__b,
12454       (vector unsigned char)__c);
12455 }
12456 #endif // __POWER8_VECTOR__
12457
12458 static __inline__ vector signed int __ATTRS_o_ai
12459 vec_sube(vector signed int __a, vector signed int __b,
12460          vector signed int __c) {
12461   vector signed int __mask = {1, 1, 1, 1};
12462   vector signed int __carry = __c & __mask;
12463   return vec_adde(__a, ~__b, __carry);
12464 }
12465
12466 static __inline__ vector unsigned int __ATTRS_o_ai
12467 vec_sube(vector unsigned int __a, vector unsigned int __b,
12468          vector unsigned int __c) {
12469   vector unsigned int __mask = {1, 1, 1, 1};
12470   vector unsigned int __carry = __c & __mask;
12471   return vec_adde(__a, ~__b, __carry);
12472 }
12473 /* vec_sum4s */
12474
12475 static __inline__ vector int __ATTRS_o_ai vec_sum4s(vector signed char __a,
12476                                                     vector int __b) {
12477   return __builtin_altivec_vsum4sbs(__a, __b);
12478 }
12479
12480 static __inline__ vector unsigned int __ATTRS_o_ai
12481 vec_sum4s(vector unsigned char __a, vector unsigned int __b) {
12482   return __builtin_altivec_vsum4ubs(__a, __b);
12483 }
12484
12485 static __inline__ vector int __ATTRS_o_ai vec_sum4s(vector signed short __a,
12486                                                     vector int __b) {
12487   return __builtin_altivec_vsum4shs(__a, __b);
12488 }
12489
12490 /* vec_vsum4sbs */
12491
12492 static __inline__ vector int __attribute__((__always_inline__))
12493 vec_vsum4sbs(vector signed char __a, vector int __b) {
12494   return __builtin_altivec_vsum4sbs(__a, __b);
12495 }
12496
12497 /* vec_vsum4ubs */
12498
12499 static __inline__ vector unsigned int __attribute__((__always_inline__))
12500 vec_vsum4ubs(vector unsigned char __a, vector unsigned int __b) {
12501   return __builtin_altivec_vsum4ubs(__a, __b);
12502 }
12503
12504 /* vec_vsum4shs */
12505
12506 static __inline__ vector int __attribute__((__always_inline__))
12507 vec_vsum4shs(vector signed short __a, vector int __b) {
12508   return __builtin_altivec_vsum4shs(__a, __b);
12509 }
12510
12511 /* vec_sum2s */
12512
12513 /* The vsum2sws instruction has a big-endian bias, so that the second
12514    input vector and the result always reference big-endian elements
12515    1 and 3 (little-endian element 0 and 2).  For ease of porting the
12516    programmer wants elements 1 and 3 in both cases, so for little
12517    endian we must perform some permutes.  */
12518
12519 static __inline__ vector signed int __attribute__((__always_inline__))
12520 vec_sum2s(vector int __a, vector int __b) {
12521 #ifdef __LITTLE_ENDIAN__
12522   vector int __c = (vector signed int)vec_perm(
12523       __b, __b, (vector unsigned char)(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15,
12524                                        8, 9, 10, 11));
12525   __c = __builtin_altivec_vsum2sws(__a, __c);
12526   return (vector signed int)vec_perm(
12527       __c, __c, (vector unsigned char)(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15,
12528                                        8, 9, 10, 11));
12529 #else
12530   return __builtin_altivec_vsum2sws(__a, __b);
12531 #endif
12532 }
12533
12534 /* vec_vsum2sws */
12535
12536 static __inline__ vector signed int __attribute__((__always_inline__))
12537 vec_vsum2sws(vector int __a, vector int __b) {
12538 #ifdef __LITTLE_ENDIAN__
12539   vector int __c = (vector signed int)vec_perm(
12540       __b, __b, (vector unsigned char)(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15,
12541                                        8, 9, 10, 11));
12542   __c = __builtin_altivec_vsum2sws(__a, __c);
12543   return (vector signed int)vec_perm(
12544       __c, __c, (vector unsigned char)(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15,
12545                                        8, 9, 10, 11));
12546 #else
12547   return __builtin_altivec_vsum2sws(__a, __b);
12548 #endif
12549 }
12550
12551 /* vec_sums */
12552
12553 /* The vsumsws instruction has a big-endian bias, so that the second
12554    input vector and the result always reference big-endian element 3
12555    (little-endian element 0).  For ease of porting the programmer
12556    wants element 3 in both cases, so for little endian we must perform
12557    some permutes.  */
12558
12559 static __inline__ vector signed int __attribute__((__always_inline__))
12560 vec_sums(vector signed int __a, vector signed int __b) {
12561 #ifdef __LITTLE_ENDIAN__
12562   __b = (vector signed int)vec_splat(__b, 3);
12563   __b = __builtin_altivec_vsumsws(__a, __b);
12564   return (vector signed int)(0, 0, 0, __b[0]);
12565 #else
12566   return __builtin_altivec_vsumsws(__a, __b);
12567 #endif
12568 }
12569
12570 /* vec_vsumsws */
12571
12572 static __inline__ vector signed int __attribute__((__always_inline__))
12573 vec_vsumsws(vector signed int __a, vector signed int __b) {
12574 #ifdef __LITTLE_ENDIAN__
12575   __b = (vector signed int)vec_splat(__b, 3);
12576   __b = __builtin_altivec_vsumsws(__a, __b);
12577   return (vector signed int)(0, 0, 0, __b[0]);
12578 #else
12579   return __builtin_altivec_vsumsws(__a, __b);
12580 #endif
12581 }
12582
12583 /* vec_trunc */
12584
12585 static __inline__ vector float __ATTRS_o_ai vec_trunc(vector float __a) {
12586 #ifdef __VSX__
12587   return __builtin_vsx_xvrspiz(__a);
12588 #else
12589   return __builtin_altivec_vrfiz(__a);
12590 #endif
12591 }
12592
12593 #ifdef __VSX__
12594 static __inline__ vector double __ATTRS_o_ai vec_trunc(vector double __a) {
12595   return __builtin_vsx_xvrdpiz(__a);
12596 }
12597 #endif
12598
12599 /* vec_roundz */
12600 static __inline__ vector float __ATTRS_o_ai vec_roundz(vector float __a) {
12601   return vec_trunc(__a);
12602 }
12603
12604 #ifdef __VSX__
12605 static __inline__ vector double __ATTRS_o_ai vec_roundz(vector double __a) {
12606   return vec_trunc(__a);
12607 }
12608 #endif
12609
12610 /* vec_vrfiz */
12611
12612 static __inline__ vector float __attribute__((__always_inline__))
12613 vec_vrfiz(vector float __a) {
12614   return __builtin_altivec_vrfiz(__a);
12615 }
12616
12617 /* vec_unpackh */
12618
12619 /* The vector unpack instructions all have a big-endian bias, so for
12620    little endian we must reverse the meanings of "high" and "low."  */
12621 #ifdef __LITTLE_ENDIAN__
12622 #define vec_vupkhpx(__a) __builtin_altivec_vupklpx((vector short)(__a))
12623 #define vec_vupklpx(__a) __builtin_altivec_vupkhpx((vector short)(__a))
12624 #else
12625 #define vec_vupkhpx(__a) __builtin_altivec_vupkhpx((vector short)(__a))
12626 #define vec_vupklpx(__a) __builtin_altivec_vupklpx((vector short)(__a))
12627 #endif
12628
12629 static __inline__ vector short __ATTRS_o_ai
12630 vec_unpackh(vector signed char __a) {
12631 #ifdef __LITTLE_ENDIAN__
12632   return __builtin_altivec_vupklsb((vector char)__a);
12633 #else
12634   return __builtin_altivec_vupkhsb((vector char)__a);
12635 #endif
12636 }
12637
12638 static __inline__ vector bool short __ATTRS_o_ai
12639 vec_unpackh(vector bool char __a) {
12640 #ifdef __LITTLE_ENDIAN__
12641   return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
12642 #else
12643   return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
12644 #endif
12645 }
12646
12647 static __inline__ vector int __ATTRS_o_ai vec_unpackh(vector short __a) {
12648 #ifdef __LITTLE_ENDIAN__
12649   return __builtin_altivec_vupklsh(__a);
12650 #else
12651   return __builtin_altivec_vupkhsh(__a);
12652 #endif
12653 }
12654
12655 static __inline__ vector bool int __ATTRS_o_ai
12656 vec_unpackh(vector bool short __a) {
12657 #ifdef __LITTLE_ENDIAN__
12658   return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
12659 #else
12660   return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
12661 #endif
12662 }
12663
12664 static __inline__ vector unsigned int __ATTRS_o_ai
12665 vec_unpackh(vector pixel __a) {
12666 #ifdef __LITTLE_ENDIAN__
12667   return (vector unsigned int)__builtin_altivec_vupklpx((vector short)__a);
12668 #else
12669   return (vector unsigned int)__builtin_altivec_vupkhpx((vector short)__a);
12670 #endif
12671 }
12672
12673 #ifdef __POWER8_VECTOR__
12674 static __inline__ vector long long __ATTRS_o_ai vec_unpackh(vector int __a) {
12675 #ifdef __LITTLE_ENDIAN__
12676   return __builtin_altivec_vupklsw(__a);
12677 #else
12678   return __builtin_altivec_vupkhsw(__a);
12679 #endif
12680 }
12681
12682 static __inline__ vector bool long long __ATTRS_o_ai
12683 vec_unpackh(vector bool int __a) {
12684 #ifdef __LITTLE_ENDIAN__
12685   return (vector bool long long)__builtin_altivec_vupklsw((vector int)__a);
12686 #else
12687   return (vector bool long long)__builtin_altivec_vupkhsw((vector int)__a);
12688 #endif
12689 }
12690
12691 static __inline__ vector double __ATTRS_o_ai
12692 vec_unpackh(vector float __a) {
12693   return (vector double)(__a[0], __a[1]);
12694 }
12695 #endif
12696
12697 /* vec_vupkhsb */
12698
12699 static __inline__ vector short __ATTRS_o_ai
12700 vec_vupkhsb(vector signed char __a) {
12701 #ifdef __LITTLE_ENDIAN__
12702   return __builtin_altivec_vupklsb((vector char)__a);
12703 #else
12704   return __builtin_altivec_vupkhsb((vector char)__a);
12705 #endif
12706 }
12707
12708 static __inline__ vector bool short __ATTRS_o_ai
12709 vec_vupkhsb(vector bool char __a) {
12710 #ifdef __LITTLE_ENDIAN__
12711   return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
12712 #else
12713   return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
12714 #endif
12715 }
12716
12717 /* vec_vupkhsh */
12718
12719 static __inline__ vector int __ATTRS_o_ai vec_vupkhsh(vector short __a) {
12720 #ifdef __LITTLE_ENDIAN__
12721   return __builtin_altivec_vupklsh(__a);
12722 #else
12723   return __builtin_altivec_vupkhsh(__a);
12724 #endif
12725 }
12726
12727 static __inline__ vector bool int __ATTRS_o_ai
12728 vec_vupkhsh(vector bool short __a) {
12729 #ifdef __LITTLE_ENDIAN__
12730   return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
12731 #else
12732   return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
12733 #endif
12734 }
12735
12736 static __inline__ vector unsigned int __ATTRS_o_ai
12737 vec_vupkhsh(vector pixel __a) {
12738 #ifdef __LITTLE_ENDIAN__
12739   return (vector unsigned int)__builtin_altivec_vupklpx((vector short)__a);
12740 #else
12741   return (vector unsigned int)__builtin_altivec_vupkhpx((vector short)__a);
12742 #endif
12743 }
12744
12745 /* vec_vupkhsw */
12746
12747 #ifdef __POWER8_VECTOR__
12748 static __inline__ vector long long __ATTRS_o_ai vec_vupkhsw(vector int __a) {
12749 #ifdef __LITTLE_ENDIAN__
12750   return __builtin_altivec_vupklsw(__a);
12751 #else
12752   return __builtin_altivec_vupkhsw(__a);
12753 #endif
12754 }
12755
12756 static __inline__ vector bool long long __ATTRS_o_ai
12757 vec_vupkhsw(vector bool int __a) {
12758 #ifdef __LITTLE_ENDIAN__
12759   return (vector bool long long)__builtin_altivec_vupklsw((vector int)__a);
12760 #else
12761   return (vector bool long long)__builtin_altivec_vupkhsw((vector int)__a);
12762 #endif
12763 }
12764 #endif
12765
12766 /* vec_unpackl */
12767
12768 static __inline__ vector short __ATTRS_o_ai
12769 vec_unpackl(vector signed char __a) {
12770 #ifdef __LITTLE_ENDIAN__
12771   return __builtin_altivec_vupkhsb((vector char)__a);
12772 #else
12773   return __builtin_altivec_vupklsb((vector char)__a);
12774 #endif
12775 }
12776
12777 static __inline__ vector bool short __ATTRS_o_ai
12778 vec_unpackl(vector bool char __a) {
12779 #ifdef __LITTLE_ENDIAN__
12780   return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
12781 #else
12782   return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
12783 #endif
12784 }
12785
12786 static __inline__ vector int __ATTRS_o_ai vec_unpackl(vector short __a) {
12787 #ifdef __LITTLE_ENDIAN__
12788   return __builtin_altivec_vupkhsh(__a);
12789 #else
12790   return __builtin_altivec_vupklsh(__a);
12791 #endif
12792 }
12793
12794 static __inline__ vector bool int __ATTRS_o_ai
12795 vec_unpackl(vector bool short __a) {
12796 #ifdef __LITTLE_ENDIAN__
12797   return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
12798 #else
12799   return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
12800 #endif
12801 }
12802
12803 static __inline__ vector unsigned int __ATTRS_o_ai
12804 vec_unpackl(vector pixel __a) {
12805 #ifdef __LITTLE_ENDIAN__
12806   return (vector unsigned int)__builtin_altivec_vupkhpx((vector short)__a);
12807 #else
12808   return (vector unsigned int)__builtin_altivec_vupklpx((vector short)__a);
12809 #endif
12810 }
12811
12812 #ifdef __POWER8_VECTOR__
12813 static __inline__ vector long long __ATTRS_o_ai vec_unpackl(vector int __a) {
12814 #ifdef __LITTLE_ENDIAN__
12815   return __builtin_altivec_vupkhsw(__a);
12816 #else
12817   return __builtin_altivec_vupklsw(__a);
12818 #endif
12819 }
12820
12821 static __inline__ vector bool long long __ATTRS_o_ai
12822 vec_unpackl(vector bool int __a) {
12823 #ifdef __LITTLE_ENDIAN__
12824   return (vector bool long long)__builtin_altivec_vupkhsw((vector int)__a);
12825 #else
12826   return (vector bool long long)__builtin_altivec_vupklsw((vector int)__a);
12827 #endif
12828 }
12829
12830 static __inline__ vector double __ATTRS_o_ai
12831 vec_unpackl(vector float __a) {
12832   return (vector double)(__a[2], __a[3]);
12833 }
12834 #endif
12835
12836 /* vec_vupklsb */
12837
12838 static __inline__ vector short __ATTRS_o_ai
12839 vec_vupklsb(vector signed char __a) {
12840 #ifdef __LITTLE_ENDIAN__
12841   return __builtin_altivec_vupkhsb((vector char)__a);
12842 #else
12843   return __builtin_altivec_vupklsb((vector char)__a);
12844 #endif
12845 }
12846
12847 static __inline__ vector bool short __ATTRS_o_ai
12848 vec_vupklsb(vector bool char __a) {
12849 #ifdef __LITTLE_ENDIAN__
12850   return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
12851 #else
12852   return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
12853 #endif
12854 }
12855
12856 /* vec_vupklsh */
12857
12858 static __inline__ vector int __ATTRS_o_ai vec_vupklsh(vector short __a) {
12859 #ifdef __LITTLE_ENDIAN__
12860   return __builtin_altivec_vupkhsh(__a);
12861 #else
12862   return __builtin_altivec_vupklsh(__a);
12863 #endif
12864 }
12865
12866 static __inline__ vector bool int __ATTRS_o_ai
12867 vec_vupklsh(vector bool short __a) {
12868 #ifdef __LITTLE_ENDIAN__
12869   return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
12870 #else
12871   return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
12872 #endif
12873 }
12874
12875 static __inline__ vector unsigned int __ATTRS_o_ai
12876 vec_vupklsh(vector pixel __a) {
12877 #ifdef __LITTLE_ENDIAN__
12878   return (vector unsigned int)__builtin_altivec_vupkhpx((vector short)__a);
12879 #else
12880   return (vector unsigned int)__builtin_altivec_vupklpx((vector short)__a);
12881 #endif
12882 }
12883
12884 /* vec_vupklsw */
12885
12886 #ifdef __POWER8_VECTOR__
12887 static __inline__ vector long long __ATTRS_o_ai vec_vupklsw(vector int __a) {
12888 #ifdef __LITTLE_ENDIAN__
12889   return __builtin_altivec_vupkhsw(__a);
12890 #else
12891   return __builtin_altivec_vupklsw(__a);
12892 #endif
12893 }
12894
12895 static __inline__ vector bool long long __ATTRS_o_ai
12896 vec_vupklsw(vector bool int __a) {
12897 #ifdef __LITTLE_ENDIAN__
12898   return (vector bool long long)__builtin_altivec_vupkhsw((vector int)__a);
12899 #else
12900   return (vector bool long long)__builtin_altivec_vupklsw((vector int)__a);
12901 #endif
12902 }
12903 #endif
12904
12905 /* vec_vsx_ld */
12906
12907 #ifdef __VSX__
12908
12909 static __inline__ vector bool int __ATTRS_o_ai
12910 vec_vsx_ld(int __a, const vector bool int *__b) {
12911   return (vector bool int)__builtin_vsx_lxvw4x(__a, __b);
12912 }
12913
12914 static __inline__ vector signed int __ATTRS_o_ai
12915 vec_vsx_ld(int __a, const vector signed int *__b) {
12916   return (vector signed int)__builtin_vsx_lxvw4x(__a, __b);
12917 }
12918
12919 static __inline__ vector signed int __ATTRS_o_ai
12920 vec_vsx_ld(int __a, const signed int *__b) {
12921   return (vector signed int)__builtin_vsx_lxvw4x(__a, __b);
12922 }
12923
12924 static __inline__ vector unsigned int __ATTRS_o_ai
12925 vec_vsx_ld(int __a, const vector unsigned int *__b) {
12926   return (vector unsigned int)__builtin_vsx_lxvw4x(__a, __b);
12927 }
12928
12929 static __inline__ vector unsigned int __ATTRS_o_ai
12930 vec_vsx_ld(int __a, const unsigned int *__b) {
12931   return (vector unsigned int)__builtin_vsx_lxvw4x(__a, __b);
12932 }
12933
12934 static __inline__ vector float __ATTRS_o_ai
12935 vec_vsx_ld(int __a, const vector float *__b) {
12936   return (vector float)__builtin_vsx_lxvw4x(__a, __b);
12937 }
12938
12939 static __inline__ vector float __ATTRS_o_ai vec_vsx_ld(int __a,
12940                                                        const float *__b) {
12941   return (vector float)__builtin_vsx_lxvw4x(__a, __b);
12942 }
12943
12944 static __inline__ vector signed long long __ATTRS_o_ai
12945 vec_vsx_ld(int __a, const vector signed long long *__b) {
12946   return (vector signed long long)__builtin_vsx_lxvd2x(__a, __b);
12947 }
12948
12949 static __inline__ vector unsigned long long __ATTRS_o_ai
12950 vec_vsx_ld(int __a, const vector unsigned long long *__b) {
12951   return (vector unsigned long long)__builtin_vsx_lxvd2x(__a, __b);
12952 }
12953
12954 static __inline__ vector double __ATTRS_o_ai
12955 vec_vsx_ld(int __a, const vector double *__b) {
12956   return (vector double)__builtin_vsx_lxvd2x(__a, __b);
12957 }
12958
12959 static __inline__ vector double __ATTRS_o_ai
12960 vec_vsx_ld(int __a, const double *__b) {
12961   return (vector double)__builtin_vsx_lxvd2x(__a, __b);
12962 }
12963
12964 static __inline__ vector bool short __ATTRS_o_ai
12965 vec_vsx_ld(int __a, const vector bool short *__b) {
12966   return (vector bool short)__builtin_vsx_lxvw4x(__a, __b);
12967 }
12968
12969 static __inline__ vector signed short __ATTRS_o_ai
12970 vec_vsx_ld(int __a, const vector signed short *__b) {
12971   return (vector signed short)__builtin_vsx_lxvw4x(__a, __b);
12972 }
12973
12974 static __inline__ vector signed short __ATTRS_o_ai
12975 vec_vsx_ld(int __a, const signed short *__b) {
12976   return (vector signed short)__builtin_vsx_lxvw4x(__a, __b);
12977 }
12978
12979 static __inline__ vector unsigned short __ATTRS_o_ai
12980 vec_vsx_ld(int __a, const vector unsigned short *__b) {
12981   return (vector unsigned short)__builtin_vsx_lxvw4x(__a, __b);
12982 }
12983
12984 static __inline__ vector unsigned short __ATTRS_o_ai
12985 vec_vsx_ld(int __a, const unsigned short *__b) {
12986   return (vector unsigned short)__builtin_vsx_lxvw4x(__a, __b);
12987 }
12988
12989 static __inline__ vector bool char __ATTRS_o_ai
12990 vec_vsx_ld(int __a, const vector bool char *__b) {
12991   return (vector bool char)__builtin_vsx_lxvw4x(__a, __b);
12992 }
12993
12994 static __inline__ vector signed char __ATTRS_o_ai
12995 vec_vsx_ld(int __a, const vector signed char *__b) {
12996   return (vector signed char)__builtin_vsx_lxvw4x(__a, __b);
12997 }
12998
12999 static __inline__ vector signed char __ATTRS_o_ai
13000 vec_vsx_ld(int __a, const signed char *__b) {
13001   return (vector signed char)__builtin_vsx_lxvw4x(__a, __b);
13002 }
13003
13004 static __inline__ vector unsigned char __ATTRS_o_ai
13005 vec_vsx_ld(int __a, const vector unsigned char *__b) {
13006   return (vector unsigned char)__builtin_vsx_lxvw4x(__a, __b);
13007 }
13008
13009 static __inline__ vector unsigned char __ATTRS_o_ai
13010 vec_vsx_ld(int __a, const unsigned char *__b) {
13011   return (vector unsigned char)__builtin_vsx_lxvw4x(__a, __b);
13012 }
13013
13014 #endif
13015
13016 /* vec_vsx_st */
13017
13018 #ifdef __VSX__
13019
13020 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool int __a, int __b,
13021                                                vector bool int *__c) {
13022   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13023 }
13024
13025 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool int __a, int __b,
13026                                                signed int *__c) {
13027   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13028 }
13029
13030 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool int __a, int __b,
13031                                                unsigned int *__c) {
13032   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13033 }
13034
13035 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed int __a, int __b,
13036                                                vector signed int *__c) {
13037   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13038 }
13039
13040 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed int __a, int __b,
13041                                                signed int *__c) {
13042   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13043 }
13044
13045 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned int __a, int __b,
13046                                                vector unsigned int *__c) {
13047   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13048 }
13049
13050 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned int __a, int __b,
13051                                                unsigned int *__c) {
13052   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13053 }
13054
13055 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector float __a, int __b,
13056                                                vector float *__c) {
13057   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13058 }
13059
13060 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector float __a, int __b,
13061                                                float *__c) {
13062   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13063 }
13064
13065 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed long long __a,
13066                                                int __b,
13067                                                vector signed long long *__c) {
13068   __builtin_vsx_stxvd2x((vector double)__a, __b, __c);
13069 }
13070
13071 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned long long __a,
13072                                                int __b,
13073                                                vector unsigned long long *__c) {
13074   __builtin_vsx_stxvd2x((vector double)__a, __b, __c);
13075 }
13076
13077 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector double __a, int __b,
13078                                                vector double *__c) {
13079   __builtin_vsx_stxvd2x((vector double)__a, __b, __c);
13080 }
13081
13082 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector double __a, int __b,
13083                                                double *__c) {
13084   __builtin_vsx_stxvd2x((vector double)__a, __b, __c);
13085 }
13086
13087 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool short __a, int __b,
13088                                                vector bool short *__c) {
13089   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13090 }
13091
13092 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool short __a, int __b,
13093                                                signed short *__c) {
13094   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13095 }
13096
13097 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool short __a, int __b,
13098                                                unsigned short *__c) {
13099   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13100 }
13101 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed short __a, int __b,
13102                                                vector signed short *__c) {
13103   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13104 }
13105
13106 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed short __a, int __b,
13107                                                signed short *__c) {
13108   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13109 }
13110
13111 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned short __a,
13112                                                int __b,
13113                                                vector unsigned short *__c) {
13114   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13115 }
13116
13117 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned short __a,
13118                                                int __b, unsigned short *__c) {
13119   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13120 }
13121
13122 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool char __a, int __b,
13123                                                vector bool char *__c) {
13124   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13125 }
13126
13127 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool char __a, int __b,
13128                                                signed char *__c) {
13129   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13130 }
13131
13132 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool char __a, int __b,
13133                                                unsigned char *__c) {
13134   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13135 }
13136
13137 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed char __a, int __b,
13138                                                vector signed char *__c) {
13139   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13140 }
13141
13142 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed char __a, int __b,
13143                                                signed char *__c) {
13144   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13145 }
13146
13147 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned char __a,
13148                                                int __b,
13149                                                vector unsigned char *__c) {
13150   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13151 }
13152
13153 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned char __a,
13154                                                int __b, unsigned char *__c) {
13155   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
13156 }
13157
13158 #endif
13159
13160 #ifdef __VSX__
13161 #define vec_xxpermdi __builtin_vsx_xxpermdi
13162 #define vec_xxsldwi __builtin_vsx_xxsldwi
13163 #define vec_permi(__a, __b, __c)                                               \
13164   _Generic((__a), vector signed long long                                      \
13165            : __builtin_shufflevector((__a), (__b), (((__c) >> 1) & 0x1),       \
13166                                      (((__c)&0x1) + 2)),                       \
13167              vector unsigned long long                                         \
13168            : __builtin_shufflevector((__a), (__b), (((__c) >> 1) & 0x1),       \
13169                                      (((__c)&0x1) + 2)),                       \
13170              vector double                                                     \
13171            : __builtin_shufflevector((__a), (__b), (((__c) >> 1) & 0x1),       \
13172                                      (((__c)&0x1) + 2)))
13173 #endif
13174
13175 /* vec_xor */
13176
13177 #define __builtin_altivec_vxor vec_xor
13178
13179 static __inline__ vector signed char __ATTRS_o_ai
13180 vec_xor(vector signed char __a, vector signed char __b) {
13181   return __a ^ __b;
13182 }
13183
13184 static __inline__ vector signed char __ATTRS_o_ai
13185 vec_xor(vector bool char __a, vector signed char __b) {
13186   return (vector signed char)__a ^ __b;
13187 }
13188
13189 static __inline__ vector signed char __ATTRS_o_ai
13190 vec_xor(vector signed char __a, vector bool char __b) {
13191   return __a ^ (vector signed char)__b;
13192 }
13193
13194 static __inline__ vector unsigned char __ATTRS_o_ai
13195 vec_xor(vector unsigned char __a, vector unsigned char __b) {
13196   return __a ^ __b;
13197 }
13198
13199 static __inline__ vector unsigned char __ATTRS_o_ai
13200 vec_xor(vector bool char __a, vector unsigned char __b) {
13201   return (vector unsigned char)__a ^ __b;
13202 }
13203
13204 static __inline__ vector unsigned char __ATTRS_o_ai
13205 vec_xor(vector unsigned char __a, vector bool char __b) {
13206   return __a ^ (vector unsigned char)__b;
13207 }
13208
13209 static __inline__ vector bool char __ATTRS_o_ai vec_xor(vector bool char __a,
13210                                                         vector bool char __b) {
13211   return __a ^ __b;
13212 }
13213
13214 static __inline__ vector short __ATTRS_o_ai vec_xor(vector short __a,
13215                                                     vector short __b) {
13216   return __a ^ __b;
13217 }
13218
13219 static __inline__ vector short __ATTRS_o_ai vec_xor(vector bool short __a,
13220                                                     vector short __b) {
13221   return (vector short)__a ^ __b;
13222 }
13223
13224 static __inline__ vector short __ATTRS_o_ai vec_xor(vector short __a,
13225                                                     vector bool short __b) {
13226   return __a ^ (vector short)__b;
13227 }
13228
13229 static __inline__ vector unsigned short __ATTRS_o_ai
13230 vec_xor(vector unsigned short __a, vector unsigned short __b) {
13231   return __a ^ __b;
13232 }
13233
13234 static __inline__ vector unsigned short __ATTRS_o_ai
13235 vec_xor(vector bool short __a, vector unsigned short __b) {
13236   return (vector unsigned short)__a ^ __b;
13237 }
13238
13239 static __inline__ vector unsigned short __ATTRS_o_ai
13240 vec_xor(vector unsigned short __a, vector bool short __b) {
13241   return __a ^ (vector unsigned short)__b;
13242 }
13243
13244 static __inline__ vector bool short __ATTRS_o_ai
13245 vec_xor(vector bool short __a, vector bool short __b) {
13246   return __a ^ __b;
13247 }
13248
13249 static __inline__ vector int __ATTRS_o_ai vec_xor(vector int __a,
13250                                                   vector int __b) {
13251   return __a ^ __b;
13252 }
13253
13254 static __inline__ vector int __ATTRS_o_ai vec_xor(vector bool int __a,
13255                                                   vector int __b) {
13256   return (vector int)__a ^ __b;
13257 }
13258
13259 static __inline__ vector int __ATTRS_o_ai vec_xor(vector int __a,
13260                                                   vector bool int __b) {
13261   return __a ^ (vector int)__b;
13262 }
13263
13264 static __inline__ vector unsigned int __ATTRS_o_ai
13265 vec_xor(vector unsigned int __a, vector unsigned int __b) {
13266   return __a ^ __b;
13267 }
13268
13269 static __inline__ vector unsigned int __ATTRS_o_ai
13270 vec_xor(vector bool int __a, vector unsigned int __b) {
13271   return (vector unsigned int)__a ^ __b;
13272 }
13273
13274 static __inline__ vector unsigned int __ATTRS_o_ai
13275 vec_xor(vector unsigned int __a, vector bool int __b) {
13276   return __a ^ (vector unsigned int)__b;
13277 }
13278
13279 static __inline__ vector bool int __ATTRS_o_ai vec_xor(vector bool int __a,
13280                                                        vector bool int __b) {
13281   return __a ^ __b;
13282 }
13283
13284 static __inline__ vector float __ATTRS_o_ai vec_xor(vector float __a,
13285                                                     vector float __b) {
13286   vector unsigned int __res =
13287       (vector unsigned int)__a ^ (vector unsigned int)__b;
13288   return (vector float)__res;
13289 }
13290
13291 static __inline__ vector float __ATTRS_o_ai vec_xor(vector bool int __a,
13292                                                     vector float __b) {
13293   vector unsigned int __res =
13294       (vector unsigned int)__a ^ (vector unsigned int)__b;
13295   return (vector float)__res;
13296 }
13297
13298 static __inline__ vector float __ATTRS_o_ai vec_xor(vector float __a,
13299                                                     vector bool int __b) {
13300   vector unsigned int __res =
13301       (vector unsigned int)__a ^ (vector unsigned int)__b;
13302   return (vector float)__res;
13303 }
13304
13305 #ifdef __VSX__
13306 static __inline__ vector signed long long __ATTRS_o_ai
13307 vec_xor(vector signed long long __a, vector signed long long __b) {
13308   return __a ^ __b;
13309 }
13310
13311 static __inline__ vector signed long long __ATTRS_o_ai
13312 vec_xor(vector bool long long __a, vector signed long long __b) {
13313   return (vector signed long long)__a ^ __b;
13314 }
13315
13316 static __inline__ vector signed long long __ATTRS_o_ai
13317 vec_xor(vector signed long long __a, vector bool long long __b) {
13318   return __a ^ (vector signed long long)__b;
13319 }
13320
13321 static __inline__ vector unsigned long long __ATTRS_o_ai
13322 vec_xor(vector unsigned long long __a, vector unsigned long long __b) {
13323   return __a ^ __b;
13324 }
13325
13326 static __inline__ vector unsigned long long __ATTRS_o_ai
13327 vec_xor(vector bool long long __a, vector unsigned long long __b) {
13328   return (vector unsigned long long)__a ^ __b;
13329 }
13330
13331 static __inline__ vector unsigned long long __ATTRS_o_ai
13332 vec_xor(vector unsigned long long __a, vector bool long long __b) {
13333   return __a ^ (vector unsigned long long)__b;
13334 }
13335
13336 static __inline__ vector bool long long __ATTRS_o_ai
13337 vec_xor(vector bool long long __a, vector bool long long __b) {
13338   return __a ^ __b;
13339 }
13340
13341 static __inline__ vector double __ATTRS_o_ai vec_xor(vector double __a,
13342                                                      vector double __b) {
13343   return (vector double)((vector unsigned long long)__a ^
13344                          (vector unsigned long long)__b);
13345 }
13346
13347 static __inline__ vector double __ATTRS_o_ai
13348 vec_xor(vector double __a, vector bool long long __b) {
13349   return (vector double)((vector unsigned long long)__a ^
13350                          (vector unsigned long long)__b);
13351 }
13352
13353 static __inline__ vector double __ATTRS_o_ai vec_xor(vector bool long long __a,
13354                                                      vector double __b) {
13355   return (vector double)((vector unsigned long long)__a ^
13356                          (vector unsigned long long)__b);
13357 }
13358 #endif
13359
13360 /* vec_vxor */
13361
13362 static __inline__ vector signed char __ATTRS_o_ai
13363 vec_vxor(vector signed char __a, vector signed char __b) {
13364   return __a ^ __b;
13365 }
13366
13367 static __inline__ vector signed char __ATTRS_o_ai
13368 vec_vxor(vector bool char __a, vector signed char __b) {
13369   return (vector signed char)__a ^ __b;
13370 }
13371
13372 static __inline__ vector signed char __ATTRS_o_ai
13373 vec_vxor(vector signed char __a, vector bool char __b) {
13374   return __a ^ (vector signed char)__b;
13375 }
13376
13377 static __inline__ vector unsigned char __ATTRS_o_ai
13378 vec_vxor(vector unsigned char __a, vector unsigned char __b) {
13379   return __a ^ __b;
13380 }
13381
13382 static __inline__ vector unsigned char __ATTRS_o_ai
13383 vec_vxor(vector bool char __a, vector unsigned char __b) {
13384   return (vector unsigned char)__a ^ __b;
13385 }
13386
13387 static __inline__ vector unsigned char __ATTRS_o_ai
13388 vec_vxor(vector unsigned char __a, vector bool char __b) {
13389   return __a ^ (vector unsigned char)__b;
13390 }
13391
13392 static __inline__ vector bool char __ATTRS_o_ai vec_vxor(vector bool char __a,
13393                                                          vector bool char __b) {
13394   return __a ^ __b;
13395 }
13396
13397 static __inline__ vector short __ATTRS_o_ai vec_vxor(vector short __a,
13398                                                      vector short __b) {
13399   return __a ^ __b;
13400 }
13401
13402 static __inline__ vector short __ATTRS_o_ai vec_vxor(vector bool short __a,
13403                                                      vector short __b) {
13404   return (vector short)__a ^ __b;
13405 }
13406
13407 static __inline__ vector short __ATTRS_o_ai vec_vxor(vector short __a,
13408                                                      vector bool short __b) {
13409   return __a ^ (vector short)__b;
13410 }
13411
13412 static __inline__ vector unsigned short __ATTRS_o_ai
13413 vec_vxor(vector unsigned short __a, vector unsigned short __b) {
13414   return __a ^ __b;
13415 }
13416
13417 static __inline__ vector unsigned short __ATTRS_o_ai
13418 vec_vxor(vector bool short __a, vector unsigned short __b) {
13419   return (vector unsigned short)__a ^ __b;
13420 }
13421
13422 static __inline__ vector unsigned short __ATTRS_o_ai
13423 vec_vxor(vector unsigned short __a, vector bool short __b) {
13424   return __a ^ (vector unsigned short)__b;
13425 }
13426
13427 static __inline__ vector bool short __ATTRS_o_ai
13428 vec_vxor(vector bool short __a, vector bool short __b) {
13429   return __a ^ __b;
13430 }
13431
13432 static __inline__ vector int __ATTRS_o_ai vec_vxor(vector int __a,
13433                                                    vector int __b) {
13434   return __a ^ __b;
13435 }
13436
13437 static __inline__ vector int __ATTRS_o_ai vec_vxor(vector bool int __a,
13438                                                    vector int __b) {
13439   return (vector int)__a ^ __b;
13440 }
13441
13442 static __inline__ vector int __ATTRS_o_ai vec_vxor(vector int __a,
13443                                                    vector bool int __b) {
13444   return __a ^ (vector int)__b;
13445 }
13446
13447 static __inline__ vector unsigned int __ATTRS_o_ai
13448 vec_vxor(vector unsigned int __a, vector unsigned int __b) {
13449   return __a ^ __b;
13450 }
13451
13452 static __inline__ vector unsigned int __ATTRS_o_ai
13453 vec_vxor(vector bool int __a, vector unsigned int __b) {
13454   return (vector unsigned int)__a ^ __b;
13455 }
13456
13457 static __inline__ vector unsigned int __ATTRS_o_ai
13458 vec_vxor(vector unsigned int __a, vector bool int __b) {
13459   return __a ^ (vector unsigned int)__b;
13460 }
13461
13462 static __inline__ vector bool int __ATTRS_o_ai vec_vxor(vector bool int __a,
13463                                                         vector bool int __b) {
13464   return __a ^ __b;
13465 }
13466
13467 static __inline__ vector float __ATTRS_o_ai vec_vxor(vector float __a,
13468                                                      vector float __b) {
13469   vector unsigned int __res =
13470       (vector unsigned int)__a ^ (vector unsigned int)__b;
13471   return (vector float)__res;
13472 }
13473
13474 static __inline__ vector float __ATTRS_o_ai vec_vxor(vector bool int __a,
13475                                                      vector float __b) {
13476   vector unsigned int __res =
13477       (vector unsigned int)__a ^ (vector unsigned int)__b;
13478   return (vector float)__res;
13479 }
13480
13481 static __inline__ vector float __ATTRS_o_ai vec_vxor(vector float __a,
13482                                                      vector bool int __b) {
13483   vector unsigned int __res =
13484       (vector unsigned int)__a ^ (vector unsigned int)__b;
13485   return (vector float)__res;
13486 }
13487
13488 #ifdef __VSX__
13489 static __inline__ vector signed long long __ATTRS_o_ai
13490 vec_vxor(vector signed long long __a, vector signed long long __b) {
13491   return __a ^ __b;
13492 }
13493
13494 static __inline__ vector signed long long __ATTRS_o_ai
13495 vec_vxor(vector bool long long __a, vector signed long long __b) {
13496   return (vector signed long long)__a ^ __b;
13497 }
13498
13499 static __inline__ vector signed long long __ATTRS_o_ai
13500 vec_vxor(vector signed long long __a, vector bool long long __b) {
13501   return __a ^ (vector signed long long)__b;
13502 }
13503
13504 static __inline__ vector unsigned long long __ATTRS_o_ai
13505 vec_vxor(vector unsigned long long __a, vector unsigned long long __b) {
13506   return __a ^ __b;
13507 }
13508
13509 static __inline__ vector unsigned long long __ATTRS_o_ai
13510 vec_vxor(vector bool long long __a, vector unsigned long long __b) {
13511   return (vector unsigned long long)__a ^ __b;
13512 }
13513
13514 static __inline__ vector unsigned long long __ATTRS_o_ai
13515 vec_vxor(vector unsigned long long __a, vector bool long long __b) {
13516   return __a ^ (vector unsigned long long)__b;
13517 }
13518
13519 static __inline__ vector bool long long __ATTRS_o_ai
13520 vec_vxor(vector bool long long __a, vector bool long long __b) {
13521   return __a ^ __b;
13522 }
13523 #endif
13524
13525 /* ------------------------ extensions for CBEA ----------------------------- */
13526
13527 /* vec_extract */
13528
13529 static __inline__ signed char __ATTRS_o_ai vec_extract(vector signed char __a,
13530                                                        signed int __b) {
13531   return __a[__b & 0xf];
13532 }
13533
13534 static __inline__ unsigned char __ATTRS_o_ai
13535 vec_extract(vector unsigned char __a, signed int __b) {
13536   return __a[__b & 0xf];
13537 }
13538
13539 static __inline__ unsigned char __ATTRS_o_ai vec_extract(vector bool char __a,
13540                                                          signed int __b) {
13541   return __a[__b & 0xf];
13542 }
13543
13544 static __inline__ signed short __ATTRS_o_ai vec_extract(vector signed short __a,
13545                                                         signed int __b) {
13546   return __a[__b & 0x7];
13547 }
13548
13549 static __inline__ unsigned short __ATTRS_o_ai
13550 vec_extract(vector unsigned short __a, signed int __b) {
13551   return __a[__b & 0x7];
13552 }
13553
13554 static __inline__ unsigned short __ATTRS_o_ai vec_extract(vector bool short __a,
13555                                                           signed int __b) {
13556   return __a[__b & 0x7];
13557 }
13558
13559 static __inline__ signed int __ATTRS_o_ai vec_extract(vector signed int __a,
13560                                                       signed int __b) {
13561   return __a[__b & 0x3];
13562 }
13563
13564 static __inline__ unsigned int __ATTRS_o_ai vec_extract(vector unsigned int __a,
13565                                                         signed int __b) {
13566   return __a[__b & 0x3];
13567 }
13568
13569 static __inline__ unsigned int __ATTRS_o_ai vec_extract(vector bool int __a,
13570                                                         signed int __b) {
13571   return __a[__b & 0x3];
13572 }
13573
13574 #ifdef __VSX__
13575 static __inline__ signed long long __ATTRS_o_ai
13576 vec_extract(vector signed long long __a, signed int __b) {
13577   return __a[__b & 0x1];
13578 }
13579
13580 static __inline__ unsigned long long __ATTRS_o_ai
13581 vec_extract(vector unsigned long long __a, signed int __b) {
13582   return __a[__b & 0x1];
13583 }
13584
13585 static __inline__ unsigned long long __ATTRS_o_ai
13586 vec_extract(vector bool long long __a, signed int __b) {
13587   return __a[__b & 0x1];
13588 }
13589
13590 static __inline__ double __ATTRS_o_ai vec_extract(vector double __a,
13591                                                   signed int __b) {
13592   return __a[__b & 0x1];
13593 }
13594 #endif
13595
13596 static __inline__ float __ATTRS_o_ai vec_extract(vector float __a,
13597                                                  signed int __b) {
13598   return __a[__b & 0x3];
13599 }
13600
13601 #ifdef __POWER9_VECTOR__
13602
13603 #define vec_insert4b __builtin_vsx_insertword
13604 #define vec_extract4b __builtin_vsx_extractuword
13605
13606 /* vec_extract_exp */
13607
13608 static __inline__ vector unsigned int __ATTRS_o_ai
13609 vec_extract_exp(vector float __a) {
13610   return __builtin_vsx_xvxexpsp(__a);
13611 }
13612
13613 static __inline__ vector unsigned long long __ATTRS_o_ai
13614 vec_extract_exp(vector double __a) {
13615   return __builtin_vsx_xvxexpdp(__a);
13616 }
13617
13618 /* vec_extract_sig */
13619
13620 static __inline__ vector unsigned int __ATTRS_o_ai
13621 vec_extract_sig(vector float __a) {
13622   return __builtin_vsx_xvxsigsp(__a);
13623 }
13624
13625 static __inline__ vector unsigned long long __ATTRS_o_ai
13626 vec_extract_sig (vector double __a) {
13627   return __builtin_vsx_xvxsigdp(__a);
13628 }
13629
13630 static __inline__ vector float __ATTRS_o_ai
13631 vec_extract_fp32_from_shorth(vector unsigned short __a) {
13632   vector unsigned short __b =
13633 #ifdef __LITTLE_ENDIAN__
13634             __builtin_shufflevector(__a, __a, 0, -1, 1, -1, 2, -1, 3, -1);
13635 #else
13636             __builtin_shufflevector(__a, __a, -1, 0, -1, 1, -1, 2, -1, 3);
13637 #endif
13638   return __builtin_vsx_xvcvhpsp(__b);
13639 }
13640
13641 static __inline__ vector float __ATTRS_o_ai
13642 vec_extract_fp32_from_shortl(vector unsigned short __a) {
13643   vector unsigned short __b =
13644 #ifdef __LITTLE_ENDIAN__
13645             __builtin_shufflevector(__a, __a, 4, -1, 5, -1, 6, -1, 7, -1);
13646 #else
13647             __builtin_shufflevector(__a, __a, -1, 4, -1, 5, -1, 6, -1, 7);
13648 #endif
13649   return __builtin_vsx_xvcvhpsp(__b);
13650 }
13651 #endif /* __POWER9_VECTOR__ */
13652
13653 /* vec_insert */
13654
13655 static __inline__ vector signed char __ATTRS_o_ai
13656 vec_insert(signed char __a, vector signed char __b, int __c) {
13657   __b[__c & 0xF] = __a;
13658   return __b;
13659 }
13660
13661 static __inline__ vector unsigned char __ATTRS_o_ai
13662 vec_insert(unsigned char __a, vector unsigned char __b, int __c) {
13663   __b[__c & 0xF] = __a;
13664   return __b;
13665 }
13666
13667 static __inline__ vector bool char __ATTRS_o_ai vec_insert(unsigned char __a,
13668                                                            vector bool char __b,
13669                                                            int __c) {
13670   __b[__c & 0xF] = __a;
13671   return __b;
13672 }
13673
13674 static __inline__ vector signed short __ATTRS_o_ai
13675 vec_insert(signed short __a, vector signed short __b, int __c) {
13676   __b[__c & 0x7] = __a;
13677   return __b;
13678 }
13679
13680 static __inline__ vector unsigned short __ATTRS_o_ai
13681 vec_insert(unsigned short __a, vector unsigned short __b, int __c) {
13682   __b[__c & 0x7] = __a;
13683   return __b;
13684 }
13685
13686 static __inline__ vector bool short __ATTRS_o_ai
13687 vec_insert(unsigned short __a, vector bool short __b, int __c) {
13688   __b[__c & 0x7] = __a;
13689   return __b;
13690 }
13691
13692 static __inline__ vector signed int __ATTRS_o_ai
13693 vec_insert(signed int __a, vector signed int __b, int __c) {
13694   __b[__c & 0x3] = __a;
13695   return __b;
13696 }
13697
13698 static __inline__ vector unsigned int __ATTRS_o_ai
13699 vec_insert(unsigned int __a, vector unsigned int __b, int __c) {
13700   __b[__c & 0x3] = __a;
13701   return __b;
13702 }
13703
13704 static __inline__ vector bool int __ATTRS_o_ai vec_insert(unsigned int __a,
13705                                                           vector bool int __b,
13706                                                           int __c) {
13707   __b[__c & 0x3] = __a;
13708   return __b;
13709 }
13710
13711 #ifdef __VSX__
13712 static __inline__ vector signed long long __ATTRS_o_ai
13713 vec_insert(signed long long __a, vector signed long long __b, int __c) {
13714   __b[__c & 0x1] = __a;
13715   return __b;
13716 }
13717
13718 static __inline__ vector unsigned long long __ATTRS_o_ai
13719 vec_insert(unsigned long long __a, vector unsigned long long __b, int __c) {
13720   __b[__c & 0x1] = __a;
13721   return __b;
13722 }
13723
13724 static __inline__ vector bool long long __ATTRS_o_ai
13725 vec_insert(unsigned long long __a, vector bool long long __b, int __c) {
13726   __b[__c & 0x1] = __a;
13727   return __b;
13728 }
13729 static __inline__ vector double __ATTRS_o_ai vec_insert(double __a,
13730                                                         vector double __b,
13731                                                         int __c) {
13732   __b[__c & 0x1] = __a;
13733   return __b;
13734 }
13735 #endif
13736
13737 static __inline__ vector float __ATTRS_o_ai vec_insert(float __a,
13738                                                        vector float __b,
13739                                                        int __c) {
13740   __b[__c & 0x3] = __a;
13741   return __b;
13742 }
13743
13744 /* vec_lvlx */
13745
13746 static __inline__ vector signed char __ATTRS_o_ai
13747 vec_lvlx(int __a, const signed char *__b) {
13748   return vec_perm(vec_ld(__a, __b), (vector signed char)(0),
13749                   vec_lvsl(__a, __b));
13750 }
13751
13752 static __inline__ vector signed char __ATTRS_o_ai
13753 vec_lvlx(int __a, const vector signed char *__b) {
13754   return vec_perm(vec_ld(__a, __b), (vector signed char)(0),
13755                   vec_lvsl(__a, (unsigned char *)__b));
13756 }
13757
13758 static __inline__ vector unsigned char __ATTRS_o_ai
13759 vec_lvlx(int __a, const unsigned char *__b) {
13760   return vec_perm(vec_ld(__a, __b), (vector unsigned char)(0),
13761                   vec_lvsl(__a, __b));
13762 }
13763
13764 static __inline__ vector unsigned char __ATTRS_o_ai
13765 vec_lvlx(int __a, const vector unsigned char *__b) {
13766   return vec_perm(vec_ld(__a, __b), (vector unsigned char)(0),
13767                   vec_lvsl(__a, (unsigned char *)__b));
13768 }
13769
13770 static __inline__ vector bool char __ATTRS_o_ai
13771 vec_lvlx(int __a, const vector bool char *__b) {
13772   return vec_perm(vec_ld(__a, __b), (vector bool char)(0),
13773                   vec_lvsl(__a, (unsigned char *)__b));
13774 }
13775
13776 static __inline__ vector short __ATTRS_o_ai vec_lvlx(int __a,
13777                                                      const short *__b) {
13778   return vec_perm(vec_ld(__a, __b), (vector short)(0), vec_lvsl(__a, __b));
13779 }
13780
13781 static __inline__ vector short __ATTRS_o_ai vec_lvlx(int __a,
13782                                                      const vector short *__b) {
13783   return vec_perm(vec_ld(__a, __b), (vector short)(0),
13784                   vec_lvsl(__a, (unsigned char *)__b));
13785 }
13786
13787 static __inline__ vector unsigned short __ATTRS_o_ai
13788 vec_lvlx(int __a, const unsigned short *__b) {
13789   return vec_perm(vec_ld(__a, __b), (vector unsigned short)(0),
13790                   vec_lvsl(__a, __b));
13791 }
13792
13793 static __inline__ vector unsigned short __ATTRS_o_ai
13794 vec_lvlx(int __a, const vector unsigned short *__b) {
13795   return vec_perm(vec_ld(__a, __b), (vector unsigned short)(0),
13796                   vec_lvsl(__a, (unsigned char *)__b));
13797 }
13798
13799 static __inline__ vector bool short __ATTRS_o_ai
13800 vec_lvlx(int __a, const vector bool short *__b) {
13801   return vec_perm(vec_ld(__a, __b), (vector bool short)(0),
13802                   vec_lvsl(__a, (unsigned char *)__b));
13803 }
13804
13805 static __inline__ vector pixel __ATTRS_o_ai vec_lvlx(int __a,
13806                                                      const vector pixel *__b) {
13807   return vec_perm(vec_ld(__a, __b), (vector pixel)(0),
13808                   vec_lvsl(__a, (unsigned char *)__b));
13809 }
13810
13811 static __inline__ vector int __ATTRS_o_ai vec_lvlx(int __a, const int *__b) {
13812   return vec_perm(vec_ld(__a, __b), (vector int)(0), vec_lvsl(__a, __b));
13813 }
13814
13815 static __inline__ vector int __ATTRS_o_ai vec_lvlx(int __a,
13816                                                    const vector int *__b) {
13817   return vec_perm(vec_ld(__a, __b), (vector int)(0),
13818                   vec_lvsl(__a, (unsigned char *)__b));
13819 }
13820
13821 static __inline__ vector unsigned int __ATTRS_o_ai
13822 vec_lvlx(int __a, const unsigned int *__b) {
13823   return vec_perm(vec_ld(__a, __b), (vector unsigned int)(0),
13824                   vec_lvsl(__a, __b));
13825 }
13826
13827 static __inline__ vector unsigned int __ATTRS_o_ai
13828 vec_lvlx(int __a, const vector unsigned int *__b) {
13829   return vec_perm(vec_ld(__a, __b), (vector unsigned int)(0),
13830                   vec_lvsl(__a, (unsigned char *)__b));
13831 }
13832
13833 static __inline__ vector bool int __ATTRS_o_ai
13834 vec_lvlx(int __a, const vector bool int *__b) {
13835   return vec_perm(vec_ld(__a, __b), (vector bool int)(0),
13836                   vec_lvsl(__a, (unsigned char *)__b));
13837 }
13838
13839 static __inline__ vector float __ATTRS_o_ai vec_lvlx(int __a,
13840                                                      const float *__b) {
13841   return vec_perm(vec_ld(__a, __b), (vector float)(0), vec_lvsl(__a, __b));
13842 }
13843
13844 static __inline__ vector float __ATTRS_o_ai vec_lvlx(int __a,
13845                                                      const vector float *__b) {
13846   return vec_perm(vec_ld(__a, __b), (vector float)(0),
13847                   vec_lvsl(__a, (unsigned char *)__b));
13848 }
13849
13850 /* vec_lvlxl */
13851
13852 static __inline__ vector signed char __ATTRS_o_ai
13853 vec_lvlxl(int __a, const signed char *__b) {
13854   return vec_perm(vec_ldl(__a, __b), (vector signed char)(0),
13855                   vec_lvsl(__a, __b));
13856 }
13857
13858 static __inline__ vector signed char __ATTRS_o_ai
13859 vec_lvlxl(int __a, const vector signed char *__b) {
13860   return vec_perm(vec_ldl(__a, __b), (vector signed char)(0),
13861                   vec_lvsl(__a, (unsigned char *)__b));
13862 }
13863
13864 static __inline__ vector unsigned char __ATTRS_o_ai
13865 vec_lvlxl(int __a, const unsigned char *__b) {
13866   return vec_perm(vec_ldl(__a, __b), (vector unsigned char)(0),
13867                   vec_lvsl(__a, __b));
13868 }
13869
13870 static __inline__ vector unsigned char __ATTRS_o_ai
13871 vec_lvlxl(int __a, const vector unsigned char *__b) {
13872   return vec_perm(vec_ldl(__a, __b), (vector unsigned char)(0),
13873                   vec_lvsl(__a, (unsigned char *)__b));
13874 }
13875
13876 static __inline__ vector bool char __ATTRS_o_ai
13877 vec_lvlxl(int __a, const vector bool char *__b) {
13878   return vec_perm(vec_ldl(__a, __b), (vector bool char)(0),
13879                   vec_lvsl(__a, (unsigned char *)__b));
13880 }
13881
13882 static __inline__ vector short __ATTRS_o_ai vec_lvlxl(int __a,
13883                                                       const short *__b) {
13884   return vec_perm(vec_ldl(__a, __b), (vector short)(0), vec_lvsl(__a, __b));
13885 }
13886
13887 static __inline__ vector short __ATTRS_o_ai vec_lvlxl(int __a,
13888                                                       const vector short *__b) {
13889   return vec_perm(vec_ldl(__a, __b), (vector short)(0),
13890                   vec_lvsl(__a, (unsigned char *)__b));
13891 }
13892
13893 static __inline__ vector unsigned short __ATTRS_o_ai
13894 vec_lvlxl(int __a, const unsigned short *__b) {
13895   return vec_perm(vec_ldl(__a, __b), (vector unsigned short)(0),
13896                   vec_lvsl(__a, __b));
13897 }
13898
13899 static __inline__ vector unsigned short __ATTRS_o_ai
13900 vec_lvlxl(int __a, const vector unsigned short *__b) {
13901   return vec_perm(vec_ldl(__a, __b), (vector unsigned short)(0),
13902                   vec_lvsl(__a, (unsigned char *)__b));
13903 }
13904
13905 static __inline__ vector bool short __ATTRS_o_ai
13906 vec_lvlxl(int __a, const vector bool short *__b) {
13907   return vec_perm(vec_ldl(__a, __b), (vector bool short)(0),
13908                   vec_lvsl(__a, (unsigned char *)__b));
13909 }
13910
13911 static __inline__ vector pixel __ATTRS_o_ai vec_lvlxl(int __a,
13912                                                       const vector pixel *__b) {
13913   return vec_perm(vec_ldl(__a, __b), (vector pixel)(0),
13914                   vec_lvsl(__a, (unsigned char *)__b));
13915 }
13916
13917 static __inline__ vector int __ATTRS_o_ai vec_lvlxl(int __a, const int *__b) {
13918   return vec_perm(vec_ldl(__a, __b), (vector int)(0), vec_lvsl(__a, __b));
13919 }
13920
13921 static __inline__ vector int __ATTRS_o_ai vec_lvlxl(int __a,
13922                                                     const vector int *__b) {
13923   return vec_perm(vec_ldl(__a, __b), (vector int)(0),
13924                   vec_lvsl(__a, (unsigned char *)__b));
13925 }
13926
13927 static __inline__ vector unsigned int __ATTRS_o_ai
13928 vec_lvlxl(int __a, const unsigned int *__b) {
13929   return vec_perm(vec_ldl(__a, __b), (vector unsigned int)(0),
13930                   vec_lvsl(__a, __b));
13931 }
13932
13933 static __inline__ vector unsigned int __ATTRS_o_ai
13934 vec_lvlxl(int __a, const vector unsigned int *__b) {
13935   return vec_perm(vec_ldl(__a, __b), (vector unsigned int)(0),
13936                   vec_lvsl(__a, (unsigned char *)__b));
13937 }
13938
13939 static __inline__ vector bool int __ATTRS_o_ai
13940 vec_lvlxl(int __a, const vector bool int *__b) {
13941   return vec_perm(vec_ldl(__a, __b), (vector bool int)(0),
13942                   vec_lvsl(__a, (unsigned char *)__b));
13943 }
13944
13945 static __inline__ vector float __ATTRS_o_ai vec_lvlxl(int __a,
13946                                                       const float *__b) {
13947   return vec_perm(vec_ldl(__a, __b), (vector float)(0), vec_lvsl(__a, __b));
13948 }
13949
13950 static __inline__ vector float __ATTRS_o_ai vec_lvlxl(int __a,
13951                                                       vector float *__b) {
13952   return vec_perm(vec_ldl(__a, __b), (vector float)(0),
13953                   vec_lvsl(__a, (unsigned char *)__b));
13954 }
13955
13956 /* vec_lvrx */
13957
13958 static __inline__ vector signed char __ATTRS_o_ai
13959 vec_lvrx(int __a, const signed char *__b) {
13960   return vec_perm((vector signed char)(0), vec_ld(__a, __b),
13961                   vec_lvsl(__a, __b));
13962 }
13963
13964 static __inline__ vector signed char __ATTRS_o_ai
13965 vec_lvrx(int __a, const vector signed char *__b) {
13966   return vec_perm((vector signed char)(0), vec_ld(__a, __b),
13967                   vec_lvsl(__a, (unsigned char *)__b));
13968 }
13969
13970 static __inline__ vector unsigned char __ATTRS_o_ai
13971 vec_lvrx(int __a, const unsigned char *__b) {
13972   return vec_perm((vector unsigned char)(0), vec_ld(__a, __b),
13973                   vec_lvsl(__a, __b));
13974 }
13975
13976 static __inline__ vector unsigned char __ATTRS_o_ai
13977 vec_lvrx(int __a, const vector unsigned char *__b) {
13978   return vec_perm((vector unsigned char)(0), vec_ld(__a, __b),
13979                   vec_lvsl(__a, (unsigned char *)__b));
13980 }
13981
13982 static __inline__ vector bool char __ATTRS_o_ai
13983 vec_lvrx(int __a, const vector bool char *__b) {
13984   return vec_perm((vector bool char)(0), vec_ld(__a, __b),
13985                   vec_lvsl(__a, (unsigned char *)__b));
13986 }
13987
13988 static __inline__ vector short __ATTRS_o_ai vec_lvrx(int __a,
13989                                                      const short *__b) {
13990   return vec_perm((vector short)(0), vec_ld(__a, __b), vec_lvsl(__a, __b));
13991 }
13992
13993 static __inline__ vector short __ATTRS_o_ai vec_lvrx(int __a,
13994                                                      const vector short *__b) {
13995   return vec_perm((vector short)(0), vec_ld(__a, __b),
13996                   vec_lvsl(__a, (unsigned char *)__b));
13997 }
13998
13999 static __inline__ vector unsigned short __ATTRS_o_ai
14000 vec_lvrx(int __a, const unsigned short *__b) {
14001   return vec_perm((vector unsigned short)(0), vec_ld(__a, __b),
14002                   vec_lvsl(__a, __b));
14003 }
14004
14005 static __inline__ vector unsigned short __ATTRS_o_ai
14006 vec_lvrx(int __a, const vector unsigned short *__b) {
14007   return vec_perm((vector unsigned short)(0), vec_ld(__a, __b),
14008                   vec_lvsl(__a, (unsigned char *)__b));
14009 }
14010
14011 static __inline__ vector bool short __ATTRS_o_ai
14012 vec_lvrx(int __a, const vector bool short *__b) {
14013   return vec_perm((vector bool short)(0), vec_ld(__a, __b),
14014                   vec_lvsl(__a, (unsigned char *)__b));
14015 }
14016
14017 static __inline__ vector pixel __ATTRS_o_ai vec_lvrx(int __a,
14018                                                      const vector pixel *__b) {
14019   return vec_perm((vector pixel)(0), vec_ld(__a, __b),
14020                   vec_lvsl(__a, (unsigned char *)__b));
14021 }
14022
14023 static __inline__ vector int __ATTRS_o_ai vec_lvrx(int __a, const int *__b) {
14024   return vec_perm((vector int)(0), vec_ld(__a, __b), vec_lvsl(__a, __b));
14025 }
14026
14027 static __inline__ vector int __ATTRS_o_ai vec_lvrx(int __a,
14028                                                    const vector int *__b) {
14029   return vec_perm((vector int)(0), vec_ld(__a, __b),
14030                   vec_lvsl(__a, (unsigned char *)__b));
14031 }
14032
14033 static __inline__ vector unsigned int __ATTRS_o_ai
14034 vec_lvrx(int __a, const unsigned int *__b) {
14035   return vec_perm((vector unsigned int)(0), vec_ld(__a, __b),
14036                   vec_lvsl(__a, __b));
14037 }
14038
14039 static __inline__ vector unsigned int __ATTRS_o_ai
14040 vec_lvrx(int __a, const vector unsigned int *__b) {
14041   return vec_perm((vector unsigned int)(0), vec_ld(__a, __b),
14042                   vec_lvsl(__a, (unsigned char *)__b));
14043 }
14044
14045 static __inline__ vector bool int __ATTRS_o_ai
14046 vec_lvrx(int __a, const vector bool int *__b) {
14047   return vec_perm((vector bool int)(0), vec_ld(__a, __b),
14048                   vec_lvsl(__a, (unsigned char *)__b));
14049 }
14050
14051 static __inline__ vector float __ATTRS_o_ai vec_lvrx(int __a,
14052                                                      const float *__b) {
14053   return vec_perm((vector float)(0), vec_ld(__a, __b), vec_lvsl(__a, __b));
14054 }
14055
14056 static __inline__ vector float __ATTRS_o_ai vec_lvrx(int __a,
14057                                                      const vector float *__b) {
14058   return vec_perm((vector float)(0), vec_ld(__a, __b),
14059                   vec_lvsl(__a, (unsigned char *)__b));
14060 }
14061
14062 /* vec_lvrxl */
14063
14064 static __inline__ vector signed char __ATTRS_o_ai
14065 vec_lvrxl(int __a, const signed char *__b) {
14066   return vec_perm((vector signed char)(0), vec_ldl(__a, __b),
14067                   vec_lvsl(__a, __b));
14068 }
14069
14070 static __inline__ vector signed char __ATTRS_o_ai
14071 vec_lvrxl(int __a, const vector signed char *__b) {
14072   return vec_perm((vector signed char)(0), vec_ldl(__a, __b),
14073                   vec_lvsl(__a, (unsigned char *)__b));
14074 }
14075
14076 static __inline__ vector unsigned char __ATTRS_o_ai
14077 vec_lvrxl(int __a, const unsigned char *__b) {
14078   return vec_perm((vector unsigned char)(0), vec_ldl(__a, __b),
14079                   vec_lvsl(__a, __b));
14080 }
14081
14082 static __inline__ vector unsigned char __ATTRS_o_ai
14083 vec_lvrxl(int __a, const vector unsigned char *__b) {
14084   return vec_perm((vector unsigned char)(0), vec_ldl(__a, __b),
14085                   vec_lvsl(__a, (unsigned char *)__b));
14086 }
14087
14088 static __inline__ vector bool char __ATTRS_o_ai
14089 vec_lvrxl(int __a, const vector bool char *__b) {
14090   return vec_perm((vector bool char)(0), vec_ldl(__a, __b),
14091                   vec_lvsl(__a, (unsigned char *)__b));
14092 }
14093
14094 static __inline__ vector short __ATTRS_o_ai vec_lvrxl(int __a,
14095                                                       const short *__b) {
14096   return vec_perm((vector short)(0), vec_ldl(__a, __b), vec_lvsl(__a, __b));
14097 }
14098
14099 static __inline__ vector short __ATTRS_o_ai vec_lvrxl(int __a,
14100                                                       const vector short *__b) {
14101   return vec_perm((vector short)(0), vec_ldl(__a, __b),
14102                   vec_lvsl(__a, (unsigned char *)__b));
14103 }
14104
14105 static __inline__ vector unsigned short __ATTRS_o_ai
14106 vec_lvrxl(int __a, const unsigned short *__b) {
14107   return vec_perm((vector unsigned short)(0), vec_ldl(__a, __b),
14108                   vec_lvsl(__a, __b));
14109 }
14110
14111 static __inline__ vector unsigned short __ATTRS_o_ai
14112 vec_lvrxl(int __a, const vector unsigned short *__b) {
14113   return vec_perm((vector unsigned short)(0), vec_ldl(__a, __b),
14114                   vec_lvsl(__a, (unsigned char *)__b));
14115 }
14116
14117 static __inline__ vector bool short __ATTRS_o_ai
14118 vec_lvrxl(int __a, const vector bool short *__b) {
14119   return vec_perm((vector bool short)(0), vec_ldl(__a, __b),
14120                   vec_lvsl(__a, (unsigned char *)__b));
14121 }
14122
14123 static __inline__ vector pixel __ATTRS_o_ai vec_lvrxl(int __a,
14124                                                       const vector pixel *__b) {
14125   return vec_perm((vector pixel)(0), vec_ldl(__a, __b),
14126                   vec_lvsl(__a, (unsigned char *)__b));
14127 }
14128
14129 static __inline__ vector int __ATTRS_o_ai vec_lvrxl(int __a, const int *__b) {
14130   return vec_perm((vector int)(0), vec_ldl(__a, __b), vec_lvsl(__a, __b));
14131 }
14132
14133 static __inline__ vector int __ATTRS_o_ai vec_lvrxl(int __a,
14134                                                     const vector int *__b) {
14135   return vec_perm((vector int)(0), vec_ldl(__a, __b),
14136                   vec_lvsl(__a, (unsigned char *)__b));
14137 }
14138
14139 static __inline__ vector unsigned int __ATTRS_o_ai
14140 vec_lvrxl(int __a, const unsigned int *__b) {
14141   return vec_perm((vector unsigned int)(0), vec_ldl(__a, __b),
14142                   vec_lvsl(__a, __b));
14143 }
14144
14145 static __inline__ vector unsigned int __ATTRS_o_ai
14146 vec_lvrxl(int __a, const vector unsigned int *__b) {
14147   return vec_perm((vector unsigned int)(0), vec_ldl(__a, __b),
14148                   vec_lvsl(__a, (unsigned char *)__b));
14149 }
14150
14151 static __inline__ vector bool int __ATTRS_o_ai
14152 vec_lvrxl(int __a, const vector bool int *__b) {
14153   return vec_perm((vector bool int)(0), vec_ldl(__a, __b),
14154                   vec_lvsl(__a, (unsigned char *)__b));
14155 }
14156
14157 static __inline__ vector float __ATTRS_o_ai vec_lvrxl(int __a,
14158                                                       const float *__b) {
14159   return vec_perm((vector float)(0), vec_ldl(__a, __b), vec_lvsl(__a, __b));
14160 }
14161
14162 static __inline__ vector float __ATTRS_o_ai vec_lvrxl(int __a,
14163                                                       const vector float *__b) {
14164   return vec_perm((vector float)(0), vec_ldl(__a, __b),
14165                   vec_lvsl(__a, (unsigned char *)__b));
14166 }
14167
14168 /* vec_stvlx */
14169
14170 static __inline__ void __ATTRS_o_ai vec_stvlx(vector signed char __a, int __b,
14171                                               signed char *__c) {
14172   return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
14173                 __c);
14174 }
14175
14176 static __inline__ void __ATTRS_o_ai vec_stvlx(vector signed char __a, int __b,
14177                                               vector signed char *__c) {
14178   return vec_st(
14179       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14180       __b, __c);
14181 }
14182
14183 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned char __a, int __b,
14184                                               unsigned char *__c) {
14185   return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
14186                 __c);
14187 }
14188
14189 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned char __a, int __b,
14190                                               vector unsigned char *__c) {
14191   return vec_st(
14192       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14193       __b, __c);
14194 }
14195
14196 static __inline__ void __ATTRS_o_ai vec_stvlx(vector bool char __a, int __b,
14197                                               vector bool char *__c) {
14198   return vec_st(
14199       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14200       __b, __c);
14201 }
14202
14203 static __inline__ void __ATTRS_o_ai vec_stvlx(vector short __a, int __b,
14204                                               short *__c) {
14205   return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
14206                 __c);
14207 }
14208
14209 static __inline__ void __ATTRS_o_ai vec_stvlx(vector short __a, int __b,
14210                                               vector short *__c) {
14211   return vec_st(
14212       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14213       __b, __c);
14214 }
14215
14216 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned short __a,
14217                                               int __b, unsigned short *__c) {
14218   return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
14219                 __c);
14220 }
14221
14222 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned short __a,
14223                                               int __b,
14224                                               vector unsigned short *__c) {
14225   return vec_st(
14226       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14227       __b, __c);
14228 }
14229
14230 static __inline__ void __ATTRS_o_ai vec_stvlx(vector bool short __a, int __b,
14231                                               vector bool short *__c) {
14232   return vec_st(
14233       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14234       __b, __c);
14235 }
14236
14237 static __inline__ void __ATTRS_o_ai vec_stvlx(vector pixel __a, int __b,
14238                                               vector pixel *__c) {
14239   return vec_st(
14240       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14241       __b, __c);
14242 }
14243
14244 static __inline__ void __ATTRS_o_ai vec_stvlx(vector int __a, int __b,
14245                                               int *__c) {
14246   return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
14247                 __c);
14248 }
14249
14250 static __inline__ void __ATTRS_o_ai vec_stvlx(vector int __a, int __b,
14251                                               vector int *__c) {
14252   return vec_st(
14253       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14254       __b, __c);
14255 }
14256
14257 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned int __a, int __b,
14258                                               unsigned int *__c) {
14259   return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
14260                 __c);
14261 }
14262
14263 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned int __a, int __b,
14264                                               vector unsigned int *__c) {
14265   return vec_st(
14266       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14267       __b, __c);
14268 }
14269
14270 static __inline__ void __ATTRS_o_ai vec_stvlx(vector bool int __a, int __b,
14271                                               vector bool int *__c) {
14272   return vec_st(
14273       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14274       __b, __c);
14275 }
14276
14277 static __inline__ void __ATTRS_o_ai vec_stvlx(vector float __a, int __b,
14278                                               vector float *__c) {
14279   return vec_st(
14280       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14281       __b, __c);
14282 }
14283
14284 /* vec_stvlxl */
14285
14286 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector signed char __a, int __b,
14287                                                signed char *__c) {
14288   return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
14289                  __c);
14290 }
14291
14292 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector signed char __a, int __b,
14293                                                vector signed char *__c) {
14294   return vec_stl(
14295       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14296       __b, __c);
14297 }
14298
14299 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned char __a,
14300                                                int __b, unsigned char *__c) {
14301   return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
14302                  __c);
14303 }
14304
14305 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned char __a,
14306                                                int __b,
14307                                                vector unsigned char *__c) {
14308   return vec_stl(
14309       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14310       __b, __c);
14311 }
14312
14313 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector bool char __a, int __b,
14314                                                vector bool char *__c) {
14315   return vec_stl(
14316       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14317       __b, __c);
14318 }
14319
14320 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector short __a, int __b,
14321                                                short *__c) {
14322   return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
14323                  __c);
14324 }
14325
14326 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector short __a, int __b,
14327                                                vector short *__c) {
14328   return vec_stl(
14329       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14330       __b, __c);
14331 }
14332
14333 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned short __a,
14334                                                int __b, unsigned short *__c) {
14335   return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
14336                  __c);
14337 }
14338
14339 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned short __a,
14340                                                int __b,
14341                                                vector unsigned short *__c) {
14342   return vec_stl(
14343       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14344       __b, __c);
14345 }
14346
14347 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector bool short __a, int __b,
14348                                                vector bool short *__c) {
14349   return vec_stl(
14350       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14351       __b, __c);
14352 }
14353
14354 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector pixel __a, int __b,
14355                                                vector pixel *__c) {
14356   return vec_stl(
14357       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14358       __b, __c);
14359 }
14360
14361 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector int __a, int __b,
14362                                                int *__c) {
14363   return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
14364                  __c);
14365 }
14366
14367 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector int __a, int __b,
14368                                                vector int *__c) {
14369   return vec_stl(
14370       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14371       __b, __c);
14372 }
14373
14374 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned int __a, int __b,
14375                                                unsigned int *__c) {
14376   return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
14377                  __c);
14378 }
14379
14380 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned int __a, int __b,
14381                                                vector unsigned int *__c) {
14382   return vec_stl(
14383       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14384       __b, __c);
14385 }
14386
14387 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector bool int __a, int __b,
14388                                                vector bool int *__c) {
14389   return vec_stl(
14390       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14391       __b, __c);
14392 }
14393
14394 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector float __a, int __b,
14395                                                vector float *__c) {
14396   return vec_stl(
14397       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
14398       __b, __c);
14399 }
14400
14401 /* vec_stvrx */
14402
14403 static __inline__ void __ATTRS_o_ai vec_stvrx(vector signed char __a, int __b,
14404                                               signed char *__c) {
14405   return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
14406                 __c);
14407 }
14408
14409 static __inline__ void __ATTRS_o_ai vec_stvrx(vector signed char __a, int __b,
14410                                               vector signed char *__c) {
14411   return vec_st(
14412       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14413       __b, __c);
14414 }
14415
14416 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned char __a, int __b,
14417                                               unsigned char *__c) {
14418   return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
14419                 __c);
14420 }
14421
14422 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned char __a, int __b,
14423                                               vector unsigned char *__c) {
14424   return vec_st(
14425       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14426       __b, __c);
14427 }
14428
14429 static __inline__ void __ATTRS_o_ai vec_stvrx(vector bool char __a, int __b,
14430                                               vector bool char *__c) {
14431   return vec_st(
14432       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14433       __b, __c);
14434 }
14435
14436 static __inline__ void __ATTRS_o_ai vec_stvrx(vector short __a, int __b,
14437                                               short *__c) {
14438   return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
14439                 __c);
14440 }
14441
14442 static __inline__ void __ATTRS_o_ai vec_stvrx(vector short __a, int __b,
14443                                               vector short *__c) {
14444   return vec_st(
14445       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14446       __b, __c);
14447 }
14448
14449 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned short __a,
14450                                               int __b, unsigned short *__c) {
14451   return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
14452                 __c);
14453 }
14454
14455 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned short __a,
14456                                               int __b,
14457                                               vector unsigned short *__c) {
14458   return vec_st(
14459       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14460       __b, __c);
14461 }
14462
14463 static __inline__ void __ATTRS_o_ai vec_stvrx(vector bool short __a, int __b,
14464                                               vector bool short *__c) {
14465   return vec_st(
14466       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14467       __b, __c);
14468 }
14469
14470 static __inline__ void __ATTRS_o_ai vec_stvrx(vector pixel __a, int __b,
14471                                               vector pixel *__c) {
14472   return vec_st(
14473       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14474       __b, __c);
14475 }
14476
14477 static __inline__ void __ATTRS_o_ai vec_stvrx(vector int __a, int __b,
14478                                               int *__c) {
14479   return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
14480                 __c);
14481 }
14482
14483 static __inline__ void __ATTRS_o_ai vec_stvrx(vector int __a, int __b,
14484                                               vector int *__c) {
14485   return vec_st(
14486       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14487       __b, __c);
14488 }
14489
14490 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned int __a, int __b,
14491                                               unsigned int *__c) {
14492   return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
14493                 __c);
14494 }
14495
14496 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned int __a, int __b,
14497                                               vector unsigned int *__c) {
14498   return vec_st(
14499       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14500       __b, __c);
14501 }
14502
14503 static __inline__ void __ATTRS_o_ai vec_stvrx(vector bool int __a, int __b,
14504                                               vector bool int *__c) {
14505   return vec_st(
14506       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14507       __b, __c);
14508 }
14509
14510 static __inline__ void __ATTRS_o_ai vec_stvrx(vector float __a, int __b,
14511                                               vector float *__c) {
14512   return vec_st(
14513       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14514       __b, __c);
14515 }
14516
14517 /* vec_stvrxl */
14518
14519 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector signed char __a, int __b,
14520                                                signed char *__c) {
14521   return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
14522                  __c);
14523 }
14524
14525 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector signed char __a, int __b,
14526                                                vector signed char *__c) {
14527   return vec_stl(
14528       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14529       __b, __c);
14530 }
14531
14532 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned char __a,
14533                                                int __b, unsigned char *__c) {
14534   return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
14535                  __c);
14536 }
14537
14538 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned char __a,
14539                                                int __b,
14540                                                vector unsigned char *__c) {
14541   return vec_stl(
14542       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14543       __b, __c);
14544 }
14545
14546 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector bool char __a, int __b,
14547                                                vector bool char *__c) {
14548   return vec_stl(
14549       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14550       __b, __c);
14551 }
14552
14553 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector short __a, int __b,
14554                                                short *__c) {
14555   return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
14556                  __c);
14557 }
14558
14559 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector short __a, int __b,
14560                                                vector short *__c) {
14561   return vec_stl(
14562       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14563       __b, __c);
14564 }
14565
14566 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned short __a,
14567                                                int __b, unsigned short *__c) {
14568   return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
14569                  __c);
14570 }
14571
14572 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned short __a,
14573                                                int __b,
14574                                                vector unsigned short *__c) {
14575   return vec_stl(
14576       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14577       __b, __c);
14578 }
14579
14580 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector bool short __a, int __b,
14581                                                vector bool short *__c) {
14582   return vec_stl(
14583       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14584       __b, __c);
14585 }
14586
14587 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector pixel __a, int __b,
14588                                                vector pixel *__c) {
14589   return vec_stl(
14590       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14591       __b, __c);
14592 }
14593
14594 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector int __a, int __b,
14595                                                int *__c) {
14596   return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
14597                  __c);
14598 }
14599
14600 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector int __a, int __b,
14601                                                vector int *__c) {
14602   return vec_stl(
14603       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14604       __b, __c);
14605 }
14606
14607 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned int __a, int __b,
14608                                                unsigned int *__c) {
14609   return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
14610                  __c);
14611 }
14612
14613 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned int __a, int __b,
14614                                                vector unsigned int *__c) {
14615   return vec_stl(
14616       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14617       __b, __c);
14618 }
14619
14620 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector bool int __a, int __b,
14621                                                vector bool int *__c) {
14622   return vec_stl(
14623       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14624       __b, __c);
14625 }
14626
14627 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector float __a, int __b,
14628                                                vector float *__c) {
14629   return vec_stl(
14630       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
14631       __b, __c);
14632 }
14633
14634 /* vec_promote */
14635
14636 static __inline__ vector signed char __ATTRS_o_ai vec_promote(signed char __a,
14637                                                               int __b) {
14638   vector signed char __res = (vector signed char)(0);
14639   __res[__b & 0x7] = __a;
14640   return __res;
14641 }
14642
14643 static __inline__ vector unsigned char __ATTRS_o_ai
14644 vec_promote(unsigned char __a, int __b) {
14645   vector unsigned char __res = (vector unsigned char)(0);
14646   __res[__b & 0x7] = __a;
14647   return __res;
14648 }
14649
14650 static __inline__ vector short __ATTRS_o_ai vec_promote(short __a, int __b) {
14651   vector short __res = (vector short)(0);
14652   __res[__b & 0x7] = __a;
14653   return __res;
14654 }
14655
14656 static __inline__ vector unsigned short __ATTRS_o_ai
14657 vec_promote(unsigned short __a, int __b) {
14658   vector unsigned short __res = (vector unsigned short)(0);
14659   __res[__b & 0x7] = __a;
14660   return __res;
14661 }
14662
14663 static __inline__ vector int __ATTRS_o_ai vec_promote(int __a, int __b) {
14664   vector int __res = (vector int)(0);
14665   __res[__b & 0x3] = __a;
14666   return __res;
14667 }
14668
14669 static __inline__ vector unsigned int __ATTRS_o_ai vec_promote(unsigned int __a,
14670                                                                int __b) {
14671   vector unsigned int __res = (vector unsigned int)(0);
14672   __res[__b & 0x3] = __a;
14673   return __res;
14674 }
14675
14676 static __inline__ vector float __ATTRS_o_ai vec_promote(float __a, int __b) {
14677   vector float __res = (vector float)(0);
14678   __res[__b & 0x3] = __a;
14679   return __res;
14680 }
14681
14682 #ifdef __VSX__
14683 static __inline__ vector double __ATTRS_o_ai vec_promote(double __a, int __b) {
14684   vector double __res = (vector double)(0);
14685   __res[__b & 0x1] = __a;
14686   return __res;
14687 }
14688
14689 static __inline__ vector signed long long __ATTRS_o_ai
14690 vec_promote(signed long long __a, int __b) {
14691   vector signed long long __res = (vector signed long long)(0);
14692   __res[__b & 0x1] = __a;
14693   return __res;
14694 }
14695
14696 static __inline__ vector unsigned long long __ATTRS_o_ai
14697 vec_promote(unsigned long long __a, int __b) {
14698   vector unsigned long long __res = (vector unsigned long long)(0);
14699   __res[__b & 0x1] = __a;
14700   return __res;
14701 }
14702 #endif
14703
14704 /* vec_splats */
14705
14706 static __inline__ vector signed char __ATTRS_o_ai vec_splats(signed char __a) {
14707   return (vector signed char)(__a);
14708 }
14709
14710 static __inline__ vector unsigned char __ATTRS_o_ai
14711 vec_splats(unsigned char __a) {
14712   return (vector unsigned char)(__a);
14713 }
14714
14715 static __inline__ vector short __ATTRS_o_ai vec_splats(short __a) {
14716   return (vector short)(__a);
14717 }
14718
14719 static __inline__ vector unsigned short __ATTRS_o_ai
14720 vec_splats(unsigned short __a) {
14721   return (vector unsigned short)(__a);
14722 }
14723
14724 static __inline__ vector int __ATTRS_o_ai vec_splats(int __a) {
14725   return (vector int)(__a);
14726 }
14727
14728 static __inline__ vector unsigned int __ATTRS_o_ai
14729 vec_splats(unsigned int __a) {
14730   return (vector unsigned int)(__a);
14731 }
14732
14733 #ifdef __VSX__
14734 static __inline__ vector signed long long __ATTRS_o_ai
14735 vec_splats(signed long long __a) {
14736   return (vector signed long long)(__a);
14737 }
14738
14739 static __inline__ vector unsigned long long __ATTRS_o_ai
14740 vec_splats(unsigned long long __a) {
14741   return (vector unsigned long long)(__a);
14742 }
14743
14744 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__) &&                    \
14745     defined(__SIZEOF_INT128__)
14746 static __inline__ vector signed __int128 __ATTRS_o_ai
14747 vec_splats(signed __int128 __a) {
14748   return (vector signed __int128)(__a);
14749 }
14750
14751 static __inline__ vector unsigned __int128 __ATTRS_o_ai
14752 vec_splats(unsigned __int128 __a) {
14753   return (vector unsigned __int128)(__a);
14754 }
14755
14756 #endif
14757
14758 static __inline__ vector double __ATTRS_o_ai vec_splats(double __a) {
14759   return (vector double)(__a);
14760 }
14761 #endif
14762
14763 static __inline__ vector float __ATTRS_o_ai vec_splats(float __a) {
14764   return (vector float)(__a);
14765 }
14766
14767 /* ----------------------------- predicates --------------------------------- */
14768
14769 /* vec_all_eq */
14770
14771 static __inline__ int __ATTRS_o_ai vec_all_eq(vector signed char __a,
14772                                               vector signed char __b) {
14773   return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
14774                                       (vector char)__b);
14775 }
14776
14777 static __inline__ int __ATTRS_o_ai vec_all_eq(vector signed char __a,
14778                                               vector bool char __b) {
14779   return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
14780                                       (vector char)__b);
14781 }
14782
14783 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned char __a,
14784                                               vector unsigned char __b) {
14785   return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
14786                                       (vector char)__b);
14787 }
14788
14789 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned char __a,
14790                                               vector bool char __b) {
14791   return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
14792                                       (vector char)__b);
14793 }
14794
14795 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool char __a,
14796                                               vector signed char __b) {
14797   return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
14798                                       (vector char)__b);
14799 }
14800
14801 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool char __a,
14802                                               vector unsigned char __b) {
14803   return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
14804                                       (vector char)__b);
14805 }
14806
14807 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool char __a,
14808                                               vector bool char __b) {
14809   return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
14810                                       (vector char)__b);
14811 }
14812
14813 static __inline__ int __ATTRS_o_ai vec_all_eq(vector short __a,
14814                                               vector short __b) {
14815   return __builtin_altivec_vcmpequh_p(__CR6_LT, __a, __b);
14816 }
14817
14818 static __inline__ int __ATTRS_o_ai vec_all_eq(vector short __a,
14819                                               vector bool short __b) {
14820   return __builtin_altivec_vcmpequh_p(__CR6_LT, __a, (vector short)__b);
14821 }
14822
14823 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned short __a,
14824                                               vector unsigned short __b) {
14825   return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
14826                                       (vector short)__b);
14827 }
14828
14829 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned short __a,
14830                                               vector bool short __b) {
14831   return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
14832                                       (vector short)__b);
14833 }
14834
14835 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool short __a,
14836                                               vector short __b) {
14837   return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
14838                                       (vector short)__b);
14839 }
14840
14841 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool short __a,
14842                                               vector unsigned short __b) {
14843   return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
14844                                       (vector short)__b);
14845 }
14846
14847 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool short __a,
14848                                               vector bool short __b) {
14849   return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
14850                                       (vector short)__b);
14851 }
14852
14853 static __inline__ int __ATTRS_o_ai vec_all_eq(vector pixel __a,
14854                                               vector pixel __b) {
14855   return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
14856                                       (vector short)__b);
14857 }
14858
14859 static __inline__ int __ATTRS_o_ai vec_all_eq(vector int __a, vector int __b) {
14860   return __builtin_altivec_vcmpequw_p(__CR6_LT, __a, __b);
14861 }
14862
14863 static __inline__ int __ATTRS_o_ai vec_all_eq(vector int __a,
14864                                               vector bool int __b) {
14865   return __builtin_altivec_vcmpequw_p(__CR6_LT, __a, (vector int)__b);
14866 }
14867
14868 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned int __a,
14869                                               vector unsigned int __b) {
14870   return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
14871                                       (vector int)__b);
14872 }
14873
14874 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned int __a,
14875                                               vector bool int __b) {
14876   return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
14877                                       (vector int)__b);
14878 }
14879
14880 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool int __a,
14881                                               vector int __b) {
14882   return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
14883                                       (vector int)__b);
14884 }
14885
14886 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool int __a,
14887                                               vector unsigned int __b) {
14888   return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
14889                                       (vector int)__b);
14890 }
14891
14892 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool int __a,
14893                                               vector bool int __b) {
14894   return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
14895                                       (vector int)__b);
14896 }
14897
14898 #ifdef __VSX__
14899 static __inline__ int __ATTRS_o_ai vec_all_eq(vector signed long long __a,
14900                                               vector signed long long __b) {
14901 #ifdef __POWER8_VECTOR__
14902   return __builtin_altivec_vcmpequd_p(__CR6_LT, __a, __b);
14903 #else
14904   // No vcmpequd on Power7 so we xor the two vectors and compare against zero as
14905   // 32-bit elements.
14906   return vec_all_eq((vector signed int)vec_xor(__a, __b), (vector signed int)0);
14907 #endif
14908 }
14909
14910 static __inline__ int __ATTRS_o_ai vec_all_eq(vector long long __a,
14911                                               vector bool long long __b) {
14912   return vec_all_eq((vector signed long long)__a, (vector signed long long)__b);
14913 }
14914
14915 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned long long __a,
14916                                               vector unsigned long long __b) {
14917   return vec_all_eq((vector signed long long)__a, (vector signed long long)__b);
14918 }
14919
14920 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned long long __a,
14921                                               vector bool long long __b) {
14922   return vec_all_eq((vector signed long long)__a, (vector signed long long)__b);
14923 }
14924
14925 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool long long __a,
14926                                               vector long long __b) {
14927   return vec_all_eq((vector signed long long)__a, (vector signed long long)__b);
14928 }
14929
14930 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool long long __a,
14931                                               vector unsigned long long __b) {
14932   return vec_all_eq((vector signed long long)__a, (vector signed long long)__b);
14933 }
14934
14935 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool long long __a,
14936                                               vector bool long long __b) {
14937   return vec_all_eq((vector signed long long)__a, (vector signed long long)__b);
14938 }
14939 #endif
14940
14941 static __inline__ int __ATTRS_o_ai vec_all_eq(vector float __a,
14942                                               vector float __b) {
14943 #ifdef __VSX__
14944   return __builtin_vsx_xvcmpeqsp_p(__CR6_LT, __a, __b);
14945 #else
14946   return __builtin_altivec_vcmpeqfp_p(__CR6_LT, __a, __b);
14947 #endif
14948 }
14949
14950 #ifdef __VSX__
14951 static __inline__ int __ATTRS_o_ai vec_all_eq(vector double __a,
14952                                               vector double __b) {
14953   return __builtin_vsx_xvcmpeqdp_p(__CR6_LT, __a, __b);
14954 }
14955 #endif
14956
14957 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
14958 static __inline__ int __ATTRS_o_ai vec_all_eq(vector signed __int128 __a,
14959                                               vector signed __int128 __b) {
14960   return __builtin_altivec_vcmpequq_p(__CR6_LT, (vector unsigned __int128)__a,
14961                                       (vector signed __int128)__b);
14962 }
14963
14964 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned __int128 __a,
14965                                               vector unsigned __int128 __b) {
14966   return __builtin_altivec_vcmpequq_p(__CR6_LT, __a,
14967                                       (vector signed __int128)__b);
14968 }
14969
14970 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool __int128 __a,
14971                                               vector bool __int128 __b) {
14972   return __builtin_altivec_vcmpequq_p(__CR6_LT, (vector unsigned __int128)__a,
14973                                       (vector signed __int128)__b);
14974 }
14975 #endif
14976
14977 /* vec_all_ge */
14978
14979 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed char __a,
14980                                               vector signed char __b) {
14981   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, __b, __a);
14982 }
14983
14984 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed char __a,
14985                                               vector bool char __b) {
14986   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, (vector signed char)__b, __a);
14987 }
14988
14989 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned char __a,
14990                                               vector unsigned char __b) {
14991   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __b, __a);
14992 }
14993
14994 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned char __a,
14995                                               vector bool char __b) {
14996   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__b, __a);
14997 }
14998
14999 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool char __a,
15000                                               vector signed char __b) {
15001   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, __b, (vector signed char)__a);
15002 }
15003
15004 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool char __a,
15005                                               vector unsigned char __b) {
15006   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __b, (vector unsigned char)__a);
15007 }
15008
15009 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool char __a,
15010                                               vector bool char __b) {
15011   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__b,
15012                                       (vector unsigned char)__a);
15013 }
15014
15015 static __inline__ int __ATTRS_o_ai vec_all_ge(vector short __a,
15016                                               vector short __b) {
15017   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, __b, __a);
15018 }
15019
15020 static __inline__ int __ATTRS_o_ai vec_all_ge(vector short __a,
15021                                               vector bool short __b) {
15022   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, (vector short)__b, __a);
15023 }
15024
15025 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned short __a,
15026                                               vector unsigned short __b) {
15027   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __b, __a);
15028 }
15029
15030 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned short __a,
15031                                               vector bool short __b) {
15032   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__b,
15033                                       __a);
15034 }
15035
15036 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool short __a,
15037                                               vector short __b) {
15038   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, __b, (vector signed short)__a);
15039 }
15040
15041 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool short __a,
15042                                               vector unsigned short __b) {
15043   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __b,
15044                                       (vector unsigned short)__a);
15045 }
15046
15047 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool short __a,
15048                                               vector bool short __b) {
15049   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__b,
15050                                       (vector unsigned short)__a);
15051 }
15052
15053 static __inline__ int __ATTRS_o_ai vec_all_ge(vector int __a, vector int __b) {
15054   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, __b, __a);
15055 }
15056
15057 static __inline__ int __ATTRS_o_ai vec_all_ge(vector int __a,
15058                                               vector bool int __b) {
15059   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, (vector int)__b, __a);
15060 }
15061
15062 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned int __a,
15063                                               vector unsigned int __b) {
15064   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __b, __a);
15065 }
15066
15067 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned int __a,
15068                                               vector bool int __b) {
15069   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__b, __a);
15070 }
15071
15072 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool int __a,
15073                                               vector int __b) {
15074   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, __b, (vector signed int)__a);
15075 }
15076
15077 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool int __a,
15078                                               vector unsigned int __b) {
15079   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __b, (vector unsigned int)__a);
15080 }
15081
15082 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool int __a,
15083                                               vector bool int __b) {
15084   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__b,
15085                                       (vector unsigned int)__a);
15086 }
15087
15088 #ifdef __VSX__
15089 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed long long __a,
15090                                               vector signed long long __b) {
15091   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, __b, __a);
15092 }
15093 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed long long __a,
15094                                               vector bool long long __b) {
15095   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, (vector signed long long)__b,
15096                                       __a);
15097 }
15098
15099 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned long long __a,
15100                                               vector unsigned long long __b) {
15101   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __b, __a);
15102 }
15103
15104 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned long long __a,
15105                                               vector bool long long __b) {
15106   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__b,
15107                                       __a);
15108 }
15109
15110 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool long long __a,
15111                                               vector signed long long __b) {
15112   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, __b,
15113                                       (vector signed long long)__a);
15114 }
15115
15116 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool long long __a,
15117                                               vector unsigned long long __b) {
15118   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __b,
15119                                       (vector unsigned long long)__a);
15120 }
15121
15122 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool long long __a,
15123                                               vector bool long long __b) {
15124   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__b,
15125                                       (vector unsigned long long)__a);
15126 }
15127 #endif
15128
15129 static __inline__ int __ATTRS_o_ai vec_all_ge(vector float __a,
15130                                               vector float __b) {
15131 #ifdef __VSX__
15132   return __builtin_vsx_xvcmpgesp_p(__CR6_LT, __a, __b);
15133 #else
15134   return __builtin_altivec_vcmpgefp_p(__CR6_LT, __a, __b);
15135 #endif
15136 }
15137
15138 #ifdef __VSX__
15139 static __inline__ int __ATTRS_o_ai vec_all_ge(vector double __a,
15140                                               vector double __b) {
15141   return __builtin_vsx_xvcmpgedp_p(__CR6_LT, __a, __b);
15142 }
15143 #endif
15144
15145 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
15146 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed __int128 __a,
15147                                               vector signed __int128 __b) {
15148   return __builtin_altivec_vcmpgtsq_p(__CR6_EQ, __b, __a);
15149 }
15150
15151 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned __int128 __a,
15152                                               vector unsigned __int128 __b) {
15153   return __builtin_altivec_vcmpgtuq_p(__CR6_EQ, __b, __a);
15154 }
15155 #endif
15156
15157 /* vec_all_gt */
15158
15159 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed char __a,
15160                                               vector signed char __b) {
15161   return __builtin_altivec_vcmpgtsb_p(__CR6_LT, __a, __b);
15162 }
15163
15164 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed char __a,
15165                                               vector bool char __b) {
15166   return __builtin_altivec_vcmpgtsb_p(__CR6_LT, __a, (vector signed char)__b);
15167 }
15168
15169 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned char __a,
15170                                               vector unsigned char __b) {
15171   return __builtin_altivec_vcmpgtub_p(__CR6_LT, __a, __b);
15172 }
15173
15174 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned char __a,
15175                                               vector bool char __b) {
15176   return __builtin_altivec_vcmpgtub_p(__CR6_LT, __a, (vector unsigned char)__b);
15177 }
15178
15179 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool char __a,
15180                                               vector signed char __b) {
15181   return __builtin_altivec_vcmpgtsb_p(__CR6_LT, (vector signed char)__a, __b);
15182 }
15183
15184 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool char __a,
15185                                               vector unsigned char __b) {
15186   return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__a, __b);
15187 }
15188
15189 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool char __a,
15190                                               vector bool char __b) {
15191   return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__a,
15192                                       (vector unsigned char)__b);
15193 }
15194
15195 static __inline__ int __ATTRS_o_ai vec_all_gt(vector short __a,
15196                                               vector short __b) {
15197   return __builtin_altivec_vcmpgtsh_p(__CR6_LT, __a, __b);
15198 }
15199
15200 static __inline__ int __ATTRS_o_ai vec_all_gt(vector short __a,
15201                                               vector bool short __b) {
15202   return __builtin_altivec_vcmpgtsh_p(__CR6_LT, __a, (vector short)__b);
15203 }
15204
15205 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned short __a,
15206                                               vector unsigned short __b) {
15207   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __a, __b);
15208 }
15209
15210 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned short __a,
15211                                               vector bool short __b) {
15212   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __a,
15213                                       (vector unsigned short)__b);
15214 }
15215
15216 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool short __a,
15217                                               vector short __b) {
15218   return __builtin_altivec_vcmpgtsh_p(__CR6_LT, (vector signed short)__a, __b);
15219 }
15220
15221 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool short __a,
15222                                               vector unsigned short __b) {
15223   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__a,
15224                                       __b);
15225 }
15226
15227 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool short __a,
15228                                               vector bool short __b) {
15229   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__a,
15230                                       (vector unsigned short)__b);
15231 }
15232
15233 static __inline__ int __ATTRS_o_ai vec_all_gt(vector int __a, vector int __b) {
15234   return __builtin_altivec_vcmpgtsw_p(__CR6_LT, __a, __b);
15235 }
15236
15237 static __inline__ int __ATTRS_o_ai vec_all_gt(vector int __a,
15238                                               vector bool int __b) {
15239   return __builtin_altivec_vcmpgtsw_p(__CR6_LT, __a, (vector int)__b);
15240 }
15241
15242 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned int __a,
15243                                               vector unsigned int __b) {
15244   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __a, __b);
15245 }
15246
15247 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned int __a,
15248                                               vector bool int __b) {
15249   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __a, (vector unsigned int)__b);
15250 }
15251
15252 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool int __a,
15253                                               vector int __b) {
15254   return __builtin_altivec_vcmpgtsw_p(__CR6_LT, (vector signed int)__a, __b);
15255 }
15256
15257 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool int __a,
15258                                               vector unsigned int __b) {
15259   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__a, __b);
15260 }
15261
15262 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool int __a,
15263                                               vector bool int __b) {
15264   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__a,
15265                                       (vector unsigned int)__b);
15266 }
15267
15268 #ifdef __VSX__
15269 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed long long __a,
15270                                               vector signed long long __b) {
15271   return __builtin_altivec_vcmpgtsd_p(__CR6_LT, __a, __b);
15272 }
15273 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed long long __a,
15274                                               vector bool long long __b) {
15275   return __builtin_altivec_vcmpgtsd_p(__CR6_LT, __a,
15276                                       (vector signed long long)__b);
15277 }
15278
15279 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned long long __a,
15280                                               vector unsigned long long __b) {
15281   return __builtin_altivec_vcmpgtud_p(__CR6_LT, __a, __b);
15282 }
15283
15284 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned long long __a,
15285                                               vector bool long long __b) {
15286   return __builtin_altivec_vcmpgtud_p(__CR6_LT, __a,
15287                                       (vector unsigned long long)__b);
15288 }
15289
15290 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool long long __a,
15291                                               vector signed long long __b) {
15292   return __builtin_altivec_vcmpgtsd_p(__CR6_LT, (vector signed long long)__a,
15293                                       __b);
15294 }
15295
15296 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool long long __a,
15297                                               vector unsigned long long __b) {
15298   return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__a,
15299                                       __b);
15300 }
15301
15302 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool long long __a,
15303                                               vector bool long long __b) {
15304   return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__a,
15305                                       (vector unsigned long long)__b);
15306 }
15307 #endif
15308
15309 static __inline__ int __ATTRS_o_ai vec_all_gt(vector float __a,
15310                                               vector float __b) {
15311 #ifdef __VSX__
15312   return __builtin_vsx_xvcmpgtsp_p(__CR6_LT, __a, __b);
15313 #else
15314   return __builtin_altivec_vcmpgtfp_p(__CR6_LT, __a, __b);
15315 #endif
15316 }
15317
15318 #ifdef __VSX__
15319 static __inline__ int __ATTRS_o_ai vec_all_gt(vector double __a,
15320                                               vector double __b) {
15321   return __builtin_vsx_xvcmpgtdp_p(__CR6_LT, __a, __b);
15322 }
15323 #endif
15324
15325 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
15326 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed __int128 __a,
15327                                               vector signed __int128 __b) {
15328   return __builtin_altivec_vcmpgtsq_p(__CR6_LT, __a, __b);
15329 }
15330
15331 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned __int128 __a,
15332                                               vector unsigned __int128 __b) {
15333   return __builtin_altivec_vcmpgtuq_p(__CR6_LT, __a, __b);
15334 }
15335 #endif
15336
15337 /* vec_all_in */
15338
15339 static __inline__ int __attribute__((__always_inline__))
15340 vec_all_in(vector float __a, vector float __b) {
15341   return __builtin_altivec_vcmpbfp_p(__CR6_EQ, __a, __b);
15342 }
15343
15344 /* vec_all_le */
15345
15346 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed char __a,
15347                                               vector signed char __b) {
15348   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, __a, __b);
15349 }
15350
15351 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed char __a,
15352                                               vector bool char __b) {
15353   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, __a, (vector signed char)__b);
15354 }
15355
15356 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned char __a,
15357                                               vector unsigned char __b) {
15358   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __a, __b);
15359 }
15360
15361 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned char __a,
15362                                               vector bool char __b) {
15363   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __a, (vector unsigned char)__b);
15364 }
15365
15366 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool char __a,
15367                                               vector signed char __b) {
15368   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, (vector signed char)__a, __b);
15369 }
15370
15371 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool char __a,
15372                                               vector unsigned char __b) {
15373   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__a, __b);
15374 }
15375
15376 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool char __a,
15377                                               vector bool char __b) {
15378   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__a,
15379                                       (vector unsigned char)__b);
15380 }
15381
15382 static __inline__ int __ATTRS_o_ai vec_all_le(vector short __a,
15383                                               vector short __b) {
15384   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, __a, __b);
15385 }
15386
15387 static __inline__ int __ATTRS_o_ai vec_all_le(vector short __a,
15388                                               vector bool short __b) {
15389   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, __a, (vector short)__b);
15390 }
15391
15392 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned short __a,
15393                                               vector unsigned short __b) {
15394   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __a, __b);
15395 }
15396
15397 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned short __a,
15398                                               vector bool short __b) {
15399   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __a,
15400                                       (vector unsigned short)__b);
15401 }
15402
15403 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool short __a,
15404                                               vector short __b) {
15405   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, (vector signed short)__a, __b);
15406 }
15407
15408 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool short __a,
15409                                               vector unsigned short __b) {
15410   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__a,
15411                                       __b);
15412 }
15413
15414 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool short __a,
15415                                               vector bool short __b) {
15416   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__a,
15417                                       (vector unsigned short)__b);
15418 }
15419
15420 static __inline__ int __ATTRS_o_ai vec_all_le(vector int __a, vector int __b) {
15421   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, __a, __b);
15422 }
15423
15424 static __inline__ int __ATTRS_o_ai vec_all_le(vector int __a,
15425                                               vector bool int __b) {
15426   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, __a, (vector int)__b);
15427 }
15428
15429 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned int __a,
15430                                               vector unsigned int __b) {
15431   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __a, __b);
15432 }
15433
15434 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned int __a,
15435                                               vector bool int __b) {
15436   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __a, (vector unsigned int)__b);
15437 }
15438
15439 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool int __a,
15440                                               vector int __b) {
15441   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, (vector signed int)__a, __b);
15442 }
15443
15444 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool int __a,
15445                                               vector unsigned int __b) {
15446   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__a, __b);
15447 }
15448
15449 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool int __a,
15450                                               vector bool int __b) {
15451   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__a,
15452                                       (vector unsigned int)__b);
15453 }
15454
15455 #ifdef __VSX__
15456 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed long long __a,
15457                                               vector signed long long __b) {
15458   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, __a, __b);
15459 }
15460
15461 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned long long __a,
15462                                               vector unsigned long long __b) {
15463   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __a, __b);
15464 }
15465
15466 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed long long __a,
15467                                               vector bool long long __b) {
15468   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, __a,
15469                                       (vector signed long long)__b);
15470 }
15471
15472 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned long long __a,
15473                                               vector bool long long __b) {
15474   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __a,
15475                                       (vector unsigned long long)__b);
15476 }
15477
15478 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool long long __a,
15479                                               vector signed long long __b) {
15480   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, (vector signed long long)__a,
15481                                       __b);
15482 }
15483
15484 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool long long __a,
15485                                               vector unsigned long long __b) {
15486   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__a,
15487                                       __b);
15488 }
15489
15490 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool long long __a,
15491                                               vector bool long long __b) {
15492   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__a,
15493                                       (vector unsigned long long)__b);
15494 }
15495 #endif
15496
15497 static __inline__ int __ATTRS_o_ai vec_all_le(vector float __a,
15498                                               vector float __b) {
15499 #ifdef __VSX__
15500   return __builtin_vsx_xvcmpgesp_p(__CR6_LT, __b, __a);
15501 #else
15502   return __builtin_altivec_vcmpgefp_p(__CR6_LT, __b, __a);
15503 #endif
15504 }
15505
15506 #ifdef __VSX__
15507 static __inline__ int __ATTRS_o_ai vec_all_le(vector double __a,
15508                                               vector double __b) {
15509   return __builtin_vsx_xvcmpgedp_p(__CR6_LT, __b, __a);
15510 }
15511 #endif
15512
15513 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
15514 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed __int128 __a,
15515                                               vector signed __int128 __b) {
15516   return __builtin_altivec_vcmpgtsq_p(__CR6_EQ, __a, __b);
15517 }
15518
15519 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned __int128 __a,
15520                                               vector unsigned __int128 __b) {
15521   return __builtin_altivec_vcmpgtuq_p(__CR6_EQ, __a, __b);
15522 }
15523 #endif
15524
15525 /* vec_all_lt */
15526
15527 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed char __a,
15528                                               vector signed char __b) {
15529   return __builtin_altivec_vcmpgtsb_p(__CR6_LT, __b, __a);
15530 }
15531
15532 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed char __a,
15533                                               vector bool char __b) {
15534   return __builtin_altivec_vcmpgtsb_p(__CR6_LT, (vector signed char)__b, __a);
15535 }
15536
15537 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned char __a,
15538                                               vector unsigned char __b) {
15539   return __builtin_altivec_vcmpgtub_p(__CR6_LT, __b, __a);
15540 }
15541
15542 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned char __a,
15543                                               vector bool char __b) {
15544   return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__b, __a);
15545 }
15546
15547 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool char __a,
15548                                               vector signed char __b) {
15549   return __builtin_altivec_vcmpgtsb_p(__CR6_LT, __b, (vector signed char)__a);
15550 }
15551
15552 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool char __a,
15553                                               vector unsigned char __b) {
15554   return __builtin_altivec_vcmpgtub_p(__CR6_LT, __b, (vector unsigned char)__a);
15555 }
15556
15557 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool char __a,
15558                                               vector bool char __b) {
15559   return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__b,
15560                                       (vector unsigned char)__a);
15561 }
15562
15563 static __inline__ int __ATTRS_o_ai vec_all_lt(vector short __a,
15564                                               vector short __b) {
15565   return __builtin_altivec_vcmpgtsh_p(__CR6_LT, __b, __a);
15566 }
15567
15568 static __inline__ int __ATTRS_o_ai vec_all_lt(vector short __a,
15569                                               vector bool short __b) {
15570   return __builtin_altivec_vcmpgtsh_p(__CR6_LT, (vector short)__b, __a);
15571 }
15572
15573 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned short __a,
15574                                               vector unsigned short __b) {
15575   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __b, __a);
15576 }
15577
15578 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned short __a,
15579                                               vector bool short __b) {
15580   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__b,
15581                                       __a);
15582 }
15583
15584 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool short __a,
15585                                               vector short __b) {
15586   return __builtin_altivec_vcmpgtsh_p(__CR6_LT, __b, (vector signed short)__a);
15587 }
15588
15589 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool short __a,
15590                                               vector unsigned short __b) {
15591   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __b,
15592                                       (vector unsigned short)__a);
15593 }
15594
15595 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool short __a,
15596                                               vector bool short __b) {
15597   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__b,
15598                                       (vector unsigned short)__a);
15599 }
15600
15601 static __inline__ int __ATTRS_o_ai vec_all_lt(vector int __a, vector int __b) {
15602   return __builtin_altivec_vcmpgtsw_p(__CR6_LT, __b, __a);
15603 }
15604
15605 static __inline__ int __ATTRS_o_ai vec_all_lt(vector int __a,
15606                                               vector bool int __b) {
15607   return __builtin_altivec_vcmpgtsw_p(__CR6_LT, (vector int)__b, __a);
15608 }
15609
15610 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned int __a,
15611                                               vector unsigned int __b) {
15612   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __b, __a);
15613 }
15614
15615 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned int __a,
15616                                               vector bool int __b) {
15617   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__b, __a);
15618 }
15619
15620 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool int __a,
15621                                               vector int __b) {
15622   return __builtin_altivec_vcmpgtsw_p(__CR6_LT, __b, (vector signed int)__a);
15623 }
15624
15625 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool int __a,
15626                                               vector unsigned int __b) {
15627   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __b, (vector unsigned int)__a);
15628 }
15629
15630 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool int __a,
15631                                               vector bool int __b) {
15632   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__b,
15633                                       (vector unsigned int)__a);
15634 }
15635
15636 #ifdef __VSX__
15637 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed long long __a,
15638                                               vector signed long long __b) {
15639   return __builtin_altivec_vcmpgtsd_p(__CR6_LT, __b, __a);
15640 }
15641
15642 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned long long __a,
15643                                               vector unsigned long long __b) {
15644   return __builtin_altivec_vcmpgtud_p(__CR6_LT, __b, __a);
15645 }
15646
15647 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed long long __a,
15648                                               vector bool long long __b) {
15649   return __builtin_altivec_vcmpgtsd_p(__CR6_LT, (vector signed long long)__b,
15650                                       __a);
15651 }
15652
15653 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned long long __a,
15654                                               vector bool long long __b) {
15655   return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__b,
15656                                       __a);
15657 }
15658
15659 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool long long __a,
15660                                               vector signed long long __b) {
15661   return __builtin_altivec_vcmpgtsd_p(__CR6_LT, __b,
15662                                       (vector signed long long)__a);
15663 }
15664
15665 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool long long __a,
15666                                               vector unsigned long long __b) {
15667   return __builtin_altivec_vcmpgtud_p(__CR6_LT, __b,
15668                                       (vector unsigned long long)__a);
15669 }
15670
15671 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool long long __a,
15672                                               vector bool long long __b) {
15673   return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__b,
15674                                       (vector unsigned long long)__a);
15675 }
15676 #endif
15677
15678 static __inline__ int __ATTRS_o_ai vec_all_lt(vector float __a,
15679                                               vector float __b) {
15680 #ifdef __VSX__
15681   return __builtin_vsx_xvcmpgtsp_p(__CR6_LT, __b, __a);
15682 #else
15683   return __builtin_altivec_vcmpgtfp_p(__CR6_LT, __b, __a);
15684 #endif
15685 }
15686
15687 #ifdef __VSX__
15688 static __inline__ int __ATTRS_o_ai vec_all_lt(vector double __a,
15689                                               vector double __b) {
15690   return __builtin_vsx_xvcmpgtdp_p(__CR6_LT, __b, __a);
15691 }
15692 #endif
15693
15694 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
15695 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed __int128 __a,
15696                                               vector signed __int128 __b) {
15697   return __builtin_altivec_vcmpgtsq_p(__CR6_LT, __b, __a);
15698 }
15699
15700 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned __int128 __a,
15701                                               vector unsigned __int128 __b) {
15702   return __builtin_altivec_vcmpgtuq_p(__CR6_LT, __b, __a);
15703 }
15704 #endif
15705
15706 /* vec_all_nan */
15707
15708 static __inline__ int __ATTRS_o_ai vec_all_nan(vector float __a) {
15709 #ifdef __VSX__
15710   return __builtin_vsx_xvcmpeqsp_p(__CR6_EQ, __a, __a);
15711 #else
15712   return __builtin_altivec_vcmpeqfp_p(__CR6_EQ, __a, __a);
15713 #endif
15714 }
15715
15716 #ifdef __VSX__
15717 static __inline__ int __ATTRS_o_ai vec_all_nan(vector double __a) {
15718   return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ, __a, __a);
15719 }
15720 #endif
15721
15722 /* vec_all_ne */
15723
15724 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed char __a,
15725                                               vector signed char __b) {
15726   return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
15727                                       (vector char)__b);
15728 }
15729
15730 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed char __a,
15731                                               vector bool char __b) {
15732   return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
15733                                       (vector char)__b);
15734 }
15735
15736 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned char __a,
15737                                               vector unsigned char __b) {
15738   return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
15739                                       (vector char)__b);
15740 }
15741
15742 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned char __a,
15743                                               vector bool char __b) {
15744   return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
15745                                       (vector char)__b);
15746 }
15747
15748 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool char __a,
15749                                               vector signed char __b) {
15750   return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
15751                                       (vector char)__b);
15752 }
15753
15754 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool char __a,
15755                                               vector unsigned char __b) {
15756   return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
15757                                       (vector char)__b);
15758 }
15759
15760 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool char __a,
15761                                               vector bool char __b) {
15762   return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
15763                                       (vector char)__b);
15764 }
15765
15766 static __inline__ int __ATTRS_o_ai vec_all_ne(vector short __a,
15767                                               vector short __b) {
15768   return __builtin_altivec_vcmpequh_p(__CR6_EQ, __a, __b);
15769 }
15770
15771 static __inline__ int __ATTRS_o_ai vec_all_ne(vector short __a,
15772                                               vector bool short __b) {
15773   return __builtin_altivec_vcmpequh_p(__CR6_EQ, __a, (vector short)__b);
15774 }
15775
15776 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned short __a,
15777                                               vector unsigned short __b) {
15778   return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
15779                                       (vector short)__b);
15780 }
15781
15782 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned short __a,
15783                                               vector bool short __b) {
15784   return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
15785                                       (vector short)__b);
15786 }
15787
15788 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool short __a,
15789                                               vector short __b) {
15790   return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
15791                                       (vector short)__b);
15792 }
15793
15794 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool short __a,
15795                                               vector unsigned short __b) {
15796   return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
15797                                       (vector short)__b);
15798 }
15799
15800 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool short __a,
15801                                               vector bool short __b) {
15802   return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
15803                                       (vector short)__b);
15804 }
15805
15806 static __inline__ int __ATTRS_o_ai vec_all_ne(vector pixel __a,
15807                                               vector pixel __b) {
15808   return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
15809                                       (vector short)__b);
15810 }
15811
15812 static __inline__ int __ATTRS_o_ai vec_all_ne(vector int __a, vector int __b) {
15813   return __builtin_altivec_vcmpequw_p(__CR6_EQ, __a, __b);
15814 }
15815
15816 static __inline__ int __ATTRS_o_ai vec_all_ne(vector int __a,
15817                                               vector bool int __b) {
15818   return __builtin_altivec_vcmpequw_p(__CR6_EQ, __a, (vector int)__b);
15819 }
15820
15821 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned int __a,
15822                                               vector unsigned int __b) {
15823   return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
15824                                       (vector int)__b);
15825 }
15826
15827 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned int __a,
15828                                               vector bool int __b) {
15829   return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
15830                                       (vector int)__b);
15831 }
15832
15833 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool int __a,
15834                                               vector int __b) {
15835   return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
15836                                       (vector int)__b);
15837 }
15838
15839 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool int __a,
15840                                               vector unsigned int __b) {
15841   return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
15842                                       (vector int)__b);
15843 }
15844
15845 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool int __a,
15846                                               vector bool int __b) {
15847   return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
15848                                       (vector int)__b);
15849 }
15850
15851 #ifdef __VSX__
15852 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed long long __a,
15853                                               vector signed long long __b) {
15854   return __builtin_altivec_vcmpequd_p(__CR6_EQ, __a, __b);
15855 }
15856
15857 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned long long __a,
15858                                               vector unsigned long long __b) {
15859   return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector long long)__a,
15860                                       (vector long long)__b);
15861 }
15862
15863 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed long long __a,
15864                                               vector bool long long __b) {
15865   return __builtin_altivec_vcmpequd_p(__CR6_EQ, __a,
15866                                       (vector signed long long)__b);
15867 }
15868
15869 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned long long __a,
15870                                               vector bool long long __b) {
15871   return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector signed long long)__a,
15872                                       (vector signed long long)__b);
15873 }
15874
15875 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool long long __a,
15876                                               vector signed long long __b) {
15877   return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector signed long long)__a,
15878                                       (vector signed long long)__b);
15879 }
15880
15881 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool long long __a,
15882                                               vector unsigned long long __b) {
15883   return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector signed long long)__a,
15884                                       (vector signed long long)__b);
15885 }
15886
15887 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool long long __a,
15888                                               vector bool long long __b) {
15889   return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector signed long long)__a,
15890                                       (vector signed long long)__b);
15891 }
15892 #endif
15893
15894 static __inline__ int __ATTRS_o_ai vec_all_ne(vector float __a,
15895                                               vector float __b) {
15896 #ifdef __VSX__
15897   return __builtin_vsx_xvcmpeqsp_p(__CR6_EQ, __a, __b);
15898 #else
15899   return __builtin_altivec_vcmpeqfp_p(__CR6_EQ, __a, __b);
15900 #endif
15901 }
15902
15903 #ifdef __VSX__
15904 static __inline__ int __ATTRS_o_ai vec_all_ne(vector double __a,
15905                                               vector double __b) {
15906   return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ, __a, __b);
15907 }
15908 #endif
15909
15910 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
15911 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed __int128 __a,
15912                                               vector signed __int128 __b) {
15913   return __builtin_altivec_vcmpequq_p(__CR6_EQ, (vector unsigned __int128)__a,
15914                                       __b);
15915 }
15916
15917 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned __int128 __a,
15918                                               vector unsigned __int128 __b) {
15919   return __builtin_altivec_vcmpequq_p(__CR6_EQ, __a,
15920                                       (vector signed __int128)__b);
15921 }
15922
15923 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool __int128 __a,
15924                                               vector bool __int128 __b) {
15925   return __builtin_altivec_vcmpequq_p(__CR6_EQ, (vector unsigned __int128)__a,
15926                                       (vector signed __int128)__b);
15927 }
15928 #endif
15929
15930 /* vec_all_nge */
15931
15932 static __inline__ int __ATTRS_o_ai vec_all_nge(vector float __a,
15933                                                vector float __b) {
15934 #ifdef __VSX__
15935   return __builtin_vsx_xvcmpgesp_p(__CR6_EQ, __a, __b);
15936 #else
15937   return __builtin_altivec_vcmpgefp_p(__CR6_EQ, __a, __b);
15938 #endif
15939 }
15940
15941 #ifdef __VSX__
15942 static __inline__ int __ATTRS_o_ai vec_all_nge(vector double __a,
15943                                                vector double __b) {
15944   return __builtin_vsx_xvcmpgedp_p(__CR6_EQ, __a, __b);
15945 }
15946 #endif
15947
15948 /* vec_all_ngt */
15949
15950 static __inline__ int __ATTRS_o_ai vec_all_ngt(vector float __a,
15951                                                vector float __b) {
15952 #ifdef __VSX__
15953   return __builtin_vsx_xvcmpgtsp_p(__CR6_EQ, __a, __b);
15954 #else
15955   return __builtin_altivec_vcmpgtfp_p(__CR6_EQ, __a, __b);
15956 #endif
15957 }
15958
15959 #ifdef __VSX__
15960 static __inline__ int __ATTRS_o_ai vec_all_ngt(vector double __a,
15961                                                vector double __b) {
15962   return __builtin_vsx_xvcmpgtdp_p(__CR6_EQ, __a, __b);
15963 }
15964 #endif
15965
15966 /* vec_all_nle */
15967
15968 static __inline__ int __ATTRS_o_ai
15969 vec_all_nle(vector float __a, vector float __b) {
15970 #ifdef __VSX__
15971   return __builtin_vsx_xvcmpgesp_p(__CR6_EQ, __b, __a);
15972 #else
15973   return __builtin_altivec_vcmpgefp_p(__CR6_EQ, __b, __a);
15974 #endif
15975 }
15976
15977 #ifdef __VSX__
15978 static __inline__ int __ATTRS_o_ai vec_all_nle(vector double __a,
15979                                                vector double __b) {
15980   return __builtin_vsx_xvcmpgedp_p(__CR6_EQ, __b, __a);
15981 }
15982 #endif
15983
15984 /* vec_all_nlt */
15985
15986 static __inline__ int __ATTRS_o_ai
15987 vec_all_nlt(vector float __a, vector float __b) {
15988 #ifdef __VSX__
15989   return __builtin_vsx_xvcmpgtsp_p(__CR6_EQ, __b, __a);
15990 #else
15991   return __builtin_altivec_vcmpgtfp_p(__CR6_EQ, __b, __a);
15992 #endif
15993 }
15994
15995 #ifdef __VSX__
15996 static __inline__ int __ATTRS_o_ai vec_all_nlt(vector double __a,
15997                                                vector double __b) {
15998   return __builtin_vsx_xvcmpgtdp_p(__CR6_EQ, __b, __a);
15999 }
16000 #endif
16001
16002 /* vec_all_numeric */
16003
16004 static __inline__ int __ATTRS_o_ai
16005 vec_all_numeric(vector float __a) {
16006 #ifdef __VSX__
16007   return __builtin_vsx_xvcmpeqsp_p(__CR6_LT, __a, __a);
16008 #else
16009   return __builtin_altivec_vcmpeqfp_p(__CR6_LT, __a, __a);
16010 #endif
16011 }
16012
16013 #ifdef __VSX__
16014 static __inline__ int __ATTRS_o_ai vec_all_numeric(vector double __a) {
16015   return __builtin_vsx_xvcmpeqdp_p(__CR6_LT, __a, __a);
16016 }
16017 #endif
16018
16019 /* vec_any_eq */
16020
16021 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed char __a,
16022                                               vector signed char __b) {
16023   return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
16024                                       (vector char)__b);
16025 }
16026
16027 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed char __a,
16028                                               vector bool char __b) {
16029   return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
16030                                       (vector char)__b);
16031 }
16032
16033 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned char __a,
16034                                               vector unsigned char __b) {
16035   return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
16036                                       (vector char)__b);
16037 }
16038
16039 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned char __a,
16040                                               vector bool char __b) {
16041   return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
16042                                       (vector char)__b);
16043 }
16044
16045 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool char __a,
16046                                               vector signed char __b) {
16047   return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
16048                                       (vector char)__b);
16049 }
16050
16051 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool char __a,
16052                                               vector unsigned char __b) {
16053   return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
16054                                       (vector char)__b);
16055 }
16056
16057 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool char __a,
16058                                               vector bool char __b) {
16059   return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
16060                                       (vector char)__b);
16061 }
16062
16063 static __inline__ int __ATTRS_o_ai vec_any_eq(vector short __a,
16064                                               vector short __b) {
16065   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, __a, __b);
16066 }
16067
16068 static __inline__ int __ATTRS_o_ai vec_any_eq(vector short __a,
16069                                               vector bool short __b) {
16070   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, __a, (vector short)__b);
16071 }
16072
16073 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned short __a,
16074                                               vector unsigned short __b) {
16075   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
16076                                       (vector short)__b);
16077 }
16078
16079 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned short __a,
16080                                               vector bool short __b) {
16081   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
16082                                       (vector short)__b);
16083 }
16084
16085 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool short __a,
16086                                               vector short __b) {
16087   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
16088                                       (vector short)__b);
16089 }
16090
16091 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool short __a,
16092                                               vector unsigned short __b) {
16093   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
16094                                       (vector short)__b);
16095 }
16096
16097 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool short __a,
16098                                               vector bool short __b) {
16099   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
16100                                       (vector short)__b);
16101 }
16102
16103 static __inline__ int __ATTRS_o_ai vec_any_eq(vector pixel __a,
16104                                               vector pixel __b) {
16105   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
16106                                       (vector short)__b);
16107 }
16108
16109 static __inline__ int __ATTRS_o_ai vec_any_eq(vector int __a, vector int __b) {
16110   return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, __a, __b);
16111 }
16112
16113 static __inline__ int __ATTRS_o_ai vec_any_eq(vector int __a,
16114                                               vector bool int __b) {
16115   return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, __a, (vector int)__b);
16116 }
16117
16118 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned int __a,
16119                                               vector unsigned int __b) {
16120   return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
16121                                       (vector int)__b);
16122 }
16123
16124 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned int __a,
16125                                               vector bool int __b) {
16126   return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
16127                                       (vector int)__b);
16128 }
16129
16130 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool int __a,
16131                                               vector int __b) {
16132   return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
16133                                       (vector int)__b);
16134 }
16135
16136 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool int __a,
16137                                               vector unsigned int __b) {
16138   return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
16139                                       (vector int)__b);
16140 }
16141
16142 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool int __a,
16143                                               vector bool int __b) {
16144   return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
16145                                       (vector int)__b);
16146 }
16147
16148 #ifdef __VSX__
16149 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed long long __a,
16150                                               vector signed long long __b) {
16151   return __builtin_altivec_vcmpequd_p(__CR6_EQ_REV, __a, __b);
16152 }
16153
16154 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned long long __a,
16155                                               vector unsigned long long __b) {
16156   return __builtin_altivec_vcmpequd_p(__CR6_EQ_REV, (vector long long)__a,
16157                                       (vector long long)__b);
16158 }
16159
16160 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed long long __a,
16161                                               vector bool long long __b) {
16162   return __builtin_altivec_vcmpequd_p(__CR6_EQ_REV, __a,
16163                                       (vector signed long long)__b);
16164 }
16165
16166 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned long long __a,
16167                                               vector bool long long __b) {
16168   return __builtin_altivec_vcmpequd_p(
16169       __CR6_EQ_REV, (vector signed long long)__a, (vector signed long long)__b);
16170 }
16171
16172 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool long long __a,
16173                                               vector signed long long __b) {
16174   return __builtin_altivec_vcmpequd_p(
16175       __CR6_EQ_REV, (vector signed long long)__a, (vector signed long long)__b);
16176 }
16177
16178 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool long long __a,
16179                                               vector unsigned long long __b) {
16180   return __builtin_altivec_vcmpequd_p(
16181       __CR6_EQ_REV, (vector signed long long)__a, (vector signed long long)__b);
16182 }
16183
16184 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool long long __a,
16185                                               vector bool long long __b) {
16186   return __builtin_altivec_vcmpequd_p(
16187       __CR6_EQ_REV, (vector signed long long)__a, (vector signed long long)__b);
16188 }
16189 #endif
16190
16191 static __inline__ int __ATTRS_o_ai vec_any_eq(vector float __a,
16192                                               vector float __b) {
16193 #ifdef __VSX__
16194   return __builtin_vsx_xvcmpeqsp_p(__CR6_EQ_REV, __a, __b);
16195 #else
16196   return __builtin_altivec_vcmpeqfp_p(__CR6_EQ_REV, __a, __b);
16197 #endif
16198 }
16199
16200 #ifdef __VSX__
16201 static __inline__ int __ATTRS_o_ai vec_any_eq(vector double __a,
16202                                               vector double __b) {
16203   return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ_REV, __a, __b);
16204 }
16205 #endif
16206
16207 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
16208 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed __int128 __a,
16209                                               vector signed __int128 __b) {
16210   return __builtin_altivec_vcmpequq_p(__CR6_EQ_REV,
16211                                       (vector unsigned __int128)__a, __b);
16212 }
16213
16214 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned __int128 __a,
16215                                               vector unsigned __int128 __b) {
16216   return __builtin_altivec_vcmpequq_p(__CR6_EQ_REV, __a,
16217                                       (vector signed __int128)__b);
16218 }
16219
16220 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool __int128 __a,
16221                                               vector bool __int128 __b) {
16222   return __builtin_altivec_vcmpequq_p(
16223       __CR6_EQ_REV, (vector unsigned __int128)__a, (vector signed __int128)__b);
16224 }
16225 #endif
16226
16227 /* vec_any_ge */
16228
16229 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed char __a,
16230                                               vector signed char __b) {
16231   return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, __b, __a);
16232 }
16233
16234 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed char __a,
16235                                               vector bool char __b) {
16236   return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, (vector signed char)__b,
16237                                       __a);
16238 }
16239
16240 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned char __a,
16241                                               vector unsigned char __b) {
16242   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __b, __a);
16243 }
16244
16245 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned char __a,
16246                                               vector bool char __b) {
16247   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__b,
16248                                       __a);
16249 }
16250
16251 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool char __a,
16252                                               vector signed char __b) {
16253   return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, __b,
16254                                       (vector signed char)__a);
16255 }
16256
16257 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool char __a,
16258                                               vector unsigned char __b) {
16259   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __b,
16260                                       (vector unsigned char)__a);
16261 }
16262
16263 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool char __a,
16264                                               vector bool char __b) {
16265   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__b,
16266                                       (vector unsigned char)__a);
16267 }
16268
16269 static __inline__ int __ATTRS_o_ai vec_any_ge(vector short __a,
16270                                               vector short __b) {
16271   return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, __b, __a);
16272 }
16273
16274 static __inline__ int __ATTRS_o_ai vec_any_ge(vector short __a,
16275                                               vector bool short __b) {
16276   return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, (vector short)__b, __a);
16277 }
16278
16279 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned short __a,
16280                                               vector unsigned short __b) {
16281   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __b, __a);
16282 }
16283
16284 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned short __a,
16285                                               vector bool short __b) {
16286   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__b,
16287                                       __a);
16288 }
16289
16290 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool short __a,
16291                                               vector short __b) {
16292   return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, __b,
16293                                       (vector signed short)__a);
16294 }
16295
16296 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool short __a,
16297                                               vector unsigned short __b) {
16298   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __b,
16299                                       (vector unsigned short)__a);
16300 }
16301
16302 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool short __a,
16303                                               vector bool short __b) {
16304   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__b,
16305                                       (vector unsigned short)__a);
16306 }
16307
16308 static __inline__ int __ATTRS_o_ai vec_any_ge(vector int __a, vector int __b) {
16309   return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, __b, __a);
16310 }
16311
16312 static __inline__ int __ATTRS_o_ai vec_any_ge(vector int __a,
16313                                               vector bool int __b) {
16314   return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, (vector int)__b, __a);
16315 }
16316
16317 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned int __a,
16318                                               vector unsigned int __b) {
16319   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __b, __a);
16320 }
16321
16322 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned int __a,
16323                                               vector bool int __b) {
16324   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__b,
16325                                       __a);
16326 }
16327
16328 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool int __a,
16329                                               vector int __b) {
16330   return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, __b,
16331                                       (vector signed int)__a);
16332 }
16333
16334 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool int __a,
16335                                               vector unsigned int __b) {
16336   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __b,
16337                                       (vector unsigned int)__a);
16338 }
16339
16340 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool int __a,
16341                                               vector bool int __b) {
16342   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__b,
16343                                       (vector unsigned int)__a);
16344 }
16345
16346 #ifdef __VSX__
16347 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed long long __a,
16348                                               vector signed long long __b) {
16349   return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV, __b, __a);
16350 }
16351
16352 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned long long __a,
16353                                               vector unsigned long long __b) {
16354   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __b, __a);
16355 }
16356
16357 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed long long __a,
16358                                               vector bool long long __b) {
16359   return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV,
16360                                       (vector signed long long)__b, __a);
16361 }
16362
16363 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned long long __a,
16364                                               vector bool long long __b) {
16365   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
16366                                       (vector unsigned long long)__b, __a);
16367 }
16368
16369 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool long long __a,
16370                                               vector signed long long __b) {
16371   return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV, __b,
16372                                       (vector signed long long)__a);
16373 }
16374
16375 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool long long __a,
16376                                               vector unsigned long long __b) {
16377   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __b,
16378                                       (vector unsigned long long)__a);
16379 }
16380
16381 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool long long __a,
16382                                               vector bool long long __b) {
16383   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
16384                                       (vector unsigned long long)__b,
16385                                       (vector unsigned long long)__a);
16386 }
16387 #endif
16388
16389 static __inline__ int __ATTRS_o_ai vec_any_ge(vector float __a,
16390                                               vector float __b) {
16391 #ifdef __VSX__
16392   return __builtin_vsx_xvcmpgesp_p(__CR6_EQ_REV, __a, __b);
16393 #else
16394   return __builtin_altivec_vcmpgefp_p(__CR6_EQ_REV, __a, __b);
16395 #endif
16396 }
16397
16398 #ifdef __VSX__
16399 static __inline__ int __ATTRS_o_ai vec_any_ge(vector double __a,
16400                                               vector double __b) {
16401   return __builtin_vsx_xvcmpgedp_p(__CR6_EQ_REV, __a, __b);
16402 }
16403 #endif
16404
16405 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
16406 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed __int128 __a,
16407                                               vector signed __int128 __b) {
16408   return __builtin_altivec_vcmpgtsq_p(__CR6_LT_REV, __b, __a);
16409 }
16410
16411 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned __int128 __a,
16412                                               vector unsigned __int128 __b) {
16413   return __builtin_altivec_vcmpgtuq_p(__CR6_LT_REV, __b, __a);
16414 }
16415 #endif
16416
16417 /* vec_any_gt */
16418
16419 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed char __a,
16420                                               vector signed char __b) {
16421   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, __a, __b);
16422 }
16423
16424 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed char __a,
16425                                               vector bool char __b) {
16426   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, __a,
16427                                       (vector signed char)__b);
16428 }
16429
16430 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned char __a,
16431                                               vector unsigned char __b) {
16432   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __a, __b);
16433 }
16434
16435 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned char __a,
16436                                               vector bool char __b) {
16437   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __a,
16438                                       (vector unsigned char)__b);
16439 }
16440
16441 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool char __a,
16442                                               vector signed char __b) {
16443   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, (vector signed char)__a,
16444                                       __b);
16445 }
16446
16447 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool char __a,
16448                                               vector unsigned char __b) {
16449   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__a,
16450                                       __b);
16451 }
16452
16453 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool char __a,
16454                                               vector bool char __b) {
16455   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__a,
16456                                       (vector unsigned char)__b);
16457 }
16458
16459 static __inline__ int __ATTRS_o_ai vec_any_gt(vector short __a,
16460                                               vector short __b) {
16461   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, __a, __b);
16462 }
16463
16464 static __inline__ int __ATTRS_o_ai vec_any_gt(vector short __a,
16465                                               vector bool short __b) {
16466   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, __a, (vector short)__b);
16467 }
16468
16469 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned short __a,
16470                                               vector unsigned short __b) {
16471   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __a, __b);
16472 }
16473
16474 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned short __a,
16475                                               vector bool short __b) {
16476   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __a,
16477                                       (vector unsigned short)__b);
16478 }
16479
16480 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool short __a,
16481                                               vector short __b) {
16482   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, (vector signed short)__a,
16483                                       __b);
16484 }
16485
16486 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool short __a,
16487                                               vector unsigned short __b) {
16488   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__a,
16489                                       __b);
16490 }
16491
16492 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool short __a,
16493                                               vector bool short __b) {
16494   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__a,
16495                                       (vector unsigned short)__b);
16496 }
16497
16498 static __inline__ int __ATTRS_o_ai vec_any_gt(vector int __a, vector int __b) {
16499   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, __a, __b);
16500 }
16501
16502 static __inline__ int __ATTRS_o_ai vec_any_gt(vector int __a,
16503                                               vector bool int __b) {
16504   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, __a, (vector int)__b);
16505 }
16506
16507 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned int __a,
16508                                               vector unsigned int __b) {
16509   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __a, __b);
16510 }
16511
16512 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned int __a,
16513                                               vector bool int __b) {
16514   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __a,
16515                                       (vector unsigned int)__b);
16516 }
16517
16518 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool int __a,
16519                                               vector int __b) {
16520   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, (vector signed int)__a,
16521                                       __b);
16522 }
16523
16524 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool int __a,
16525                                               vector unsigned int __b) {
16526   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__a,
16527                                       __b);
16528 }
16529
16530 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool int __a,
16531                                               vector bool int __b) {
16532   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__a,
16533                                       (vector unsigned int)__b);
16534 }
16535
16536 #ifdef __VSX__
16537 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed long long __a,
16538                                               vector signed long long __b) {
16539   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV, __a, __b);
16540 }
16541
16542 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned long long __a,
16543                                               vector unsigned long long __b) {
16544   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __a, __b);
16545 }
16546
16547 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed long long __a,
16548                                               vector bool long long __b) {
16549   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV, __a,
16550                                       (vector signed long long)__b);
16551 }
16552
16553 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned long long __a,
16554                                               vector bool long long __b) {
16555   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __a,
16556                                       (vector unsigned long long)__b);
16557 }
16558
16559 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool long long __a,
16560                                               vector signed long long __b) {
16561   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV,
16562                                       (vector signed long long)__a, __b);
16563 }
16564
16565 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool long long __a,
16566                                               vector unsigned long long __b) {
16567   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
16568                                       (vector unsigned long long)__a, __b);
16569 }
16570
16571 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool long long __a,
16572                                               vector bool long long __b) {
16573   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
16574                                       (vector unsigned long long)__a,
16575                                       (vector unsigned long long)__b);
16576 }
16577 #endif
16578
16579 static __inline__ int __ATTRS_o_ai vec_any_gt(vector float __a,
16580                                               vector float __b) {
16581 #ifdef __VSX__
16582   return __builtin_vsx_xvcmpgtsp_p(__CR6_EQ_REV, __a, __b);
16583 #else
16584   return __builtin_altivec_vcmpgtfp_p(__CR6_EQ_REV, __a, __b);
16585 #endif
16586 }
16587
16588 #ifdef __VSX__
16589 static __inline__ int __ATTRS_o_ai vec_any_gt(vector double __a,
16590                                               vector double __b) {
16591   return __builtin_vsx_xvcmpgtdp_p(__CR6_EQ_REV, __a, __b);
16592 }
16593 #endif
16594
16595 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
16596 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed __int128 __a,
16597                                               vector signed __int128 __b) {
16598   return __builtin_altivec_vcmpgtsq_p(__CR6_EQ_REV, __a, __b);
16599 }
16600
16601 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned __int128 __a,
16602                                               vector unsigned __int128 __b) {
16603   return __builtin_altivec_vcmpgtuq_p(__CR6_EQ_REV, __a, __b);
16604 }
16605 #endif
16606
16607 /* vec_any_le */
16608
16609 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed char __a,
16610                                               vector signed char __b) {
16611   return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, __a, __b);
16612 }
16613
16614 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed char __a,
16615                                               vector bool char __b) {
16616   return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, __a,
16617                                       (vector signed char)__b);
16618 }
16619
16620 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned char __a,
16621                                               vector unsigned char __b) {
16622   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __a, __b);
16623 }
16624
16625 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned char __a,
16626                                               vector bool char __b) {
16627   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __a,
16628                                       (vector unsigned char)__b);
16629 }
16630
16631 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool char __a,
16632                                               vector signed char __b) {
16633   return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, (vector signed char)__a,
16634                                       __b);
16635 }
16636
16637 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool char __a,
16638                                               vector unsigned char __b) {
16639   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__a,
16640                                       __b);
16641 }
16642
16643 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool char __a,
16644                                               vector bool char __b) {
16645   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__a,
16646                                       (vector unsigned char)__b);
16647 }
16648
16649 static __inline__ int __ATTRS_o_ai vec_any_le(vector short __a,
16650                                               vector short __b) {
16651   return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, __a, __b);
16652 }
16653
16654 static __inline__ int __ATTRS_o_ai vec_any_le(vector short __a,
16655                                               vector bool short __b) {
16656   return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, __a, (vector short)__b);
16657 }
16658
16659 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned short __a,
16660                                               vector unsigned short __b) {
16661   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __a, __b);
16662 }
16663
16664 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned short __a,
16665                                               vector bool short __b) {
16666   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __a,
16667                                       (vector unsigned short)__b);
16668 }
16669
16670 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool short __a,
16671                                               vector short __b) {
16672   return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, (vector signed short)__a,
16673                                       __b);
16674 }
16675
16676 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool short __a,
16677                                               vector unsigned short __b) {
16678   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__a,
16679                                       __b);
16680 }
16681
16682 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool short __a,
16683                                               vector bool short __b) {
16684   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__a,
16685                                       (vector unsigned short)__b);
16686 }
16687
16688 static __inline__ int __ATTRS_o_ai vec_any_le(vector int __a, vector int __b) {
16689   return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, __a, __b);
16690 }
16691
16692 static __inline__ int __ATTRS_o_ai vec_any_le(vector int __a,
16693                                               vector bool int __b) {
16694   return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, __a, (vector int)__b);
16695 }
16696
16697 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned int __a,
16698                                               vector unsigned int __b) {
16699   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __a, __b);
16700 }
16701
16702 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned int __a,
16703                                               vector bool int __b) {
16704   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __a,
16705                                       (vector unsigned int)__b);
16706 }
16707
16708 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool int __a,
16709                                               vector int __b) {
16710   return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, (vector signed int)__a,
16711                                       __b);
16712 }
16713
16714 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool int __a,
16715                                               vector unsigned int __b) {
16716   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__a,
16717                                       __b);
16718 }
16719
16720 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool int __a,
16721                                               vector bool int __b) {
16722   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__a,
16723                                       (vector unsigned int)__b);
16724 }
16725
16726 #ifdef __VSX__
16727 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed long long __a,
16728                                               vector signed long long __b) {
16729   return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV, __a, __b);
16730 }
16731
16732 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned long long __a,
16733                                               vector unsigned long long __b) {
16734   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __a, __b);
16735 }
16736
16737 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed long long __a,
16738                                               vector bool long long __b) {
16739   return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV, __a,
16740                                       (vector signed long long)__b);
16741 }
16742
16743 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned long long __a,
16744                                               vector bool long long __b) {
16745   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __a,
16746                                       (vector unsigned long long)__b);
16747 }
16748
16749 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool long long __a,
16750                                               vector signed long long __b) {
16751   return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV,
16752                                       (vector signed long long)__a, __b);
16753 }
16754
16755 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool long long __a,
16756                                               vector unsigned long long __b) {
16757   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
16758                                       (vector unsigned long long)__a, __b);
16759 }
16760
16761 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool long long __a,
16762                                               vector bool long long __b) {
16763   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
16764                                       (vector unsigned long long)__a,
16765                                       (vector unsigned long long)__b);
16766 }
16767 #endif
16768
16769 static __inline__ int __ATTRS_o_ai vec_any_le(vector float __a,
16770                                               vector float __b) {
16771 #ifdef __VSX__
16772   return __builtin_vsx_xvcmpgesp_p(__CR6_EQ_REV, __b, __a);
16773 #else
16774   return __builtin_altivec_vcmpgefp_p(__CR6_EQ_REV, __b, __a);
16775 #endif
16776 }
16777
16778 #ifdef __VSX__
16779 static __inline__ int __ATTRS_o_ai vec_any_le(vector double __a,
16780                                               vector double __b) {
16781   return __builtin_vsx_xvcmpgedp_p(__CR6_EQ_REV, __b, __a);
16782 }
16783 #endif
16784
16785 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
16786 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed __int128 __a,
16787                                               vector signed __int128 __b) {
16788   return __builtin_altivec_vcmpgtsq_p(__CR6_LT_REV, __a, __b);
16789 }
16790
16791 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned __int128 __a,
16792                                               vector unsigned __int128 __b) {
16793   return __builtin_altivec_vcmpgtuq_p(__CR6_LT_REV, __a, __b);
16794 }
16795 #endif
16796
16797 /* vec_any_lt */
16798
16799 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed char __a,
16800                                               vector signed char __b) {
16801   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, __b, __a);
16802 }
16803
16804 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed char __a,
16805                                               vector bool char __b) {
16806   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, (vector signed char)__b,
16807                                       __a);
16808 }
16809
16810 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned char __a,
16811                                               vector unsigned char __b) {
16812   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __b, __a);
16813 }
16814
16815 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned char __a,
16816                                               vector bool char __b) {
16817   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__b,
16818                                       __a);
16819 }
16820
16821 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool char __a,
16822                                               vector signed char __b) {
16823   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, __b,
16824                                       (vector signed char)__a);
16825 }
16826
16827 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool char __a,
16828                                               vector unsigned char __b) {
16829   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __b,
16830                                       (vector unsigned char)__a);
16831 }
16832
16833 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool char __a,
16834                                               vector bool char __b) {
16835   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__b,
16836                                       (vector unsigned char)__a);
16837 }
16838
16839 static __inline__ int __ATTRS_o_ai vec_any_lt(vector short __a,
16840                                               vector short __b) {
16841   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, __b, __a);
16842 }
16843
16844 static __inline__ int __ATTRS_o_ai vec_any_lt(vector short __a,
16845                                               vector bool short __b) {
16846   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, (vector short)__b, __a);
16847 }
16848
16849 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned short __a,
16850                                               vector unsigned short __b) {
16851   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __b, __a);
16852 }
16853
16854 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned short __a,
16855                                               vector bool short __b) {
16856   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__b,
16857                                       __a);
16858 }
16859
16860 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool short __a,
16861                                               vector short __b) {
16862   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, __b,
16863                                       (vector signed short)__a);
16864 }
16865
16866 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool short __a,
16867                                               vector unsigned short __b) {
16868   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __b,
16869                                       (vector unsigned short)__a);
16870 }
16871
16872 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool short __a,
16873                                               vector bool short __b) {
16874   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__b,
16875                                       (vector unsigned short)__a);
16876 }
16877
16878 static __inline__ int __ATTRS_o_ai vec_any_lt(vector int __a, vector int __b) {
16879   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, __b, __a);
16880 }
16881
16882 static __inline__ int __ATTRS_o_ai vec_any_lt(vector int __a,
16883                                               vector bool int __b) {
16884   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, (vector int)__b, __a);
16885 }
16886
16887 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned int __a,
16888                                               vector unsigned int __b) {
16889   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __b, __a);
16890 }
16891
16892 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned int __a,
16893                                               vector bool int __b) {
16894   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__b,
16895                                       __a);
16896 }
16897
16898 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool int __a,
16899                                               vector int __b) {
16900   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, __b,
16901                                       (vector signed int)__a);
16902 }
16903
16904 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool int __a,
16905                                               vector unsigned int __b) {
16906   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __b,
16907                                       (vector unsigned int)__a);
16908 }
16909
16910 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool int __a,
16911                                               vector bool int __b) {
16912   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__b,
16913                                       (vector unsigned int)__a);
16914 }
16915
16916 #ifdef __VSX__
16917 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed long long __a,
16918                                               vector signed long long __b) {
16919   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV, __b, __a);
16920 }
16921
16922 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned long long __a,
16923                                               vector unsigned long long __b) {
16924   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __b, __a);
16925 }
16926
16927 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed long long __a,
16928                                               vector bool long long __b) {
16929   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV,
16930                                       (vector signed long long)__b, __a);
16931 }
16932
16933 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned long long __a,
16934                                               vector bool long long __b) {
16935   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
16936                                       (vector unsigned long long)__b, __a);
16937 }
16938
16939 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool long long __a,
16940                                               vector signed long long __b) {
16941   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV, __b,
16942                                       (vector signed long long)__a);
16943 }
16944
16945 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool long long __a,
16946                                               vector unsigned long long __b) {
16947   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __b,
16948                                       (vector unsigned long long)__a);
16949 }
16950
16951 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool long long __a,
16952                                               vector bool long long __b) {
16953   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
16954                                       (vector unsigned long long)__b,
16955                                       (vector unsigned long long)__a);
16956 }
16957 #endif
16958
16959 static __inline__ int __ATTRS_o_ai vec_any_lt(vector float __a,
16960                                               vector float __b) {
16961 #ifdef __VSX__
16962   return __builtin_vsx_xvcmpgtsp_p(__CR6_EQ_REV, __b, __a);
16963 #else
16964   return __builtin_altivec_vcmpgtfp_p(__CR6_EQ_REV, __b, __a);
16965 #endif
16966 }
16967
16968 #ifdef __VSX__
16969 static __inline__ int __ATTRS_o_ai vec_any_lt(vector double __a,
16970                                               vector double __b) {
16971   return __builtin_vsx_xvcmpgtdp_p(__CR6_EQ_REV, __b, __a);
16972 }
16973 #endif
16974
16975 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
16976 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed __int128 __a,
16977                                               vector signed __int128 __b) {
16978   return __builtin_altivec_vcmpgtsq_p(__CR6_EQ_REV, __b, __a);
16979 }
16980
16981 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned __int128 __a,
16982                                               vector unsigned __int128 __b) {
16983   return __builtin_altivec_vcmpgtuq_p(__CR6_EQ_REV, __b, __a);
16984 }
16985 #endif
16986
16987 /* vec_any_nan */
16988
16989 static __inline__ int __ATTRS_o_ai vec_any_nan(vector float __a) {
16990 #ifdef __VSX__
16991   return __builtin_vsx_xvcmpeqsp_p(__CR6_LT_REV, __a, __a);
16992 #else
16993   return __builtin_altivec_vcmpeqfp_p(__CR6_LT_REV, __a, __a);
16994 #endif
16995 }
16996 #ifdef __VSX__
16997 static __inline__ int __ATTRS_o_ai vec_any_nan(vector double __a) {
16998   return __builtin_vsx_xvcmpeqdp_p(__CR6_LT_REV, __a, __a);
16999 }
17000 #endif
17001
17002 /* vec_any_ne */
17003
17004 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed char __a,
17005                                               vector signed char __b) {
17006   return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
17007                                       (vector char)__b);
17008 }
17009
17010 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed char __a,
17011                                               vector bool char __b) {
17012   return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
17013                                       (vector char)__b);
17014 }
17015
17016 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned char __a,
17017                                               vector unsigned char __b) {
17018   return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
17019                                       (vector char)__b);
17020 }
17021
17022 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned char __a,
17023                                               vector bool char __b) {
17024   return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
17025                                       (vector char)__b);
17026 }
17027
17028 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool char __a,
17029                                               vector signed char __b) {
17030   return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
17031                                       (vector char)__b);
17032 }
17033
17034 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool char __a,
17035                                               vector unsigned char __b) {
17036   return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
17037                                       (vector char)__b);
17038 }
17039
17040 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool char __a,
17041                                               vector bool char __b) {
17042   return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
17043                                       (vector char)__b);
17044 }
17045
17046 static __inline__ int __ATTRS_o_ai vec_any_ne(vector short __a,
17047                                               vector short __b) {
17048   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, __a, __b);
17049 }
17050
17051 static __inline__ int __ATTRS_o_ai vec_any_ne(vector short __a,
17052                                               vector bool short __b) {
17053   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, __a, (vector short)__b);
17054 }
17055
17056 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned short __a,
17057                                               vector unsigned short __b) {
17058   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
17059                                       (vector short)__b);
17060 }
17061
17062 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned short __a,
17063                                               vector bool short __b) {
17064   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
17065                                       (vector short)__b);
17066 }
17067
17068 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool short __a,
17069                                               vector short __b) {
17070   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
17071                                       (vector short)__b);
17072 }
17073
17074 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool short __a,
17075                                               vector unsigned short __b) {
17076   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
17077                                       (vector short)__b);
17078 }
17079
17080 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool short __a,
17081                                               vector bool short __b) {
17082   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
17083                                       (vector short)__b);
17084 }
17085
17086 static __inline__ int __ATTRS_o_ai vec_any_ne(vector pixel __a,
17087                                               vector pixel __b) {
17088   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
17089                                       (vector short)__b);
17090 }
17091
17092 static __inline__ int __ATTRS_o_ai vec_any_ne(vector int __a, vector int __b) {
17093   return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, __a, __b);
17094 }
17095
17096 static __inline__ int __ATTRS_o_ai vec_any_ne(vector int __a,
17097                                               vector bool int __b) {
17098   return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, __a, (vector int)__b);
17099 }
17100
17101 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned int __a,
17102                                               vector unsigned int __b) {
17103   return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
17104                                       (vector int)__b);
17105 }
17106
17107 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned int __a,
17108                                               vector bool int __b) {
17109   return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
17110                                       (vector int)__b);
17111 }
17112
17113 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool int __a,
17114                                               vector int __b) {
17115   return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
17116                                       (vector int)__b);
17117 }
17118
17119 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool int __a,
17120                                               vector unsigned int __b) {
17121   return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
17122                                       (vector int)__b);
17123 }
17124
17125 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool int __a,
17126                                               vector bool int __b) {
17127   return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
17128                                       (vector int)__b);
17129 }
17130
17131 #ifdef __VSX__
17132 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed long long __a,
17133                                               vector signed long long __b) {
17134 #ifdef __POWER8_VECTOR__
17135   return __builtin_altivec_vcmpequd_p(__CR6_LT_REV, __a, __b);
17136 #else
17137   // Take advantage of the optimized sequence for vec_all_eq when vcmpequd is
17138   // not available.
17139   return !vec_all_eq(__a, __b);
17140 #endif
17141 }
17142
17143 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned long long __a,
17144                                               vector unsigned long long __b) {
17145   return vec_any_ne((vector signed long long)__a, (vector signed long long)__b);
17146 }
17147
17148 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed long long __a,
17149                                               vector bool long long __b) {
17150   return vec_any_ne((vector signed long long)__a, (vector signed long long)__b);
17151 }
17152
17153 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned long long __a,
17154                                               vector bool long long __b) {
17155   return vec_any_ne((vector signed long long)__a, (vector signed long long)__b);
17156 }
17157
17158 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool long long __a,
17159                                               vector signed long long __b) {
17160   return vec_any_ne((vector signed long long)__a, (vector signed long long)__b);
17161 }
17162
17163 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool long long __a,
17164                                               vector unsigned long long __b) {
17165   return vec_any_ne((vector signed long long)__a, (vector signed long long)__b);
17166 }
17167
17168 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool long long __a,
17169                                               vector bool long long __b) {
17170   return vec_any_ne((vector signed long long)__a, (vector signed long long)__b);
17171 }
17172 #endif
17173
17174 static __inline__ int __ATTRS_o_ai vec_any_ne(vector float __a,
17175                                               vector float __b) {
17176 #ifdef __VSX__
17177   return __builtin_vsx_xvcmpeqsp_p(__CR6_LT_REV, __a, __b);
17178 #else
17179   return __builtin_altivec_vcmpeqfp_p(__CR6_LT_REV, __a, __b);
17180 #endif
17181 }
17182
17183 #ifdef __VSX__
17184 static __inline__ int __ATTRS_o_ai vec_any_ne(vector double __a,
17185                                               vector double __b) {
17186   return __builtin_vsx_xvcmpeqdp_p(__CR6_LT_REV, __a, __b);
17187 }
17188 #endif
17189
17190 #if defined(__POWER10_VECTOR__) && defined(__SIZEOF_INT128__)
17191 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed __int128 __a,
17192                                               vector signed __int128 __b) {
17193   return __builtin_altivec_vcmpequq_p(__CR6_LT_REV,
17194                                       (vector unsigned __int128)__a, __b);
17195 }
17196
17197 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned __int128 __a,
17198                                               vector unsigned __int128 __b) {
17199   return __builtin_altivec_vcmpequq_p(__CR6_LT_REV, __a,
17200                                       (vector signed __int128)__b);
17201 }
17202
17203 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool __int128 __a,
17204                                               vector bool __int128 __b) {
17205   return __builtin_altivec_vcmpequq_p(
17206       __CR6_LT_REV, (vector unsigned __int128)__a, (vector signed __int128)__b);
17207 }
17208 #endif
17209
17210 /* vec_any_nge */
17211
17212 static __inline__ int __ATTRS_o_ai vec_any_nge(vector float __a,
17213                                                vector float __b) {
17214 #ifdef __VSX__
17215   return __builtin_vsx_xvcmpgesp_p(__CR6_LT_REV, __a, __b);
17216 #else
17217   return __builtin_altivec_vcmpgefp_p(__CR6_LT_REV, __a, __b);
17218 #endif
17219 }
17220
17221 #ifdef __VSX__
17222 static __inline__ int __ATTRS_o_ai vec_any_nge(vector double __a,
17223                                                vector double __b) {
17224   return __builtin_vsx_xvcmpgedp_p(__CR6_LT_REV, __a, __b);
17225 }
17226 #endif
17227
17228 /* vec_any_ngt */
17229
17230 static __inline__ int __ATTRS_o_ai vec_any_ngt(vector float __a,
17231                                                vector float __b) {
17232 #ifdef __VSX__
17233   return __builtin_vsx_xvcmpgtsp_p(__CR6_LT_REV, __a, __b);
17234 #else
17235   return __builtin_altivec_vcmpgtfp_p(__CR6_LT_REV, __a, __b);
17236 #endif
17237 }
17238
17239 #ifdef __VSX__
17240 static __inline__ int __ATTRS_o_ai vec_any_ngt(vector double __a,
17241                                                vector double __b) {
17242   return __builtin_vsx_xvcmpgtdp_p(__CR6_LT_REV, __a, __b);
17243 }
17244 #endif
17245
17246 /* vec_any_nle */
17247
17248 static __inline__ int __ATTRS_o_ai vec_any_nle(vector float __a,
17249                                                vector float __b) {
17250 #ifdef __VSX__
17251   return __builtin_vsx_xvcmpgesp_p(__CR6_LT_REV, __b, __a);
17252 #else
17253   return __builtin_altivec_vcmpgefp_p(__CR6_LT_REV, __b, __a);
17254 #endif
17255 }
17256
17257 #ifdef __VSX__
17258 static __inline__ int __ATTRS_o_ai vec_any_nle(vector double __a,
17259                                                vector double __b) {
17260   return __builtin_vsx_xvcmpgedp_p(__CR6_LT_REV, __b, __a);
17261 }
17262 #endif
17263
17264 /* vec_any_nlt */
17265
17266 static __inline__ int __ATTRS_o_ai vec_any_nlt(vector float __a,
17267                                                vector float __b) {
17268 #ifdef __VSX__
17269   return __builtin_vsx_xvcmpgtsp_p(__CR6_LT_REV, __b, __a);
17270 #else
17271   return __builtin_altivec_vcmpgtfp_p(__CR6_LT_REV, __b, __a);
17272 #endif
17273 }
17274
17275 #ifdef __VSX__
17276 static __inline__ int __ATTRS_o_ai vec_any_nlt(vector double __a,
17277                                                vector double __b) {
17278   return __builtin_vsx_xvcmpgtdp_p(__CR6_LT_REV, __b, __a);
17279 }
17280 #endif
17281
17282 /* vec_any_numeric */
17283
17284 static __inline__ int __ATTRS_o_ai vec_any_numeric(vector float __a) {
17285 #ifdef __VSX__
17286   return __builtin_vsx_xvcmpeqsp_p(__CR6_EQ_REV, __a, __a);
17287 #else
17288   return __builtin_altivec_vcmpeqfp_p(__CR6_EQ_REV, __a, __a);
17289 #endif
17290 }
17291
17292 #ifdef __VSX__
17293 static __inline__ int __ATTRS_o_ai vec_any_numeric(vector double __a) {
17294   return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ_REV, __a, __a);
17295 }
17296 #endif
17297
17298 /* vec_any_out */
17299
17300 static __inline__ int __attribute__((__always_inline__))
17301 vec_any_out(vector float __a, vector float __b) {
17302   return __builtin_altivec_vcmpbfp_p(__CR6_EQ_REV, __a, __b);
17303 }
17304
17305 /* Power 8 Crypto functions
17306 Note: We diverge from the current GCC implementation with regard
17307 to cryptography and related functions as follows:
17308 - Only the SHA and AES instructions and builtins are disabled by -mno-crypto
17309 - The remaining ones are only available on Power8 and up so
17310   require -mpower8-vector
17311 The justification for this is that export requirements require that
17312 Category:Vector.Crypto is optional (i.e. compliant hardware may not provide
17313 support). As a result, we need to be able to turn off support for those.
17314 The remaining ones (currently controlled by -mcrypto for GCC) still
17315 need to be provided on compliant hardware even if Vector.Crypto is not
17316 provided.
17317 */
17318 #ifdef __CRYPTO__
17319 #define vec_sbox_be __builtin_altivec_crypto_vsbox
17320 #define vec_cipher_be __builtin_altivec_crypto_vcipher
17321 #define vec_cipherlast_be __builtin_altivec_crypto_vcipherlast
17322 #define vec_ncipher_be __builtin_altivec_crypto_vncipher
17323 #define vec_ncipherlast_be __builtin_altivec_crypto_vncipherlast
17324
17325 #ifdef __VSX__
17326 static __inline__ vector unsigned char __attribute__((__always_inline__))
17327 __builtin_crypto_vsbox(vector unsigned char __a) {
17328   return __builtin_altivec_crypto_vsbox(__a);
17329 }
17330
17331 static __inline__ vector unsigned char __attribute__((__always_inline__))
17332 __builtin_crypto_vcipher(vector unsigned char __a,
17333                          vector unsigned char __b) {
17334   return __builtin_altivec_crypto_vcipher(__a, __b);
17335 }
17336
17337 static __inline__ vector unsigned char __attribute__((__always_inline__))
17338 __builtin_crypto_vcipherlast(vector unsigned char __a,
17339                              vector unsigned char __b) {
17340   return __builtin_altivec_crypto_vcipherlast(__a, __b);
17341 }
17342
17343 static __inline__ vector unsigned char __attribute__((__always_inline__))
17344 __builtin_crypto_vncipher(vector unsigned char __a,
17345                           vector unsigned char __b) {
17346   return __builtin_altivec_crypto_vncipher(__a, __b);
17347 }
17348
17349 static __inline__ vector unsigned char  __attribute__((__always_inline__))
17350 __builtin_crypto_vncipherlast(vector unsigned char __a,
17351                               vector unsigned char __b) {
17352   return __builtin_altivec_crypto_vncipherlast(__a, __b);
17353 }
17354 #endif /* __VSX__ */
17355
17356 #define __builtin_crypto_vshasigmad __builtin_altivec_crypto_vshasigmad
17357 #define __builtin_crypto_vshasigmaw __builtin_altivec_crypto_vshasigmaw
17358
17359 #define vec_shasigma_be(X, Y, Z)                                               \
17360   _Generic((X), vector unsigned int                                            \
17361            : __builtin_crypto_vshasigmaw, vector unsigned long long            \
17362            : __builtin_crypto_vshasigmad)((X), (Y), (Z))
17363 #endif
17364
17365 #ifdef __POWER8_VECTOR__
17366 static __inline__ vector bool char __ATTRS_o_ai
17367 vec_permxor(vector bool char __a, vector bool char __b,
17368             vector bool char __c) {
17369   return (vector bool char)__builtin_altivec_crypto_vpermxor(
17370       (vector unsigned char)__a, (vector unsigned char)__b,
17371       (vector unsigned char)__c);
17372 }
17373
17374 static __inline__ vector signed char __ATTRS_o_ai
17375 vec_permxor(vector signed char __a, vector signed char __b,
17376             vector signed char __c) {
17377   return (vector signed char)__builtin_altivec_crypto_vpermxor(
17378       (vector unsigned char)__a, (vector unsigned char)__b,
17379       (vector unsigned char)__c);
17380 }
17381
17382 static __inline__ vector unsigned char __ATTRS_o_ai
17383 vec_permxor(vector unsigned char __a, vector unsigned char __b,
17384             vector unsigned char __c) {
17385   return __builtin_altivec_crypto_vpermxor(__a, __b, __c);
17386 }
17387
17388 static __inline__ vector unsigned char __ATTRS_o_ai
17389 __builtin_crypto_vpermxor(vector unsigned char __a, vector unsigned char __b,
17390                           vector unsigned char __c) {
17391   return __builtin_altivec_crypto_vpermxor(__a, __b, __c);
17392 }
17393
17394 static __inline__ vector unsigned short __ATTRS_o_ai
17395 __builtin_crypto_vpermxor(vector unsigned short __a, vector unsigned short __b,
17396                           vector unsigned short __c) {
17397   return (vector unsigned short)__builtin_altivec_crypto_vpermxor(
17398       (vector unsigned char)__a, (vector unsigned char)__b,
17399       (vector unsigned char)__c);
17400 }
17401
17402 static __inline__ vector unsigned int __ATTRS_o_ai __builtin_crypto_vpermxor(
17403     vector unsigned int __a, vector unsigned int __b, vector unsigned int __c) {
17404   return (vector unsigned int)__builtin_altivec_crypto_vpermxor(
17405       (vector unsigned char)__a, (vector unsigned char)__b,
17406       (vector unsigned char)__c);
17407 }
17408
17409 static __inline__ vector unsigned long long __ATTRS_o_ai
17410 __builtin_crypto_vpermxor(vector unsigned long long __a,
17411                           vector unsigned long long __b,
17412                           vector unsigned long long __c) {
17413   return (vector unsigned long long)__builtin_altivec_crypto_vpermxor(
17414       (vector unsigned char)__a, (vector unsigned char)__b,
17415       (vector unsigned char)__c);
17416 }
17417
17418 static __inline__ vector unsigned char __ATTRS_o_ai
17419 __builtin_crypto_vpmsumb(vector unsigned char __a, vector unsigned char __b) {
17420   return __builtin_altivec_crypto_vpmsumb(__a, __b);
17421 }
17422
17423 static __inline__ vector unsigned short __ATTRS_o_ai
17424 __builtin_crypto_vpmsumb(vector unsigned short __a, vector unsigned short __b) {
17425   return __builtin_altivec_crypto_vpmsumh(__a, __b);
17426 }
17427
17428 static __inline__ vector unsigned int __ATTRS_o_ai
17429 __builtin_crypto_vpmsumb(vector unsigned int __a, vector unsigned int __b) {
17430   return __builtin_altivec_crypto_vpmsumw(__a, __b);
17431 }
17432
17433 static __inline__ vector unsigned long long __ATTRS_o_ai
17434 __builtin_crypto_vpmsumb(vector unsigned long long __a,
17435                          vector unsigned long long __b) {
17436   return __builtin_altivec_crypto_vpmsumd(__a, __b);
17437 }
17438
17439 static __inline__ vector signed char __ATTRS_o_ai
17440 vec_vgbbd(vector signed char __a) {
17441   return (vector signed char)__builtin_altivec_vgbbd((vector unsigned char)__a);
17442 }
17443
17444 #define vec_pmsum_be __builtin_crypto_vpmsumb
17445 #define vec_gb __builtin_altivec_vgbbd
17446
17447 static __inline__ vector unsigned char __ATTRS_o_ai
17448 vec_vgbbd(vector unsigned char __a) {
17449   return __builtin_altivec_vgbbd(__a);
17450 }
17451
17452 static __inline__ vector signed long long __ATTRS_o_ai
17453 vec_gbb(vector signed long long __a) {
17454   return (vector signed long long)__builtin_altivec_vgbbd(
17455       (vector unsigned char)__a);
17456 }
17457
17458 static __inline__ vector unsigned long long __ATTRS_o_ai
17459 vec_gbb(vector unsigned long long __a) {
17460   return (vector unsigned long long)__builtin_altivec_vgbbd(
17461       (vector unsigned char)__a);
17462 }
17463
17464 static __inline__ vector long long __ATTRS_o_ai
17465 vec_vbpermq(vector signed char __a, vector signed char __b) {
17466   return (vector long long)__builtin_altivec_vbpermq((vector unsigned char)__a,
17467                                                      (vector unsigned char)__b);
17468 }
17469
17470 static __inline__ vector long long __ATTRS_o_ai
17471 vec_vbpermq(vector unsigned char __a, vector unsigned char __b) {
17472   return (vector long long)__builtin_altivec_vbpermq(__a, __b);
17473 }
17474
17475 #if defined(__powerpc64__) && defined(__SIZEOF_INT128__)
17476 static __inline__ vector unsigned long long __ATTRS_o_ai
17477 vec_bperm(vector unsigned __int128 __a, vector unsigned char __b) {
17478   return __builtin_altivec_vbpermq((vector unsigned char)__a,
17479                                    (vector unsigned char)__b);
17480 }
17481 #endif
17482 static __inline__ vector unsigned char __ATTRS_o_ai
17483 vec_bperm(vector unsigned char __a, vector unsigned char __b) {
17484   return (vector unsigned char)__builtin_altivec_vbpermq(__a, __b);
17485 }
17486 #endif // __POWER8_VECTOR__
17487 #ifdef __POWER9_VECTOR__
17488 static __inline__ vector unsigned long long __ATTRS_o_ai
17489 vec_bperm(vector unsigned long long __a, vector unsigned char __b) {
17490   return __builtin_altivec_vbpermd(__a, __b);
17491 }
17492 #endif
17493
17494
17495 /* vec_reve */
17496
17497 static inline __ATTRS_o_ai vector bool char vec_reve(vector bool char __a) {
17498   return __builtin_shufflevector(__a, __a, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6,
17499                                  5, 4, 3, 2, 1, 0);
17500 }
17501
17502 static inline __ATTRS_o_ai vector signed char vec_reve(vector signed char __a) {
17503   return __builtin_shufflevector(__a, __a, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6,
17504                                  5, 4, 3, 2, 1, 0);
17505 }
17506
17507 static inline __ATTRS_o_ai vector unsigned char
17508 vec_reve(vector unsigned char __a) {
17509   return __builtin_shufflevector(__a, __a, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6,
17510                                  5, 4, 3, 2, 1, 0);
17511 }
17512
17513 static inline __ATTRS_o_ai vector bool int vec_reve(vector bool int __a) {
17514   return __builtin_shufflevector(__a, __a, 3, 2, 1, 0);
17515 }
17516
17517 static inline __ATTRS_o_ai vector signed int vec_reve(vector signed int __a) {
17518   return __builtin_shufflevector(__a, __a, 3, 2, 1, 0);
17519 }
17520
17521 static inline __ATTRS_o_ai vector unsigned int
17522 vec_reve(vector unsigned int __a) {
17523   return __builtin_shufflevector(__a, __a, 3, 2, 1, 0);
17524 }
17525
17526 static inline __ATTRS_o_ai vector bool short vec_reve(vector bool short __a) {
17527   return __builtin_shufflevector(__a, __a, 7, 6, 5, 4, 3, 2, 1, 0);
17528 }
17529
17530 static inline __ATTRS_o_ai vector signed short
17531 vec_reve(vector signed short __a) {
17532   return __builtin_shufflevector(__a, __a, 7, 6, 5, 4, 3, 2, 1, 0);
17533 }
17534
17535 static inline __ATTRS_o_ai vector unsigned short
17536 vec_reve(vector unsigned short __a) {
17537   return __builtin_shufflevector(__a, __a, 7, 6, 5, 4, 3, 2, 1, 0);
17538 }
17539
17540 static inline __ATTRS_o_ai vector float vec_reve(vector float __a) {
17541   return __builtin_shufflevector(__a, __a, 3, 2, 1, 0);
17542 }
17543
17544 #ifdef __VSX__
17545 static inline __ATTRS_o_ai vector bool long long
17546 vec_reve(vector bool long long __a) {
17547   return __builtin_shufflevector(__a, __a, 1, 0);
17548 }
17549
17550 static inline __ATTRS_o_ai vector signed long long
17551 vec_reve(vector signed long long __a) {
17552   return __builtin_shufflevector(__a, __a, 1, 0);
17553 }
17554
17555 static inline __ATTRS_o_ai vector unsigned long long
17556 vec_reve(vector unsigned long long __a) {
17557   return __builtin_shufflevector(__a, __a, 1, 0);
17558 }
17559
17560 static inline __ATTRS_o_ai vector double vec_reve(vector double __a) {
17561   return __builtin_shufflevector(__a, __a, 1, 0);
17562 }
17563 #endif
17564
17565 /* vec_revb */
17566 static __inline__ vector bool char __ATTRS_o_ai
17567 vec_revb(vector bool char __a) {
17568   return __a;
17569 }
17570
17571 static __inline__ vector signed char __ATTRS_o_ai
17572 vec_revb(vector signed char __a) {
17573   return __a;
17574 }
17575
17576 static __inline__ vector unsigned char __ATTRS_o_ai
17577 vec_revb(vector unsigned char __a) {
17578   return __a;
17579 }
17580
17581 static __inline__ vector bool short __ATTRS_o_ai
17582 vec_revb(vector bool short __a) {
17583   vector unsigned char __indices =
17584       { 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14 };
17585   return vec_perm(__a, __a, __indices);
17586 }
17587
17588 static __inline__ vector signed short __ATTRS_o_ai
17589 vec_revb(vector signed short __a) {
17590   vector unsigned char __indices =
17591       { 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14 };
17592   return vec_perm(__a, __a, __indices);
17593 }
17594
17595 static __inline__ vector unsigned short __ATTRS_o_ai
17596 vec_revb(vector unsigned short __a) {
17597   vector unsigned char __indices =
17598      { 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14 };
17599   return vec_perm(__a, __a, __indices);
17600 }
17601
17602 static __inline__ vector bool int __ATTRS_o_ai
17603 vec_revb(vector bool int __a) {
17604   vector unsigned char __indices =
17605       { 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12 };
17606   return vec_perm(__a, __a, __indices);
17607 }
17608
17609 static __inline__ vector signed int __ATTRS_o_ai
17610 vec_revb(vector signed int __a) {
17611   vector unsigned char __indices =
17612       { 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12 };
17613   return vec_perm(__a, __a, __indices);
17614 }
17615
17616 static __inline__ vector unsigned int __ATTRS_o_ai
17617 vec_revb(vector unsigned int __a) {
17618   vector unsigned char __indices =
17619       { 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12 };
17620   return vec_perm(__a, __a, __indices);
17621 }
17622
17623 static __inline__ vector float __ATTRS_o_ai
17624 vec_revb(vector float __a) {
17625  vector unsigned char __indices =
17626       { 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12 };
17627  return vec_perm(__a, __a, __indices);
17628 }
17629
17630 #ifdef __VSX__
17631 static __inline__ vector bool long long __ATTRS_o_ai
17632 vec_revb(vector bool long long __a) {
17633   vector unsigned char __indices =
17634       { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8 };
17635   return vec_perm(__a, __a, __indices);
17636 }
17637
17638 static __inline__ vector signed long long __ATTRS_o_ai
17639 vec_revb(vector signed long long __a) {
17640   vector unsigned char __indices =
17641       { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8 };
17642   return vec_perm(__a, __a, __indices);
17643 }
17644
17645 static __inline__ vector unsigned long long __ATTRS_o_ai
17646 vec_revb(vector unsigned long long __a) {
17647   vector unsigned char __indices =
17648       { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8 };
17649   return vec_perm(__a, __a, __indices);
17650 }
17651
17652 static __inline__ vector double __ATTRS_o_ai
17653 vec_revb(vector double __a) {
17654   vector unsigned char __indices =
17655       { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8 };
17656   return vec_perm(__a, __a, __indices);
17657 }
17658 #endif /* End __VSX__ */
17659
17660 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__) &&                    \
17661     defined(__SIZEOF_INT128__)
17662 static __inline__ vector signed __int128 __ATTRS_o_ai
17663 vec_revb(vector signed __int128 __a) {
17664   vector unsigned char __indices =
17665       { 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
17666   return (vector signed __int128)vec_perm((vector signed int)__a,
17667                                           (vector signed int)__a,
17668                                            __indices);
17669 }
17670
17671 static __inline__ vector unsigned __int128 __ATTRS_o_ai
17672 vec_revb(vector unsigned __int128 __a) {
17673   vector unsigned char __indices =
17674       { 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
17675   return (vector unsigned __int128)vec_perm((vector signed int)__a,
17676                                             (vector signed int)__a,
17677                                              __indices);
17678 }
17679 #endif /* END __POWER8_VECTOR__ && __powerpc64__ */
17680
17681 /* vec_xl */
17682
17683 #define vec_xld2 vec_xl
17684 #define vec_xlw4 vec_xl
17685 typedef vector signed char unaligned_vec_schar __attribute__((aligned(1)));
17686 typedef vector unsigned char unaligned_vec_uchar __attribute__((aligned(1)));
17687 typedef vector signed short unaligned_vec_sshort __attribute__((aligned(1)));
17688 typedef vector unsigned short unaligned_vec_ushort __attribute__((aligned(1)));
17689 typedef vector signed int unaligned_vec_sint __attribute__((aligned(1)));
17690 typedef vector unsigned int unaligned_vec_uint __attribute__((aligned(1)));
17691 typedef vector float unaligned_vec_float __attribute__((aligned(1)));
17692
17693 static inline __ATTRS_o_ai vector signed char vec_xl(ptrdiff_t __offset,
17694                                                      const signed char *__ptr) {
17695   return *(unaligned_vec_schar *)(__ptr + __offset);
17696 }
17697
17698 static inline __ATTRS_o_ai vector unsigned char
17699 vec_xl(ptrdiff_t __offset, const unsigned char *__ptr) {
17700   return *(unaligned_vec_uchar*)(__ptr + __offset);
17701 }
17702
17703 static inline __ATTRS_o_ai vector signed short
17704 vec_xl(ptrdiff_t __offset, const signed short *__ptr) {
17705   signed char *__addr = (signed char *)__ptr + __offset;
17706   return *(unaligned_vec_sshort *)__addr;
17707 }
17708
17709 static inline __ATTRS_o_ai vector unsigned short
17710 vec_xl(ptrdiff_t __offset, const unsigned short *__ptr) {
17711   signed char *__addr = (signed char *)__ptr + __offset;
17712   return *(unaligned_vec_ushort *)__addr;
17713 }
17714
17715 static inline __ATTRS_o_ai vector signed int vec_xl(ptrdiff_t __offset,
17716                                                     const signed int *__ptr) {
17717   signed char *__addr = (signed char *)__ptr + __offset;
17718   return *(unaligned_vec_sint *)__addr;
17719 }
17720
17721 static inline __ATTRS_o_ai vector unsigned int
17722 vec_xl(ptrdiff_t __offset, const unsigned int *__ptr) {
17723   signed char *__addr = (signed char *)__ptr + __offset;
17724   return *(unaligned_vec_uint *)__addr;
17725 }
17726
17727 static inline __ATTRS_o_ai vector float vec_xl(ptrdiff_t __offset,
17728                                                const float *__ptr) {
17729   signed char *__addr = (signed char *)__ptr + __offset;
17730   return *(unaligned_vec_float *)__addr;
17731 }
17732
17733 #ifdef __VSX__
17734 typedef vector signed long long unaligned_vec_sll __attribute__((aligned(1)));
17735 typedef vector unsigned long long unaligned_vec_ull __attribute__((aligned(1)));
17736 typedef vector double unaligned_vec_double __attribute__((aligned(1)));
17737
17738 static inline __ATTRS_o_ai vector signed long long
17739 vec_xl(ptrdiff_t __offset, const signed long long *__ptr) {
17740   signed char *__addr = (signed char *)__ptr + __offset;
17741   return *(unaligned_vec_sll *)__addr;
17742 }
17743
17744 static inline __ATTRS_o_ai vector unsigned long long
17745 vec_xl(ptrdiff_t __offset, const unsigned long long *__ptr) {
17746   signed char *__addr = (signed char *)__ptr + __offset;
17747   return *(unaligned_vec_ull *)__addr;
17748 }
17749
17750 static inline __ATTRS_o_ai vector double vec_xl(ptrdiff_t __offset,
17751                                                 const double *__ptr) {
17752   signed char *__addr = (signed char *)__ptr + __offset;
17753   return *(unaligned_vec_double *)__addr;
17754 }
17755 #endif
17756
17757 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__) &&                    \
17758     defined(__SIZEOF_INT128__)
17759 typedef vector signed __int128 unaligned_vec_si128 __attribute__((aligned(1)));
17760 typedef vector unsigned __int128 unaligned_vec_ui128
17761     __attribute__((aligned(1)));
17762 static inline __ATTRS_o_ai vector signed __int128
17763 vec_xl(ptrdiff_t __offset, const signed __int128 *__ptr) {
17764   signed char *__addr = (signed char *)__ptr + __offset;
17765   return *(unaligned_vec_si128 *)__addr;
17766 }
17767
17768 static inline __ATTRS_o_ai vector unsigned __int128
17769 vec_xl(ptrdiff_t __offset, const unsigned __int128 *__ptr) {
17770   signed char *__addr = (signed char *)__ptr + __offset;
17771   return *(unaligned_vec_ui128 *)__addr;
17772 }
17773 #endif
17774
17775 /* vec_xl_be */
17776
17777 #ifdef __LITTLE_ENDIAN__
17778 static __inline__ vector signed char __ATTRS_o_ai
17779 vec_xl_be(ptrdiff_t __offset, const signed char *__ptr) {
17780   vector signed char __vec = (vector signed char)__builtin_vsx_lxvd2x_be(__offset, __ptr);
17781   return __builtin_shufflevector(__vec, __vec, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14,
17782                                  13, 12, 11, 10, 9, 8);
17783 }
17784
17785 static __inline__ vector unsigned char __ATTRS_o_ai
17786 vec_xl_be(ptrdiff_t __offset, const unsigned char *__ptr) {
17787   vector unsigned char __vec = (vector unsigned char)__builtin_vsx_lxvd2x_be(__offset, __ptr);
17788   return __builtin_shufflevector(__vec, __vec, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14,
17789                                  13, 12, 11, 10, 9, 8);
17790 }
17791
17792 static __inline__ vector signed short __ATTRS_o_ai
17793 vec_xl_be(ptrdiff_t __offset, const signed short *__ptr) {
17794   vector signed short __vec = (vector signed short)__builtin_vsx_lxvd2x_be(__offset, __ptr);
17795   return __builtin_shufflevector(__vec, __vec, 3, 2, 1, 0, 7, 6, 5, 4);
17796 }
17797
17798 static __inline__ vector unsigned short __ATTRS_o_ai
17799 vec_xl_be(ptrdiff_t __offset, const unsigned short *__ptr) {
17800   vector unsigned short __vec = (vector unsigned short)__builtin_vsx_lxvd2x_be(__offset, __ptr);
17801   return __builtin_shufflevector(__vec, __vec, 3, 2, 1, 0, 7, 6, 5, 4);
17802 }
17803
17804 static __inline__ vector signed int __ATTRS_o_ai
17805 vec_xl_be(signed long long  __offset, const signed int *__ptr) {
17806   return (vector signed int)__builtin_vsx_lxvw4x_be(__offset, __ptr);
17807 }
17808
17809 static __inline__ vector unsigned int __ATTRS_o_ai
17810 vec_xl_be(signed long long  __offset, const unsigned int *__ptr) {
17811   return (vector unsigned int)__builtin_vsx_lxvw4x_be(__offset, __ptr);
17812 }
17813
17814 static __inline__ vector float __ATTRS_o_ai
17815 vec_xl_be(signed long long  __offset, const float *__ptr) {
17816   return (vector float)__builtin_vsx_lxvw4x_be(__offset, __ptr);
17817 }
17818
17819 #ifdef __VSX__
17820 static __inline__ vector signed long long __ATTRS_o_ai
17821 vec_xl_be(signed long long  __offset, const signed long long *__ptr) {
17822   return (vector signed long long)__builtin_vsx_lxvd2x_be(__offset, __ptr);
17823 }
17824
17825 static __inline__ vector unsigned long long __ATTRS_o_ai
17826 vec_xl_be(signed long long  __offset, const unsigned long long *__ptr) {
17827   return (vector unsigned long long)__builtin_vsx_lxvd2x_be(__offset, __ptr);
17828 }
17829
17830 static __inline__ vector double __ATTRS_o_ai
17831 vec_xl_be(signed long long  __offset, const double *__ptr) {
17832   return (vector double)__builtin_vsx_lxvd2x_be(__offset, __ptr);
17833 }
17834 #endif
17835
17836 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__) &&                    \
17837     defined(__SIZEOF_INT128__)
17838 static __inline__ vector signed __int128 __ATTRS_o_ai
17839 vec_xl_be(signed long long  __offset, const signed __int128 *__ptr) {
17840   return vec_xl(__offset, __ptr);
17841 }
17842
17843 static __inline__ vector unsigned __int128 __ATTRS_o_ai
17844 vec_xl_be(signed long long  __offset, const unsigned __int128 *__ptr) {
17845   return vec_xl(__offset, __ptr);
17846 }
17847 #endif
17848 #else
17849   #define vec_xl_be vec_xl
17850 #endif
17851
17852 #if defined(__POWER10_VECTOR__) && defined(__VSX__) &&                         \
17853     defined(__SIZEOF_INT128__)
17854
17855 /* vec_xl_sext */
17856
17857 static __inline__ vector signed __int128 __ATTRS_o_ai
17858 vec_xl_sext(ptrdiff_t __offset, const signed char *__pointer) {
17859   return (vector signed __int128)*(__pointer + __offset);
17860 }
17861
17862 static __inline__ vector signed __int128 __ATTRS_o_ai
17863 vec_xl_sext(ptrdiff_t __offset, const signed short *__pointer) {
17864   return (vector signed __int128)*(__pointer + __offset);
17865 }
17866
17867 static __inline__ vector signed __int128 __ATTRS_o_ai
17868 vec_xl_sext(ptrdiff_t __offset, const signed int *__pointer) {
17869   return (vector signed __int128)*(__pointer + __offset);
17870 }
17871
17872 static __inline__ vector signed __int128 __ATTRS_o_ai
17873 vec_xl_sext(ptrdiff_t __offset, const signed long long *__pointer) {
17874   return (vector signed __int128)*(__pointer + __offset);
17875 }
17876
17877 /* vec_xl_zext */
17878
17879 static __inline__ vector unsigned __int128 __ATTRS_o_ai
17880 vec_xl_zext(ptrdiff_t __offset, const unsigned char *__pointer) {
17881   return (vector unsigned __int128)*(__pointer + __offset);
17882 }
17883
17884 static __inline__ vector unsigned __int128 __ATTRS_o_ai
17885 vec_xl_zext(ptrdiff_t __offset, const unsigned short *__pointer) {
17886   return (vector unsigned __int128)*(__pointer + __offset);
17887 }
17888
17889 static __inline__ vector unsigned __int128 __ATTRS_o_ai
17890 vec_xl_zext(ptrdiff_t __offset, const unsigned int *__pointer) {
17891   return (vector unsigned __int128)*(__pointer + __offset);
17892 }
17893
17894 static __inline__ vector unsigned __int128 __ATTRS_o_ai
17895 vec_xl_zext(ptrdiff_t __offset, const unsigned long long *__pointer) {
17896   return (vector unsigned __int128)*(__pointer + __offset);
17897 }
17898
17899 #endif
17900
17901 /* vec_xlds */
17902 #ifdef __VSX__
17903 static __inline__ vector signed long long __ATTRS_o_ai
17904 vec_xlds(ptrdiff_t __offset, const signed long long *__ptr) {
17905   signed long long *__addr = (signed long long*)((signed char *)__ptr + __offset);
17906   return (vector signed long long) *__addr;
17907 }
17908
17909 static __inline__ vector unsigned long long __ATTRS_o_ai
17910 vec_xlds(ptrdiff_t __offset, const unsigned long long *__ptr) {
17911   unsigned long long *__addr = (unsigned long long *)((signed char *)__ptr + __offset);
17912   return (unaligned_vec_ull) *__addr;
17913 }
17914
17915 static __inline__ vector double __ATTRS_o_ai vec_xlds(ptrdiff_t __offset,
17916                                                       const double *__ptr) {
17917   double *__addr = (double*)((signed char *)__ptr + __offset);
17918   return (unaligned_vec_double) *__addr;
17919 }
17920
17921 /* vec_load_splats */
17922 static __inline__ vector signed int __ATTRS_o_ai
17923 vec_load_splats(signed long long __offset, const signed int *__ptr) {
17924   signed int *__addr = (signed int*)((signed char *)__ptr + __offset);
17925   return (vector signed int)*__addr;
17926 }
17927
17928 static __inline__ vector signed int __ATTRS_o_ai
17929 vec_load_splats(unsigned long long __offset, const signed int *__ptr) {
17930   signed int *__addr = (signed int*)((signed char *)__ptr + __offset);
17931   return (vector signed int)*__addr;
17932 }
17933
17934 static __inline__ vector unsigned int __ATTRS_o_ai
17935 vec_load_splats(signed long long __offset, const unsigned int *__ptr) {
17936   unsigned int *__addr = (unsigned int*)((signed char *)__ptr + __offset);
17937   return (vector unsigned int)*__addr;
17938 }
17939
17940 static __inline__ vector unsigned int __ATTRS_o_ai
17941 vec_load_splats(unsigned long long __offset, const unsigned int *__ptr) {
17942   unsigned int *__addr = (unsigned int*)((signed char *)__ptr + __offset);
17943   return (vector unsigned int)*__addr;
17944 }
17945
17946 static __inline__ vector float __ATTRS_o_ai
17947 vec_load_splats(signed long long __offset, const float *__ptr) {
17948   float *__addr = (float*)((signed char *)__ptr + __offset);
17949   return (vector float)*__addr;
17950 }
17951
17952 static __inline__ vector float __ATTRS_o_ai
17953 vec_load_splats(unsigned long long __offset, const float *__ptr) {
17954   float *__addr = (float*)((signed char *)__ptr + __offset);
17955   return (vector float)*__addr;
17956 }
17957 #endif
17958
17959 /* vec_xst */
17960
17961 #define vec_xstd2 vec_xst
17962 #define vec_xstw4 vec_xst
17963 static inline __ATTRS_o_ai void
17964 vec_xst(vector signed char __vec, ptrdiff_t __offset, signed char *__ptr) {
17965   *(unaligned_vec_schar *)(__ptr + __offset) = __vec;
17966 }
17967
17968 static inline __ATTRS_o_ai void
17969 vec_xst(vector unsigned char __vec, ptrdiff_t __offset, unsigned char *__ptr) {
17970   *(unaligned_vec_uchar *)(__ptr + __offset) = __vec;
17971 }
17972
17973 static inline __ATTRS_o_ai void
17974 vec_xst(vector signed short __vec, ptrdiff_t __offset, signed short *__ptr) {
17975   signed char *__addr = (signed char *)__ptr + __offset;
17976   *(unaligned_vec_sshort *)__addr = __vec;
17977 }
17978
17979 static inline __ATTRS_o_ai void vec_xst(vector unsigned short __vec,
17980                                         ptrdiff_t __offset,
17981                                         unsigned short *__ptr) {
17982   signed char *__addr = (signed char *)__ptr + __offset;
17983   *(unaligned_vec_ushort *)__addr = __vec;
17984 }
17985
17986 static inline __ATTRS_o_ai void vec_xst(vector signed int __vec,
17987                                         ptrdiff_t __offset, signed int *__ptr) {
17988   signed char *__addr = (signed char *)__ptr + __offset;
17989   *(unaligned_vec_sint *)__addr = __vec;
17990 }
17991
17992 static inline __ATTRS_o_ai void
17993 vec_xst(vector unsigned int __vec, ptrdiff_t __offset, unsigned int *__ptr) {
17994   signed char *__addr = (signed char *)__ptr + __offset;
17995   *(unaligned_vec_uint *)__addr = __vec;
17996 }
17997
17998 static inline __ATTRS_o_ai void vec_xst(vector float __vec, ptrdiff_t __offset,
17999                                         float *__ptr) {
18000   signed char *__addr = (signed char *)__ptr + __offset;
18001   *(unaligned_vec_float *)__addr = __vec;
18002 }
18003
18004 #ifdef __VSX__
18005 static inline __ATTRS_o_ai void vec_xst(vector signed long long __vec,
18006                                         ptrdiff_t __offset,
18007                                         signed long long *__ptr) {
18008   signed char *__addr = (signed char *)__ptr + __offset;
18009   *(unaligned_vec_sll *)__addr = __vec;
18010 }
18011
18012 static inline __ATTRS_o_ai void vec_xst(vector unsigned long long __vec,
18013                                         ptrdiff_t __offset,
18014                                         unsigned long long *__ptr) {
18015   signed char *__addr = (signed char *)__ptr + __offset;
18016   *(unaligned_vec_ull *)__addr = __vec;
18017 }
18018
18019 static inline __ATTRS_o_ai void vec_xst(vector double __vec, ptrdiff_t __offset,
18020                                         double *__ptr) {
18021   signed char *__addr = (signed char *)__ptr + __offset;
18022   *(unaligned_vec_double *)__addr = __vec;
18023 }
18024 #endif
18025
18026 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__) &&                    \
18027     defined(__SIZEOF_INT128__)
18028 static inline __ATTRS_o_ai void vec_xst(vector signed __int128 __vec,
18029                                         ptrdiff_t __offset,
18030                                         signed __int128 *__ptr) {
18031   signed char *__addr = (signed char *)__ptr + __offset;
18032   *(unaligned_vec_si128 *)__addr = __vec;
18033 }
18034
18035 static inline __ATTRS_o_ai void vec_xst(vector unsigned __int128 __vec,
18036                                         ptrdiff_t __offset,
18037                                         unsigned __int128 *__ptr) {
18038   signed char *__addr = (signed char *)__ptr + __offset;
18039   *(unaligned_vec_ui128 *)__addr = __vec;
18040 }
18041 #endif
18042
18043 /* vec_xst_trunc */
18044
18045 #if defined(__POWER10_VECTOR__) && defined(__VSX__) &&                         \
18046     defined(__SIZEOF_INT128__)
18047 static inline __ATTRS_o_ai void vec_xst_trunc(vector signed __int128 __vec,
18048                                               ptrdiff_t __offset,
18049                                               signed char *__ptr) {
18050   *(__ptr + __offset) = (signed char)__vec[0];
18051 }
18052
18053 static inline __ATTRS_o_ai void vec_xst_trunc(vector unsigned __int128 __vec,
18054                                               ptrdiff_t __offset,
18055                                               unsigned char *__ptr) {
18056   *(__ptr + __offset) = (unsigned char)__vec[0];
18057 }
18058
18059 static inline __ATTRS_o_ai void vec_xst_trunc(vector signed __int128 __vec,
18060                                               ptrdiff_t __offset,
18061                                               signed short *__ptr) {
18062   *(__ptr + __offset) = (signed short)__vec[0];
18063 }
18064
18065 static inline __ATTRS_o_ai void vec_xst_trunc(vector unsigned __int128 __vec,
18066                                               ptrdiff_t __offset,
18067                                               unsigned short *__ptr) {
18068   *(__ptr + __offset) = (unsigned short)__vec[0];
18069 }
18070
18071 static inline __ATTRS_o_ai void vec_xst_trunc(vector signed __int128 __vec,
18072                                               ptrdiff_t __offset,
18073                                               signed int *__ptr) {
18074   *(__ptr + __offset) = (signed int)__vec[0];
18075 }
18076
18077 static inline __ATTRS_o_ai void vec_xst_trunc(vector unsigned __int128 __vec,
18078                                               ptrdiff_t __offset,
18079                                               unsigned int *__ptr) {
18080   *(__ptr + __offset) = (unsigned int)__vec[0];
18081 }
18082
18083 static inline __ATTRS_o_ai void vec_xst_trunc(vector signed __int128 __vec,
18084                                               ptrdiff_t __offset,
18085                                               signed long long *__ptr) {
18086   *(__ptr + __offset) = (signed long long)__vec[0];
18087 }
18088
18089 static inline __ATTRS_o_ai void vec_xst_trunc(vector unsigned __int128 __vec,
18090                                               ptrdiff_t __offset,
18091                                               unsigned long long *__ptr) {
18092   *(__ptr + __offset) = (unsigned long long)__vec[0];
18093 }
18094 #endif
18095
18096 /* vec_xst_be */
18097
18098 #ifdef __LITTLE_ENDIAN__
18099 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed char __vec,
18100                                                signed long long  __offset,
18101                                                signed char *__ptr) {
18102   vector signed char __tmp =
18103      __builtin_shufflevector(__vec, __vec, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14,
18104                              13, 12, 11, 10, 9, 8);
18105   typedef __attribute__((vector_size(sizeof(__tmp)))) double __vector_double;
18106   __builtin_vsx_stxvd2x_be((__vector_double)__tmp, __offset, __ptr);
18107 }
18108
18109 static __inline__ void __ATTRS_o_ai vec_xst_be(vector unsigned char __vec,
18110                                                signed long long  __offset,
18111                                                unsigned char *__ptr) {
18112   vector unsigned char __tmp =
18113      __builtin_shufflevector(__vec, __vec, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14,
18114                              13, 12, 11, 10, 9, 8);
18115   typedef __attribute__((vector_size(sizeof(__tmp)))) double __vector_double;
18116   __builtin_vsx_stxvd2x_be((__vector_double)__tmp, __offset, __ptr);
18117 }
18118
18119 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed short __vec,
18120                                                signed long long  __offset,
18121                                                signed short *__ptr) {
18122   vector signed short __tmp =
18123      __builtin_shufflevector(__vec, __vec, 3, 2, 1, 0, 7, 6, 5, 4);
18124   typedef __attribute__((vector_size(sizeof(__tmp)))) double __vector_double;
18125   __builtin_vsx_stxvd2x_be((__vector_double)__tmp, __offset, __ptr);
18126 }
18127
18128 static __inline__ void __ATTRS_o_ai vec_xst_be(vector unsigned short __vec,
18129                                                signed long long  __offset,
18130                                                unsigned short *__ptr) {
18131   vector unsigned short __tmp =
18132      __builtin_shufflevector(__vec, __vec, 3, 2, 1, 0, 7, 6, 5, 4);
18133   typedef __attribute__((vector_size(sizeof(__tmp)))) double __vector_double;
18134   __builtin_vsx_stxvd2x_be((__vector_double)__tmp, __offset, __ptr);
18135 }
18136
18137 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed int __vec,
18138                                                signed long long  __offset,
18139                                                signed int *__ptr) {
18140   __builtin_vsx_stxvw4x_be(__vec, __offset, __ptr);
18141 }
18142
18143 static __inline__ void __ATTRS_o_ai vec_xst_be(vector unsigned int __vec,
18144                                                signed long long  __offset,
18145                                                unsigned int *__ptr) {
18146   __builtin_vsx_stxvw4x_be((vector int)__vec, __offset, __ptr);
18147 }
18148
18149 static __inline__ void __ATTRS_o_ai vec_xst_be(vector float __vec,
18150                                                signed long long  __offset,
18151                                                float *__ptr) {
18152   __builtin_vsx_stxvw4x_be((vector int)__vec, __offset, __ptr);
18153 }
18154
18155 #ifdef __VSX__
18156 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed long long __vec,
18157                                                signed long long  __offset,
18158                                                signed long long *__ptr) {
18159   __builtin_vsx_stxvd2x_be((vector double)__vec, __offset, __ptr);
18160 }
18161
18162 static __inline__ void __ATTRS_o_ai vec_xst_be(vector unsigned long long __vec,
18163                                                signed long long  __offset,
18164                                                unsigned long long *__ptr) {
18165   __builtin_vsx_stxvd2x_be((vector double)__vec, __offset, __ptr);
18166 }
18167
18168 static __inline__ void __ATTRS_o_ai vec_xst_be(vector double __vec,
18169                                                signed long long  __offset,
18170                                                double *__ptr) {
18171   __builtin_vsx_stxvd2x_be((vector double)__vec, __offset, __ptr);
18172 }
18173 #endif
18174
18175 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__) &&                    \
18176     defined(__SIZEOF_INT128__)
18177 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed __int128 __vec,
18178                                                signed long long  __offset,
18179                                                signed __int128 *__ptr) {
18180   vec_xst(__vec, __offset, __ptr);
18181 }
18182
18183 static __inline__ void __ATTRS_o_ai vec_xst_be(vector unsigned __int128 __vec,
18184                                                signed long long  __offset,
18185                                                unsigned __int128 *__ptr) {
18186   vec_xst(__vec, __offset, __ptr);
18187 }
18188 #endif
18189 #else
18190   #define vec_xst_be vec_xst
18191 #endif
18192
18193 #ifdef __POWER9_VECTOR__
18194 #define vec_test_data_class(__a, __b)                                          \
18195   _Generic(                                                                    \
18196       (__a), vector float                                                      \
18197       : (vector bool int)__builtin_vsx_xvtstdcsp((vector float)(__a), (__b)),  \
18198         vector double                                                          \
18199       : (vector bool long long)__builtin_vsx_xvtstdcdp((vector double)(__a),   \
18200                                                        (__b)))
18201
18202 #endif /* #ifdef __POWER9_VECTOR__ */
18203
18204 static vector float __ATTRS_o_ai vec_neg(vector float __a) {
18205   return -__a;
18206 }
18207
18208 #ifdef __VSX__
18209 static vector double __ATTRS_o_ai vec_neg(vector double __a) {
18210   return -__a;
18211 }
18212
18213 #endif
18214
18215 #ifdef __VSX__
18216 static vector long long __ATTRS_o_ai vec_neg(vector long long __a) {
18217   return -__a;
18218 }
18219 #endif
18220
18221 static vector signed int __ATTRS_o_ai vec_neg(vector signed int __a) {
18222   return -__a;
18223 }
18224
18225 static vector signed short __ATTRS_o_ai vec_neg(vector signed short __a) {
18226   return -__a;
18227 }
18228
18229 static vector signed char __ATTRS_o_ai vec_neg(vector signed char __a) {
18230   return -__a;
18231 }
18232
18233 static vector float __ATTRS_o_ai vec_nabs(vector float __a) {
18234   return - vec_abs(__a);
18235 }
18236
18237 #ifdef __VSX__
18238 static vector double __ATTRS_o_ai vec_nabs(vector double __a) {
18239   return - vec_abs(__a);
18240 }
18241
18242 #endif
18243
18244 #ifdef __POWER8_VECTOR__
18245 static vector long long __ATTRS_o_ai vec_nabs(vector long long __a) {
18246   return __builtin_altivec_vminsd(__a, -__a);
18247 }
18248 #endif
18249
18250 static vector signed int __ATTRS_o_ai vec_nabs(vector signed int __a) {
18251   return __builtin_altivec_vminsw(__a, -__a);
18252 }
18253
18254 static vector signed short __ATTRS_o_ai vec_nabs(vector signed short __a) {
18255   return __builtin_altivec_vminsh(__a, -__a);
18256 }
18257
18258 static vector signed char __ATTRS_o_ai vec_nabs(vector signed char __a) {
18259   return __builtin_altivec_vminsb(__a, -__a);
18260 }
18261
18262 static vector float __ATTRS_o_ai vec_recipdiv(vector float __a,
18263                                               vector float __b) {
18264   return __builtin_ppc_recipdivf(__a, __b);
18265 }
18266
18267 #ifdef __VSX__
18268 static vector double __ATTRS_o_ai vec_recipdiv(vector double __a,
18269                                                vector double __b) {
18270   return __builtin_ppc_recipdivd(__a, __b);
18271 }
18272 #endif
18273
18274 #ifdef __POWER10_VECTOR__
18275
18276 /* vec_extractm */
18277
18278 static __inline__ unsigned int __ATTRS_o_ai
18279 vec_extractm(vector unsigned char __a) {
18280   return __builtin_altivec_vextractbm(__a);
18281 }
18282
18283 static __inline__ unsigned int __ATTRS_o_ai
18284 vec_extractm(vector unsigned short __a) {
18285   return __builtin_altivec_vextracthm(__a);
18286 }
18287
18288 static __inline__ unsigned int __ATTRS_o_ai
18289 vec_extractm(vector unsigned int __a) {
18290   return __builtin_altivec_vextractwm(__a);
18291 }
18292
18293 static __inline__ unsigned int __ATTRS_o_ai
18294 vec_extractm(vector unsigned long long __a) {
18295   return __builtin_altivec_vextractdm(__a);
18296 }
18297
18298 #ifdef __SIZEOF_INT128__
18299 static __inline__ unsigned int __ATTRS_o_ai
18300 vec_extractm(vector unsigned __int128 __a) {
18301   return __builtin_altivec_vextractqm(__a);
18302 }
18303 #endif
18304
18305 /* vec_expandm */
18306
18307 static __inline__ vector unsigned char __ATTRS_o_ai
18308 vec_expandm(vector unsigned char __a) {
18309   return __builtin_altivec_vexpandbm(__a);
18310 }
18311
18312 static __inline__ vector unsigned short __ATTRS_o_ai
18313 vec_expandm(vector unsigned short __a) {
18314   return __builtin_altivec_vexpandhm(__a);
18315 }
18316
18317 static __inline__ vector unsigned int __ATTRS_o_ai
18318 vec_expandm(vector unsigned int __a) {
18319   return __builtin_altivec_vexpandwm(__a);
18320 }
18321
18322 static __inline__ vector unsigned long long __ATTRS_o_ai
18323 vec_expandm(vector unsigned long long __a) {
18324   return __builtin_altivec_vexpanddm(__a);
18325 }
18326
18327 #ifdef __SIZEOF_INT128__
18328 static __inline__ vector unsigned __int128 __ATTRS_o_ai
18329 vec_expandm(vector unsigned __int128 __a) {
18330   return __builtin_altivec_vexpandqm(__a);
18331 }
18332 #endif
18333
18334 /* vec_cntm */
18335
18336 #define vec_cntm(__a, __mp)                                                    \
18337   _Generic((__a), vector unsigned char                                         \
18338            : __builtin_altivec_vcntmbb((vector unsigned char)(__a),            \
18339                                        (unsigned char)(__mp)),                 \
18340              vector unsigned short                                             \
18341            : __builtin_altivec_vcntmbh((vector unsigned short)(__a),           \
18342                                        (unsigned char)(__mp)),                 \
18343              vector unsigned int                                               \
18344            : __builtin_altivec_vcntmbw((vector unsigned int)(__a),             \
18345                                        (unsigned char)(__mp)),                 \
18346              vector unsigned long long                                         \
18347            : __builtin_altivec_vcntmbd((vector unsigned long long)(__a),       \
18348                                        (unsigned char)(__mp)))
18349
18350 /* vec_gen[b|h|w|d|q]m */
18351
18352 static __inline__ vector unsigned char __ATTRS_o_ai
18353 vec_genbm(unsigned long long __bm) {
18354   return __builtin_altivec_mtvsrbm(__bm);
18355 }
18356
18357 static __inline__ vector unsigned short __ATTRS_o_ai
18358 vec_genhm(unsigned long long __bm) {
18359   return __builtin_altivec_mtvsrhm(__bm);
18360 }
18361
18362 static __inline__ vector unsigned int __ATTRS_o_ai
18363 vec_genwm(unsigned long long __bm) {
18364   return __builtin_altivec_mtvsrwm(__bm);
18365 }
18366
18367 static __inline__ vector unsigned long long __ATTRS_o_ai
18368 vec_gendm(unsigned long long __bm) {
18369   return __builtin_altivec_mtvsrdm(__bm);
18370 }
18371
18372 #ifdef __SIZEOF_INT128__
18373 static __inline__ vector unsigned __int128 __ATTRS_o_ai
18374 vec_genqm(unsigned long long __bm) {
18375   return __builtin_altivec_mtvsrqm(__bm);
18376 }
18377 #endif
18378
18379 /* vec_pdep */
18380
18381 static __inline__ vector unsigned long long __ATTRS_o_ai
18382 vec_pdep(vector unsigned long long __a, vector unsigned long long __b) {
18383   return __builtin_altivec_vpdepd(__a, __b);
18384 }
18385
18386 /* vec_pext */
18387
18388 static __inline__ vector unsigned long long __ATTRS_o_ai
18389 vec_pext(vector unsigned long long __a, vector unsigned long long __b) {
18390   return __builtin_altivec_vpextd(__a, __b);
18391 }
18392
18393 /* vec_cfuge */
18394
18395 static __inline__ vector unsigned long long __ATTRS_o_ai
18396 vec_cfuge(vector unsigned long long __a, vector unsigned long long __b) {
18397   return __builtin_altivec_vcfuged(__a, __b);
18398 }
18399
18400 /* vec_gnb */
18401
18402 #define vec_gnb(__a, __b) __builtin_altivec_vgnb(__a, __b)
18403
18404 /* vec_ternarylogic */
18405 #ifdef __VSX__
18406 #ifdef __SIZEOF_INT128__
18407 #define vec_ternarylogic(__a, __b, __c, __imm)                                 \
18408   _Generic((__a), vector unsigned char                                         \
18409            : (vector unsigned char)__builtin_vsx_xxeval(                       \
18410                  (vector unsigned long long)(__a),                             \
18411                  (vector unsigned long long)(__b),                             \
18412                  (vector unsigned long long)(__c), (__imm)),                   \
18413              vector unsigned short                                             \
18414            : (vector unsigned short)__builtin_vsx_xxeval(                      \
18415                  (vector unsigned long long)(__a),                             \
18416                  (vector unsigned long long)(__b),                             \
18417                  (vector unsigned long long)(__c), (__imm)),                   \
18418              vector unsigned int                                               \
18419            : (vector unsigned int)__builtin_vsx_xxeval(                        \
18420                  (vector unsigned long long)(__a),                             \
18421                  (vector unsigned long long)(__b),                             \
18422                  (vector unsigned long long)(__c), (__imm)),                   \
18423              vector unsigned long long                                         \
18424            : (vector unsigned long long)__builtin_vsx_xxeval(                  \
18425                  (vector unsigned long long)(__a),                             \
18426                  (vector unsigned long long)(__b),                             \
18427                  (vector unsigned long long)(__c), (__imm)),                   \
18428              vector unsigned __int128                                          \
18429            : (vector unsigned __int128)__builtin_vsx_xxeval(                   \
18430                (vector unsigned long long)(__a),                               \
18431                (vector unsigned long long)(__b),                               \
18432                (vector unsigned long long)(__c), (__imm)))
18433 #else
18434 #define vec_ternarylogic(__a, __b, __c, __imm)                                 \
18435   _Generic((__a), vector unsigned char                                         \
18436            : (vector unsigned char)__builtin_vsx_xxeval(                       \
18437                  (vector unsigned long long)(__a),                             \
18438                  (vector unsigned long long)(__b),                             \
18439                  (vector unsigned long long)(__c), (__imm)),                   \
18440              vector unsigned short                                             \
18441            : (vector unsigned short)__builtin_vsx_xxeval(                      \
18442                  (vector unsigned long long)(__a),                             \
18443                  (vector unsigned long long)(__b),                             \
18444                  (vector unsigned long long)(__c), (__imm)),                   \
18445              vector unsigned int                                               \
18446            : (vector unsigned int)__builtin_vsx_xxeval(                        \
18447                  (vector unsigned long long)(__a),                             \
18448                  (vector unsigned long long)(__b),                             \
18449                  (vector unsigned long long)(__c), (__imm)),                   \
18450              vector unsigned long long                                         \
18451            : (vector unsigned long long)__builtin_vsx_xxeval(                  \
18452                (vector unsigned long long)(__a),                               \
18453                (vector unsigned long long)(__b),                               \
18454                (vector unsigned long long)(__c), (__imm)))
18455 #endif /* __SIZEOF_INT128__ */
18456 #endif /* __VSX__ */
18457
18458 /* vec_genpcvm */
18459
18460 #ifdef __VSX__
18461 #define vec_genpcvm(__a, __imm)                                                \
18462   _Generic(                                                                    \
18463       (__a), vector unsigned char                                              \
18464       : __builtin_vsx_xxgenpcvbm((vector unsigned char)(__a), (int)(__imm)),   \
18465         vector unsigned short                                                  \
18466       : __builtin_vsx_xxgenpcvhm((vector unsigned short)(__a), (int)(__imm)),  \
18467         vector unsigned int                                                    \
18468       : __builtin_vsx_xxgenpcvwm((vector unsigned int)(__a), (int)(__imm)),    \
18469         vector unsigned long long                                              \
18470       : __builtin_vsx_xxgenpcvdm((vector unsigned long long)(__a),             \
18471                                  (int)(__imm)))
18472 #endif /* __VSX__ */
18473
18474 /* vec_clr_first */
18475
18476 static __inline__ vector signed char __ATTRS_o_ai
18477 vec_clr_first(vector signed char __a, unsigned int __n) {
18478 #ifdef __LITTLE_ENDIAN__
18479   return (vector signed char)__builtin_altivec_vclrrb((vector unsigned char)__a,
18480                                                       __n);
18481 #else
18482   return (vector signed char)__builtin_altivec_vclrlb((vector unsigned char)__a,
18483                                                       __n);
18484 #endif
18485 }
18486
18487 static __inline__ vector unsigned char __ATTRS_o_ai
18488 vec_clr_first(vector unsigned char __a, unsigned int __n) {
18489 #ifdef __LITTLE_ENDIAN__
18490   return (vector unsigned char)__builtin_altivec_vclrrb(
18491       (vector unsigned char)__a, __n);
18492 #else
18493   return (vector unsigned char)__builtin_altivec_vclrlb(
18494       (vector unsigned char)__a, __n);
18495 #endif
18496 }
18497
18498 /* vec_clr_last */
18499
18500 static __inline__ vector signed char __ATTRS_o_ai
18501 vec_clr_last(vector signed char __a, unsigned int __n) {
18502 #ifdef __LITTLE_ENDIAN__
18503   return (vector signed char)__builtin_altivec_vclrlb((vector unsigned char)__a,
18504                                                       __n);
18505 #else
18506   return (vector signed char)__builtin_altivec_vclrrb((vector unsigned char)__a,
18507                                                       __n);
18508 #endif
18509 }
18510
18511 static __inline__ vector unsigned char __ATTRS_o_ai
18512 vec_clr_last(vector unsigned char __a, unsigned int __n) {
18513 #ifdef __LITTLE_ENDIAN__
18514   return (vector unsigned char)__builtin_altivec_vclrlb(
18515       (vector unsigned char)__a, __n);
18516 #else
18517   return (vector unsigned char)__builtin_altivec_vclrrb(
18518       (vector unsigned char)__a, __n);
18519 #endif
18520 }
18521
18522 /* vec_cntlzm */
18523
18524 static __inline__ vector unsigned long long __ATTRS_o_ai
18525 vec_cntlzm(vector unsigned long long __a, vector unsigned long long __b) {
18526   return __builtin_altivec_vclzdm(__a, __b);
18527 }
18528
18529 /* vec_cnttzm */
18530
18531 static __inline__ vector unsigned long long __ATTRS_o_ai
18532 vec_cnttzm(vector unsigned long long __a, vector unsigned long long __b) {
18533   return __builtin_altivec_vctzdm(__a, __b);
18534 }
18535
18536 /* vec_mod */
18537
18538 static __inline__ vector signed int __ATTRS_o_ai
18539 vec_mod(vector signed int __a, vector signed int __b) {
18540   return __a % __b;
18541 }
18542
18543 static __inline__ vector unsigned int __ATTRS_o_ai
18544 vec_mod(vector unsigned int __a, vector unsigned int __b) {
18545   return __a % __b;
18546 }
18547
18548 static __inline__ vector signed long long __ATTRS_o_ai
18549 vec_mod(vector signed long long __a, vector signed long long __b) {
18550   return __a % __b;
18551 }
18552
18553 static __inline__ vector unsigned long long __ATTRS_o_ai
18554 vec_mod(vector unsigned long long __a, vector unsigned long long __b) {
18555   return __a % __b;
18556 }
18557
18558 #ifdef __SIZEOF_INT128__
18559 static __inline__ vector signed __int128 __ATTRS_o_ai
18560 vec_mod(vector signed __int128 __a, vector signed __int128 __b) {
18561   return __a % __b;
18562 }
18563
18564 static __inline__ vector unsigned __int128 __ATTRS_o_ai
18565 vec_mod(vector unsigned __int128 __a, vector unsigned __int128 __b) {
18566   return  __a % __b;
18567 }
18568 #endif
18569
18570 /* vec_sldb */
18571 #define vec_sldb(__a, __b, __c)                                                \
18572   _Generic(                                                                    \
18573       (__a), vector unsigned char                                              \
18574       : (vector unsigned char)__builtin_altivec_vsldbi(                        \
18575             (vector unsigned char)__a, (vector unsigned char)__b,              \
18576             (__c & 0x7)),                                                      \
18577         vector signed char                                                     \
18578       : (vector signed char)__builtin_altivec_vsldbi(                          \
18579             (vector unsigned char)__a, (vector unsigned char)__b,              \
18580             (__c & 0x7)),                                                      \
18581         vector unsigned short                                                  \
18582       : (vector unsigned short)__builtin_altivec_vsldbi(                       \
18583             (vector unsigned char)__a, (vector unsigned char)__b,              \
18584             (__c & 0x7)),                                                      \
18585         vector signed short                                                    \
18586       : (vector signed short)__builtin_altivec_vsldbi(                         \
18587             (vector unsigned char)__a, (vector unsigned char)__b,              \
18588             (__c & 0x7)),                                                      \
18589         vector unsigned int                                                    \
18590       : (vector unsigned int)__builtin_altivec_vsldbi(                         \
18591             (vector unsigned char)__a, (vector unsigned char)__b,              \
18592             (__c & 0x7)),                                                      \
18593         vector signed int                                                      \
18594       : (vector signed int)__builtin_altivec_vsldbi((vector unsigned char)__a, \
18595                                                     (vector unsigned char)__b, \
18596                                                     (__c & 0x7)),              \
18597         vector unsigned long long                                              \
18598       : (vector unsigned long long)__builtin_altivec_vsldbi(                   \
18599             (vector unsigned char)__a, (vector unsigned char)__b,              \
18600             (__c & 0x7)),                                                      \
18601         vector signed long long                                                \
18602       : (vector signed long long)__builtin_altivec_vsldbi(                     \
18603           (vector unsigned char)__a, (vector unsigned char)__b, (__c & 0x7)))
18604
18605 /* vec_srdb */
18606 #define vec_srdb(__a, __b, __c)                                                \
18607   _Generic(                                                                    \
18608       (__a), vector unsigned char                                              \
18609       : (vector unsigned char)__builtin_altivec_vsrdbi(                        \
18610             (vector unsigned char)__a, (vector unsigned char)__b,              \
18611             (__c & 0x7)),                                                      \
18612         vector signed char                                                     \
18613       : (vector signed char)__builtin_altivec_vsrdbi(                          \
18614             (vector unsigned char)__a, (vector unsigned char)__b,              \
18615             (__c & 0x7)),                                                      \
18616         vector unsigned short                                                  \
18617       : (vector unsigned short)__builtin_altivec_vsrdbi(                       \
18618             (vector unsigned char)__a, (vector unsigned char)__b,              \
18619             (__c & 0x7)),                                                      \
18620         vector signed short                                                    \
18621       : (vector signed short)__builtin_altivec_vsrdbi(                         \
18622             (vector unsigned char)__a, (vector unsigned char)__b,              \
18623             (__c & 0x7)),                                                      \
18624         vector unsigned int                                                    \
18625       : (vector unsigned int)__builtin_altivec_vsrdbi(                         \
18626             (vector unsigned char)__a, (vector unsigned char)__b,              \
18627             (__c & 0x7)),                                                      \
18628         vector signed int                                                      \
18629       : (vector signed int)__builtin_altivec_vsrdbi((vector unsigned char)__a, \
18630                                                     (vector unsigned char)__b, \
18631                                                     (__c & 0x7)),              \
18632         vector unsigned long long                                              \
18633       : (vector unsigned long long)__builtin_altivec_vsrdbi(                   \
18634             (vector unsigned char)__a, (vector unsigned char)__b,              \
18635             (__c & 0x7)),                                                      \
18636         vector signed long long                                                \
18637       : (vector signed long long)__builtin_altivec_vsrdbi(                     \
18638           (vector unsigned char)__a, (vector unsigned char)__b, (__c & 0x7)))
18639
18640 /* vec_insertl */
18641
18642 static __inline__ vector unsigned char __ATTRS_o_ai
18643 vec_insertl(unsigned char __a, vector unsigned char __b, unsigned int __c) {
18644 #ifdef __LITTLE_ENDIAN__
18645   return __builtin_altivec_vinsbrx(__b, __c, __a);
18646 #else
18647   return __builtin_altivec_vinsblx(__b, __c, __a);
18648 #endif
18649 }
18650
18651 static __inline__ vector unsigned short __ATTRS_o_ai
18652 vec_insertl(unsigned short __a, vector unsigned short __b, unsigned int __c) {
18653 #ifdef __LITTLE_ENDIAN__
18654   return __builtin_altivec_vinshrx(__b, __c, __a);
18655 #else
18656   return __builtin_altivec_vinshlx(__b, __c, __a);
18657 #endif
18658 }
18659
18660 static __inline__ vector unsigned int __ATTRS_o_ai
18661 vec_insertl(unsigned int __a, vector unsigned int __b, unsigned int __c) {
18662 #ifdef __LITTLE_ENDIAN__
18663   return __builtin_altivec_vinswrx(__b, __c, __a);
18664 #else
18665   return __builtin_altivec_vinswlx(__b, __c, __a);
18666 #endif
18667 }
18668
18669 static __inline__ vector unsigned long long __ATTRS_o_ai
18670 vec_insertl(unsigned long long __a, vector unsigned long long __b,
18671             unsigned int __c) {
18672 #ifdef __LITTLE_ENDIAN__
18673   return __builtin_altivec_vinsdrx(__b, __c, __a);
18674 #else
18675   return __builtin_altivec_vinsdlx(__b, __c, __a);
18676 #endif
18677 }
18678
18679 static __inline__ vector unsigned char __ATTRS_o_ai
18680 vec_insertl(vector unsigned char __a, vector unsigned char __b,
18681             unsigned int __c) {
18682 #ifdef __LITTLE_ENDIAN__
18683   return __builtin_altivec_vinsbvrx(__b, __c, __a);
18684 #else
18685   return __builtin_altivec_vinsbvlx(__b, __c, __a);
18686 #endif
18687 }
18688
18689 static __inline__ vector unsigned short __ATTRS_o_ai
18690 vec_insertl(vector unsigned short __a, vector unsigned short __b,
18691             unsigned int __c) {
18692 #ifdef __LITTLE_ENDIAN__
18693   return __builtin_altivec_vinshvrx(__b, __c, __a);
18694 #else
18695   return __builtin_altivec_vinshvlx(__b, __c, __a);
18696 #endif
18697 }
18698
18699 static __inline__ vector unsigned int __ATTRS_o_ai
18700 vec_insertl(vector unsigned int __a, vector unsigned int __b,
18701             unsigned int __c) {
18702 #ifdef __LITTLE_ENDIAN__
18703   return __builtin_altivec_vinswvrx(__b, __c, __a);
18704 #else
18705   return __builtin_altivec_vinswvlx(__b, __c, __a);
18706 #endif
18707 }
18708
18709 /* vec_inserth */
18710
18711 static __inline__ vector unsigned char __ATTRS_o_ai
18712 vec_inserth(unsigned char __a, vector unsigned char __b, unsigned int __c) {
18713 #ifdef __LITTLE_ENDIAN__
18714   return __builtin_altivec_vinsblx(__b, __c, __a);
18715 #else
18716   return __builtin_altivec_vinsbrx(__b, __c, __a);
18717 #endif
18718 }
18719
18720 static __inline__ vector unsigned short __ATTRS_o_ai
18721 vec_inserth(unsigned short __a, vector unsigned short __b, unsigned int __c) {
18722 #ifdef __LITTLE_ENDIAN__
18723   return __builtin_altivec_vinshlx(__b, __c, __a);
18724 #else
18725   return __builtin_altivec_vinshrx(__b, __c, __a);
18726 #endif
18727 }
18728
18729 static __inline__ vector unsigned int __ATTRS_o_ai
18730 vec_inserth(unsigned int __a, vector unsigned int __b, unsigned int __c) {
18731 #ifdef __LITTLE_ENDIAN__
18732   return __builtin_altivec_vinswlx(__b, __c, __a);
18733 #else
18734   return __builtin_altivec_vinswrx(__b, __c, __a);
18735 #endif
18736 }
18737
18738 static __inline__ vector unsigned long long __ATTRS_o_ai
18739 vec_inserth(unsigned long long __a, vector unsigned long long __b,
18740             unsigned int __c) {
18741 #ifdef __LITTLE_ENDIAN__
18742   return __builtin_altivec_vinsdlx(__b, __c, __a);
18743 #else
18744   return __builtin_altivec_vinsdrx(__b, __c, __a);
18745 #endif
18746 }
18747
18748 static __inline__ vector unsigned char __ATTRS_o_ai
18749 vec_inserth(vector unsigned char __a, vector unsigned char __b,
18750             unsigned int __c) {
18751 #ifdef __LITTLE_ENDIAN__
18752   return __builtin_altivec_vinsbvlx(__b, __c, __a);
18753 #else
18754   return __builtin_altivec_vinsbvrx(__b, __c, __a);
18755 #endif
18756 }
18757
18758 static __inline__ vector unsigned short __ATTRS_o_ai
18759 vec_inserth(vector unsigned short __a, vector unsigned short __b,
18760             unsigned int __c) {
18761 #ifdef __LITTLE_ENDIAN__
18762   return __builtin_altivec_vinshvlx(__b, __c, __a);
18763 #else
18764   return __builtin_altivec_vinshvrx(__b, __c, __a);
18765 #endif
18766 }
18767
18768 static __inline__ vector unsigned int __ATTRS_o_ai
18769 vec_inserth(vector unsigned int __a, vector unsigned int __b,
18770             unsigned int __c) {
18771 #ifdef __LITTLE_ENDIAN__
18772   return __builtin_altivec_vinswvlx(__b, __c, __a);
18773 #else
18774   return __builtin_altivec_vinswvrx(__b, __c, __a);
18775 #endif
18776 }
18777
18778 /* vec_extractl */
18779
18780 static __inline__ vector unsigned long long __ATTRS_o_ai vec_extractl(
18781     vector unsigned char __a, vector unsigned char __b, unsigned int __c) {
18782 #ifdef __LITTLE_ENDIAN__
18783   return __builtin_altivec_vextdubvrx(__a, __b, __c);
18784 #else
18785   vector unsigned long long __ret = __builtin_altivec_vextdubvlx(__a, __b, __c);
18786   return vec_sld(__ret, __ret, 8);
18787 #endif
18788 }
18789
18790 static __inline__ vector unsigned long long __ATTRS_o_ai vec_extractl(
18791     vector unsigned short __a, vector unsigned short __b, unsigned int __c) {
18792 #ifdef __LITTLE_ENDIAN__
18793   return __builtin_altivec_vextduhvrx(__a, __b, __c);
18794 #else
18795   vector unsigned long long __ret = __builtin_altivec_vextduhvlx(__a, __b, __c);
18796   return vec_sld(__ret, __ret, 8);
18797 #endif
18798 }
18799
18800 static __inline__ vector unsigned long long __ATTRS_o_ai vec_extractl(
18801     vector unsigned int __a, vector unsigned int __b, unsigned int __c) {
18802 #ifdef __LITTLE_ENDIAN__
18803   return __builtin_altivec_vextduwvrx(__a, __b, __c);
18804 #else
18805   vector unsigned long long __ret = __builtin_altivec_vextduwvlx(__a, __b, __c);
18806   return vec_sld(__ret, __ret, 8);
18807 #endif
18808 }
18809
18810 static __inline__ vector unsigned long long __ATTRS_o_ai
18811 vec_extractl(vector unsigned long long __a, vector unsigned long long __b,
18812              unsigned int __c) {
18813 #ifdef __LITTLE_ENDIAN__
18814   return __builtin_altivec_vextddvrx(__a, __b, __c);
18815 #else
18816   vector unsigned long long __ret = __builtin_altivec_vextddvlx(__a, __b, __c);
18817   return vec_sld(__ret, __ret, 8);
18818 #endif
18819 }
18820
18821 /* vec_extracth */
18822
18823 static __inline__ vector unsigned long long __ATTRS_o_ai vec_extracth(
18824     vector unsigned char __a, vector unsigned char __b, unsigned int __c) {
18825 #ifdef __LITTLE_ENDIAN__
18826   return __builtin_altivec_vextdubvlx(__a, __b, __c);
18827 #else
18828   vector unsigned long long __ret = __builtin_altivec_vextdubvrx(__a, __b, __c);
18829   return vec_sld(__ret, __ret, 8);
18830 #endif
18831 }
18832
18833 static __inline__ vector unsigned long long __ATTRS_o_ai vec_extracth(
18834     vector unsigned short __a, vector unsigned short __b, unsigned int __c) {
18835 #ifdef __LITTLE_ENDIAN__
18836   return __builtin_altivec_vextduhvlx(__a, __b, __c);
18837 #else
18838   vector unsigned long long __ret = __builtin_altivec_vextduhvrx(__a, __b, __c);
18839   return vec_sld(__ret, __ret, 8);
18840 #endif
18841 }
18842
18843 static __inline__ vector unsigned long long __ATTRS_o_ai vec_extracth(
18844     vector unsigned int __a, vector unsigned int __b, unsigned int __c) {
18845 #ifdef __LITTLE_ENDIAN__
18846   return __builtin_altivec_vextduwvlx(__a, __b, __c);
18847 #else
18848   vector unsigned long long __ret = __builtin_altivec_vextduwvrx(__a, __b, __c);
18849   return vec_sld(__ret, __ret, 8);
18850 #endif
18851 }
18852
18853 static __inline__ vector unsigned long long __ATTRS_o_ai
18854 vec_extracth(vector unsigned long long __a, vector unsigned long long __b,
18855              unsigned int __c) {
18856 #ifdef __LITTLE_ENDIAN__
18857   return __builtin_altivec_vextddvlx(__a, __b, __c);
18858 #else
18859   vector unsigned long long __ret = __builtin_altivec_vextddvrx(__a, __b, __c);
18860   return vec_sld(__ret, __ret, 8);
18861 #endif
18862 }
18863
18864 #ifdef __VSX__
18865
18866 /* vec_permx */
18867 #define vec_permx(__a, __b, __c, __d)                                          \
18868   _Generic(                                                                    \
18869       (__a), vector unsigned char                                              \
18870       : (vector unsigned char)__builtin_vsx_xxpermx(                           \
18871             (vector unsigned char)__a, (vector unsigned char)__b, __c, __d),   \
18872         vector signed char                                                     \
18873       : (vector signed char)__builtin_vsx_xxpermx(                             \
18874             (vector unsigned char)__a, (vector unsigned char)__b, __c, __d),   \
18875         vector unsigned short                                                  \
18876       : (vector unsigned short)__builtin_vsx_xxpermx(                          \
18877             (vector unsigned char)__a, (vector unsigned char)__b, __c, __d),   \
18878         vector signed short                                                    \
18879       : (vector signed short)__builtin_vsx_xxpermx(                            \
18880             (vector unsigned char)__a, (vector unsigned char)__b, __c, __d),   \
18881         vector unsigned int                                                    \
18882       : (vector unsigned int)__builtin_vsx_xxpermx(                            \
18883             (vector unsigned char)__a, (vector unsigned char)__b, __c, __d),   \
18884         vector signed int                                                      \
18885       : (vector signed int)__builtin_vsx_xxpermx(                              \
18886             (vector unsigned char)__a, (vector unsigned char)__b, __c, __d),   \
18887         vector unsigned long long                                              \
18888       : (vector unsigned long long)__builtin_vsx_xxpermx(                      \
18889             (vector unsigned char)__a, (vector unsigned char)__b, __c, __d),   \
18890         vector signed long long                                                \
18891       : (vector signed long long)__builtin_vsx_xxpermx(                        \
18892             (vector unsigned char)__a, (vector unsigned char)__b, __c, __d),   \
18893         vector float                                                           \
18894       : (vector float)__builtin_vsx_xxpermx(                                   \
18895             (vector unsigned char)__a, (vector unsigned char)__b, __c, __d),   \
18896         vector double                                                          \
18897       : (vector double)__builtin_vsx_xxpermx(                                  \
18898           (vector unsigned char)__a, (vector unsigned char)__b, __c, __d))
18899
18900 /* vec_blendv */
18901
18902 static __inline__ vector signed char __ATTRS_o_ai
18903 vec_blendv(vector signed char __a, vector signed char __b,
18904            vector unsigned char __c) {
18905   return (vector signed char)__builtin_vsx_xxblendvb(
18906       (vector unsigned char)__a, (vector unsigned char)__b, __c);
18907 }
18908
18909 static __inline__ vector unsigned char __ATTRS_o_ai
18910 vec_blendv(vector unsigned char __a, vector unsigned char __b,
18911            vector unsigned char __c) {
18912   return __builtin_vsx_xxblendvb(__a, __b, __c);
18913 }
18914
18915 static __inline__ vector signed short __ATTRS_o_ai
18916 vec_blendv(vector signed short __a, vector signed short __b,
18917            vector unsigned short __c) {
18918   return (vector signed short)__builtin_vsx_xxblendvh(
18919       (vector unsigned short)__a, (vector unsigned short)__b, __c);
18920 }
18921
18922 static __inline__ vector unsigned short __ATTRS_o_ai
18923 vec_blendv(vector unsigned short __a, vector unsigned short __b,
18924            vector unsigned short __c) {
18925   return __builtin_vsx_xxblendvh(__a, __b, __c);
18926 }
18927
18928 static __inline__ vector signed int __ATTRS_o_ai
18929 vec_blendv(vector signed int __a, vector signed int __b,
18930            vector unsigned int __c) {
18931   return (vector signed int)__builtin_vsx_xxblendvw(
18932       (vector unsigned int)__a, (vector unsigned int)__b, __c);
18933 }
18934
18935 static __inline__ vector unsigned int __ATTRS_o_ai
18936 vec_blendv(vector unsigned int __a, vector unsigned int __b,
18937            vector unsigned int __c) {
18938   return __builtin_vsx_xxblendvw(__a, __b, __c);
18939 }
18940
18941 static __inline__ vector signed long long __ATTRS_o_ai
18942 vec_blendv(vector signed long long __a, vector signed long long __b,
18943            vector unsigned long long __c) {
18944   return (vector signed long long)__builtin_vsx_xxblendvd(
18945       (vector unsigned long long)__a, (vector unsigned long long)__b, __c);
18946 }
18947
18948 static __inline__ vector unsigned long long __ATTRS_o_ai
18949 vec_blendv(vector unsigned long long __a, vector unsigned long long __b,
18950            vector unsigned long long __c) {
18951   return (vector unsigned long long)__builtin_vsx_xxblendvd(__a, __b, __c);
18952 }
18953
18954 static __inline__ vector float __ATTRS_o_ai
18955 vec_blendv(vector float __a, vector float __b, vector unsigned int __c) {
18956   return (vector float)__builtin_vsx_xxblendvw((vector unsigned int)__a,
18957                                                (vector unsigned int)__b, __c);
18958 }
18959
18960 static __inline__ vector double __ATTRS_o_ai
18961 vec_blendv(vector double __a, vector double __b,
18962            vector unsigned long long __c) {
18963   return (vector double)__builtin_vsx_xxblendvd(
18964       (vector unsigned long long)__a, (vector unsigned long long)__b, __c);
18965 }
18966
18967 #define vec_replace_unaligned(__a, __b, __c)                                   \
18968   _Generic((__a), vector signed int                                            \
18969            : __builtin_altivec_vinsw((vector unsigned char)__a,                \
18970                                      (unsigned int)__b, __c),                  \
18971              vector unsigned int                                               \
18972            : __builtin_altivec_vinsw((vector unsigned char)__a,                \
18973                                      (unsigned int)__b, __c),                  \
18974              vector unsigned long long                                         \
18975            : __builtin_altivec_vinsd((vector unsigned char)__a,                \
18976                                      (unsigned long long)__b, __c),            \
18977              vector signed long long                                           \
18978            : __builtin_altivec_vinsd((vector unsigned char)__a,                \
18979                                      (unsigned long long)__b, __c),            \
18980              vector float                                                      \
18981            : __builtin_altivec_vinsw((vector unsigned char)__a,                \
18982                                      (unsigned int)__b, __c),                  \
18983              vector double                                                     \
18984            : __builtin_altivec_vinsd((vector unsigned char)__a,                \
18985                                      (unsigned long long)__b, __c))
18986
18987 #define vec_replace_elt(__a, __b, __c)                                         \
18988   _Generic((__a), vector signed int                                            \
18989            : (vector signed int)__builtin_altivec_vinsw_elt(                   \
18990                  (vector unsigned char)__a, (unsigned int)__b, __c),           \
18991              vector unsigned int                                               \
18992            : (vector unsigned int)__builtin_altivec_vinsw_elt(                 \
18993                  (vector unsigned char)__a, (unsigned int)__b, __c),           \
18994              vector unsigned long long                                         \
18995            : (vector unsigned long long)__builtin_altivec_vinsd_elt(           \
18996                  (vector unsigned char)__a, (unsigned long long)__b, __c),     \
18997              vector signed long long                                           \
18998            : (vector signed long long)__builtin_altivec_vinsd_elt(             \
18999                  (vector unsigned char)__a, (unsigned long long)__b, __c),     \
19000              vector float                                                      \
19001            : (vector float)__builtin_altivec_vinsw_elt(                        \
19002                  (vector unsigned char)__a, (unsigned int)__b, __c),           \
19003              vector double                                                     \
19004            : (vector double)__builtin_altivec_vinsd_elt(                       \
19005                (vector unsigned char)__a, (unsigned long long)__b, __c))
19006
19007 /* vec_splati */
19008
19009 #define vec_splati(__a)                                                        \
19010   _Generic((__a), signed int                                                   \
19011            : ((vector signed int)__a), unsigned int                            \
19012            : ((vector unsigned int)__a), float                                 \
19013            : ((vector float)__a))
19014
19015 /* vec_spatid */
19016
19017 static __inline__ vector double __ATTRS_o_ai vec_splatid(const float __a) {
19018   return ((vector double)((double)__a));
19019 }
19020
19021 /* vec_splati_ins */
19022
19023 static __inline__ vector signed int __ATTRS_o_ai vec_splati_ins(
19024     vector signed int __a, const unsigned int __b, const signed int __c) {
19025   const unsigned int __d = __b & 0x01;
19026 #ifdef __LITTLE_ENDIAN__
19027   __a[1 - __d] = __c;
19028   __a[3 - __d] = __c;
19029 #else
19030   __a[__d] = __c;
19031   __a[2 + __d] = __c;
19032 #endif
19033   return __a;
19034 }
19035
19036 static __inline__ vector unsigned int __ATTRS_o_ai vec_splati_ins(
19037     vector unsigned int __a, const unsigned int __b, const unsigned int __c) {
19038   const unsigned int __d = __b & 0x01;
19039 #ifdef __LITTLE_ENDIAN__
19040   __a[1 - __d] = __c;
19041   __a[3 - __d] = __c;
19042 #else
19043   __a[__d] = __c;
19044   __a[2 + __d] = __c;
19045 #endif
19046   return __a;
19047 }
19048
19049 static __inline__ vector float __ATTRS_o_ai
19050 vec_splati_ins(vector float __a, const unsigned int __b, const float __c) {
19051   const unsigned int __d = __b & 0x01;
19052 #ifdef __LITTLE_ENDIAN__
19053   __a[1 - __d] = __c;
19054   __a[3 - __d] = __c;
19055 #else
19056   __a[__d] = __c;
19057   __a[2 + __d] = __c;
19058 #endif
19059   return __a;
19060 }
19061
19062 /* vec_test_lsbb_all_ones */
19063
19064 static __inline__ int __ATTRS_o_ai
19065 vec_test_lsbb_all_ones(vector unsigned char __a) {
19066   return __builtin_vsx_xvtlsbb(__a, 1);
19067 }
19068
19069 /* vec_test_lsbb_all_zeros */
19070
19071 static __inline__ int __ATTRS_o_ai
19072 vec_test_lsbb_all_zeros(vector unsigned char __a) {
19073   return __builtin_vsx_xvtlsbb(__a, 0);
19074 }
19075 #endif /* __VSX__ */
19076
19077 /* vec_stril */
19078
19079 static __inline__ vector unsigned char __ATTRS_o_ai
19080 vec_stril(vector unsigned char __a) {
19081 #ifdef __LITTLE_ENDIAN__
19082   return (vector unsigned char)__builtin_altivec_vstribr(
19083       (vector unsigned char)__a);
19084 #else
19085   return (vector unsigned char)__builtin_altivec_vstribl(
19086       (vector unsigned char)__a);
19087 #endif
19088 }
19089
19090 static __inline__ vector signed char __ATTRS_o_ai
19091 vec_stril(vector signed char __a) {
19092 #ifdef __LITTLE_ENDIAN__
19093   return (vector signed char)__builtin_altivec_vstribr(
19094       (vector unsigned char)__a);
19095 #else
19096   return (vector signed char)__builtin_altivec_vstribl(
19097       (vector unsigned char)__a);
19098 #endif
19099 }
19100
19101 static __inline__ vector unsigned short __ATTRS_o_ai
19102 vec_stril(vector unsigned short __a) {
19103 #ifdef __LITTLE_ENDIAN__
19104   return (vector unsigned short)__builtin_altivec_vstrihr(
19105       (vector signed short)__a);
19106 #else
19107   return (vector unsigned short)__builtin_altivec_vstrihl(
19108       (vector signed short)__a);
19109 #endif
19110 }
19111
19112 static __inline__ vector signed short __ATTRS_o_ai
19113 vec_stril(vector signed short __a) {
19114 #ifdef __LITTLE_ENDIAN__
19115   return __builtin_altivec_vstrihr(__a);
19116 #else
19117   return __builtin_altivec_vstrihl(__a);
19118 #endif
19119 }
19120
19121 /* vec_stril_p */
19122
19123 static __inline__ int __ATTRS_o_ai vec_stril_p(vector unsigned char __a) {
19124 #ifdef __LITTLE_ENDIAN__
19125   return __builtin_altivec_vstribr_p(__CR6_EQ, (vector unsigned char)__a);
19126 #else
19127   return __builtin_altivec_vstribl_p(__CR6_EQ, (vector unsigned char)__a);
19128 #endif
19129 }
19130
19131 static __inline__ int __ATTRS_o_ai vec_stril_p(vector signed char __a) {
19132 #ifdef __LITTLE_ENDIAN__
19133   return __builtin_altivec_vstribr_p(__CR6_EQ, (vector unsigned char)__a);
19134 #else
19135   return __builtin_altivec_vstribl_p(__CR6_EQ, (vector unsigned char)__a);
19136 #endif
19137 }
19138
19139 static __inline__ int __ATTRS_o_ai vec_stril_p(vector unsigned short __a) {
19140 #ifdef __LITTLE_ENDIAN__
19141   return __builtin_altivec_vstrihr_p(__CR6_EQ, (vector signed short)__a);
19142 #else
19143   return __builtin_altivec_vstrihl_p(__CR6_EQ, (vector signed short)__a);
19144 #endif
19145 }
19146
19147 static __inline__ int __ATTRS_o_ai vec_stril_p(vector signed short __a) {
19148 #ifdef __LITTLE_ENDIAN__
19149   return __builtin_altivec_vstrihr_p(__CR6_EQ, __a);
19150 #else
19151   return __builtin_altivec_vstrihl_p(__CR6_EQ, __a);
19152 #endif
19153 }
19154
19155 /* vec_strir */
19156
19157 static __inline__ vector unsigned char __ATTRS_o_ai
19158 vec_strir(vector unsigned char __a) {
19159 #ifdef __LITTLE_ENDIAN__
19160   return (vector unsigned char)__builtin_altivec_vstribl(
19161       (vector unsigned char)__a);
19162 #else
19163   return (vector unsigned char)__builtin_altivec_vstribr(
19164       (vector unsigned char)__a);
19165 #endif
19166 }
19167
19168 static __inline__ vector signed char __ATTRS_o_ai
19169 vec_strir(vector signed char __a) {
19170 #ifdef __LITTLE_ENDIAN__
19171   return (vector signed char)__builtin_altivec_vstribl(
19172       (vector unsigned char)__a);
19173 #else
19174   return (vector signed char)__builtin_altivec_vstribr(
19175       (vector unsigned char)__a);
19176 #endif
19177 }
19178
19179 static __inline__ vector unsigned short __ATTRS_o_ai
19180 vec_strir(vector unsigned short __a) {
19181 #ifdef __LITTLE_ENDIAN__
19182   return (vector unsigned short)__builtin_altivec_vstrihl(
19183       (vector signed short)__a);
19184 #else
19185   return (vector unsigned short)__builtin_altivec_vstrihr(
19186       (vector signed short)__a);
19187 #endif
19188 }
19189
19190 static __inline__ vector signed short __ATTRS_o_ai
19191 vec_strir(vector signed short __a) {
19192 #ifdef __LITTLE_ENDIAN__
19193   return __builtin_altivec_vstrihl(__a);
19194 #else
19195   return __builtin_altivec_vstrihr(__a);
19196 #endif
19197 }
19198
19199 /* vec_strir_p */
19200
19201 static __inline__ int __ATTRS_o_ai vec_strir_p(vector unsigned char __a) {
19202 #ifdef __LITTLE_ENDIAN__
19203   return __builtin_altivec_vstribl_p(__CR6_EQ, (vector unsigned char)__a);
19204 #else
19205   return __builtin_altivec_vstribr_p(__CR6_EQ, (vector unsigned char)__a);
19206 #endif
19207 }
19208
19209 static __inline__ int __ATTRS_o_ai vec_strir_p(vector signed char __a) {
19210 #ifdef __LITTLE_ENDIAN__
19211   return __builtin_altivec_vstribl_p(__CR6_EQ, (vector unsigned char)__a);
19212 #else
19213   return __builtin_altivec_vstribr_p(__CR6_EQ, (vector unsigned char)__a);
19214 #endif
19215 }
19216
19217 static __inline__ int __ATTRS_o_ai vec_strir_p(vector unsigned short __a) {
19218 #ifdef __LITTLE_ENDIAN__
19219   return __builtin_altivec_vstrihl_p(__CR6_EQ, (vector signed short)__a);
19220 #else
19221   return __builtin_altivec_vstrihr_p(__CR6_EQ, (vector signed short)__a);
19222 #endif
19223 }
19224
19225 static __inline__ int __ATTRS_o_ai vec_strir_p(vector signed short __a) {
19226 #ifdef __LITTLE_ENDIAN__
19227   return __builtin_altivec_vstrihl_p(__CR6_EQ, __a);
19228 #else
19229   return __builtin_altivec_vstrihr_p(__CR6_EQ, __a);
19230 #endif
19231 }
19232
19233 /* vs[l | r | ra] */
19234
19235 #ifdef __SIZEOF_INT128__
19236 static __inline__ vector unsigned __int128 __ATTRS_o_ai
19237 vec_sl(vector unsigned __int128 __a, vector unsigned __int128 __b) {
19238   return __a << (__b % (vector unsigned __int128)(sizeof(unsigned __int128) *
19239                                                   __CHAR_BIT__));
19240 }
19241
19242 static __inline__ vector signed __int128 __ATTRS_o_ai
19243 vec_sl(vector signed __int128 __a, vector unsigned __int128 __b) {
19244   return __a << (__b % (vector unsigned __int128)(sizeof(unsigned __int128) *
19245                                                   __CHAR_BIT__));
19246 }
19247
19248 static __inline__ vector unsigned __int128 __ATTRS_o_ai
19249 vec_sr(vector unsigned __int128 __a, vector unsigned __int128 __b) {
19250   return __a >> (__b % (vector unsigned __int128)(sizeof(unsigned __int128) *
19251                                                   __CHAR_BIT__));
19252 }
19253
19254 static __inline__ vector signed __int128 __ATTRS_o_ai
19255 vec_sr(vector signed __int128 __a, vector unsigned __int128 __b) {
19256   return (
19257       vector signed __int128)(((vector unsigned __int128)__a) >>
19258                               (__b %
19259                                (vector unsigned __int128)(sizeof(
19260                                                               unsigned __int128) *
19261                                                           __CHAR_BIT__)));
19262 }
19263
19264 static __inline__ vector unsigned __int128 __ATTRS_o_ai
19265 vec_sra(vector unsigned __int128 __a, vector unsigned __int128 __b) {
19266   return (
19267       vector unsigned __int128)(((vector signed __int128)__a) >>
19268                                 (__b %
19269                                  (vector unsigned __int128)(sizeof(
19270                                                                 unsigned __int128) *
19271                                                             __CHAR_BIT__)));
19272 }
19273
19274 static __inline__ vector signed __int128 __ATTRS_o_ai
19275 vec_sra(vector signed __int128 __a, vector unsigned __int128 __b) {
19276   return __a >> (__b % (vector unsigned __int128)(sizeof(unsigned __int128) *
19277                                                   __CHAR_BIT__));
19278 }
19279
19280 #endif /* __SIZEOF_INT128__ */
19281 #endif /* __POWER10_VECTOR__ */
19282
19283 #ifdef __POWER8_VECTOR__
19284 #define __bcdadd(__a, __b, __ps) __builtin_ppc_bcdadd((__a), (__b), (__ps))
19285 #define __bcdsub(__a, __b, __ps) __builtin_ppc_bcdsub((__a), (__b), (__ps))
19286
19287 static __inline__ long __bcdadd_ofl(vector unsigned char __a,
19288                                     vector unsigned char __b) {
19289   return __builtin_ppc_bcdadd_p(__CR6_SO, __a, __b);
19290 }
19291
19292 static __inline__ long __bcdsub_ofl(vector unsigned char __a,
19293                                     vector unsigned char __b) {
19294   return __builtin_ppc_bcdsub_p(__CR6_SO, __a, __b);
19295 }
19296
19297 static __inline__ long __bcd_invalid(vector unsigned char __a) {
19298   return __builtin_ppc_bcdsub_p(__CR6_SO, __a, __a);
19299 }
19300
19301 static __inline__ long __bcdcmpeq(vector unsigned char __a,
19302                                   vector unsigned char __b) {
19303   return __builtin_ppc_bcdsub_p(__CR6_EQ, __a, __b);
19304 }
19305
19306 static __inline__ long __bcdcmplt(vector unsigned char __a,
19307                                   vector unsigned char __b) {
19308   return __builtin_ppc_bcdsub_p(__CR6_LT, __a, __b);
19309 }
19310
19311 static __inline__ long __bcdcmpgt(vector unsigned char __a,
19312                                   vector unsigned char __b) {
19313   return __builtin_ppc_bcdsub_p(__CR6_GT, __a, __b);
19314 }
19315
19316 static __inline__ long __bcdcmple(vector unsigned char __a,
19317                                   vector unsigned char __b) {
19318   return __builtin_ppc_bcdsub_p(__CR6_GT_REV, __a, __b);
19319 }
19320
19321 static __inline__ long __bcdcmpge(vector unsigned char __a,
19322                                   vector unsigned char __b) {
19323   return __builtin_ppc_bcdsub_p(__CR6_LT_REV, __a, __b);
19324 }
19325
19326 #endif // __POWER8_VECTOR__
19327
19328 #undef __ATTRS_o_ai
19329
19330 #endif /* __ALTIVEC_H */