contrib/llvm/tools/clang/lib/Headers/altivec.h

   1 /*===---- altivec.h - Standard header for type generic math ---------------===*\
   2  *
   3  * Permission is hereby granted, free of charge, to any person obtaining a copy
   4  * of this software and associated documentation files (the "Software"), to deal
   5  * in the Software without restriction, including without limitation the rights
   6  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   7  * copies of the Software, and to permit persons to whom the Software is
   8  * furnished to do so, subject to the following conditions:
   9  *
  10  * The above copyright notice and this permission notice shall be included in
  11  * all copies or substantial portions of the Software.
  12  *
  13  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  14  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  15  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  16  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  17  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  18  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  19  * THE SOFTWARE.
  20  *
  21 \*===----------------------------------------------------------------------===*/
  22
  23 #ifndef __ALTIVEC_H
  24 #define __ALTIVEC_H
  25
  26 #ifndef __ALTIVEC__
  27 #error "AltiVec support not enabled"
  28 #endif
  29
  30 /* Constants for mapping CR6 bits to predicate result. */
  31
  32 #define __CR6_EQ 0
  33 #define __CR6_EQ_REV 1
  34 #define __CR6_LT 2
  35 #define __CR6_LT_REV 3
  36
  37 /* Constants for vec_test_data_class */
  38 #define __VEC_CLASS_FP_SUBNORMAL_N (1 << 0)
  39 #define __VEC_CLASS_FP_SUBNORMAL_P (1 << 1)
  40 #define __VEC_CLASS_FP_SUBNORMAL (__VEC_CLASS_FP_SUBNORMAL_P | \
  41                                   __VEC_CLASS_FP_SUBNORMAL_N)
  42 #define __VEC_CLASS_FP_ZERO_N (1<<2)
  43 #define __VEC_CLASS_FP_ZERO_P (1<<3)
  44 #define __VEC_CLASS_FP_ZERO (__VEC_CLASS_FP_ZERO_P           | \
  45                              __VEC_CLASS_FP_ZERO_N)
  46 #define __VEC_CLASS_FP_INFINITY_N (1<<4)
  47 #define __VEC_CLASS_FP_INFINITY_P (1<<5)
  48 #define __VEC_CLASS_FP_INFINITY (__VEC_CLASS_FP_INFINITY_P   | \
  49                                  __VEC_CLASS_FP_INFINITY_N)
  50 #define __VEC_CLASS_FP_NAN (1<<6)
  51 #define __VEC_CLASS_FP_NOT_NORMAL (__VEC_CLASS_FP_NAN        | \
  52                                    __VEC_CLASS_FP_SUBNORMAL  | \
  53                                    __VEC_CLASS_FP_ZERO       | \
  54                                    __VEC_CLASS_FP_INFINITY)
  55
  56 #define __ATTRS_o_ai __attribute__((__overloadable__, __always_inline__))
  57
  58 #ifdef __POWER9_VECTOR__
  59 #include <stddef.h>
  60 #endif
  61
  62 static __inline__ vector signed char __ATTRS_o_ai vec_perm(
  63     vector signed char __a, vector signed char __b, vector unsigned char __c);
  64
  65 static __inline__ vector unsigned char __ATTRS_o_ai
  66 vec_perm(vector unsigned char __a, vector unsigned char __b,
  67          vector unsigned char __c);
  68
  69 static __inline__ vector bool char __ATTRS_o_ai
  70 vec_perm(vector bool char __a, vector bool char __b, vector unsigned char __c);
  71
  72 static __inline__ vector short __ATTRS_o_ai vec_perm(vector signed short __a,
  73                                                      vector signed short __b,
  74                                                      vector unsigned char __c);
  75
  76 static __inline__ vector unsigned short __ATTRS_o_ai
  77 vec_perm(vector unsigned short __a, vector unsigned short __b,
  78          vector unsigned char __c);
  79
  80 static __inline__ vector bool short __ATTRS_o_ai vec_perm(
  81     vector bool short __a, vector bool short __b, vector unsigned char __c);
  82
  83 static __inline__ vector pixel __ATTRS_o_ai vec_perm(vector pixel __a,
  84                                                      vector pixel __b,
  85                                                      vector unsigned char __c);
  86
  87 static __inline__ vector int __ATTRS_o_ai vec_perm(vector signed int __a,
  88                                                    vector signed int __b,
  89                                                    vector unsigned char __c);
  90
  91 static __inline__ vector unsigned int __ATTRS_o_ai vec_perm(
  92     vector unsigned int __a, vector unsigned int __b, vector unsigned char __c);
  93
  94 static __inline__ vector bool int __ATTRS_o_ai
  95 vec_perm(vector bool int __a, vector bool int __b, vector unsigned char __c);
  96
  97 static __inline__ vector float __ATTRS_o_ai vec_perm(vector float __a,
  98                                                      vector float __b,
  99                                                      vector unsigned char __c);
 100
 101 #ifdef __VSX__
 102 static __inline__ vector long long __ATTRS_o_ai
 103 vec_perm(vector signed long long __a, vector signed long long __b,
 104          vector unsigned char __c);
 105
 106 static __inline__ vector unsigned long long __ATTRS_o_ai
 107 vec_perm(vector unsigned long long __a, vector unsigned long long __b,
 108          vector unsigned char __c);
 109
 110 static __inline__ vector bool long long __ATTRS_o_ai
 111 vec_perm(vector bool long long __a, vector bool long long __b,
 112          vector unsigned char __c);
 113
 114 static __inline__ vector double __ATTRS_o_ai vec_perm(vector double __a,
 115                                                       vector double __b,
 116                                                       vector unsigned char __c);
 117 #endif
 118
 119 static __inline__ vector unsigned char __ATTRS_o_ai
 120 vec_xor(vector unsigned char __a, vector unsigned char __b);
 121
 122 /* vec_abs */
 123
 124 #define __builtin_altivec_abs_v16qi vec_abs
 125 #define __builtin_altivec_abs_v8hi vec_abs
 126 #define __builtin_altivec_abs_v4si vec_abs
 127
 128 static __inline__ vector signed char __ATTRS_o_ai
 129 vec_abs(vector signed char __a) {
 130   return __builtin_altivec_vmaxsb(__a, -__a);
 131 }
 132
 133 static __inline__ vector signed short __ATTRS_o_ai
 134 vec_abs(vector signed short __a) {
 135   return __builtin_altivec_vmaxsh(__a, -__a);
 136 }
 137
 138 static __inline__ vector signed int __ATTRS_o_ai
 139 vec_abs(vector signed int __a) {
 140   return __builtin_altivec_vmaxsw(__a, -__a);
 141 }
 142
 143 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
 144 static __inline__ vector signed long long __ATTRS_o_ai
 145 vec_abs(vector signed long long __a) {
 146   return __builtin_altivec_vmaxsd(__a, -__a);
 147 }
 148 #endif
 149
 150 static __inline__ vector float __ATTRS_o_ai vec_abs(vector float __a) {
 151 #ifdef __VSX__
 152   return __builtin_vsx_xvabssp(__a);
 153 #else
 154   vector unsigned int __res =
 155       (vector unsigned int)__a & (vector unsigned int)(0x7FFFFFFF);
 156   return (vector float)__res;
 157 #endif
 158 }
 159
 160 #ifdef __VSX__
 161 static __inline__ vector double __ATTRS_o_ai vec_abs(vector double __a) {
 162   return __builtin_vsx_xvabsdp(__a);
 163 }
 164 #endif
 165
 166 /* vec_abss */
 167 #define __builtin_altivec_abss_v16qi vec_abss
 168 #define __builtin_altivec_abss_v8hi vec_abss
 169 #define __builtin_altivec_abss_v4si vec_abss
 170
 171 static __inline__ vector signed char __ATTRS_o_ai
 172 vec_abss(vector signed char __a) {
 173   return __builtin_altivec_vmaxsb(
 174       __a, __builtin_altivec_vsubsbs((vector signed char)(0), __a));
 175 }
 176
 177 static __inline__ vector signed short __ATTRS_o_ai
 178 vec_abss(vector signed short __a) {
 179   return __builtin_altivec_vmaxsh(
 180       __a, __builtin_altivec_vsubshs((vector signed short)(0), __a));
 181 }
 182
 183 static __inline__ vector signed int __ATTRS_o_ai
 184 vec_abss(vector signed int __a) {
 185   return __builtin_altivec_vmaxsw(
 186       __a, __builtin_altivec_vsubsws((vector signed int)(0), __a));
 187 }
 188
 189 /* vec_absd */
 190 #if defined(__POWER9_VECTOR__)
 191
 192 static __inline__ vector unsigned char __ATTRS_o_ai
 193 vec_absd(vector unsigned char __a, vector unsigned char __b) {
 194   return __builtin_altivec_vabsdub(__a, __b);
 195 }
 196
 197 static __inline__ vector unsigned short __ATTRS_o_ai
 198 vec_absd(vector unsigned short __a, vector unsigned short __b) {
 199   return __builtin_altivec_vabsduh(__a, __b);
 200 }
 201
 202 static __inline__ vector unsigned int __ATTRS_o_ai
 203 vec_absd(vector unsigned int __a,  vector unsigned int __b) {
 204   return __builtin_altivec_vabsduw(__a, __b);
 205 }
 206
 207 #endif /* End __POWER9_VECTOR__ */
 208
 209 /* vec_add */
 210
 211 static __inline__ vector signed char __ATTRS_o_ai
 212 vec_add(vector signed char __a, vector signed char __b) {
 213   return __a + __b;
 214 }
 215
 216 static __inline__ vector signed char __ATTRS_o_ai
 217 vec_add(vector bool char __a, vector signed char __b) {
 218   return (vector signed char)__a + __b;
 219 }
 220
 221 static __inline__ vector signed char __ATTRS_o_ai
 222 vec_add(vector signed char __a, vector bool char __b) {
 223   return __a + (vector signed char)__b;
 224 }
 225
 226 static __inline__ vector unsigned char __ATTRS_o_ai
 227 vec_add(vector unsigned char __a, vector unsigned char __b) {
 228   return __a + __b;
 229 }
 230
 231 static __inline__ vector unsigned char __ATTRS_o_ai
 232 vec_add(vector bool char __a, vector unsigned char __b) {
 233   return (vector unsigned char)__a + __b;
 234 }
 235
 236 static __inline__ vector unsigned char __ATTRS_o_ai
 237 vec_add(vector unsigned char __a, vector bool char __b) {
 238   return __a + (vector unsigned char)__b;
 239 }
 240
 241 static __inline__ vector short __ATTRS_o_ai vec_add(vector short __a,
 242                                                     vector short __b) {
 243   return __a + __b;
 244 }
 245
 246 static __inline__ vector short __ATTRS_o_ai vec_add(vector bool short __a,
 247                                                     vector short __b) {
 248   return (vector short)__a + __b;
 249 }
 250
 251 static __inline__ vector short __ATTRS_o_ai vec_add(vector short __a,
 252                                                     vector bool short __b) {
 253   return __a + (vector short)__b;
 254 }
 255
 256 static __inline__ vector unsigned short __ATTRS_o_ai
 257 vec_add(vector unsigned short __a, vector unsigned short __b) {
 258   return __a + __b;
 259 }
 260
 261 static __inline__ vector unsigned short __ATTRS_o_ai
 262 vec_add(vector bool short __a, vector unsigned short __b) {
 263   return (vector unsigned short)__a + __b;
 264 }
 265
 266 static __inline__ vector unsigned short __ATTRS_o_ai
 267 vec_add(vector unsigned short __a, vector bool short __b) {
 268   return __a + (vector unsigned short)__b;
 269 }
 270
 271 static __inline__ vector int __ATTRS_o_ai vec_add(vector int __a,
 272                                                   vector int __b) {
 273   return __a + __b;
 274 }
 275
 276 static __inline__ vector int __ATTRS_o_ai vec_add(vector bool int __a,
 277                                                   vector int __b) {
 278   return (vector int)__a + __b;
 279 }
 280
 281 static __inline__ vector int __ATTRS_o_ai vec_add(vector int __a,
 282                                                   vector bool int __b) {
 283   return __a + (vector int)__b;
 284 }
 285
 286 static __inline__ vector unsigned int __ATTRS_o_ai
 287 vec_add(vector unsigned int __a, vector unsigned int __b) {
 288   return __a + __b;
 289 }
 290
 291 static __inline__ vector unsigned int __ATTRS_o_ai
 292 vec_add(vector bool int __a, vector unsigned int __b) {
 293   return (vector unsigned int)__a + __b;
 294 }
 295
 296 static __inline__ vector unsigned int __ATTRS_o_ai
 297 vec_add(vector unsigned int __a, vector bool int __b) {
 298   return __a + (vector unsigned int)__b;
 299 }
 300
 301 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
 302 static __inline__ vector signed long long __ATTRS_o_ai
 303 vec_add(vector signed long long __a, vector signed long long __b) {
 304   return __a + __b;
 305 }
 306
 307 static __inline__ vector unsigned long long __ATTRS_o_ai
 308 vec_add(vector unsigned long long __a, vector unsigned long long __b) {
 309   return __a + __b;
 310 }
 311
 312 static __inline__ vector signed __int128 __ATTRS_o_ai
 313 vec_add(vector signed __int128 __a, vector signed __int128 __b) {
 314   return __a + __b;
 315 }
 316
 317 static __inline__ vector unsigned __int128 __ATTRS_o_ai
 318 vec_add(vector unsigned __int128 __a, vector unsigned __int128 __b) {
 319   return __a + __b;
 320 }
 321 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
 322
 323 static __inline__ vector float __ATTRS_o_ai vec_add(vector float __a,
 324                                                     vector float __b) {
 325   return __a + __b;
 326 }
 327
 328 #ifdef __VSX__
 329 static __inline__ vector double __ATTRS_o_ai vec_add(vector double __a,
 330                                                      vector double __b) {
 331   return __a + __b;
 332 }
 333 #endif // __VSX__
 334
 335 /* vec_adde */
 336
 337 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
 338 static __inline__ vector signed __int128 __ATTRS_o_ai
 339 vec_adde(vector signed __int128 __a, vector signed __int128 __b,
 340          vector signed __int128 __c) {
 341   return __builtin_altivec_vaddeuqm(__a, __b, __c);
 342 }
 343
 344 static __inline__ vector unsigned __int128 __ATTRS_o_ai
 345 vec_adde(vector unsigned __int128 __a, vector unsigned __int128 __b,
 346          vector unsigned __int128 __c) {
 347   return __builtin_altivec_vaddeuqm(__a, __b, __c);
 348 }
 349 #endif
 350
 351 static __inline__ vector signed int __ATTRS_o_ai
 352 vec_adde(vector signed int __a, vector signed int __b,
 353          vector signed int __c) {
 354   vector signed int __mask = {1, 1, 1, 1};
 355   vector signed int __carry = __c & __mask;
 356   return vec_add(vec_add(__a, __b), __carry);
 357 }
 358
 359 static __inline__ vector unsigned int __ATTRS_o_ai
 360 vec_adde(vector unsigned int __a, vector unsigned int __b,
 361          vector unsigned int __c) {
 362   vector unsigned int __mask = {1, 1, 1, 1};
 363   vector unsigned int __carry = __c & __mask;
 364   return vec_add(vec_add(__a, __b), __carry);
 365 }
 366
 367 /* vec_addec */
 368
 369 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
 370 static __inline__ vector signed __int128 __ATTRS_o_ai
 371 vec_addec(vector signed __int128 __a, vector signed __int128 __b,
 372           vector signed __int128 __c) {
 373   return __builtin_altivec_vaddecuq(__a, __b, __c);
 374 }
 375
 376 static __inline__ vector unsigned __int128 __ATTRS_o_ai
 377 vec_addec(vector unsigned __int128 __a, vector unsigned __int128 __b,
 378           vector unsigned __int128 __c) {
 379   return __builtin_altivec_vaddecuq(__a, __b, __c);
 380 }
 381
 382 static __inline__ vector signed int __ATTRS_o_ai
 383 vec_addec(vector signed int __a, vector signed int __b,
 384           vector signed int __c) {
 385
 386   signed int __result[4];
 387   for (int i = 0; i < 4; i++) {
 388     unsigned int __tempa = (unsigned int) __a[i];
 389     unsigned int __tempb = (unsigned int) __b[i];
 390     unsigned int __tempc = (unsigned int) __c[i];
 391     __tempc = __tempc & 0x00000001;
 392     unsigned long long __longa = (unsigned long long) __tempa;
 393     unsigned long long __longb = (unsigned long long) __tempb;
 394     unsigned long long __longc = (unsigned long long) __tempc;
 395     unsigned long long __sum = __longa + __longb + __longc;
 396     unsigned long long __res = (__sum >> 32) & 0x01;
 397     unsigned long long __tempres = (unsigned int) __res;
 398     __result[i] = (signed int) __tempres;
 399   }
 400
 401   vector signed int ret = { __result[0], __result[1], __result[2], __result[3] };
 402   return ret;
 403 }
 404
 405 static __inline__ vector unsigned int __ATTRS_o_ai
 406 vec_addec(vector unsigned int __a, vector unsigned int __b,
 407           vector unsigned int __c) {
 408
 409   unsigned int __result[4];
 410   for (int i = 0; i < 4; i++) {
 411     unsigned int __tempc = __c[i] & 1;
 412     unsigned long long __longa = (unsigned long long) __a[i];
 413     unsigned long long __longb = (unsigned long long) __b[i];
 414     unsigned long long __longc = (unsigned long long) __tempc;
 415     unsigned long long __sum = __longa + __longb + __longc;
 416     unsigned long long __res = (__sum >> 32) & 0x01;
 417     unsigned long long __tempres = (unsigned int) __res;
 418     __result[i] = (signed int) __tempres;
 419   }
 420
 421   vector unsigned int ret = { __result[0], __result[1], __result[2], __result[3] };
 422   return ret;
 423 }
 424
 425 #endif
 426
 427 /* vec_vaddubm */
 428
 429 #define __builtin_altivec_vaddubm vec_vaddubm
 430
 431 static __inline__ vector signed char __ATTRS_o_ai
 432 vec_vaddubm(vector signed char __a, vector signed char __b) {
 433   return __a + __b;
 434 }
 435
 436 static __inline__ vector signed char __ATTRS_o_ai
 437 vec_vaddubm(vector bool char __a, vector signed char __b) {
 438   return (vector signed char)__a + __b;
 439 }
 440
 441 static __inline__ vector signed char __ATTRS_o_ai
 442 vec_vaddubm(vector signed char __a, vector bool char __b) {
 443   return __a + (vector signed char)__b;
 444 }
 445
 446 static __inline__ vector unsigned char __ATTRS_o_ai
 447 vec_vaddubm(vector unsigned char __a, vector unsigned char __b) {
 448   return __a + __b;
 449 }
 450
 451 static __inline__ vector unsigned char __ATTRS_o_ai
 452 vec_vaddubm(vector bool char __a, vector unsigned char __b) {
 453   return (vector unsigned char)__a + __b;
 454 }
 455
 456 static __inline__ vector unsigned char __ATTRS_o_ai
 457 vec_vaddubm(vector unsigned char __a, vector bool char __b) {
 458   return __a + (vector unsigned char)__b;
 459 }
 460
 461 /* vec_vadduhm */
 462
 463 #define __builtin_altivec_vadduhm vec_vadduhm
 464
 465 static __inline__ vector short __ATTRS_o_ai vec_vadduhm(vector short __a,
 466                                                         vector short __b) {
 467   return __a + __b;
 468 }
 469
 470 static __inline__ vector short __ATTRS_o_ai vec_vadduhm(vector bool short __a,
 471                                                         vector short __b) {
 472   return (vector short)__a + __b;
 473 }
 474
 475 static __inline__ vector short __ATTRS_o_ai vec_vadduhm(vector short __a,
 476                                                         vector bool short __b) {
 477   return __a + (vector short)__b;
 478 }
 479
 480 static __inline__ vector unsigned short __ATTRS_o_ai
 481 vec_vadduhm(vector unsigned short __a, vector unsigned short __b) {
 482   return __a + __b;
 483 }
 484
 485 static __inline__ vector unsigned short __ATTRS_o_ai
 486 vec_vadduhm(vector bool short __a, vector unsigned short __b) {
 487   return (vector unsigned short)__a + __b;
 488 }
 489
 490 static __inline__ vector unsigned short __ATTRS_o_ai
 491 vec_vadduhm(vector unsigned short __a, vector bool short __b) {
 492   return __a + (vector unsigned short)__b;
 493 }
 494
 495 /* vec_vadduwm */
 496
 497 #define __builtin_altivec_vadduwm vec_vadduwm
 498
 499 static __inline__ vector int __ATTRS_o_ai vec_vadduwm(vector int __a,
 500                                                       vector int __b) {
 501   return __a + __b;
 502 }
 503
 504 static __inline__ vector int __ATTRS_o_ai vec_vadduwm(vector bool int __a,
 505                                                       vector int __b) {
 506   return (vector int)__a + __b;
 507 }
 508
 509 static __inline__ vector int __ATTRS_o_ai vec_vadduwm(vector int __a,
 510                                                       vector bool int __b) {
 511   return __a + (vector int)__b;
 512 }
 513
 514 static __inline__ vector unsigned int __ATTRS_o_ai
 515 vec_vadduwm(vector unsigned int __a, vector unsigned int __b) {
 516   return __a + __b;
 517 }
 518
 519 static __inline__ vector unsigned int __ATTRS_o_ai
 520 vec_vadduwm(vector bool int __a, vector unsigned int __b) {
 521   return (vector unsigned int)__a + __b;
 522 }
 523
 524 static __inline__ vector unsigned int __ATTRS_o_ai
 525 vec_vadduwm(vector unsigned int __a, vector bool int __b) {
 526   return __a + (vector unsigned int)__b;
 527 }
 528
 529 /* vec_vaddfp */
 530
 531 #define __builtin_altivec_vaddfp vec_vaddfp
 532
 533 static __inline__ vector float __attribute__((__always_inline__))
 534 vec_vaddfp(vector float __a, vector float __b) {
 535   return __a + __b;
 536 }
 537
 538 /* vec_addc */
 539
 540 static __inline__ vector signed int __ATTRS_o_ai
 541 vec_addc(vector signed int __a, vector signed int __b) {
 542   return (vector signed int)__builtin_altivec_vaddcuw((vector unsigned int)__a,
 543                                                       (vector unsigned int)__b);
 544 }
 545
 546 static __inline__ vector unsigned int __ATTRS_o_ai
 547 vec_addc(vector unsigned int __a, vector unsigned int __b) {
 548   return __builtin_altivec_vaddcuw(__a, __b);
 549 }
 550
 551 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
 552 static __inline__ vector signed __int128 __ATTRS_o_ai
 553 vec_addc(vector signed __int128 __a, vector signed __int128 __b) {
 554   return (vector signed __int128)__builtin_altivec_vaddcuq(
 555       (vector unsigned __int128)__a, (vector unsigned __int128)__b);
 556 }
 557
 558 static __inline__ vector unsigned __int128 __ATTRS_o_ai
 559 vec_addc(vector unsigned __int128 __a, vector unsigned __int128 __b) {
 560   return __builtin_altivec_vaddcuq(__a, __b);
 561 }
 562 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
 563
 564 /* vec_vaddcuw */
 565
 566 static __inline__ vector unsigned int __attribute__((__always_inline__))
 567 vec_vaddcuw(vector unsigned int __a, vector unsigned int __b) {
 568   return __builtin_altivec_vaddcuw(__a, __b);
 569 }
 570
 571 /* vec_adds */
 572
 573 static __inline__ vector signed char __ATTRS_o_ai
 574 vec_adds(vector signed char __a, vector signed char __b) {
 575   return __builtin_altivec_vaddsbs(__a, __b);
 576 }
 577
 578 static __inline__ vector signed char __ATTRS_o_ai
 579 vec_adds(vector bool char __a, vector signed char __b) {
 580   return __builtin_altivec_vaddsbs((vector signed char)__a, __b);
 581 }
 582
 583 static __inline__ vector signed char __ATTRS_o_ai
 584 vec_adds(vector signed char __a, vector bool char __b) {
 585   return __builtin_altivec_vaddsbs(__a, (vector signed char)__b);
 586 }
 587
 588 static __inline__ vector unsigned char __ATTRS_o_ai
 589 vec_adds(vector unsigned char __a, vector unsigned char __b) {
 590   return __builtin_altivec_vaddubs(__a, __b);
 591 }
 592
 593 static __inline__ vector unsigned char __ATTRS_o_ai
 594 vec_adds(vector bool char __a, vector unsigned char __b) {
 595   return __builtin_altivec_vaddubs((vector unsigned char)__a, __b);
 596 }
 597
 598 static __inline__ vector unsigned char __ATTRS_o_ai
 599 vec_adds(vector unsigned char __a, vector bool char __b) {
 600   return __builtin_altivec_vaddubs(__a, (vector unsigned char)__b);
 601 }
 602
 603 static __inline__ vector short __ATTRS_o_ai vec_adds(vector short __a,
 604                                                      vector short __b) {
 605   return __builtin_altivec_vaddshs(__a, __b);
 606 }
 607
 608 static __inline__ vector short __ATTRS_o_ai vec_adds(vector bool short __a,
 609                                                      vector short __b) {
 610   return __builtin_altivec_vaddshs((vector short)__a, __b);
 611 }
 612
 613 static __inline__ vector short __ATTRS_o_ai vec_adds(vector short __a,
 614                                                      vector bool short __b) {
 615   return __builtin_altivec_vaddshs(__a, (vector short)__b);
 616 }
 617
 618 static __inline__ vector unsigned short __ATTRS_o_ai
 619 vec_adds(vector unsigned short __a, vector unsigned short __b) {
 620   return __builtin_altivec_vadduhs(__a, __b);
 621 }
 622
 623 static __inline__ vector unsigned short __ATTRS_o_ai
 624 vec_adds(vector bool short __a, vector unsigned short __b) {
 625   return __builtin_altivec_vadduhs((vector unsigned short)__a, __b);
 626 }
 627
 628 static __inline__ vector unsigned short __ATTRS_o_ai
 629 vec_adds(vector unsigned short __a, vector bool short __b) {
 630   return __builtin_altivec_vadduhs(__a, (vector unsigned short)__b);
 631 }
 632
 633 static __inline__ vector int __ATTRS_o_ai vec_adds(vector int __a,
 634                                                    vector int __b) {
 635   return __builtin_altivec_vaddsws(__a, __b);
 636 }
 637
 638 static __inline__ vector int __ATTRS_o_ai vec_adds(vector bool int __a,
 639                                                    vector int __b) {
 640   return __builtin_altivec_vaddsws((vector int)__a, __b);
 641 }
 642
 643 static __inline__ vector int __ATTRS_o_ai vec_adds(vector int __a,
 644                                                    vector bool int __b) {
 645   return __builtin_altivec_vaddsws(__a, (vector int)__b);
 646 }
 647
 648 static __inline__ vector unsigned int __ATTRS_o_ai
 649 vec_adds(vector unsigned int __a, vector unsigned int __b) {
 650   return __builtin_altivec_vadduws(__a, __b);
 651 }
 652
 653 static __inline__ vector unsigned int __ATTRS_o_ai
 654 vec_adds(vector bool int __a, vector unsigned int __b) {
 655   return __builtin_altivec_vadduws((vector unsigned int)__a, __b);
 656 }
 657
 658 static __inline__ vector unsigned int __ATTRS_o_ai
 659 vec_adds(vector unsigned int __a, vector bool int __b) {
 660   return __builtin_altivec_vadduws(__a, (vector unsigned int)__b);
 661 }
 662
 663 /* vec_vaddsbs */
 664
 665 static __inline__ vector signed char __ATTRS_o_ai
 666 vec_vaddsbs(vector signed char __a, vector signed char __b) {
 667   return __builtin_altivec_vaddsbs(__a, __b);
 668 }
 669
 670 static __inline__ vector signed char __ATTRS_o_ai
 671 vec_vaddsbs(vector bool char __a, vector signed char __b) {
 672   return __builtin_altivec_vaddsbs((vector signed char)__a, __b);
 673 }
 674
 675 static __inline__ vector signed char __ATTRS_o_ai
 676 vec_vaddsbs(vector signed char __a, vector bool char __b) {
 677   return __builtin_altivec_vaddsbs(__a, (vector signed char)__b);
 678 }
 679
 680 /* vec_vaddubs */
 681
 682 static __inline__ vector unsigned char __ATTRS_o_ai
 683 vec_vaddubs(vector unsigned char __a, vector unsigned char __b) {
 684   return __builtin_altivec_vaddubs(__a, __b);
 685 }
 686
 687 static __inline__ vector unsigned char __ATTRS_o_ai
 688 vec_vaddubs(vector bool char __a, vector unsigned char __b) {
 689   return __builtin_altivec_vaddubs((vector unsigned char)__a, __b);
 690 }
 691
 692 static __inline__ vector unsigned char __ATTRS_o_ai
 693 vec_vaddubs(vector unsigned char __a, vector bool char __b) {
 694   return __builtin_altivec_vaddubs(__a, (vector unsigned char)__b);
 695 }
 696
 697 /* vec_vaddshs */
 698
 699 static __inline__ vector short __ATTRS_o_ai vec_vaddshs(vector short __a,
 700                                                         vector short __b) {
 701   return __builtin_altivec_vaddshs(__a, __b);
 702 }
 703
 704 static __inline__ vector short __ATTRS_o_ai vec_vaddshs(vector bool short __a,
 705                                                         vector short __b) {
 706   return __builtin_altivec_vaddshs((vector short)__a, __b);
 707 }
 708
 709 static __inline__ vector short __ATTRS_o_ai vec_vaddshs(vector short __a,
 710                                                         vector bool short __b) {
 711   return __builtin_altivec_vaddshs(__a, (vector short)__b);
 712 }
 713
 714 /* vec_vadduhs */
 715
 716 static __inline__ vector unsigned short __ATTRS_o_ai
 717 vec_vadduhs(vector unsigned short __a, vector unsigned short __b) {
 718   return __builtin_altivec_vadduhs(__a, __b);
 719 }
 720
 721 static __inline__ vector unsigned short __ATTRS_o_ai
 722 vec_vadduhs(vector bool short __a, vector unsigned short __b) {
 723   return __builtin_altivec_vadduhs((vector unsigned short)__a, __b);
 724 }
 725
 726 static __inline__ vector unsigned short __ATTRS_o_ai
 727 vec_vadduhs(vector unsigned short __a, vector bool short __b) {
 728   return __builtin_altivec_vadduhs(__a, (vector unsigned short)__b);
 729 }
 730
 731 /* vec_vaddsws */
 732
 733 static __inline__ vector int __ATTRS_o_ai vec_vaddsws(vector int __a,
 734                                                       vector int __b) {
 735   return __builtin_altivec_vaddsws(__a, __b);
 736 }
 737
 738 static __inline__ vector int __ATTRS_o_ai vec_vaddsws(vector bool int __a,
 739                                                       vector int __b) {
 740   return __builtin_altivec_vaddsws((vector int)__a, __b);
 741 }
 742
 743 static __inline__ vector int __ATTRS_o_ai vec_vaddsws(vector int __a,
 744                                                       vector bool int __b) {
 745   return __builtin_altivec_vaddsws(__a, (vector int)__b);
 746 }
 747
 748 /* vec_vadduws */
 749
 750 static __inline__ vector unsigned int __ATTRS_o_ai
 751 vec_vadduws(vector unsigned int __a, vector unsigned int __b) {
 752   return __builtin_altivec_vadduws(__a, __b);
 753 }
 754
 755 static __inline__ vector unsigned int __ATTRS_o_ai
 756 vec_vadduws(vector bool int __a, vector unsigned int __b) {
 757   return __builtin_altivec_vadduws((vector unsigned int)__a, __b);
 758 }
 759
 760 static __inline__ vector unsigned int __ATTRS_o_ai
 761 vec_vadduws(vector unsigned int __a, vector bool int __b) {
 762   return __builtin_altivec_vadduws(__a, (vector unsigned int)__b);
 763 }
 764
 765 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
 766 /* vec_vadduqm */
 767
 768 static __inline__ vector signed __int128 __ATTRS_o_ai
 769 vec_vadduqm(vector signed __int128 __a, vector signed __int128 __b) {
 770   return __a + __b;
 771 }
 772
 773 static __inline__ vector unsigned __int128 __ATTRS_o_ai
 774 vec_vadduqm(vector unsigned __int128 __a, vector unsigned __int128 __b) {
 775   return __a + __b;
 776 }
 777
 778 /* vec_vaddeuqm */
 779
 780 static __inline__ vector signed __int128 __ATTRS_o_ai
 781 vec_vaddeuqm(vector signed __int128 __a, vector signed __int128 __b,
 782              vector signed __int128 __c) {
 783   return __builtin_altivec_vaddeuqm(__a, __b, __c);
 784 }
 785
 786 static __inline__ vector unsigned __int128 __ATTRS_o_ai
 787 vec_vaddeuqm(vector unsigned __int128 __a, vector unsigned __int128 __b,
 788              vector unsigned __int128 __c) {
 789   return __builtin_altivec_vaddeuqm(__a, __b, __c);
 790 }
 791
 792 /* vec_vaddcuq */
 793
 794 static __inline__ vector signed __int128 __ATTRS_o_ai
 795 vec_vaddcuq(vector signed __int128 __a, vector signed __int128 __b) {
 796   return __builtin_altivec_vaddcuq(__a, __b);
 797 }
 798
 799 static __inline__ vector unsigned __int128 __ATTRS_o_ai
 800 vec_vaddcuq(vector unsigned __int128 __a, vector unsigned __int128 __b) {
 801   return __builtin_altivec_vaddcuq(__a, __b);
 802 }
 803
 804 /* vec_vaddecuq */
 805
 806 static __inline__ vector signed __int128 __ATTRS_o_ai
 807 vec_vaddecuq(vector signed __int128 __a, vector signed __int128 __b,
 808              vector signed __int128 __c) {
 809   return __builtin_altivec_vaddecuq(__a, __b, __c);
 810 }
 811
 812 static __inline__ vector unsigned __int128 __ATTRS_o_ai
 813 vec_vaddecuq(vector unsigned __int128 __a, vector unsigned __int128 __b,
 814              vector unsigned __int128 __c) {
 815   return __builtin_altivec_vaddecuq(__a, __b, __c);
 816 }
 817 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
 818
 819 /* vec_and */
 820
 821 #define __builtin_altivec_vand vec_and
 822
 823 static __inline__ vector signed char __ATTRS_o_ai
 824 vec_and(vector signed char __a, vector signed char __b) {
 825   return __a & __b;
 826 }
 827
 828 static __inline__ vector signed char __ATTRS_o_ai
 829 vec_and(vector bool char __a, vector signed char __b) {
 830   return (vector signed char)__a & __b;
 831 }
 832
 833 static __inline__ vector signed char __ATTRS_o_ai
 834 vec_and(vector signed char __a, vector bool char __b) {
 835   return __a & (vector signed char)__b;
 836 }
 837
 838 static __inline__ vector unsigned char __ATTRS_o_ai
 839 vec_and(vector unsigned char __a, vector unsigned char __b) {
 840   return __a & __b;
 841 }
 842
 843 static __inline__ vector unsigned char __ATTRS_o_ai
 844 vec_and(vector bool char __a, vector unsigned char __b) {
 845   return (vector unsigned char)__a & __b;
 846 }
 847
 848 static __inline__ vector unsigned char __ATTRS_o_ai
 849 vec_and(vector unsigned char __a, vector bool char __b) {
 850   return __a & (vector unsigned char)__b;
 851 }
 852
 853 static __inline__ vector bool char __ATTRS_o_ai vec_and(vector bool char __a,
 854                                                         vector bool char __b) {
 855   return __a & __b;
 856 }
 857
 858 static __inline__ vector short __ATTRS_o_ai vec_and(vector short __a,
 859                                                     vector short __b) {
 860   return __a & __b;
 861 }
 862
 863 static __inline__ vector short __ATTRS_o_ai vec_and(vector bool short __a,
 864                                                     vector short __b) {
 865   return (vector short)__a & __b;
 866 }
 867
 868 static __inline__ vector short __ATTRS_o_ai vec_and(vector short __a,
 869                                                     vector bool short __b) {
 870   return __a & (vector short)__b;
 871 }
 872
 873 static __inline__ vector unsigned short __ATTRS_o_ai
 874 vec_and(vector unsigned short __a, vector unsigned short __b) {
 875   return __a & __b;
 876 }
 877
 878 static __inline__ vector unsigned short __ATTRS_o_ai
 879 vec_and(vector bool short __a, vector unsigned short __b) {
 880   return (vector unsigned short)__a & __b;
 881 }
 882
 883 static __inline__ vector unsigned short __ATTRS_o_ai
 884 vec_and(vector unsigned short __a, vector bool short __b) {
 885   return __a & (vector unsigned short)__b;
 886 }
 887
 888 static __inline__ vector bool short __ATTRS_o_ai
 889 vec_and(vector bool short __a, vector bool short __b) {
 890   return __a & __b;
 891 }
 892
 893 static __inline__ vector int __ATTRS_o_ai vec_and(vector int __a,
 894                                                   vector int __b) {
 895   return __a & __b;
 896 }
 897
 898 static __inline__ vector int __ATTRS_o_ai vec_and(vector bool int __a,
 899                                                   vector int __b) {
 900   return (vector int)__a & __b;
 901 }
 902
 903 static __inline__ vector int __ATTRS_o_ai vec_and(vector int __a,
 904                                                   vector bool int __b) {
 905   return __a & (vector int)__b;
 906 }
 907
 908 static __inline__ vector unsigned int __ATTRS_o_ai
 909 vec_and(vector unsigned int __a, vector unsigned int __b) {
 910   return __a & __b;
 911 }
 912
 913 static __inline__ vector unsigned int __ATTRS_o_ai
 914 vec_and(vector bool int __a, vector unsigned int __b) {
 915   return (vector unsigned int)__a & __b;
 916 }
 917
 918 static __inline__ vector unsigned int __ATTRS_o_ai
 919 vec_and(vector unsigned int __a, vector bool int __b) {
 920   return __a & (vector unsigned int)__b;
 921 }
 922
 923 static __inline__ vector bool int __ATTRS_o_ai vec_and(vector bool int __a,
 924                                                        vector bool int __b) {
 925   return __a & __b;
 926 }
 927
 928 static __inline__ vector float __ATTRS_o_ai vec_and(vector float __a,
 929                                                     vector float __b) {
 930   vector unsigned int __res =
 931       (vector unsigned int)__a & (vector unsigned int)__b;
 932   return (vector float)__res;
 933 }
 934
 935 static __inline__ vector float __ATTRS_o_ai vec_and(vector bool int __a,
 936                                                     vector float __b) {
 937   vector unsigned int __res =
 938       (vector unsigned int)__a & (vector unsigned int)__b;
 939   return (vector float)__res;
 940 }
 941
 942 static __inline__ vector float __ATTRS_o_ai vec_and(vector float __a,
 943                                                     vector bool int __b) {
 944   vector unsigned int __res =
 945       (vector unsigned int)__a & (vector unsigned int)__b;
 946   return (vector float)__res;
 947 }
 948
 949 #ifdef __VSX__
 950 static __inline__ vector double __ATTRS_o_ai vec_and(vector bool long long __a,
 951                                                      vector double __b) {
 952   vector unsigned long long __res =
 953       (vector unsigned long long)__a & (vector unsigned long long)__b;
 954   return (vector double)__res;
 955 }
 956
 957 static __inline__ vector double __ATTRS_o_ai
 958 vec_and(vector double __a, vector bool long long __b) {
 959   vector unsigned long long __res =
 960       (vector unsigned long long)__a & (vector unsigned long long)__b;
 961   return (vector double)__res;
 962 }
 963
 964 static __inline__ vector double __ATTRS_o_ai vec_and(vector double __a,
 965                                                      vector double __b) {
 966   vector unsigned long long __res =
 967       (vector unsigned long long)__a & (vector unsigned long long)__b;
 968   return (vector double)__res;
 969 }
 970
 971 static __inline__ vector signed long long __ATTRS_o_ai
 972 vec_and(vector signed long long __a, vector signed long long __b) {
 973   return __a & __b;
 974 }
 975
 976 static __inline__ vector signed long long __ATTRS_o_ai
 977 vec_and(vector bool long long __a, vector signed long long __b) {
 978   return (vector signed long long)__a & __b;
 979 }
 980
 981 static __inline__ vector signed long long __ATTRS_o_ai
 982 vec_and(vector signed long long __a, vector bool long long __b) {
 983   return __a & (vector signed long long)__b;
 984 }
 985
 986 static __inline__ vector unsigned long long __ATTRS_o_ai
 987 vec_and(vector unsigned long long __a, vector unsigned long long __b) {
 988   return __a & __b;
 989 }
 990
 991 static __inline__ vector unsigned long long __ATTRS_o_ai
 992 vec_and(vector bool long long __a, vector unsigned long long __b) {
 993   return (vector unsigned long long)__a & __b;
 994 }
 995
 996 static __inline__ vector unsigned long long __ATTRS_o_ai
 997 vec_and(vector unsigned long long __a, vector bool long long __b) {
 998   return __a & (vector unsigned long long)__b;
 999 }
1000
1001 static __inline__ vector bool long long __ATTRS_o_ai
1002 vec_and(vector bool long long __a, vector bool long long __b) {
1003   return __a & __b;
1004 }
1005 #endif
1006
1007 /* vec_vand */
1008
1009 static __inline__ vector signed char __ATTRS_o_ai
1010 vec_vand(vector signed char __a, vector signed char __b) {
1011   return __a & __b;
1012 }
1013
1014 static __inline__ vector signed char __ATTRS_o_ai
1015 vec_vand(vector bool char __a, vector signed char __b) {
1016   return (vector signed char)__a & __b;
1017 }
1018
1019 static __inline__ vector signed char __ATTRS_o_ai
1020 vec_vand(vector signed char __a, vector bool char __b) {
1021   return __a & (vector signed char)__b;
1022 }
1023
1024 static __inline__ vector unsigned char __ATTRS_o_ai
1025 vec_vand(vector unsigned char __a, vector unsigned char __b) {
1026   return __a & __b;
1027 }
1028
1029 static __inline__ vector unsigned char __ATTRS_o_ai
1030 vec_vand(vector bool char __a, vector unsigned char __b) {
1031   return (vector unsigned char)__a & __b;
1032 }
1033
1034 static __inline__ vector unsigned char __ATTRS_o_ai
1035 vec_vand(vector unsigned char __a, vector bool char __b) {
1036   return __a & (vector unsigned char)__b;
1037 }
1038
1039 static __inline__ vector bool char __ATTRS_o_ai vec_vand(vector bool char __a,
1040                                                          vector bool char __b) {
1041   return __a & __b;
1042 }
1043
1044 static __inline__ vector short __ATTRS_o_ai vec_vand(vector short __a,
1045                                                      vector short __b) {
1046   return __a & __b;
1047 }
1048
1049 static __inline__ vector short __ATTRS_o_ai vec_vand(vector bool short __a,
1050                                                      vector short __b) {
1051   return (vector short)__a & __b;
1052 }
1053
1054 static __inline__ vector short __ATTRS_o_ai vec_vand(vector short __a,
1055                                                      vector bool short __b) {
1056   return __a & (vector short)__b;
1057 }
1058
1059 static __inline__ vector unsigned short __ATTRS_o_ai
1060 vec_vand(vector unsigned short __a, vector unsigned short __b) {
1061   return __a & __b;
1062 }
1063
1064 static __inline__ vector unsigned short __ATTRS_o_ai
1065 vec_vand(vector bool short __a, vector unsigned short __b) {
1066   return (vector unsigned short)__a & __b;
1067 }
1068
1069 static __inline__ vector unsigned short __ATTRS_o_ai
1070 vec_vand(vector unsigned short __a, vector bool short __b) {
1071   return __a & (vector unsigned short)__b;
1072 }
1073
1074 static __inline__ vector bool short __ATTRS_o_ai
1075 vec_vand(vector bool short __a, vector bool short __b) {
1076   return __a & __b;
1077 }
1078
1079 static __inline__ vector int __ATTRS_o_ai vec_vand(vector int __a,
1080                                                    vector int __b) {
1081   return __a & __b;
1082 }
1083
1084 static __inline__ vector int __ATTRS_o_ai vec_vand(vector bool int __a,
1085                                                    vector int __b) {
1086   return (vector int)__a & __b;
1087 }
1088
1089 static __inline__ vector int __ATTRS_o_ai vec_vand(vector int __a,
1090                                                    vector bool int __b) {
1091   return __a & (vector int)__b;
1092 }
1093
1094 static __inline__ vector unsigned int __ATTRS_o_ai
1095 vec_vand(vector unsigned int __a, vector unsigned int __b) {
1096   return __a & __b;
1097 }
1098
1099 static __inline__ vector unsigned int __ATTRS_o_ai
1100 vec_vand(vector bool int __a, vector unsigned int __b) {
1101   return (vector unsigned int)__a & __b;
1102 }
1103
1104 static __inline__ vector unsigned int __ATTRS_o_ai
1105 vec_vand(vector unsigned int __a, vector bool int __b) {
1106   return __a & (vector unsigned int)__b;
1107 }
1108
1109 static __inline__ vector bool int __ATTRS_o_ai vec_vand(vector bool int __a,
1110                                                         vector bool int __b) {
1111   return __a & __b;
1112 }
1113
1114 static __inline__ vector float __ATTRS_o_ai vec_vand(vector float __a,
1115                                                      vector float __b) {
1116   vector unsigned int __res =
1117       (vector unsigned int)__a & (vector unsigned int)__b;
1118   return (vector float)__res;
1119 }
1120
1121 static __inline__ vector float __ATTRS_o_ai vec_vand(vector bool int __a,
1122                                                      vector float __b) {
1123   vector unsigned int __res =
1124       (vector unsigned int)__a & (vector unsigned int)__b;
1125   return (vector float)__res;
1126 }
1127
1128 static __inline__ vector float __ATTRS_o_ai vec_vand(vector float __a,
1129                                                      vector bool int __b) {
1130   vector unsigned int __res =
1131       (vector unsigned int)__a & (vector unsigned int)__b;
1132   return (vector float)__res;
1133 }
1134
1135 #ifdef __VSX__
1136 static __inline__ vector signed long long __ATTRS_o_ai
1137 vec_vand(vector signed long long __a, vector signed long long __b) {
1138   return __a & __b;
1139 }
1140
1141 static __inline__ vector signed long long __ATTRS_o_ai
1142 vec_vand(vector bool long long __a, vector signed long long __b) {
1143   return (vector signed long long)__a & __b;
1144 }
1145
1146 static __inline__ vector signed long long __ATTRS_o_ai
1147 vec_vand(vector signed long long __a, vector bool long long __b) {
1148   return __a & (vector signed long long)__b;
1149 }
1150
1151 static __inline__ vector unsigned long long __ATTRS_o_ai
1152 vec_vand(vector unsigned long long __a, vector unsigned long long __b) {
1153   return __a & __b;
1154 }
1155
1156 static __inline__ vector unsigned long long __ATTRS_o_ai
1157 vec_vand(vector bool long long __a, vector unsigned long long __b) {
1158   return (vector unsigned long long)__a & __b;
1159 }
1160
1161 static __inline__ vector unsigned long long __ATTRS_o_ai
1162 vec_vand(vector unsigned long long __a, vector bool long long __b) {
1163   return __a & (vector unsigned long long)__b;
1164 }
1165
1166 static __inline__ vector bool long long __ATTRS_o_ai
1167 vec_vand(vector bool long long __a, vector bool long long __b) {
1168   return __a & __b;
1169 }
1170 #endif
1171
1172 /* vec_andc */
1173
1174 #define __builtin_altivec_vandc vec_andc
1175
1176 static __inline__ vector signed char __ATTRS_o_ai
1177 vec_andc(vector signed char __a, vector signed char __b) {
1178   return __a & ~__b;
1179 }
1180
1181 static __inline__ vector signed char __ATTRS_o_ai
1182 vec_andc(vector bool char __a, vector signed char __b) {
1183   return (vector signed char)__a & ~__b;
1184 }
1185
1186 static __inline__ vector signed char __ATTRS_o_ai
1187 vec_andc(vector signed char __a, vector bool char __b) {
1188   return __a & ~(vector signed char)__b;
1189 }
1190
1191 static __inline__ vector unsigned char __ATTRS_o_ai
1192 vec_andc(vector unsigned char __a, vector unsigned char __b) {
1193   return __a & ~__b;
1194 }
1195
1196 static __inline__ vector unsigned char __ATTRS_o_ai
1197 vec_andc(vector bool char __a, vector unsigned char __b) {
1198   return (vector unsigned char)__a & ~__b;
1199 }
1200
1201 static __inline__ vector unsigned char __ATTRS_o_ai
1202 vec_andc(vector unsigned char __a, vector bool char __b) {
1203   return __a & ~(vector unsigned char)__b;
1204 }
1205
1206 static __inline__ vector bool char __ATTRS_o_ai vec_andc(vector bool char __a,
1207                                                          vector bool char __b) {
1208   return __a & ~__b;
1209 }
1210
1211 static __inline__ vector short __ATTRS_o_ai vec_andc(vector short __a,
1212                                                      vector short __b) {
1213   return __a & ~__b;
1214 }
1215
1216 static __inline__ vector short __ATTRS_o_ai vec_andc(vector bool short __a,
1217                                                      vector short __b) {
1218   return (vector short)__a & ~__b;
1219 }
1220
1221 static __inline__ vector short __ATTRS_o_ai vec_andc(vector short __a,
1222                                                      vector bool short __b) {
1223   return __a & ~(vector short)__b;
1224 }
1225
1226 static __inline__ vector unsigned short __ATTRS_o_ai
1227 vec_andc(vector unsigned short __a, vector unsigned short __b) {
1228   return __a & ~__b;
1229 }
1230
1231 static __inline__ vector unsigned short __ATTRS_o_ai
1232 vec_andc(vector bool short __a, vector unsigned short __b) {
1233   return (vector unsigned short)__a & ~__b;
1234 }
1235
1236 static __inline__ vector unsigned short __ATTRS_o_ai
1237 vec_andc(vector unsigned short __a, vector bool short __b) {
1238   return __a & ~(vector unsigned short)__b;
1239 }
1240
1241 static __inline__ vector bool short __ATTRS_o_ai
1242 vec_andc(vector bool short __a, vector bool short __b) {
1243   return __a & ~__b;
1244 }
1245
1246 static __inline__ vector int __ATTRS_o_ai vec_andc(vector int __a,
1247                                                    vector int __b) {
1248   return __a & ~__b;
1249 }
1250
1251 static __inline__ vector int __ATTRS_o_ai vec_andc(vector bool int __a,
1252                                                    vector int __b) {
1253   return (vector int)__a & ~__b;
1254 }
1255
1256 static __inline__ vector int __ATTRS_o_ai vec_andc(vector int __a,
1257                                                    vector bool int __b) {
1258   return __a & ~(vector int)__b;
1259 }
1260
1261 static __inline__ vector unsigned int __ATTRS_o_ai
1262 vec_andc(vector unsigned int __a, vector unsigned int __b) {
1263   return __a & ~__b;
1264 }
1265
1266 static __inline__ vector unsigned int __ATTRS_o_ai
1267 vec_andc(vector bool int __a, vector unsigned int __b) {
1268   return (vector unsigned int)__a & ~__b;
1269 }
1270
1271 static __inline__ vector unsigned int __ATTRS_o_ai
1272 vec_andc(vector unsigned int __a, vector bool int __b) {
1273   return __a & ~(vector unsigned int)__b;
1274 }
1275
1276 static __inline__ vector bool int __ATTRS_o_ai vec_andc(vector bool int __a,
1277                                                         vector bool int __b) {
1278   return __a & ~__b;
1279 }
1280
1281 static __inline__ vector float __ATTRS_o_ai vec_andc(vector float __a,
1282                                                      vector float __b) {
1283   vector unsigned int __res =
1284       (vector unsigned int)__a & ~(vector unsigned int)__b;
1285   return (vector float)__res;
1286 }
1287
1288 static __inline__ vector float __ATTRS_o_ai vec_andc(vector bool int __a,
1289                                                      vector float __b) {
1290   vector unsigned int __res =
1291       (vector unsigned int)__a & ~(vector unsigned int)__b;
1292   return (vector float)__res;
1293 }
1294
1295 static __inline__ vector float __ATTRS_o_ai vec_andc(vector float __a,
1296                                                      vector bool int __b) {
1297   vector unsigned int __res =
1298       (vector unsigned int)__a & ~(vector unsigned int)__b;
1299   return (vector float)__res;
1300 }
1301
1302 #ifdef __VSX__
1303 static __inline__ vector double __ATTRS_o_ai vec_andc(vector bool long long __a,
1304                                                       vector double __b) {
1305   vector unsigned long long __res =
1306       (vector unsigned long long)__a & ~(vector unsigned long long)__b;
1307   return (vector double)__res;
1308 }
1309
1310 static __inline__ vector double __ATTRS_o_ai
1311 vec_andc(vector double __a, vector bool long long __b) {
1312   vector unsigned long long __res =
1313       (vector unsigned long long)__a & ~(vector unsigned long long)__b;
1314   return (vector double)__res;
1315 }
1316
1317 static __inline__ vector double __ATTRS_o_ai vec_andc(vector double __a,
1318                                                       vector double __b) {
1319   vector unsigned long long __res =
1320       (vector unsigned long long)__a & ~(vector unsigned long long)__b;
1321   return (vector double)__res;
1322 }
1323
1324 static __inline__ vector signed long long __ATTRS_o_ai
1325 vec_andc(vector signed long long __a, vector signed long long __b) {
1326   return __a & ~__b;
1327 }
1328
1329 static __inline__ vector signed long long __ATTRS_o_ai
1330 vec_andc(vector bool long long __a, vector signed long long __b) {
1331   return (vector signed long long)__a & ~__b;
1332 }
1333
1334 static __inline__ vector signed long long __ATTRS_o_ai
1335 vec_andc(vector signed long long __a, vector bool long long __b) {
1336   return __a & ~(vector signed long long)__b;
1337 }
1338
1339 static __inline__ vector unsigned long long __ATTRS_o_ai
1340 vec_andc(vector unsigned long long __a, vector unsigned long long __b) {
1341   return __a & ~__b;
1342 }
1343
1344 static __inline__ vector unsigned long long __ATTRS_o_ai
1345 vec_andc(vector bool long long __a, vector unsigned long long __b) {
1346   return (vector unsigned long long)__a & ~__b;
1347 }
1348
1349 static __inline__ vector unsigned long long __ATTRS_o_ai
1350 vec_andc(vector unsigned long long __a, vector bool long long __b) {
1351   return __a & ~(vector unsigned long long)__b;
1352 }
1353
1354 static __inline__ vector bool long long __ATTRS_o_ai
1355 vec_andc(vector bool long long __a, vector bool long long __b) {
1356   return __a & ~__b;
1357 }
1358 #endif
1359
1360 /* vec_vandc */
1361
1362 static __inline__ vector signed char __ATTRS_o_ai
1363 vec_vandc(vector signed char __a, vector signed char __b) {
1364   return __a & ~__b;
1365 }
1366
1367 static __inline__ vector signed char __ATTRS_o_ai
1368 vec_vandc(vector bool char __a, vector signed char __b) {
1369   return (vector signed char)__a & ~__b;
1370 }
1371
1372 static __inline__ vector signed char __ATTRS_o_ai
1373 vec_vandc(vector signed char __a, vector bool char __b) {
1374   return __a & ~(vector signed char)__b;
1375 }
1376
1377 static __inline__ vector unsigned char __ATTRS_o_ai
1378 vec_vandc(vector unsigned char __a, vector unsigned char __b) {
1379   return __a & ~__b;
1380 }
1381
1382 static __inline__ vector unsigned char __ATTRS_o_ai
1383 vec_vandc(vector bool char __a, vector unsigned char __b) {
1384   return (vector unsigned char)__a & ~__b;
1385 }
1386
1387 static __inline__ vector unsigned char __ATTRS_o_ai
1388 vec_vandc(vector unsigned char __a, vector bool char __b) {
1389   return __a & ~(vector unsigned char)__b;
1390 }
1391
1392 static __inline__ vector bool char __ATTRS_o_ai
1393 vec_vandc(vector bool char __a, vector bool char __b) {
1394   return __a & ~__b;
1395 }
1396
1397 static __inline__ vector short __ATTRS_o_ai vec_vandc(vector short __a,
1398                                                       vector short __b) {
1399   return __a & ~__b;
1400 }
1401
1402 static __inline__ vector short __ATTRS_o_ai vec_vandc(vector bool short __a,
1403                                                       vector short __b) {
1404   return (vector short)__a & ~__b;
1405 }
1406
1407 static __inline__ vector short __ATTRS_o_ai vec_vandc(vector short __a,
1408                                                       vector bool short __b) {
1409   return __a & ~(vector short)__b;
1410 }
1411
1412 static __inline__ vector unsigned short __ATTRS_o_ai
1413 vec_vandc(vector unsigned short __a, vector unsigned short __b) {
1414   return __a & ~__b;
1415 }
1416
1417 static __inline__ vector unsigned short __ATTRS_o_ai
1418 vec_vandc(vector bool short __a, vector unsigned short __b) {
1419   return (vector unsigned short)__a & ~__b;
1420 }
1421
1422 static __inline__ vector unsigned short __ATTRS_o_ai
1423 vec_vandc(vector unsigned short __a, vector bool short __b) {
1424   return __a & ~(vector unsigned short)__b;
1425 }
1426
1427 static __inline__ vector bool short __ATTRS_o_ai
1428 vec_vandc(vector bool short __a, vector bool short __b) {
1429   return __a & ~__b;
1430 }
1431
1432 static __inline__ vector int __ATTRS_o_ai vec_vandc(vector int __a,
1433                                                     vector int __b) {
1434   return __a & ~__b;
1435 }
1436
1437 static __inline__ vector int __ATTRS_o_ai vec_vandc(vector bool int __a,
1438                                                     vector int __b) {
1439   return (vector int)__a & ~__b;
1440 }
1441
1442 static __inline__ vector int __ATTRS_o_ai vec_vandc(vector int __a,
1443                                                     vector bool int __b) {
1444   return __a & ~(vector int)__b;
1445 }
1446
1447 static __inline__ vector unsigned int __ATTRS_o_ai
1448 vec_vandc(vector unsigned int __a, vector unsigned int __b) {
1449   return __a & ~__b;
1450 }
1451
1452 static __inline__ vector unsigned int __ATTRS_o_ai
1453 vec_vandc(vector bool int __a, vector unsigned int __b) {
1454   return (vector unsigned int)__a & ~__b;
1455 }
1456
1457 static __inline__ vector unsigned int __ATTRS_o_ai
1458 vec_vandc(vector unsigned int __a, vector bool int __b) {
1459   return __a & ~(vector unsigned int)__b;
1460 }
1461
1462 static __inline__ vector bool int __ATTRS_o_ai vec_vandc(vector bool int __a,
1463                                                          vector bool int __b) {
1464   return __a & ~__b;
1465 }
1466
1467 static __inline__ vector float __ATTRS_o_ai vec_vandc(vector float __a,
1468                                                       vector float __b) {
1469   vector unsigned int __res =
1470       (vector unsigned int)__a & ~(vector unsigned int)__b;
1471   return (vector float)__res;
1472 }
1473
1474 static __inline__ vector float __ATTRS_o_ai vec_vandc(vector bool int __a,
1475                                                       vector float __b) {
1476   vector unsigned int __res =
1477       (vector unsigned int)__a & ~(vector unsigned int)__b;
1478   return (vector float)__res;
1479 }
1480
1481 static __inline__ vector float __ATTRS_o_ai vec_vandc(vector float __a,
1482                                                       vector bool int __b) {
1483   vector unsigned int __res =
1484       (vector unsigned int)__a & ~(vector unsigned int)__b;
1485   return (vector float)__res;
1486 }
1487
1488 #ifdef __VSX__
1489 static __inline__ vector signed long long __ATTRS_o_ai
1490 vec_vandc(vector signed long long __a, vector signed long long __b) {
1491   return __a & ~__b;
1492 }
1493
1494 static __inline__ vector signed long long __ATTRS_o_ai
1495 vec_vandc(vector bool long long __a, vector signed long long __b) {
1496   return (vector signed long long)__a & ~__b;
1497 }
1498
1499 static __inline__ vector signed long long __ATTRS_o_ai
1500 vec_vandc(vector signed long long __a, vector bool long long __b) {
1501   return __a & ~(vector signed long long)__b;
1502 }
1503
1504 static __inline__ vector unsigned long long __ATTRS_o_ai
1505 vec_vandc(vector unsigned long long __a, vector unsigned long long __b) {
1506   return __a & ~__b;
1507 }
1508
1509 static __inline__ vector unsigned long long __ATTRS_o_ai
1510 vec_vandc(vector bool long long __a, vector unsigned long long __b) {
1511   return (vector unsigned long long)__a & ~__b;
1512 }
1513
1514 static __inline__ vector unsigned long long __ATTRS_o_ai
1515 vec_vandc(vector unsigned long long __a, vector bool long long __b) {
1516   return __a & ~(vector unsigned long long)__b;
1517 }
1518
1519 static __inline__ vector bool long long __ATTRS_o_ai
1520 vec_vandc(vector bool long long __a, vector bool long long __b) {
1521   return __a & ~__b;
1522 }
1523 #endif
1524
1525 /* vec_avg */
1526
1527 static __inline__ vector signed char __ATTRS_o_ai
1528 vec_avg(vector signed char __a, vector signed char __b) {
1529   return __builtin_altivec_vavgsb(__a, __b);
1530 }
1531
1532 static __inline__ vector unsigned char __ATTRS_o_ai
1533 vec_avg(vector unsigned char __a, vector unsigned char __b) {
1534   return __builtin_altivec_vavgub(__a, __b);
1535 }
1536
1537 static __inline__ vector short __ATTRS_o_ai vec_avg(vector short __a,
1538                                                     vector short __b) {
1539   return __builtin_altivec_vavgsh(__a, __b);
1540 }
1541
1542 static __inline__ vector unsigned short __ATTRS_o_ai
1543 vec_avg(vector unsigned short __a, vector unsigned short __b) {
1544   return __builtin_altivec_vavguh(__a, __b);
1545 }
1546
1547 static __inline__ vector int __ATTRS_o_ai vec_avg(vector int __a,
1548                                                   vector int __b) {
1549   return __builtin_altivec_vavgsw(__a, __b);
1550 }
1551
1552 static __inline__ vector unsigned int __ATTRS_o_ai
1553 vec_avg(vector unsigned int __a, vector unsigned int __b) {
1554   return __builtin_altivec_vavguw(__a, __b);
1555 }
1556
1557 /* vec_vavgsb */
1558
1559 static __inline__ vector signed char __attribute__((__always_inline__))
1560 vec_vavgsb(vector signed char __a, vector signed char __b) {
1561   return __builtin_altivec_vavgsb(__a, __b);
1562 }
1563
1564 /* vec_vavgub */
1565
1566 static __inline__ vector unsigned char __attribute__((__always_inline__))
1567 vec_vavgub(vector unsigned char __a, vector unsigned char __b) {
1568   return __builtin_altivec_vavgub(__a, __b);
1569 }
1570
1571 /* vec_vavgsh */
1572
1573 static __inline__ vector short __attribute__((__always_inline__))
1574 vec_vavgsh(vector short __a, vector short __b) {
1575   return __builtin_altivec_vavgsh(__a, __b);
1576 }
1577
1578 /* vec_vavguh */
1579
1580 static __inline__ vector unsigned short __attribute__((__always_inline__))
1581 vec_vavguh(vector unsigned short __a, vector unsigned short __b) {
1582   return __builtin_altivec_vavguh(__a, __b);
1583 }
1584
1585 /* vec_vavgsw */
1586
1587 static __inline__ vector int __attribute__((__always_inline__))
1588 vec_vavgsw(vector int __a, vector int __b) {
1589   return __builtin_altivec_vavgsw(__a, __b);
1590 }
1591
1592 /* vec_vavguw */
1593
1594 static __inline__ vector unsigned int __attribute__((__always_inline__))
1595 vec_vavguw(vector unsigned int __a, vector unsigned int __b) {
1596   return __builtin_altivec_vavguw(__a, __b);
1597 }
1598
1599 /* vec_ceil */
1600
1601 static __inline__ vector float __ATTRS_o_ai vec_ceil(vector float __a) {
1602 #ifdef __VSX__
1603   return __builtin_vsx_xvrspip(__a);
1604 #else
1605   return __builtin_altivec_vrfip(__a);
1606 #endif
1607 }
1608
1609 #ifdef __VSX__
1610 static __inline__ vector double __ATTRS_o_ai vec_ceil(vector double __a) {
1611   return __builtin_vsx_xvrdpip(__a);
1612 }
1613 #endif
1614
1615 /* vec_vrfip */
1616
1617 static __inline__ vector float __attribute__((__always_inline__))
1618 vec_vrfip(vector float __a) {
1619   return __builtin_altivec_vrfip(__a);
1620 }
1621
1622 /* vec_cmpb */
1623
1624 static __inline__ vector int __attribute__((__always_inline__))
1625 vec_cmpb(vector float __a, vector float __b) {
1626   return __builtin_altivec_vcmpbfp(__a, __b);
1627 }
1628
1629 /* vec_vcmpbfp */
1630
1631 static __inline__ vector int __attribute__((__always_inline__))
1632 vec_vcmpbfp(vector float __a, vector float __b) {
1633   return __builtin_altivec_vcmpbfp(__a, __b);
1634 }
1635
1636 /* vec_cmpeq */
1637
1638 static __inline__ vector bool char __ATTRS_o_ai
1639 vec_cmpeq(vector signed char __a, vector signed char __b) {
1640   return (vector bool char)__builtin_altivec_vcmpequb((vector char)__a,
1641                                                       (vector char)__b);
1642 }
1643
1644 static __inline__ vector bool char __ATTRS_o_ai
1645 vec_cmpeq(vector unsigned char __a, vector unsigned char __b) {
1646   return (vector bool char)__builtin_altivec_vcmpequb((vector char)__a,
1647                                                       (vector char)__b);
1648 }
1649
1650 static __inline__ vector bool char __ATTRS_o_ai
1651 vec_cmpeq(vector bool char __a, vector bool char __b) {
1652   return (vector bool char)__builtin_altivec_vcmpequb((vector char)__a,
1653                                                       (vector char)__b);
1654 }
1655
1656 static __inline__ vector bool short __ATTRS_o_ai vec_cmpeq(vector short __a,
1657                                                            vector short __b) {
1658   return (vector bool short)__builtin_altivec_vcmpequh(__a, __b);
1659 }
1660
1661 static __inline__ vector bool short __ATTRS_o_ai
1662 vec_cmpeq(vector unsigned short __a, vector unsigned short __b) {
1663   return (vector bool short)__builtin_altivec_vcmpequh((vector short)__a,
1664                                                        (vector short)__b);
1665 }
1666
1667 static __inline__ vector bool short __ATTRS_o_ai
1668 vec_cmpeq(vector bool short __a, vector bool short __b) {
1669   return (vector bool short)__builtin_altivec_vcmpequh((vector short)__a,
1670                                                        (vector short)__b);
1671 }
1672
1673 static __inline__ vector bool int __ATTRS_o_ai vec_cmpeq(vector int __a,
1674                                                          vector int __b) {
1675   return (vector bool int)__builtin_altivec_vcmpequw(__a, __b);
1676 }
1677
1678 static __inline__ vector bool int __ATTRS_o_ai
1679 vec_cmpeq(vector unsigned int __a, vector unsigned int __b) {
1680   return (vector bool int)__builtin_altivec_vcmpequw((vector int)__a,
1681                                                      (vector int)__b);
1682 }
1683
1684 static __inline__ vector bool int __ATTRS_o_ai vec_cmpeq(vector bool int __a,
1685                                                          vector bool int __b) {
1686   return (vector bool int)__builtin_altivec_vcmpequw((vector int)__a,
1687                                                      (vector int)__b);
1688 }
1689
1690 #ifdef __POWER8_VECTOR__
1691 static __inline__ vector bool long long __ATTRS_o_ai
1692 vec_cmpeq(vector signed long long __a, vector signed long long __b) {
1693   return (vector bool long long)__builtin_altivec_vcmpequd(__a, __b);
1694 }
1695
1696 static __inline__ vector bool long long __ATTRS_o_ai
1697 vec_cmpeq(vector unsigned long long __a, vector unsigned long long __b) {
1698   return (vector bool long long)__builtin_altivec_vcmpequd(
1699       (vector long long)__a, (vector long long)__b);
1700 }
1701
1702 static __inline__ vector bool long long __ATTRS_o_ai
1703 vec_cmpeq(vector bool long long __a, vector bool long long __b) {
1704   return (vector bool long long)__builtin_altivec_vcmpequd(
1705       (vector long long)__a, (vector long long)__b);
1706 }
1707
1708 #endif
1709
1710 static __inline__ vector bool int __ATTRS_o_ai vec_cmpeq(vector float __a,
1711                                                          vector float __b) {
1712 #ifdef __VSX__
1713   return (vector bool int)__builtin_vsx_xvcmpeqsp(__a, __b);
1714 #else
1715   return (vector bool int)__builtin_altivec_vcmpeqfp(__a, __b);
1716 #endif
1717 }
1718
1719 #ifdef __VSX__
1720 static __inline__ vector bool long long __ATTRS_o_ai
1721 vec_cmpeq(vector double __a, vector double __b) {
1722   return (vector bool long long)__builtin_vsx_xvcmpeqdp(__a, __b);
1723 }
1724 #endif
1725
1726 #ifdef __POWER9_VECTOR__
1727 /* vec_cmpne */
1728
1729 static __inline__ vector bool char __ATTRS_o_ai
1730 vec_cmpne(vector bool char __a, vector bool char __b) {
1731   return (vector bool char)__builtin_altivec_vcmpneb((vector char)__a,
1732                                                      (vector char)__b);
1733 }
1734
1735 static __inline__ vector bool char __ATTRS_o_ai
1736 vec_cmpne(vector signed char __a, vector signed char __b) {
1737   return (vector bool char)__builtin_altivec_vcmpneb((vector char)__a,
1738                                                      (vector char)__b);
1739 }
1740
1741 static __inline__ vector bool char __ATTRS_o_ai
1742 vec_cmpne(vector unsigned char __a, vector unsigned char __b) {
1743   return (vector bool char)__builtin_altivec_vcmpneb((vector char)__a,
1744                                                      (vector char)__b);
1745 }
1746
1747 static __inline__ vector bool short __ATTRS_o_ai
1748 vec_cmpne(vector bool short __a, vector bool short __b) {
1749   return (vector bool short)__builtin_altivec_vcmpneh((vector short)__a,
1750                                                       (vector short)__b);
1751 }
1752
1753 static __inline__ vector bool short __ATTRS_o_ai
1754 vec_cmpne(vector signed short __a, vector signed short __b) {
1755   return (vector bool short)__builtin_altivec_vcmpneh((vector short)__a,
1756                                                       (vector short)__b);
1757 }
1758
1759 static __inline__ vector bool short __ATTRS_o_ai
1760 vec_cmpne(vector unsigned short __a, vector unsigned short __b) {
1761   return (vector bool short)__builtin_altivec_vcmpneh((vector short)__a,
1762                                                       (vector short)__b);
1763 }
1764
1765 static __inline__ vector bool int __ATTRS_o_ai
1766 vec_cmpne(vector bool int __a, vector bool int __b) {
1767   return (vector bool int)__builtin_altivec_vcmpnew((vector int)__a,
1768                                                     (vector int)__b);
1769 }
1770
1771 static __inline__ vector bool int __ATTRS_o_ai
1772 vec_cmpne(vector signed int __a, vector signed int __b) {
1773   return (vector bool int)__builtin_altivec_vcmpnew((vector int)__a,
1774                                                     (vector int)__b);
1775 }
1776
1777 static __inline__ vector bool int __ATTRS_o_ai
1778 vec_cmpne(vector unsigned int __a, vector unsigned int __b) {
1779   return (vector bool int)__builtin_altivec_vcmpnew((vector int)__a,
1780                                                     (vector int)__b);
1781 }
1782
1783 static __inline__ vector bool long long __ATTRS_o_ai
1784 vec_cmpne(vector bool long long __a, vector bool long long __b) {
1785   return (vector bool long long)
1786     ~(__builtin_altivec_vcmpequd((vector long long)__a, (vector long long)__b));
1787 }
1788
1789 static __inline__ vector bool long long __ATTRS_o_ai
1790 vec_cmpne(vector signed long long __a, vector signed long long __b) {
1791   return (vector bool long long)
1792     ~(__builtin_altivec_vcmpequd((vector long long)__a, (vector long long)__b));
1793 }
1794
1795 static __inline__ vector bool long long __ATTRS_o_ai
1796 vec_cmpne(vector unsigned long long __a, vector unsigned long long __b) {
1797   return (vector bool long long)
1798     ~(__builtin_altivec_vcmpequd((vector long long)__a, (vector long long)__b));
1799 }
1800
1801 static __inline__ vector bool int __ATTRS_o_ai
1802 vec_cmpne(vector float __a, vector float __b) {
1803   return (vector bool int)__builtin_altivec_vcmpnew((vector int)__a,
1804                                                     (vector int)__b);
1805 }
1806
1807 static __inline__ vector bool long long __ATTRS_o_ai
1808 vec_cmpne(vector double __a, vector double __b) {
1809   return (vector bool long long)
1810     ~(__builtin_altivec_vcmpequd((vector long long)__a, (vector long long)__b));
1811 }
1812
1813 /* vec_cmpnez */
1814
1815 static __inline__ vector bool char __ATTRS_o_ai
1816 vec_cmpnez(vector signed char __a, vector signed char __b) {
1817   return (vector bool char)__builtin_altivec_vcmpnezb((vector char)__a,
1818                                                       (vector char)__b);
1819 }
1820
1821 static __inline__ vector bool char __ATTRS_o_ai
1822 vec_cmpnez(vector unsigned char __a, vector unsigned char __b) {
1823   return (vector bool char)__builtin_altivec_vcmpnezb((vector char)__a,
1824                                                       (vector char)__b);
1825 }
1826
1827 static __inline__ vector bool short __ATTRS_o_ai
1828 vec_cmpnez(vector signed short __a, vector signed short __b) {
1829   return (vector bool short)__builtin_altivec_vcmpnezh((vector short)__a,
1830                                                        (vector short)__b);
1831 }
1832
1833 static __inline__ vector bool short __ATTRS_o_ai
1834 vec_cmpnez(vector unsigned short __a, vector unsigned short __b) {
1835   return (vector bool short)__builtin_altivec_vcmpnezh((vector short)__a,
1836                                                        (vector short)__b);
1837 }
1838
1839 static __inline__ vector bool int __ATTRS_o_ai
1840 vec_cmpnez(vector signed int __a, vector signed int __b) {
1841   return (vector bool int)__builtin_altivec_vcmpnezw((vector int)__a,
1842                                                      (vector int)__b);
1843 }
1844
1845 static __inline__ vector bool int __ATTRS_o_ai
1846 vec_cmpnez(vector unsigned int __a, vector unsigned int __b) {
1847   return (vector bool int)__builtin_altivec_vcmpnezw((vector int)__a,
1848                                                      (vector int)__b);
1849 }
1850
1851 static __inline__ signed int __ATTRS_o_ai
1852 vec_cntlz_lsbb(vector signed char __a) {
1853 #ifdef __LITTLE_ENDIAN__
1854   return __builtin_altivec_vctzlsbb(__a);
1855 #else
1856   return __builtin_altivec_vclzlsbb(__a);
1857 #endif
1858 }
1859
1860 static __inline__ signed int __ATTRS_o_ai
1861 vec_cntlz_lsbb(vector unsigned char __a) {
1862 #ifdef __LITTLE_ENDIAN__
1863   return __builtin_altivec_vctzlsbb(__a);
1864 #else
1865   return __builtin_altivec_vclzlsbb(__a);
1866 #endif
1867 }
1868
1869 static __inline__ signed int __ATTRS_o_ai
1870 vec_cnttz_lsbb(vector signed char __a) {
1871 #ifdef __LITTLE_ENDIAN__
1872   return __builtin_altivec_vclzlsbb(__a);
1873 #else
1874   return __builtin_altivec_vctzlsbb(__a);
1875 #endif
1876 }
1877
1878 static __inline__ signed int __ATTRS_o_ai
1879 vec_cnttz_lsbb(vector unsigned char __a) {
1880 #ifdef __LITTLE_ENDIAN__
1881   return __builtin_altivec_vclzlsbb(__a);
1882 #else
1883   return __builtin_altivec_vctzlsbb(__a);
1884 #endif
1885 }
1886
1887 static __inline__ vector unsigned int __ATTRS_o_ai
1888 vec_parity_lsbb(vector unsigned int __a) {
1889   return __builtin_altivec_vprtybw(__a);
1890 }
1891
1892 static __inline__ vector unsigned int __ATTRS_o_ai
1893 vec_parity_lsbb(vector signed int __a) {
1894   return __builtin_altivec_vprtybw(__a);
1895 }
1896
1897 static __inline__ vector unsigned __int128 __ATTRS_o_ai
1898 vec_parity_lsbb(vector unsigned __int128 __a) {
1899   return __builtin_altivec_vprtybq(__a);
1900 }
1901
1902 static __inline__ vector unsigned __int128 __ATTRS_o_ai
1903 vec_parity_lsbb(vector signed __int128 __a) {
1904   return __builtin_altivec_vprtybq(__a);
1905 }
1906
1907 static __inline__ vector unsigned long long __ATTRS_o_ai
1908 vec_parity_lsbb(vector unsigned long long __a) {
1909   return __builtin_altivec_vprtybd(__a);
1910 }
1911
1912 static __inline__ vector unsigned long long __ATTRS_o_ai
1913 vec_parity_lsbb(vector signed long long __a) {
1914   return __builtin_altivec_vprtybd(__a);
1915 }
1916
1917 #endif
1918
1919 /* vec_cmpgt */
1920
1921 static __inline__ vector bool char __ATTRS_o_ai
1922 vec_cmpgt(vector signed char __a, vector signed char __b) {
1923   return (vector bool char)__builtin_altivec_vcmpgtsb(__a, __b);
1924 }
1925
1926 static __inline__ vector bool char __ATTRS_o_ai
1927 vec_cmpgt(vector unsigned char __a, vector unsigned char __b) {
1928   return (vector bool char)__builtin_altivec_vcmpgtub(__a, __b);
1929 }
1930
1931 static __inline__ vector bool short __ATTRS_o_ai vec_cmpgt(vector short __a,
1932                                                            vector short __b) {
1933   return (vector bool short)__builtin_altivec_vcmpgtsh(__a, __b);
1934 }
1935
1936 static __inline__ vector bool short __ATTRS_o_ai
1937 vec_cmpgt(vector unsigned short __a, vector unsigned short __b) {
1938   return (vector bool short)__builtin_altivec_vcmpgtuh(__a, __b);
1939 }
1940
1941 static __inline__ vector bool int __ATTRS_o_ai vec_cmpgt(vector int __a,
1942                                                          vector int __b) {
1943   return (vector bool int)__builtin_altivec_vcmpgtsw(__a, __b);
1944 }
1945
1946 static __inline__ vector bool int __ATTRS_o_ai
1947 vec_cmpgt(vector unsigned int __a, vector unsigned int __b) {
1948   return (vector bool int)__builtin_altivec_vcmpgtuw(__a, __b);
1949 }
1950
1951 #ifdef __POWER8_VECTOR__
1952 static __inline__ vector bool long long __ATTRS_o_ai
1953 vec_cmpgt(vector signed long long __a, vector signed long long __b) {
1954   return (vector bool long long)__builtin_altivec_vcmpgtsd(__a, __b);
1955 }
1956
1957 static __inline__ vector bool long long __ATTRS_o_ai
1958 vec_cmpgt(vector unsigned long long __a, vector unsigned long long __b) {
1959   return (vector bool long long)__builtin_altivec_vcmpgtud(__a, __b);
1960 }
1961 #endif
1962
1963 static __inline__ vector bool int __ATTRS_o_ai vec_cmpgt(vector float __a,
1964                                                          vector float __b) {
1965 #ifdef __VSX__
1966   return (vector bool int)__builtin_vsx_xvcmpgtsp(__a, __b);
1967 #else
1968   return (vector bool int)__builtin_altivec_vcmpgtfp(__a, __b);
1969 #endif
1970 }
1971
1972 #ifdef __VSX__
1973 static __inline__ vector bool long long __ATTRS_o_ai
1974 vec_cmpgt(vector double __a, vector double __b) {
1975   return (vector bool long long)__builtin_vsx_xvcmpgtdp(__a, __b);
1976 }
1977 #endif
1978
1979 /* vec_cmpge */
1980
1981 static __inline__ vector bool char __ATTRS_o_ai
1982 vec_cmpge(vector signed char __a, vector signed char __b) {
1983   return ~(vec_cmpgt(__b, __a));
1984 }
1985
1986 static __inline__ vector bool char __ATTRS_o_ai
1987 vec_cmpge(vector unsigned char __a, vector unsigned char __b) {
1988   return ~(vec_cmpgt(__b, __a));
1989 }
1990
1991 static __inline__ vector bool short __ATTRS_o_ai
1992 vec_cmpge(vector signed short __a, vector signed short __b) {
1993   return ~(vec_cmpgt(__b, __a));
1994 }
1995
1996 static __inline__ vector bool short __ATTRS_o_ai
1997 vec_cmpge(vector unsigned short __a, vector unsigned short __b) {
1998   return ~(vec_cmpgt(__b, __a));
1999 }
2000
2001 static __inline__ vector bool int __ATTRS_o_ai
2002 vec_cmpge(vector signed int __a, vector signed int __b) {
2003   return ~(vec_cmpgt(__b, __a));
2004 }
2005
2006 static __inline__ vector bool int __ATTRS_o_ai
2007 vec_cmpge(vector unsigned int __a, vector unsigned int __b) {
2008   return ~(vec_cmpgt(__b, __a));
2009 }
2010
2011 static __inline__ vector bool int __ATTRS_o_ai vec_cmpge(vector float __a,
2012                                                          vector float __b) {
2013 #ifdef __VSX__
2014   return (vector bool int)__builtin_vsx_xvcmpgesp(__a, __b);
2015 #else
2016   return (vector bool int)__builtin_altivec_vcmpgefp(__a, __b);
2017 #endif
2018 }
2019
2020 #ifdef __VSX__
2021 static __inline__ vector bool long long __ATTRS_o_ai
2022 vec_cmpge(vector double __a, vector double __b) {
2023   return (vector bool long long)__builtin_vsx_xvcmpgedp(__a, __b);
2024 }
2025 #endif
2026
2027 #ifdef __POWER8_VECTOR__
2028 static __inline__ vector bool long long __ATTRS_o_ai
2029 vec_cmpge(vector signed long long __a, vector signed long long __b) {
2030   return ~(vec_cmpgt(__b, __a));
2031 }
2032
2033 static __inline__ vector bool long long __ATTRS_o_ai
2034 vec_cmpge(vector unsigned long long __a, vector unsigned long long __b) {
2035   return ~(vec_cmpgt(__b, __a));
2036 }
2037 #endif
2038
2039 /* vec_vcmpgefp */
2040
2041 static __inline__ vector bool int __attribute__((__always_inline__))
2042 vec_vcmpgefp(vector float __a, vector float __b) {
2043   return (vector bool int)__builtin_altivec_vcmpgefp(__a, __b);
2044 }
2045
2046 /* vec_vcmpgtsb */
2047
2048 static __inline__ vector bool char __attribute__((__always_inline__))
2049 vec_vcmpgtsb(vector signed char __a, vector signed char __b) {
2050   return (vector bool char)__builtin_altivec_vcmpgtsb(__a, __b);
2051 }
2052
2053 /* vec_vcmpgtub */
2054
2055 static __inline__ vector bool char __attribute__((__always_inline__))
2056 vec_vcmpgtub(vector unsigned char __a, vector unsigned char __b) {
2057   return (vector bool char)__builtin_altivec_vcmpgtub(__a, __b);
2058 }
2059
2060 /* vec_vcmpgtsh */
2061
2062 static __inline__ vector bool short __attribute__((__always_inline__))
2063 vec_vcmpgtsh(vector short __a, vector short __b) {
2064   return (vector bool short)__builtin_altivec_vcmpgtsh(__a, __b);
2065 }
2066
2067 /* vec_vcmpgtuh */
2068
2069 static __inline__ vector bool short __attribute__((__always_inline__))
2070 vec_vcmpgtuh(vector unsigned short __a, vector unsigned short __b) {
2071   return (vector bool short)__builtin_altivec_vcmpgtuh(__a, __b);
2072 }
2073
2074 /* vec_vcmpgtsw */
2075
2076 static __inline__ vector bool int __attribute__((__always_inline__))
2077 vec_vcmpgtsw(vector int __a, vector int __b) {
2078   return (vector bool int)__builtin_altivec_vcmpgtsw(__a, __b);
2079 }
2080
2081 /* vec_vcmpgtuw */
2082
2083 static __inline__ vector bool int __attribute__((__always_inline__))
2084 vec_vcmpgtuw(vector unsigned int __a, vector unsigned int __b) {
2085   return (vector bool int)__builtin_altivec_vcmpgtuw(__a, __b);
2086 }
2087
2088 /* vec_vcmpgtfp */
2089
2090 static __inline__ vector bool int __attribute__((__always_inline__))
2091 vec_vcmpgtfp(vector float __a, vector float __b) {
2092   return (vector bool int)__builtin_altivec_vcmpgtfp(__a, __b);
2093 }
2094
2095 /* vec_cmple */
2096
2097 static __inline__ vector bool char __ATTRS_o_ai
2098 vec_cmple(vector signed char __a, vector signed char __b) {
2099   return vec_cmpge(__b, __a);
2100 }
2101
2102 static __inline__ vector bool char __ATTRS_o_ai
2103 vec_cmple(vector unsigned char __a, vector unsigned char __b) {
2104   return vec_cmpge(__b, __a);
2105 }
2106
2107 static __inline__ vector bool short __ATTRS_o_ai
2108 vec_cmple(vector signed short __a, vector signed short __b) {
2109   return vec_cmpge(__b, __a);
2110 }
2111
2112 static __inline__ vector bool short __ATTRS_o_ai
2113 vec_cmple(vector unsigned short __a, vector unsigned short __b) {
2114   return vec_cmpge(__b, __a);
2115 }
2116
2117 static __inline__ vector bool int __ATTRS_o_ai
2118 vec_cmple(vector signed int __a, vector signed int __b) {
2119   return vec_cmpge(__b, __a);
2120 }
2121
2122 static __inline__ vector bool int __ATTRS_o_ai
2123 vec_cmple(vector unsigned int __a, vector unsigned int __b) {
2124   return vec_cmpge(__b, __a);
2125 }
2126
2127 static __inline__ vector bool int __ATTRS_o_ai vec_cmple(vector float __a,
2128                                                          vector float __b) {
2129   return vec_cmpge(__b, __a);
2130 }
2131
2132 #ifdef __VSX__
2133 static __inline__ vector bool long long __ATTRS_o_ai
2134 vec_cmple(vector double __a, vector double __b) {
2135   return vec_cmpge(__b, __a);
2136 }
2137 #endif
2138
2139 #ifdef __POWER8_VECTOR__
2140 static __inline__ vector bool long long __ATTRS_o_ai
2141 vec_cmple(vector signed long long __a, vector signed long long __b) {
2142   return vec_cmpge(__b, __a);
2143 }
2144
2145 static __inline__ vector bool long long __ATTRS_o_ai
2146 vec_cmple(vector unsigned long long __a, vector unsigned long long __b) {
2147   return vec_cmpge(__b, __a);
2148 }
2149 #endif
2150
2151 /* vec_cmplt */
2152
2153 static __inline__ vector bool char __ATTRS_o_ai
2154 vec_cmplt(vector signed char __a, vector signed char __b) {
2155   return vec_cmpgt(__b, __a);
2156 }
2157
2158 static __inline__ vector bool char __ATTRS_o_ai
2159 vec_cmplt(vector unsigned char __a, vector unsigned char __b) {
2160   return vec_cmpgt(__b, __a);
2161 }
2162
2163 static __inline__ vector bool short __ATTRS_o_ai vec_cmplt(vector short __a,
2164                                                            vector short __b) {
2165   return vec_cmpgt(__b, __a);
2166 }
2167
2168 static __inline__ vector bool short __ATTRS_o_ai
2169 vec_cmplt(vector unsigned short __a, vector unsigned short __b) {
2170   return vec_cmpgt(__b, __a);
2171 }
2172
2173 static __inline__ vector bool int __ATTRS_o_ai vec_cmplt(vector int __a,
2174                                                          vector int __b) {
2175   return vec_cmpgt(__b, __a);
2176 }
2177
2178 static __inline__ vector bool int __ATTRS_o_ai
2179 vec_cmplt(vector unsigned int __a, vector unsigned int __b) {
2180   return vec_cmpgt(__b, __a);
2181 }
2182
2183 static __inline__ vector bool int __ATTRS_o_ai vec_cmplt(vector float __a,
2184                                                          vector float __b) {
2185   return vec_cmpgt(__b, __a);
2186 }
2187
2188 #ifdef __VSX__
2189 static __inline__ vector bool long long __ATTRS_o_ai
2190 vec_cmplt(vector double __a, vector double __b) {
2191   return vec_cmpgt(__b, __a);
2192 }
2193 #endif
2194
2195 #ifdef __POWER8_VECTOR__
2196 static __inline__ vector bool long long __ATTRS_o_ai
2197 vec_cmplt(vector signed long long __a, vector signed long long __b) {
2198   return vec_cmpgt(__b, __a);
2199 }
2200
2201 static __inline__ vector bool long long __ATTRS_o_ai
2202 vec_cmplt(vector unsigned long long __a, vector unsigned long long __b) {
2203   return vec_cmpgt(__b, __a);
2204 }
2205
2206 /* vec_popcnt */
2207
2208 static __inline__ vector signed char __ATTRS_o_ai
2209 vec_popcnt(vector signed char __a) {
2210   return __builtin_altivec_vpopcntb(__a);
2211 }
2212 static __inline__ vector unsigned char __ATTRS_o_ai
2213 vec_popcnt(vector unsigned char __a) {
2214   return __builtin_altivec_vpopcntb(__a);
2215 }
2216 static __inline__ vector signed short __ATTRS_o_ai
2217 vec_popcnt(vector signed short __a) {
2218   return __builtin_altivec_vpopcnth(__a);
2219 }
2220 static __inline__ vector unsigned short __ATTRS_o_ai
2221 vec_popcnt(vector unsigned short __a) {
2222   return __builtin_altivec_vpopcnth(__a);
2223 }
2224 static __inline__ vector signed int __ATTRS_o_ai
2225 vec_popcnt(vector signed int __a) {
2226   return __builtin_altivec_vpopcntw(__a);
2227 }
2228 static __inline__ vector unsigned int __ATTRS_o_ai
2229 vec_popcnt(vector unsigned int __a) {
2230   return __builtin_altivec_vpopcntw(__a);
2231 }
2232 static __inline__ vector signed long long __ATTRS_o_ai
2233 vec_popcnt(vector signed long long __a) {
2234   return __builtin_altivec_vpopcntd(__a);
2235 }
2236 static __inline__ vector unsigned long long __ATTRS_o_ai
2237 vec_popcnt(vector unsigned long long __a) {
2238   return __builtin_altivec_vpopcntd(__a);
2239 }
2240
2241 /* vec_cntlz */
2242
2243 static __inline__ vector signed char __ATTRS_o_ai
2244 vec_cntlz(vector signed char __a) {
2245   return __builtin_altivec_vclzb(__a);
2246 }
2247 static __inline__ vector unsigned char __ATTRS_o_ai
2248 vec_cntlz(vector unsigned char __a) {
2249   return __builtin_altivec_vclzb(__a);
2250 }
2251 static __inline__ vector signed short __ATTRS_o_ai
2252 vec_cntlz(vector signed short __a) {
2253   return __builtin_altivec_vclzh(__a);
2254 }
2255 static __inline__ vector unsigned short __ATTRS_o_ai
2256 vec_cntlz(vector unsigned short __a) {
2257   return __builtin_altivec_vclzh(__a);
2258 }
2259 static __inline__ vector signed int __ATTRS_o_ai
2260 vec_cntlz(vector signed int __a) {
2261   return __builtin_altivec_vclzw(__a);
2262 }
2263 static __inline__ vector unsigned int __ATTRS_o_ai
2264 vec_cntlz(vector unsigned int __a) {
2265   return __builtin_altivec_vclzw(__a);
2266 }
2267 static __inline__ vector signed long long __ATTRS_o_ai
2268 vec_cntlz(vector signed long long __a) {
2269   return __builtin_altivec_vclzd(__a);
2270 }
2271 static __inline__ vector unsigned long long __ATTRS_o_ai
2272 vec_cntlz(vector unsigned long long __a) {
2273   return __builtin_altivec_vclzd(__a);
2274 }
2275 #endif
2276
2277 #ifdef __POWER9_VECTOR__
2278
2279 /* vec_cnttz */
2280
2281 static __inline__ vector signed char __ATTRS_o_ai
2282 vec_cnttz(vector signed char __a) {
2283   return __builtin_altivec_vctzb(__a);
2284 }
2285 static __inline__ vector unsigned char __ATTRS_o_ai
2286 vec_cnttz(vector unsigned char __a) {
2287   return __builtin_altivec_vctzb(__a);
2288 }
2289 static __inline__ vector signed short __ATTRS_o_ai
2290 vec_cnttz(vector signed short __a) {
2291   return __builtin_altivec_vctzh(__a);
2292 }
2293 static __inline__ vector unsigned short __ATTRS_o_ai
2294 vec_cnttz(vector unsigned short __a) {
2295   return __builtin_altivec_vctzh(__a);
2296 }
2297 static __inline__ vector signed int __ATTRS_o_ai
2298 vec_cnttz(vector signed int __a) {
2299   return __builtin_altivec_vctzw(__a);
2300 }
2301 static __inline__ vector unsigned int __ATTRS_o_ai
2302 vec_cnttz(vector unsigned int __a) {
2303   return __builtin_altivec_vctzw(__a);
2304 }
2305 static __inline__ vector signed long long __ATTRS_o_ai
2306 vec_cnttz(vector signed long long __a) {
2307   return __builtin_altivec_vctzd(__a);
2308 }
2309 static __inline__ vector unsigned long long __ATTRS_o_ai
2310 vec_cnttz(vector unsigned long long __a) {
2311   return __builtin_altivec_vctzd(__a);
2312 }
2313
2314 /* vec_first_match_index */
2315
2316 static __inline__ unsigned __ATTRS_o_ai
2317 vec_first_match_index(vector signed char __a, vector signed char __b) {
2318   vector unsigned long long __res =
2319 #ifdef __LITTLE_ENDIAN__
2320     vec_cnttz((vector unsigned long long)vec_cmpeq(__a, __b));
2321 #else
2322     vec_cntlz((vector unsigned long long)vec_cmpeq(__a, __b));
2323 #endif
2324   if (__res[0] == 64) {
2325     return (__res[1] + 64) >> 3;
2326   }
2327   return __res[0] >> 3;
2328 }
2329
2330 static __inline__ unsigned __ATTRS_o_ai
2331 vec_first_match_index(vector unsigned char __a, vector unsigned char __b) {
2332   vector unsigned long long __res =
2333 #ifdef __LITTLE_ENDIAN__
2334     vec_cnttz((vector unsigned long long)vec_cmpeq(__a, __b));
2335 #else
2336     vec_cntlz((vector unsigned long long)vec_cmpeq(__a, __b));
2337 #endif
2338   if (__res[0] == 64) {
2339     return (__res[1] + 64) >> 3;
2340   }
2341   return __res[0] >> 3;
2342 }
2343
2344 static __inline__ unsigned __ATTRS_o_ai
2345 vec_first_match_index(vector signed short __a, vector signed short __b) {
2346   vector unsigned long long __res =
2347 #ifdef __LITTLE_ENDIAN__
2348     vec_cnttz((vector unsigned long long)vec_cmpeq(__a, __b));
2349 #else
2350     vec_cntlz((vector unsigned long long)vec_cmpeq(__a, __b));
2351 #endif
2352   if (__res[0] == 64) {
2353     return (__res[1] + 64) >> 4;
2354   }
2355   return __res[0] >> 4;
2356 }
2357
2358 static __inline__ unsigned __ATTRS_o_ai
2359 vec_first_match_index(vector unsigned short __a, vector unsigned short __b) {
2360   vector unsigned long long __res =
2361 #ifdef __LITTLE_ENDIAN__
2362     vec_cnttz((vector unsigned long long)vec_cmpeq(__a, __b));
2363 #else
2364     vec_cntlz((vector unsigned long long)vec_cmpeq(__a, __b));
2365 #endif
2366   if (__res[0] == 64) {
2367     return (__res[1] + 64) >> 4;
2368   }
2369   return __res[0] >> 4;
2370 }
2371
2372 static __inline__ unsigned __ATTRS_o_ai
2373 vec_first_match_index(vector signed int __a, vector signed int __b) {
2374   vector unsigned long long __res =
2375 #ifdef __LITTLE_ENDIAN__
2376     vec_cnttz((vector unsigned long long)vec_cmpeq(__a, __b));
2377 #else
2378     vec_cntlz((vector unsigned long long)vec_cmpeq(__a, __b));
2379 #endif
2380   if (__res[0] == 64) {
2381     return (__res[1] + 64) >> 5;
2382   }
2383   return __res[0] >> 5;
2384 }
2385
2386 static __inline__ unsigned __ATTRS_o_ai
2387 vec_first_match_index(vector unsigned int __a, vector unsigned int __b) {
2388   vector unsigned long long __res =
2389 #ifdef __LITTLE_ENDIAN__
2390     vec_cnttz((vector unsigned long long)vec_cmpeq(__a, __b));
2391 #else
2392     vec_cntlz((vector unsigned long long)vec_cmpeq(__a, __b));
2393 #endif
2394   if (__res[0] == 64) {
2395     return (__res[1] + 64) >> 5;
2396   }
2397   return __res[0] >> 5;
2398 }
2399
2400 /* vec_first_match_or_eos_index */
2401
2402 static __inline__ unsigned __ATTRS_o_ai
2403 vec_first_match_or_eos_index(vector signed char __a, vector signed char __b) {
2404   /* Compare the result of the comparison of two vectors with either and OR the
2405      result. Either the elements are equal or one will equal the comparison
2406      result if either is zero.
2407   */
2408   vector bool char __tmp1 = vec_cmpeq(__a, __b);
2409   vector bool char __tmp2 = __tmp1 |
2410                             vec_cmpeq((vector signed char)__tmp1, __a) |
2411                             vec_cmpeq((vector signed char)__tmp1, __b);
2412
2413   vector unsigned long long __res =
2414 #ifdef __LITTLE_ENDIAN__
2415       vec_cnttz((vector unsigned long long)__tmp2);
2416 #else
2417       vec_cntlz((vector unsigned long long)__tmp2);
2418 #endif
2419   if (__res[0] == 64) {
2420     return (__res[1] + 64) >> 3;
2421   }
2422   return __res[0] >> 3;
2423 }
2424
2425 static __inline__ unsigned __ATTRS_o_ai
2426 vec_first_match_or_eos_index(vector unsigned char __a,
2427                              vector unsigned char __b) {
2428   vector bool char __tmp1 = vec_cmpeq(__a, __b);
2429   vector bool char __tmp2 = __tmp1 |
2430                             vec_cmpeq((vector unsigned char)__tmp1, __a) |
2431                             vec_cmpeq((vector unsigned char)__tmp1, __b);
2432
2433   vector unsigned long long __res =
2434 #ifdef __LITTLE_ENDIAN__
2435       vec_cnttz((vector unsigned long long)__tmp2);
2436 #else
2437       vec_cntlz((vector unsigned long long)__tmp2);
2438 #endif
2439   if (__res[0] == 64) {
2440     return (__res[1] + 64) >> 3;
2441   }
2442   return __res[0] >> 3;
2443 }
2444
2445 static __inline__ unsigned __ATTRS_o_ai
2446 vec_first_match_or_eos_index(vector signed short __a, vector signed short __b) {
2447   vector bool short __tmp1 = vec_cmpeq(__a, __b);
2448   vector bool short __tmp2 = __tmp1 |
2449                              vec_cmpeq((vector signed short)__tmp1, __a) |
2450                              vec_cmpeq((vector signed short)__tmp1, __b);
2451
2452   vector unsigned long long __res =
2453 #ifdef __LITTLE_ENDIAN__
2454       vec_cnttz((vector unsigned long long)__tmp2);
2455 #else
2456       vec_cntlz((vector unsigned long long)__tmp2);
2457 #endif
2458   if (__res[0] == 64) {
2459     return (__res[1] + 64) >> 4;
2460   }
2461   return __res[0] >> 4;
2462 }
2463
2464 static __inline__ unsigned __ATTRS_o_ai
2465 vec_first_match_or_eos_index(vector unsigned short __a,
2466                              vector unsigned short __b) {
2467   vector bool short __tmp1 = vec_cmpeq(__a, __b);
2468   vector bool short __tmp2 = __tmp1 |
2469                              vec_cmpeq((vector unsigned short)__tmp1, __a) |
2470                              vec_cmpeq((vector unsigned short)__tmp1, __b);
2471
2472   vector unsigned long long __res =
2473 #ifdef __LITTLE_ENDIAN__
2474       vec_cnttz((vector unsigned long long)__tmp2);
2475 #else
2476       vec_cntlz((vector unsigned long long)__tmp2);
2477 #endif
2478   if (__res[0] == 64) {
2479     return (__res[1] + 64) >> 4;
2480   }
2481   return __res[0] >> 4;
2482 }
2483
2484 static __inline__ unsigned __ATTRS_o_ai
2485 vec_first_match_or_eos_index(vector signed int __a, vector signed int __b) {
2486   vector bool int __tmp1 = vec_cmpeq(__a, __b);
2487   vector bool int __tmp2 = __tmp1 | vec_cmpeq((vector signed int)__tmp1, __a) |
2488                            vec_cmpeq((vector signed int)__tmp1, __b);
2489
2490   vector unsigned long long __res =
2491 #ifdef __LITTLE_ENDIAN__
2492       vec_cnttz((vector unsigned long long)__tmp2);
2493 #else
2494       vec_cntlz((vector unsigned long long)__tmp2);
2495 #endif
2496   if (__res[0] == 64) {
2497     return (__res[1] + 64) >> 5;
2498   }
2499   return __res[0] >> 5;
2500 }
2501
2502 static __inline__ unsigned __ATTRS_o_ai
2503 vec_first_match_or_eos_index(vector unsigned int __a, vector unsigned int __b) {
2504   vector bool int __tmp1 = vec_cmpeq(__a, __b);
2505   vector bool int __tmp2 = __tmp1 |
2506                            vec_cmpeq((vector unsigned int)__tmp1, __a) |
2507                            vec_cmpeq((vector unsigned int)__tmp1, __b);
2508
2509   vector unsigned long long __res =
2510 #ifdef __LITTLE_ENDIAN__
2511     vec_cnttz((vector unsigned long long)__tmp2);
2512 #else
2513     vec_cntlz((vector unsigned long long)__tmp2);
2514 #endif
2515   if (__res[0] == 64) {
2516     return (__res[1] + 64) >> 5;
2517   }
2518   return __res[0] >> 5;
2519 }
2520
2521 /* vec_first_mismatch_index */
2522
2523 static __inline__ unsigned __ATTRS_o_ai
2524 vec_first_mismatch_index(vector signed char __a, vector signed char __b) {
2525   vector unsigned long long __res =
2526 #ifdef __LITTLE_ENDIAN__
2527     vec_cnttz((vector unsigned long long)vec_cmpne(__a, __b));
2528 #else
2529     vec_cntlz((vector unsigned long long)vec_cmpne(__a, __b));
2530 #endif
2531   if (__res[0] == 64) {
2532     return (__res[1] + 64) >> 3;
2533   }
2534   return __res[0] >> 3;
2535 }
2536
2537 static __inline__ unsigned __ATTRS_o_ai
2538 vec_first_mismatch_index(vector unsigned char __a, vector unsigned char __b) {
2539   vector unsigned long long __res =
2540 #ifdef __LITTLE_ENDIAN__
2541     vec_cnttz((vector unsigned long long)vec_cmpne(__a, __b));
2542 #else
2543     vec_cntlz((vector unsigned long long)vec_cmpne(__a, __b));
2544 #endif
2545   if (__res[0] == 64) {
2546     return (__res[1] + 64) >> 3;
2547   }
2548   return __res[0] >> 3;
2549 }
2550
2551 static __inline__ unsigned __ATTRS_o_ai
2552 vec_first_mismatch_index(vector signed short __a, vector signed short __b) {
2553   vector unsigned long long __res =
2554 #ifdef __LITTLE_ENDIAN__
2555     vec_cnttz((vector unsigned long long)vec_cmpne(__a, __b));
2556 #else
2557     vec_cntlz((vector unsigned long long)vec_cmpne(__a, __b));
2558 #endif
2559   if (__res[0] == 64) {
2560     return (__res[1] + 64) >> 4;
2561   }
2562   return __res[0] >> 4;
2563 }
2564
2565 static __inline__ unsigned __ATTRS_o_ai
2566 vec_first_mismatch_index(vector unsigned short __a, vector unsigned short __b) {
2567   vector unsigned long long __res =
2568 #ifdef __LITTLE_ENDIAN__
2569     vec_cnttz((vector unsigned long long)vec_cmpne(__a, __b));
2570 #else
2571     vec_cntlz((vector unsigned long long)vec_cmpne(__a, __b));
2572 #endif
2573   if (__res[0] == 64) {
2574     return (__res[1] + 64) >> 4;
2575   }
2576   return __res[0] >> 4;
2577 }
2578
2579 static __inline__ unsigned __ATTRS_o_ai
2580 vec_first_mismatch_index(vector signed int __a, vector signed int __b) {
2581   vector unsigned long long __res =
2582 #ifdef __LITTLE_ENDIAN__
2583     vec_cnttz((vector unsigned long long)vec_cmpne(__a, __b));
2584 #else
2585     vec_cntlz((vector unsigned long long)vec_cmpne(__a, __b));
2586 #endif
2587   if (__res[0] == 64) {
2588     return (__res[1] + 64) >> 5;
2589   }
2590   return __res[0] >> 5;
2591 }
2592
2593 static __inline__ unsigned __ATTRS_o_ai
2594 vec_first_mismatch_index(vector unsigned int __a, vector unsigned int __b) {
2595   vector unsigned long long __res =
2596 #ifdef __LITTLE_ENDIAN__
2597     vec_cnttz((vector unsigned long long)vec_cmpne(__a, __b));
2598 #else
2599     vec_cntlz((vector unsigned long long)vec_cmpne(__a, __b));
2600 #endif
2601   if (__res[0] == 64) {
2602     return (__res[1] + 64) >> 5;
2603   }
2604   return __res[0] >> 5;
2605 }
2606
2607 /* vec_first_mismatch_or_eos_index */
2608
2609 static __inline__ unsigned __ATTRS_o_ai
2610 vec_first_mismatch_or_eos_index(vector signed char __a,
2611                                 vector signed char __b) {
2612   vector unsigned long long __res =
2613 #ifdef __LITTLE_ENDIAN__
2614     vec_cnttz((vector unsigned long long)vec_cmpnez(__a, __b));
2615 #else
2616     vec_cntlz((vector unsigned long long)vec_cmpnez(__a, __b));
2617 #endif
2618   if (__res[0] == 64) {
2619     return (__res[1] + 64) >> 3;
2620   }
2621   return __res[0] >> 3;
2622 }
2623
2624 static __inline__ unsigned __ATTRS_o_ai
2625 vec_first_mismatch_or_eos_index(vector unsigned char __a,
2626                                 vector unsigned char __b) {
2627   vector unsigned long long __res =
2628 #ifdef __LITTLE_ENDIAN__
2629     vec_cnttz((vector unsigned long long)vec_cmpnez(__a, __b));
2630 #else
2631     vec_cntlz((vector unsigned long long)vec_cmpnez(__a, __b));
2632 #endif
2633   if (__res[0] == 64) {
2634     return (__res[1] + 64) >> 3;
2635   }
2636   return __res[0] >> 3;
2637 }
2638
2639 static __inline__ unsigned __ATTRS_o_ai
2640 vec_first_mismatch_or_eos_index(vector signed short __a,
2641                                 vector signed short __b) {
2642   vector unsigned long long __res =
2643 #ifdef __LITTLE_ENDIAN__
2644     vec_cnttz((vector unsigned long long)vec_cmpnez(__a, __b));
2645 #else
2646     vec_cntlz((vector unsigned long long)vec_cmpnez(__a, __b));
2647 #endif
2648   if (__res[0] == 64) {
2649     return (__res[1] + 64) >> 4;
2650   }
2651   return __res[0] >> 4;
2652 }
2653
2654 static __inline__ unsigned __ATTRS_o_ai
2655 vec_first_mismatch_or_eos_index(vector unsigned short __a,
2656                                 vector unsigned short __b) {
2657   vector unsigned long long __res =
2658 #ifdef __LITTLE_ENDIAN__
2659     vec_cnttz((vector unsigned long long)vec_cmpnez(__a, __b));
2660 #else
2661     vec_cntlz((vector unsigned long long)vec_cmpnez(__a, __b));
2662 #endif
2663   if (__res[0] == 64) {
2664     return (__res[1] + 64) >> 4;
2665   }
2666   return __res[0] >> 4;
2667 }
2668
2669 static __inline__ unsigned __ATTRS_o_ai
2670 vec_first_mismatch_or_eos_index(vector signed int __a, vector signed int __b) {
2671   vector unsigned long long __res =
2672 #ifdef __LITTLE_ENDIAN__
2673     vec_cnttz((vector unsigned long long)vec_cmpnez(__a, __b));
2674 #else
2675     vec_cntlz((vector unsigned long long)vec_cmpnez(__a, __b));
2676 #endif
2677   if (__res[0] == 64) {
2678     return (__res[1] + 64) >> 5;
2679   }
2680   return __res[0] >> 5;
2681 }
2682
2683 static __inline__ unsigned __ATTRS_o_ai
2684 vec_first_mismatch_or_eos_index(vector unsigned int __a,
2685                                 vector unsigned int __b) {
2686   vector unsigned long long __res =
2687 #ifdef __LITTLE_ENDIAN__
2688     vec_cnttz((vector unsigned long long)vec_cmpnez(__a, __b));
2689 #else
2690     vec_cntlz((vector unsigned long long)vec_cmpnez(__a, __b));
2691 #endif
2692   if (__res[0] == 64) {
2693     return (__res[1] + 64) >> 5;
2694   }
2695   return __res[0] >> 5;
2696 }
2697
2698 static __inline__ vector double  __ATTRS_o_ai
2699 vec_insert_exp(vector double __a, vector unsigned long long __b) {
2700   return __builtin_vsx_xviexpdp((vector unsigned long long)__a,__b);
2701 }
2702
2703 static __inline__ vector double  __ATTRS_o_ai
2704 vec_insert_exp(vector unsigned long long __a, vector unsigned long long __b) {
2705   return __builtin_vsx_xviexpdp(__a,__b);
2706 }
2707
2708 static __inline__ vector float  __ATTRS_o_ai
2709 vec_insert_exp(vector float __a, vector unsigned int __b) {
2710   return __builtin_vsx_xviexpsp((vector unsigned int)__a,__b);
2711 }
2712
2713 static __inline__ vector float  __ATTRS_o_ai
2714 vec_insert_exp(vector unsigned int __a, vector unsigned int __b) {
2715   return __builtin_vsx_xviexpsp(__a,__b);
2716 }
2717
2718 #if defined(__powerpc64__)
2719 static __inline__ vector signed char __ATTRS_o_ai vec_xl_len(signed char *__a,
2720                                                              size_t __b) {
2721   return (vector signed char)__builtin_vsx_lxvl(__a, (__b << 56));
2722 }
2723
2724 static __inline__ vector unsigned char __ATTRS_o_ai
2725 vec_xl_len(unsigned char *__a, size_t __b) {
2726   return (vector unsigned char)__builtin_vsx_lxvl(__a, (__b << 56));
2727 }
2728
2729 static __inline__ vector signed short __ATTRS_o_ai vec_xl_len(signed short *__a,
2730                                                               size_t __b) {
2731   return (vector signed short)__builtin_vsx_lxvl(__a, (__b << 56));
2732 }
2733
2734 static __inline__ vector unsigned short __ATTRS_o_ai
2735 vec_xl_len(unsigned short *__a, size_t __b) {
2736   return (vector unsigned short)__builtin_vsx_lxvl(__a, (__b << 56));
2737 }
2738
2739 static __inline__ vector signed int __ATTRS_o_ai vec_xl_len(signed int *__a,
2740                                                             size_t __b) {
2741   return (vector signed int)__builtin_vsx_lxvl(__a, (__b << 56));
2742 }
2743
2744 static __inline__ vector unsigned int __ATTRS_o_ai vec_xl_len(unsigned int *__a,
2745                                                               size_t __b) {
2746   return (vector unsigned int)__builtin_vsx_lxvl(__a, (__b << 56));
2747 }
2748
2749 static __inline__ vector float __ATTRS_o_ai vec_xl_len(float *__a, size_t __b) {
2750   return (vector float)__builtin_vsx_lxvl(__a, (__b << 56));
2751 }
2752
2753 static __inline__ vector signed __int128 __ATTRS_o_ai
2754 vec_xl_len(signed __int128 *__a, size_t __b) {
2755   return (vector signed __int128)__builtin_vsx_lxvl(__a, (__b << 56));
2756 }
2757
2758 static __inline__ vector unsigned __int128 __ATTRS_o_ai
2759 vec_xl_len(unsigned __int128 *__a, size_t __b) {
2760   return (vector unsigned __int128)__builtin_vsx_lxvl(__a, (__b << 56));
2761 }
2762
2763 static __inline__ vector signed long long __ATTRS_o_ai
2764 vec_xl_len(signed long long *__a, size_t __b) {
2765   return (vector signed long long)__builtin_vsx_lxvl(__a, (__b << 56));
2766 }
2767
2768 static __inline__ vector unsigned long long __ATTRS_o_ai
2769 vec_xl_len(unsigned long long *__a, size_t __b) {
2770   return (vector unsigned long long)__builtin_vsx_lxvl(__a, (__b << 56));
2771 }
2772
2773 static __inline__ vector double __ATTRS_o_ai vec_xl_len(double *__a,
2774                                                         size_t __b) {
2775   return (vector double)__builtin_vsx_lxvl(__a, (__b << 56));
2776 }
2777
2778 static __inline__ vector double __ATTRS_o_ai vec_xl_len_r(unsigned char *__a,
2779                                                           size_t __b) {
2780   vector unsigned char __res =
2781       (vector unsigned char)__builtin_vsx_lxvll(__a, (__b << 56));
2782 #ifdef __LITTLE_ENDIAN__
2783   vector unsigned char __mask =
2784       (vector unsigned char)__builtin_altivec_lvsr(16 - __b, (int *)NULL);
2785   __res = (vector unsigned char)__builtin_altivec_vperm_4si(
2786       (vector int)__res, (vector int)__res, __mask);
2787 #endif
2788   return __res;
2789 }
2790
2791 // vec_xst_len
2792 static __inline__ void __ATTRS_o_ai vec_xst_len(vector unsigned char __a,
2793                                                 unsigned char *__b,
2794                                                 size_t __c) {
2795   return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
2796 }
2797
2798 static __inline__ void __ATTRS_o_ai vec_xst_len(vector signed char __a,
2799                                                 signed char *__b, size_t __c) {
2800   return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
2801 }
2802
2803 static __inline__ void __ATTRS_o_ai vec_xst_len(vector signed short __a,
2804                                                 signed short *__b, size_t __c) {
2805   return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
2806 }
2807
2808 static __inline__ void __ATTRS_o_ai vec_xst_len(vector unsigned short __a,
2809                                                 unsigned short *__b,
2810                                                 size_t __c) {
2811   return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
2812 }
2813
2814 static __inline__ void __ATTRS_o_ai vec_xst_len(vector signed int __a,
2815                                                 signed int *__b, size_t __c) {
2816   return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
2817 }
2818
2819 static __inline__ void __ATTRS_o_ai vec_xst_len(vector unsigned int __a,
2820                                                 unsigned int *__b, size_t __c) {
2821   return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
2822 }
2823
2824 static __inline__ void __ATTRS_o_ai vec_xst_len(vector float __a, float *__b,
2825                                                 size_t __c) {
2826   return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
2827 }
2828
2829 static __inline__ void __ATTRS_o_ai vec_xst_len(vector signed __int128 __a,
2830                                                 signed __int128 *__b,
2831                                                 size_t __c) {
2832   return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
2833 }
2834
2835 static __inline__ void __ATTRS_o_ai vec_xst_len(vector unsigned __int128 __a,
2836                                                 unsigned __int128 *__b,
2837                                                 size_t __c) {
2838   return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
2839 }
2840
2841 static __inline__ void __ATTRS_o_ai vec_xst_len(vector signed long long __a,
2842                                                 signed long long *__b,
2843                                                 size_t __c) {
2844   return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
2845 }
2846
2847 static __inline__ void __ATTRS_o_ai vec_xst_len(vector unsigned long long __a,
2848                                                 unsigned long long *__b,
2849                                                 size_t __c) {
2850   return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
2851 }
2852
2853 static __inline__ void __ATTRS_o_ai vec_xst_len(vector double __a, double *__b,
2854                                                 size_t __c) {
2855   return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
2856 }
2857
2858 static __inline__ void __ATTRS_o_ai vec_xst_len_r(vector unsigned char __a,
2859                                                   unsigned char *__b,
2860                                                   size_t __c) {
2861 #ifdef __LITTLE_ENDIAN__
2862   vector unsigned char __mask =
2863       (vector unsigned char)__builtin_altivec_lvsl(16 - __c, (int *)NULL);
2864   vector unsigned char __res =
2865       __builtin_altivec_vperm_4si((vector int)__a, (vector int)__a, __mask);
2866   return __builtin_vsx_stxvll((vector int)__res, __b, (__c << 56));
2867 #else
2868   return __builtin_vsx_stxvll((vector int)__a, __b, (__c << 56));
2869 #endif
2870 }
2871 #endif
2872 #endif
2873
2874 /* vec_cpsgn */
2875
2876 #ifdef __VSX__
2877 static __inline__ vector float __ATTRS_o_ai vec_cpsgn(vector float __a,
2878                                                       vector float __b) {
2879   return __builtin_vsx_xvcpsgnsp(__a, __b);
2880 }
2881
2882 static __inline__ vector double __ATTRS_o_ai vec_cpsgn(vector double __a,
2883                                                        vector double __b) {
2884   return __builtin_vsx_xvcpsgndp(__a, __b);
2885 }
2886 #endif
2887
2888 /* vec_ctf */
2889
2890 #ifdef __VSX__
2891 #define vec_ctf(__a, __b)                                                      \
2892   _Generic((__a), vector int                                                   \
2893            : (vector float)__builtin_altivec_vcfsx((__a), (__b)),              \
2894              vector unsigned int                                               \
2895            : (vector float)__builtin_altivec_vcfux((vector int)(__a), (__b)),  \
2896              vector unsigned long long                                         \
2897            : (__builtin_convertvector((vector unsigned long long)(__a),        \
2898                                       vector double) *                         \
2899               (vector double)(vector unsigned long long)((0x3ffULL - (__b))    \
2900                                                          << 52)),              \
2901              vector signed long long                                           \
2902            : (__builtin_convertvector((vector signed long long)(__a),          \
2903                                       vector double) *                         \
2904               (vector double)(vector unsigned long long)((0x3ffULL - (__b))    \
2905                                                          << 52)))
2906 #else
2907 #define vec_ctf(__a, __b)                                                      \
2908   _Generic((__a), vector int                                                   \
2909            : (vector float)__builtin_altivec_vcfsx((__a), (__b)),              \
2910              vector unsigned int                                               \
2911            : (vector float)__builtin_altivec_vcfux((vector int)(__a), (__b)))
2912 #endif
2913
2914 /* vec_vcfsx */
2915
2916 #define vec_vcfux __builtin_altivec_vcfux
2917
2918 /* vec_vcfux */
2919
2920 #define vec_vcfsx(__a, __b) __builtin_altivec_vcfsx((vector int)(__a), (__b))
2921
2922 /* vec_cts */
2923
2924 #ifdef __VSX__
2925 #define vec_cts(__a, __b)                                                      \
2926   _Generic((__a), vector float                                                 \
2927            : __builtin_altivec_vctsxs((__a), (__b)), vector double             \
2928            : __extension__({                                                   \
2929              vector double __ret =                                             \
2930                  (__a) *                                                       \
2931                  (vector double)(vector unsigned long long)((0x3ffULL + (__b)) \
2932                                                             << 52);            \
2933              __builtin_convertvector(__ret, vector signed long long);          \
2934            }))
2935 #else
2936 #define vec_cts __builtin_altivec_vctsxs
2937 #endif
2938
2939 /* vec_vctsxs */
2940
2941 #define vec_vctsxs __builtin_altivec_vctsxs
2942
2943 /* vec_ctu */
2944
2945 #ifdef __VSX__
2946 #define vec_ctu(__a, __b)                                                      \
2947   _Generic((__a), vector float                                                 \
2948            : __builtin_altivec_vctuxs((__a), (__b)), vector double             \
2949            : __extension__({                                                   \
2950              vector double __ret =                                             \
2951                  (__a) *                                                       \
2952                  (vector double)(vector unsigned long long)((0x3ffULL + __b)   \
2953                                                             << 52);            \
2954              __builtin_convertvector(__ret, vector unsigned long long);        \
2955            }))
2956 #else
2957 #define vec_ctu __builtin_altivec_vctuxs
2958 #endif
2959
2960 /* vec_vctuxs */
2961
2962 #define vec_vctuxs __builtin_altivec_vctuxs
2963
2964 /* vec_signed */
2965
2966 static __inline__ vector signed int __ATTRS_o_ai
2967 vec_sld(vector signed int, vector signed int, unsigned const int __c);
2968
2969 static __inline__ vector signed int __ATTRS_o_ai
2970 vec_signed(vector float __a) {
2971   return __builtin_convertvector(__a, vector signed int);
2972 }
2973
2974 #ifdef __VSX__
2975 static __inline__ vector signed long long __ATTRS_o_ai
2976 vec_signed(vector double __a) {
2977   return __builtin_convertvector(__a, vector signed long long);
2978 }
2979
2980 static __inline__ vector signed int __attribute__((__always_inline__))
2981 vec_signed2(vector double __a, vector double __b) {
2982   return (vector signed int) { __a[0], __a[1], __b[0], __b[1] };
2983 }
2984
2985 static __inline__ vector signed int __ATTRS_o_ai
2986 vec_signede(vector double __a) {
2987 #ifdef __LITTLE_ENDIAN__
2988   vector signed int __ret = __builtin_vsx_xvcvdpsxws(__a);
2989   return vec_sld(__ret, __ret, 12);
2990 #else
2991   return __builtin_vsx_xvcvdpsxws(__a);
2992 #endif
2993 }
2994
2995 static __inline__ vector signed int __ATTRS_o_ai
2996 vec_signedo(vector double __a) {
2997 #ifdef __LITTLE_ENDIAN__
2998   return __builtin_vsx_xvcvdpsxws(__a);
2999 #else
3000   vector signed int __ret = __builtin_vsx_xvcvdpsxws(__a);
3001   return vec_sld(__ret, __ret, 12);
3002 #endif
3003 }
3004 #endif
3005
3006 /* vec_unsigned */
3007
3008 static __inline__ vector unsigned int __ATTRS_o_ai
3009 vec_sld(vector unsigned int, vector unsigned int, unsigned const int __c);
3010
3011 static __inline__ vector unsigned int __ATTRS_o_ai
3012 vec_unsigned(vector float __a) {
3013   return __builtin_convertvector(__a, vector unsigned int);
3014 }
3015
3016 #ifdef __VSX__
3017 static __inline__ vector unsigned long long __ATTRS_o_ai
3018 vec_unsigned(vector double __a) {
3019   return __builtin_convertvector(__a, vector unsigned long long);
3020 }
3021
3022 static __inline__ vector unsigned int __attribute__((__always_inline__))
3023 vec_unsigned2(vector double __a, vector double __b) {
3024   return (vector unsigned int) { __a[0], __a[1], __b[0], __b[1] };
3025 }
3026
3027 static __inline__ vector unsigned int __ATTRS_o_ai
3028 vec_unsignede(vector double __a) {
3029 #ifdef __LITTLE_ENDIAN__
3030   vector unsigned int __ret = __builtin_vsx_xvcvdpuxws(__a);
3031   return vec_sld(__ret, __ret, 12);
3032 #else
3033   return __builtin_vsx_xvcvdpuxws(__a);
3034 #endif
3035 }
3036
3037 static __inline__ vector unsigned int __ATTRS_o_ai
3038 vec_unsignedo(vector double __a) {
3039 #ifdef __LITTLE_ENDIAN__
3040   return __builtin_vsx_xvcvdpuxws(__a);
3041 #else
3042   vector unsigned int __ret = __builtin_vsx_xvcvdpuxws(__a);
3043   return vec_sld(__ret, __ret, 12);
3044 #endif
3045 }
3046 #endif
3047
3048 /* vec_float */
3049
3050 static __inline__ vector float __ATTRS_o_ai
3051 vec_sld(vector float, vector float, unsigned const int __c);
3052
3053 static __inline__ vector float __ATTRS_o_ai
3054 vec_float(vector signed int __a) {
3055   return __builtin_convertvector(__a, vector float);
3056 }
3057
3058 static __inline__ vector float __ATTRS_o_ai
3059 vec_float(vector unsigned int __a) {
3060   return __builtin_convertvector(__a, vector float);
3061 }
3062
3063 #ifdef __VSX__
3064 static __inline__ vector float __ATTRS_o_ai
3065 vec_float2(vector signed long long __a, vector signed long long __b) {
3066   return (vector float) { __a[0], __a[1], __b[0], __b[1] };
3067 }
3068
3069 static __inline__ vector float __ATTRS_o_ai
3070 vec_float2(vector unsigned long long __a, vector unsigned long long __b) {
3071   return (vector float) { __a[0], __a[1], __b[0], __b[1] };
3072 }
3073
3074 static __inline__ vector float __ATTRS_o_ai
3075 vec_float2(vector double __a, vector double __b) {
3076   return (vector float) { __a[0], __a[1], __b[0], __b[1] };
3077 }
3078
3079 static __inline__ vector float __ATTRS_o_ai
3080 vec_floate(vector signed long long __a) {
3081 #ifdef __LITTLE_ENDIAN__
3082   vector float __ret = __builtin_vsx_xvcvsxdsp(__a);
3083   return vec_sld(__ret, __ret, 12);
3084 #else
3085   return __builtin_vsx_xvcvsxdsp(__a);
3086 #endif
3087 }
3088
3089 static __inline__ vector float __ATTRS_o_ai
3090 vec_floate(vector unsigned long long __a) {
3091 #ifdef __LITTLE_ENDIAN__
3092   vector float __ret = __builtin_vsx_xvcvuxdsp(__a);
3093   return vec_sld(__ret, __ret, 12);
3094 #else
3095   return __builtin_vsx_xvcvuxdsp(__a);
3096 #endif
3097 }
3098
3099 static __inline__ vector float __ATTRS_o_ai
3100 vec_floate(vector double __a) {
3101 #ifdef __LITTLE_ENDIAN__
3102   vector float __ret = __builtin_vsx_xvcvdpsp(__a);
3103   return vec_sld(__ret, __ret, 12);
3104 #else
3105   return __builtin_vsx_xvcvdpsp(__a);
3106 #endif
3107 }
3108
3109 static __inline__ vector float __ATTRS_o_ai
3110 vec_floato(vector signed long long __a) {
3111 #ifdef __LITTLE_ENDIAN__
3112   return __builtin_vsx_xvcvsxdsp(__a);
3113 #else
3114   vector float __ret = __builtin_vsx_xvcvsxdsp(__a);
3115   return vec_sld(__ret, __ret, 12);
3116 #endif
3117 }
3118
3119 static __inline__ vector float __ATTRS_o_ai
3120 vec_floato(vector unsigned long long __a) {
3121 #ifdef __LITTLE_ENDIAN__
3122   return __builtin_vsx_xvcvuxdsp(__a);
3123 #else
3124   vector float __ret = __builtin_vsx_xvcvuxdsp(__a);
3125   return vec_sld(__ret, __ret, 12);
3126 #endif
3127 }
3128
3129 static __inline__ vector float __ATTRS_o_ai
3130 vec_floato(vector double __a) {
3131 #ifdef __LITTLE_ENDIAN__
3132   return __builtin_vsx_xvcvdpsp(__a);
3133 #else
3134   vector float __ret = __builtin_vsx_xvcvdpsp(__a);
3135   return vec_sld(__ret, __ret, 12);
3136 #endif
3137 }
3138 #endif
3139
3140 /* vec_double */
3141
3142 #ifdef __VSX__
3143 static __inline__ vector double __ATTRS_o_ai
3144 vec_double(vector signed long long __a) {
3145   return __builtin_convertvector(__a, vector double);
3146 }
3147
3148 static __inline__ vector double __ATTRS_o_ai
3149 vec_double(vector unsigned long long __a) {
3150   return __builtin_convertvector(__a, vector double);
3151 }
3152
3153 static __inline__ vector double __ATTRS_o_ai
3154 vec_doublee(vector signed int __a) {
3155 #ifdef __LITTLE_ENDIAN__
3156   return __builtin_vsx_xvcvsxwdp(vec_sld(__a, __a, 4));
3157 #else
3158   return __builtin_vsx_xvcvsxwdp(__a);
3159 #endif
3160 }
3161
3162 static __inline__ vector double __ATTRS_o_ai
3163 vec_doublee(vector unsigned int __a) {
3164 #ifdef __LITTLE_ENDIAN__
3165   return __builtin_vsx_xvcvuxwdp(vec_sld(__a, __a, 4));
3166 #else
3167   return __builtin_vsx_xvcvuxwdp(__a);
3168 #endif
3169 }
3170
3171 static __inline__ vector double __ATTRS_o_ai
3172 vec_doublee(vector float __a) {
3173 #ifdef __LITTLE_ENDIAN__
3174   return __builtin_vsx_xvcvspdp(vec_sld(__a, __a, 4));
3175 #else
3176   return __builtin_vsx_xvcvspdp(__a);
3177 #endif
3178 }
3179
3180 static __inline__ vector double __ATTRS_o_ai
3181 vec_doubleh(vector signed int __a) {
3182   vector double __ret = {__a[0], __a[1]};
3183   return __ret;
3184 }
3185
3186 static __inline__ vector double __ATTRS_o_ai
3187 vec_doubleh(vector unsigned int __a) {
3188   vector double __ret = {__a[0], __a[1]};
3189   return __ret;
3190 }
3191
3192 static __inline__ vector double __ATTRS_o_ai
3193 vec_doubleh(vector float __a) {
3194   vector double __ret = {__a[0], __a[1]};
3195   return __ret;
3196 }
3197
3198 static __inline__ vector double __ATTRS_o_ai
3199 vec_doublel(vector signed int __a) {
3200   vector double __ret = {__a[2], __a[3]};
3201   return __ret;
3202 }
3203
3204 static __inline__ vector double __ATTRS_o_ai
3205 vec_doublel(vector unsigned int __a) {
3206   vector double __ret = {__a[2], __a[3]};
3207   return __ret;
3208 }
3209
3210 static __inline__ vector double __ATTRS_o_ai
3211 vec_doublel(vector float __a) {
3212   vector double __ret = {__a[2], __a[3]};
3213   return __ret;
3214 }
3215
3216 static __inline__ vector double __ATTRS_o_ai
3217 vec_doubleo(vector signed int __a) {
3218 #ifdef __LITTLE_ENDIAN__
3219   return __builtin_vsx_xvcvsxwdp(__a);
3220 #else
3221   return __builtin_vsx_xvcvsxwdp(vec_sld(__a, __a, 4));
3222 #endif
3223 }
3224
3225 static __inline__ vector double __ATTRS_o_ai
3226 vec_doubleo(vector unsigned int __a) {
3227 #ifdef __LITTLE_ENDIAN__
3228   return __builtin_vsx_xvcvuxwdp(__a);
3229 #else
3230   return __builtin_vsx_xvcvuxwdp(vec_sld(__a, __a, 4));
3231 #endif
3232 }
3233
3234 static __inline__ vector double __ATTRS_o_ai
3235 vec_doubleo(vector float __a) {
3236 #ifdef __LITTLE_ENDIAN__
3237   return __builtin_vsx_xvcvspdp(__a);
3238 #else
3239   return __builtin_vsx_xvcvspdp(vec_sld(__a, __a, 4));
3240 #endif
3241 }
3242 #endif
3243
3244 /* vec_div */
3245
3246 /* Integer vector divides (vectors are scalarized, elements divided
3247    and the vectors reassembled).
3248 */
3249 static __inline__ vector signed char __ATTRS_o_ai
3250 vec_div(vector signed char __a, vector signed char __b) {
3251   return __a / __b;
3252 }
3253
3254 static __inline__ vector unsigned char __ATTRS_o_ai
3255 vec_div(vector unsigned char __a, vector unsigned char __b) {
3256   return __a / __b;
3257 }
3258
3259 static __inline__ vector signed short __ATTRS_o_ai
3260 vec_div(vector signed short __a, vector signed short __b) {
3261   return __a / __b;
3262 }
3263
3264 static __inline__ vector unsigned short __ATTRS_o_ai
3265 vec_div(vector unsigned short __a, vector unsigned short __b) {
3266   return __a / __b;
3267 }
3268
3269 static __inline__ vector signed int __ATTRS_o_ai
3270 vec_div(vector signed int __a, vector signed int __b) {
3271   return __a / __b;
3272 }
3273
3274 static __inline__ vector unsigned int __ATTRS_o_ai
3275 vec_div(vector unsigned int __a, vector unsigned int __b) {
3276   return __a / __b;
3277 }
3278
3279 #ifdef __VSX__
3280 static __inline__ vector signed long long __ATTRS_o_ai
3281 vec_div(vector signed long long __a, vector signed long long __b) {
3282   return __a / __b;
3283 }
3284
3285 static __inline__ vector unsigned long long __ATTRS_o_ai
3286 vec_div(vector unsigned long long __a, vector unsigned long long __b) {
3287   return __a / __b;
3288 }
3289
3290 static __inline__ vector float __ATTRS_o_ai vec_div(vector float __a,
3291                                                     vector float __b) {
3292   return __a / __b;
3293 }
3294
3295 static __inline__ vector double __ATTRS_o_ai vec_div(vector double __a,
3296                                                      vector double __b) {
3297   return __a / __b;
3298 }
3299 #endif
3300
3301 /* vec_dss */
3302
3303 static __inline__ void __attribute__((__always_inline__)) vec_dss(int __a) {
3304   __builtin_altivec_dss(__a);
3305 }
3306
3307 /* vec_dssall */
3308
3309 static __inline__ void __attribute__((__always_inline__)) vec_dssall(void) {
3310   __builtin_altivec_dssall();
3311 }
3312
3313 /* vec_dst */
3314 #define vec_dst(__PTR, __CW, __STR) \
3315   __extension__(                    \
3316       { __builtin_altivec_dst((const void *)(__PTR), (__CW), (__STR)); })
3317
3318 /* vec_dstst */
3319 #define vec_dstst(__PTR, __CW, __STR) \
3320   __extension__(                      \
3321       { __builtin_altivec_dstst((const void *)(__PTR), (__CW), (__STR)); })
3322
3323 /* vec_dststt */
3324 #define vec_dststt(__PTR, __CW, __STR) \
3325   __extension__(                       \
3326       { __builtin_altivec_dststt((const void *)(__PTR), (__CW), (__STR)); })
3327
3328 /* vec_dstt */
3329 #define vec_dstt(__PTR, __CW, __STR) \
3330   __extension__(                     \
3331       { __builtin_altivec_dstt((const void *)(__PTR), (__CW), (__STR)); })
3332
3333 /* vec_eqv */
3334
3335 #ifdef __POWER8_VECTOR__
3336 static __inline__ vector signed char __ATTRS_o_ai
3337 vec_eqv(vector signed char __a, vector signed char __b) {
3338   return (vector signed char)__builtin_vsx_xxleqv((vector unsigned int)__a,
3339                                                   (vector unsigned int)__b);
3340 }
3341
3342 static __inline__ vector unsigned char __ATTRS_o_ai
3343 vec_eqv(vector unsigned char __a, vector unsigned char __b) {
3344   return (vector unsigned char)__builtin_vsx_xxleqv((vector unsigned int)__a,
3345                                                     (vector unsigned int)__b);
3346 }
3347
3348 static __inline__ vector bool char __ATTRS_o_ai vec_eqv(vector bool char __a,
3349                                                         vector bool char __b) {
3350   return (vector bool char)__builtin_vsx_xxleqv((vector unsigned int)__a,
3351                                                 (vector unsigned int)__b);
3352 }
3353
3354 static __inline__ vector signed short __ATTRS_o_ai
3355 vec_eqv(vector signed short __a, vector signed short __b) {
3356   return (vector signed short)__builtin_vsx_xxleqv((vector unsigned int)__a,
3357                                                    (vector unsigned int)__b);
3358 }
3359
3360 static __inline__ vector unsigned short __ATTRS_o_ai
3361 vec_eqv(vector unsigned short __a, vector unsigned short __b) {
3362   return (vector unsigned short)__builtin_vsx_xxleqv((vector unsigned int)__a,
3363                                                      (vector unsigned int)__b);
3364 }
3365
3366 static __inline__ vector bool short __ATTRS_o_ai
3367 vec_eqv(vector bool short __a, vector bool short __b) {
3368   return (vector bool short)__builtin_vsx_xxleqv((vector unsigned int)__a,
3369                                                  (vector unsigned int)__b);
3370 }
3371
3372 static __inline__ vector signed int __ATTRS_o_ai
3373 vec_eqv(vector signed int __a, vector signed int __b) {
3374   return (vector signed int)__builtin_vsx_xxleqv((vector unsigned int)__a,
3375                                                  (vector unsigned int)__b);
3376 }
3377
3378 static __inline__ vector unsigned int __ATTRS_o_ai
3379 vec_eqv(vector unsigned int __a, vector unsigned int __b) {
3380   return __builtin_vsx_xxleqv(__a, __b);
3381 }
3382
3383 static __inline__ vector bool int __ATTRS_o_ai vec_eqv(vector bool int __a,
3384                                                        vector bool int __b) {
3385   return (vector bool int)__builtin_vsx_xxleqv((vector unsigned int)__a,
3386                                                (vector unsigned int)__b);
3387 }
3388
3389 static __inline__ vector signed long long __ATTRS_o_ai
3390 vec_eqv(vector signed long long __a, vector signed long long __b) {
3391   return (vector signed long long)__builtin_vsx_xxleqv(
3392       (vector unsigned int)__a, (vector unsigned int)__b);
3393 }
3394
3395 static __inline__ vector unsigned long long __ATTRS_o_ai
3396 vec_eqv(vector unsigned long long __a, vector unsigned long long __b) {
3397   return (vector unsigned long long)__builtin_vsx_xxleqv(
3398       (vector unsigned int)__a, (vector unsigned int)__b);
3399 }
3400
3401 static __inline__ vector bool long long __ATTRS_o_ai
3402 vec_eqv(vector bool long long __a, vector bool long long __b) {
3403   return (vector bool long long)__builtin_vsx_xxleqv((vector unsigned int)__a,
3404                                                      (vector unsigned int)__b);
3405 }
3406
3407 static __inline__ vector float __ATTRS_o_ai vec_eqv(vector float __a,
3408                                                     vector float __b) {
3409   return (vector float)__builtin_vsx_xxleqv((vector unsigned int)__a,
3410                                             (vector unsigned int)__b);
3411 }
3412
3413 static __inline__ vector double __ATTRS_o_ai vec_eqv(vector double __a,
3414                                                      vector double __b) {
3415   return (vector double)__builtin_vsx_xxleqv((vector unsigned int)__a,
3416                                              (vector unsigned int)__b);
3417 }
3418 #endif
3419
3420 /* vec_expte */
3421
3422 static __inline__ vector float __attribute__((__always_inline__))
3423 vec_expte(vector float __a) {
3424   return __builtin_altivec_vexptefp(__a);
3425 }
3426
3427 /* vec_vexptefp */
3428
3429 static __inline__ vector float __attribute__((__always_inline__))
3430 vec_vexptefp(vector float __a) {
3431   return __builtin_altivec_vexptefp(__a);
3432 }
3433
3434 /* vec_floor */
3435
3436 static __inline__ vector float __ATTRS_o_ai vec_floor(vector float __a) {
3437 #ifdef __VSX__
3438   return __builtin_vsx_xvrspim(__a);
3439 #else
3440   return __builtin_altivec_vrfim(__a);
3441 #endif
3442 }
3443
3444 #ifdef __VSX__
3445 static __inline__ vector double __ATTRS_o_ai vec_floor(vector double __a) {
3446   return __builtin_vsx_xvrdpim(__a);
3447 }
3448 #endif
3449
3450 /* vec_vrfim */
3451
3452 static __inline__ vector float __attribute__((__always_inline__))
3453 vec_vrfim(vector float __a) {
3454   return __builtin_altivec_vrfim(__a);
3455 }
3456
3457 /* vec_ld */
3458
3459 static __inline__ vector signed char __ATTRS_o_ai
3460 vec_ld(int __a, const vector signed char *__b) {
3461   return (vector signed char)__builtin_altivec_lvx(__a, __b);
3462 }
3463
3464 static __inline__ vector signed char __ATTRS_o_ai
3465 vec_ld(int __a, const signed char *__b) {
3466   return (vector signed char)__builtin_altivec_lvx(__a, __b);
3467 }
3468
3469 static __inline__ vector unsigned char __ATTRS_o_ai
3470 vec_ld(int __a, const vector unsigned char *__b) {
3471   return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
3472 }
3473
3474 static __inline__ vector unsigned char __ATTRS_o_ai
3475 vec_ld(int __a, const unsigned char *__b) {
3476   return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
3477 }
3478
3479 static __inline__ vector bool char __ATTRS_o_ai
3480 vec_ld(int __a, const vector bool char *__b) {
3481   return (vector bool char)__builtin_altivec_lvx(__a, __b);
3482 }
3483
3484 static __inline__ vector short __ATTRS_o_ai vec_ld(int __a,
3485                                                    const vector short *__b) {
3486   return (vector short)__builtin_altivec_lvx(__a, __b);
3487 }
3488
3489 static __inline__ vector short __ATTRS_o_ai vec_ld(int __a, const short *__b) {
3490   return (vector short)__builtin_altivec_lvx(__a, __b);
3491 }
3492
3493 static __inline__ vector unsigned short __ATTRS_o_ai
3494 vec_ld(int __a, const vector unsigned short *__b) {
3495   return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
3496 }
3497
3498 static __inline__ vector unsigned short __ATTRS_o_ai
3499 vec_ld(int __a, const unsigned short *__b) {
3500   return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
3501 }
3502
3503 static __inline__ vector bool short __ATTRS_o_ai
3504 vec_ld(int __a, const vector bool short *__b) {
3505   return (vector bool short)__builtin_altivec_lvx(__a, __b);
3506 }
3507
3508 static __inline__ vector pixel __ATTRS_o_ai vec_ld(int __a,
3509                                                    const vector pixel *__b) {
3510   return (vector pixel)__builtin_altivec_lvx(__a, __b);
3511 }
3512
3513 static __inline__ vector int __ATTRS_o_ai vec_ld(int __a,
3514                                                  const vector int *__b) {
3515   return (vector int)__builtin_altivec_lvx(__a, __b);
3516 }
3517
3518 static __inline__ vector int __ATTRS_o_ai vec_ld(int __a, const int *__b) {
3519   return (vector int)__builtin_altivec_lvx(__a, __b);
3520 }
3521
3522 static __inline__ vector unsigned int __ATTRS_o_ai
3523 vec_ld(int __a, const vector unsigned int *__b) {
3524   return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
3525 }
3526
3527 static __inline__ vector unsigned int __ATTRS_o_ai
3528 vec_ld(int __a, const unsigned int *__b) {
3529   return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
3530 }
3531
3532 static __inline__ vector bool int __ATTRS_o_ai
3533 vec_ld(int __a, const vector bool int *__b) {
3534   return (vector bool int)__builtin_altivec_lvx(__a, __b);
3535 }
3536
3537 static __inline__ vector float __ATTRS_o_ai vec_ld(int __a,
3538                                                    const vector float *__b) {
3539   return (vector float)__builtin_altivec_lvx(__a, __b);
3540 }
3541
3542 static __inline__ vector float __ATTRS_o_ai vec_ld(int __a, const float *__b) {
3543   return (vector float)__builtin_altivec_lvx(__a, __b);
3544 }
3545
3546 /* vec_lvx */
3547
3548 static __inline__ vector signed char __ATTRS_o_ai
3549 vec_lvx(int __a, const vector signed char *__b) {
3550   return (vector signed char)__builtin_altivec_lvx(__a, __b);
3551 }
3552
3553 static __inline__ vector signed char __ATTRS_o_ai
3554 vec_lvx(int __a, const signed char *__b) {
3555   return (vector signed char)__builtin_altivec_lvx(__a, __b);
3556 }
3557
3558 static __inline__ vector unsigned char __ATTRS_o_ai
3559 vec_lvx(int __a, const vector unsigned char *__b) {
3560   return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
3561 }
3562
3563 static __inline__ vector unsigned char __ATTRS_o_ai
3564 vec_lvx(int __a, const unsigned char *__b) {
3565   return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
3566 }
3567
3568 static __inline__ vector bool char __ATTRS_o_ai
3569 vec_lvx(int __a, const vector bool char *__b) {
3570   return (vector bool char)__builtin_altivec_lvx(__a, __b);
3571 }
3572
3573 static __inline__ vector short __ATTRS_o_ai vec_lvx(int __a,
3574                                                     const vector short *__b) {
3575   return (vector short)__builtin_altivec_lvx(__a, __b);
3576 }
3577
3578 static __inline__ vector short __ATTRS_o_ai vec_lvx(int __a, const short *__b) {
3579   return (vector short)__builtin_altivec_lvx(__a, __b);
3580 }
3581
3582 static __inline__ vector unsigned short __ATTRS_o_ai
3583 vec_lvx(int __a, const vector unsigned short *__b) {
3584   return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
3585 }
3586
3587 static __inline__ vector unsigned short __ATTRS_o_ai
3588 vec_lvx(int __a, const unsigned short *__b) {
3589   return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
3590 }
3591
3592 static __inline__ vector bool short __ATTRS_o_ai
3593 vec_lvx(int __a, const vector bool short *__b) {
3594   return (vector bool short)__builtin_altivec_lvx(__a, __b);
3595 }
3596
3597 static __inline__ vector pixel __ATTRS_o_ai vec_lvx(int __a,
3598                                                     const vector pixel *__b) {
3599   return (vector pixel)__builtin_altivec_lvx(__a, __b);
3600 }
3601
3602 static __inline__ vector int __ATTRS_o_ai vec_lvx(int __a,
3603                                                   const vector int *__b) {
3604   return (vector int)__builtin_altivec_lvx(__a, __b);
3605 }
3606
3607 static __inline__ vector int __ATTRS_o_ai vec_lvx(int __a, const int *__b) {
3608   return (vector int)__builtin_altivec_lvx(__a, __b);
3609 }
3610
3611 static __inline__ vector unsigned int __ATTRS_o_ai
3612 vec_lvx(int __a, const vector unsigned int *__b) {
3613   return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
3614 }
3615
3616 static __inline__ vector unsigned int __ATTRS_o_ai
3617 vec_lvx(int __a, const unsigned int *__b) {
3618   return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
3619 }
3620
3621 static __inline__ vector bool int __ATTRS_o_ai
3622 vec_lvx(int __a, const vector bool int *__b) {
3623   return (vector bool int)__builtin_altivec_lvx(__a, __b);
3624 }
3625
3626 static __inline__ vector float __ATTRS_o_ai vec_lvx(int __a,
3627                                                     const vector float *__b) {
3628   return (vector float)__builtin_altivec_lvx(__a, __b);
3629 }
3630
3631 static __inline__ vector float __ATTRS_o_ai vec_lvx(int __a, const float *__b) {
3632   return (vector float)__builtin_altivec_lvx(__a, __b);
3633 }
3634
3635 /* vec_lde */
3636
3637 static __inline__ vector signed char __ATTRS_o_ai
3638 vec_lde(int __a, const signed char *__b) {
3639   return (vector signed char)__builtin_altivec_lvebx(__a, __b);
3640 }
3641
3642 static __inline__ vector unsigned char __ATTRS_o_ai
3643 vec_lde(int __a, const unsigned char *__b) {
3644   return (vector unsigned char)__builtin_altivec_lvebx(__a, __b);
3645 }
3646
3647 static __inline__ vector short __ATTRS_o_ai vec_lde(int __a, const short *__b) {
3648   return (vector short)__builtin_altivec_lvehx(__a, __b);
3649 }
3650
3651 static __inline__ vector unsigned short __ATTRS_o_ai
3652 vec_lde(int __a, const unsigned short *__b) {
3653   return (vector unsigned short)__builtin_altivec_lvehx(__a, __b);
3654 }
3655
3656 static __inline__ vector int __ATTRS_o_ai vec_lde(int __a, const int *__b) {
3657   return (vector int)__builtin_altivec_lvewx(__a, __b);
3658 }
3659
3660 static __inline__ vector unsigned int __ATTRS_o_ai
3661 vec_lde(int __a, const unsigned int *__b) {
3662   return (vector unsigned int)__builtin_altivec_lvewx(__a, __b);
3663 }
3664
3665 static __inline__ vector float __ATTRS_o_ai vec_lde(int __a, const float *__b) {
3666   return (vector float)__builtin_altivec_lvewx(__a, __b);
3667 }
3668
3669 /* vec_lvebx */
3670
3671 static __inline__ vector signed char __ATTRS_o_ai
3672 vec_lvebx(int __a, const signed char *__b) {
3673   return (vector signed char)__builtin_altivec_lvebx(__a, __b);
3674 }
3675
3676 static __inline__ vector unsigned char __ATTRS_o_ai
3677 vec_lvebx(int __a, const unsigned char *__b) {
3678   return (vector unsigned char)__builtin_altivec_lvebx(__a, __b);
3679 }
3680
3681 /* vec_lvehx */
3682
3683 static __inline__ vector short __ATTRS_o_ai vec_lvehx(int __a,
3684                                                       const short *__b) {
3685   return (vector short)__builtin_altivec_lvehx(__a, __b);
3686 }
3687
3688 static __inline__ vector unsigned short __ATTRS_o_ai
3689 vec_lvehx(int __a, const unsigned short *__b) {
3690   return (vector unsigned short)__builtin_altivec_lvehx(__a, __b);
3691 }
3692
3693 /* vec_lvewx */
3694
3695 static __inline__ vector int __ATTRS_o_ai vec_lvewx(int __a, const int *__b) {
3696   return (vector int)__builtin_altivec_lvewx(__a, __b);
3697 }
3698
3699 static __inline__ vector unsigned int __ATTRS_o_ai
3700 vec_lvewx(int __a, const unsigned int *__b) {
3701   return (vector unsigned int)__builtin_altivec_lvewx(__a, __b);
3702 }
3703
3704 static __inline__ vector float __ATTRS_o_ai vec_lvewx(int __a,
3705                                                       const float *__b) {
3706   return (vector float)__builtin_altivec_lvewx(__a, __b);
3707 }
3708
3709 /* vec_ldl */
3710
3711 static __inline__ vector signed char __ATTRS_o_ai
3712 vec_ldl(int __a, const vector signed char *__b) {
3713   return (vector signed char)__builtin_altivec_lvxl(__a, __b);
3714 }
3715
3716 static __inline__ vector signed char __ATTRS_o_ai
3717 vec_ldl(int __a, const signed char *__b) {
3718   return (vector signed char)__builtin_altivec_lvxl(__a, __b);
3719 }
3720
3721 static __inline__ vector unsigned char __ATTRS_o_ai
3722 vec_ldl(int __a, const vector unsigned char *__b) {
3723   return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
3724 }
3725
3726 static __inline__ vector unsigned char __ATTRS_o_ai
3727 vec_ldl(int __a, const unsigned char *__b) {
3728   return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
3729 }
3730
3731 static __inline__ vector bool char __ATTRS_o_ai
3732 vec_ldl(int __a, const vector bool char *__b) {
3733   return (vector bool char)__builtin_altivec_lvxl(__a, __b);
3734 }
3735
3736 static __inline__ vector short __ATTRS_o_ai vec_ldl(int __a,
3737                                                     const vector short *__b) {
3738   return (vector short)__builtin_altivec_lvxl(__a, __b);
3739 }
3740
3741 static __inline__ vector short __ATTRS_o_ai vec_ldl(int __a, const short *__b) {
3742   return (vector short)__builtin_altivec_lvxl(__a, __b);
3743 }
3744
3745 static __inline__ vector unsigned short __ATTRS_o_ai
3746 vec_ldl(int __a, const vector unsigned short *__b) {
3747   return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
3748 }
3749
3750 static __inline__ vector unsigned short __ATTRS_o_ai
3751 vec_ldl(int __a, const unsigned short *__b) {
3752   return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
3753 }
3754
3755 static __inline__ vector bool short __ATTRS_o_ai
3756 vec_ldl(int __a, const vector bool short *__b) {
3757   return (vector bool short)__builtin_altivec_lvxl(__a, __b);
3758 }
3759
3760 static __inline__ vector pixel __ATTRS_o_ai vec_ldl(int __a,
3761                                                     const vector pixel *__b) {
3762   return (vector pixel short)__builtin_altivec_lvxl(__a, __b);
3763 }
3764
3765 static __inline__ vector int __ATTRS_o_ai vec_ldl(int __a,
3766                                                   const vector int *__b) {
3767   return (vector int)__builtin_altivec_lvxl(__a, __b);
3768 }
3769
3770 static __inline__ vector int __ATTRS_o_ai vec_ldl(int __a, const int *__b) {
3771   return (vector int)__builtin_altivec_lvxl(__a, __b);
3772 }
3773
3774 static __inline__ vector unsigned int __ATTRS_o_ai
3775 vec_ldl(int __a, const vector unsigned int *__b) {
3776   return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
3777 }
3778
3779 static __inline__ vector unsigned int __ATTRS_o_ai
3780 vec_ldl(int __a, const unsigned int *__b) {
3781   return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
3782 }
3783
3784 static __inline__ vector bool int __ATTRS_o_ai
3785 vec_ldl(int __a, const vector bool int *__b) {
3786   return (vector bool int)__builtin_altivec_lvxl(__a, __b);
3787 }
3788
3789 static __inline__ vector float __ATTRS_o_ai vec_ldl(int __a,
3790                                                     const vector float *__b) {
3791   return (vector float)__builtin_altivec_lvxl(__a, __b);
3792 }
3793
3794 static __inline__ vector float __ATTRS_o_ai vec_ldl(int __a, const float *__b) {
3795   return (vector float)__builtin_altivec_lvxl(__a, __b);
3796 }
3797
3798 /* vec_lvxl */
3799
3800 static __inline__ vector signed char __ATTRS_o_ai
3801 vec_lvxl(int __a, const vector signed char *__b) {
3802   return (vector signed char)__builtin_altivec_lvxl(__a, __b);
3803 }
3804
3805 static __inline__ vector signed char __ATTRS_o_ai
3806 vec_lvxl(int __a, const signed char *__b) {
3807   return (vector signed char)__builtin_altivec_lvxl(__a, __b);
3808 }
3809
3810 static __inline__ vector unsigned char __ATTRS_o_ai
3811 vec_lvxl(int __a, const vector unsigned char *__b) {
3812   return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
3813 }
3814
3815 static __inline__ vector unsigned char __ATTRS_o_ai
3816 vec_lvxl(int __a, const unsigned char *__b) {
3817   return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
3818 }
3819
3820 static __inline__ vector bool char __ATTRS_o_ai
3821 vec_lvxl(int __a, const vector bool char *__b) {
3822   return (vector bool char)__builtin_altivec_lvxl(__a, __b);
3823 }
3824
3825 static __inline__ vector short __ATTRS_o_ai vec_lvxl(int __a,
3826                                                      const vector short *__b) {
3827   return (vector short)__builtin_altivec_lvxl(__a, __b);
3828 }
3829
3830 static __inline__ vector short __ATTRS_o_ai vec_lvxl(int __a,
3831                                                      const short *__b) {
3832   return (vector short)__builtin_altivec_lvxl(__a, __b);
3833 }
3834
3835 static __inline__ vector unsigned short __ATTRS_o_ai
3836 vec_lvxl(int __a, const vector unsigned short *__b) {
3837   return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
3838 }
3839
3840 static __inline__ vector unsigned short __ATTRS_o_ai
3841 vec_lvxl(int __a, const unsigned short *__b) {
3842   return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
3843 }
3844
3845 static __inline__ vector bool short __ATTRS_o_ai
3846 vec_lvxl(int __a, const vector bool short *__b) {
3847   return (vector bool short)__builtin_altivec_lvxl(__a, __b);
3848 }
3849
3850 static __inline__ vector pixel __ATTRS_o_ai vec_lvxl(int __a,
3851                                                      const vector pixel *__b) {
3852   return (vector pixel)__builtin_altivec_lvxl(__a, __b);
3853 }
3854
3855 static __inline__ vector int __ATTRS_o_ai vec_lvxl(int __a,
3856                                                    const vector int *__b) {
3857   return (vector int)__builtin_altivec_lvxl(__a, __b);
3858 }
3859
3860 static __inline__ vector int __ATTRS_o_ai vec_lvxl(int __a, const int *__b) {
3861   return (vector int)__builtin_altivec_lvxl(__a, __b);
3862 }
3863
3864 static __inline__ vector unsigned int __ATTRS_o_ai
3865 vec_lvxl(int __a, const vector unsigned int *__b) {
3866   return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
3867 }
3868
3869 static __inline__ vector unsigned int __ATTRS_o_ai
3870 vec_lvxl(int __a, const unsigned int *__b) {
3871   return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
3872 }
3873
3874 static __inline__ vector bool int __ATTRS_o_ai
3875 vec_lvxl(int __a, const vector bool int *__b) {
3876   return (vector bool int)__builtin_altivec_lvxl(__a, __b);
3877 }
3878
3879 static __inline__ vector float __ATTRS_o_ai vec_lvxl(int __a,
3880                                                      const vector float *__b) {
3881   return (vector float)__builtin_altivec_lvxl(__a, __b);
3882 }
3883
3884 static __inline__ vector float __ATTRS_o_ai vec_lvxl(int __a,
3885                                                      const float *__b) {
3886   return (vector float)__builtin_altivec_lvxl(__a, __b);
3887 }
3888
3889 /* vec_loge */
3890
3891 static __inline__ vector float __attribute__((__always_inline__))
3892 vec_loge(vector float __a) {
3893   return __builtin_altivec_vlogefp(__a);
3894 }
3895
3896 /* vec_vlogefp */
3897
3898 static __inline__ vector float __attribute__((__always_inline__))
3899 vec_vlogefp(vector float __a) {
3900   return __builtin_altivec_vlogefp(__a);
3901 }
3902
3903 /* vec_lvsl */
3904
3905 #ifdef __LITTLE_ENDIAN__
3906 static __inline__ vector unsigned char __ATTRS_o_ai
3907     __attribute__((__deprecated__("use assignment for unaligned little endian \
3908 loads/stores"))) vec_lvsl(int __a, const signed char *__b) {
3909   vector unsigned char mask =
3910       (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
3911   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
3912                                   7,  6,  5,  4,  3,  2,  1, 0};
3913   return vec_perm(mask, mask, reverse);
3914 }
3915 #else
3916 static __inline__ vector unsigned char __ATTRS_o_ai
3917 vec_lvsl(int __a, const signed char *__b) {
3918   return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
3919 }
3920 #endif
3921
3922 #ifdef __LITTLE_ENDIAN__
3923 static __inline__ vector unsigned char __ATTRS_o_ai
3924     __attribute__((__deprecated__("use assignment for unaligned little endian \
3925 loads/stores"))) vec_lvsl(int __a, const unsigned char *__b) {
3926   vector unsigned char mask =
3927       (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
3928   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
3929                                   7,  6,  5,  4,  3,  2,  1, 0};
3930   return vec_perm(mask, mask, reverse);
3931 }
3932 #else
3933 static __inline__ vector unsigned char __ATTRS_o_ai
3934 vec_lvsl(int __a, const unsigned char *__b) {
3935   return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
3936 }
3937 #endif
3938
3939 #ifdef __LITTLE_ENDIAN__
3940 static __inline__ vector unsigned char __ATTRS_o_ai
3941     __attribute__((__deprecated__("use assignment for unaligned little endian \
3942 loads/stores"))) vec_lvsl(int __a, const short *__b) {
3943   vector unsigned char mask =
3944       (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
3945   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
3946                                   7,  6,  5,  4,  3,  2,  1, 0};
3947   return vec_perm(mask, mask, reverse);
3948 }
3949 #else
3950 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsl(int __a,
3951                                                              const short *__b) {
3952   return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
3953 }
3954 #endif
3955
3956 #ifdef __LITTLE_ENDIAN__
3957 static __inline__ vector unsigned char __ATTRS_o_ai
3958     __attribute__((__deprecated__("use assignment for unaligned little endian \
3959 loads/stores"))) vec_lvsl(int __a, const unsigned short *__b) {
3960   vector unsigned char mask =
3961       (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
3962   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
3963                                   7,  6,  5,  4,  3,  2,  1, 0};
3964   return vec_perm(mask, mask, reverse);
3965 }
3966 #else
3967 static __inline__ vector unsigned char __ATTRS_o_ai
3968 vec_lvsl(int __a, const unsigned short *__b) {
3969   return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
3970 }
3971 #endif
3972
3973 #ifdef __LITTLE_ENDIAN__
3974 static __inline__ vector unsigned char __ATTRS_o_ai
3975     __attribute__((__deprecated__("use assignment for unaligned little endian \
3976 loads/stores"))) vec_lvsl(int __a, const int *__b) {
3977   vector unsigned char mask =
3978       (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
3979   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
3980                                   7,  6,  5,  4,  3,  2,  1, 0};
3981   return vec_perm(mask, mask, reverse);
3982 }
3983 #else
3984 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsl(int __a,
3985                                                              const int *__b) {
3986   return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
3987 }
3988 #endif
3989
3990 #ifdef __LITTLE_ENDIAN__
3991 static __inline__ vector unsigned char __ATTRS_o_ai
3992     __attribute__((__deprecated__("use assignment for unaligned little endian \
3993 loads/stores"))) vec_lvsl(int __a, const unsigned int *__b) {
3994   vector unsigned char mask =
3995       (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
3996   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
3997                                   7,  6,  5,  4,  3,  2,  1, 0};
3998   return vec_perm(mask, mask, reverse);
3999 }
4000 #else
4001 static __inline__ vector unsigned char __ATTRS_o_ai
4002 vec_lvsl(int __a, const unsigned int *__b) {
4003   return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4004 }
4005 #endif
4006
4007 #ifdef __LITTLE_ENDIAN__
4008 static __inline__ vector unsigned char __ATTRS_o_ai
4009     __attribute__((__deprecated__("use assignment for unaligned little endian \
4010 loads/stores"))) vec_lvsl(int __a, const float *__b) {
4011   vector unsigned char mask =
4012       (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4013   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4014                                   7,  6,  5,  4,  3,  2,  1, 0};
4015   return vec_perm(mask, mask, reverse);
4016 }
4017 #else
4018 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsl(int __a,
4019                                                              const float *__b) {
4020   return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4021 }
4022 #endif
4023
4024 /* vec_lvsr */
4025
4026 #ifdef __LITTLE_ENDIAN__
4027 static __inline__ vector unsigned char __ATTRS_o_ai
4028     __attribute__((__deprecated__("use assignment for unaligned little endian \
4029 loads/stores"))) vec_lvsr(int __a, const signed char *__b) {
4030   vector unsigned char mask =
4031       (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4032   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4033                                   7,  6,  5,  4,  3,  2,  1, 0};
4034   return vec_perm(mask, mask, reverse);
4035 }
4036 #else
4037 static __inline__ vector unsigned char __ATTRS_o_ai
4038 vec_lvsr(int __a, const signed char *__b) {
4039   return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4040 }
4041 #endif
4042
4043 #ifdef __LITTLE_ENDIAN__
4044 static __inline__ vector unsigned char __ATTRS_o_ai
4045     __attribute__((__deprecated__("use assignment for unaligned little endian \
4046 loads/stores"))) vec_lvsr(int __a, const unsigned char *__b) {
4047   vector unsigned char mask =
4048       (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4049   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4050                                   7,  6,  5,  4,  3,  2,  1, 0};
4051   return vec_perm(mask, mask, reverse);
4052 }
4053 #else
4054 static __inline__ vector unsigned char __ATTRS_o_ai
4055 vec_lvsr(int __a, const unsigned char *__b) {
4056   return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4057 }
4058 #endif
4059
4060 #ifdef __LITTLE_ENDIAN__
4061 static __inline__ vector unsigned char __ATTRS_o_ai
4062     __attribute__((__deprecated__("use assignment for unaligned little endian \
4063 loads/stores"))) vec_lvsr(int __a, const short *__b) {
4064   vector unsigned char mask =
4065       (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4066   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4067                                   7,  6,  5,  4,  3,  2,  1, 0};
4068   return vec_perm(mask, mask, reverse);
4069 }
4070 #else
4071 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsr(int __a,
4072                                                              const short *__b) {
4073   return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4074 }
4075 #endif
4076
4077 #ifdef __LITTLE_ENDIAN__
4078 static __inline__ vector unsigned char __ATTRS_o_ai
4079     __attribute__((__deprecated__("use assignment for unaligned little endian \
4080 loads/stores"))) vec_lvsr(int __a, const unsigned short *__b) {
4081   vector unsigned char mask =
4082       (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4083   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4084                                   7,  6,  5,  4,  3,  2,  1, 0};
4085   return vec_perm(mask, mask, reverse);
4086 }
4087 #else
4088 static __inline__ vector unsigned char __ATTRS_o_ai
4089 vec_lvsr(int __a, const unsigned short *__b) {
4090   return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4091 }
4092 #endif
4093
4094 #ifdef __LITTLE_ENDIAN__
4095 static __inline__ vector unsigned char __ATTRS_o_ai
4096     __attribute__((__deprecated__("use assignment for unaligned little endian \
4097 loads/stores"))) vec_lvsr(int __a, const int *__b) {
4098   vector unsigned char mask =
4099       (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4100   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4101                                   7,  6,  5,  4,  3,  2,  1, 0};
4102   return vec_perm(mask, mask, reverse);
4103 }
4104 #else
4105 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsr(int __a,
4106                                                              const int *__b) {
4107   return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4108 }
4109 #endif
4110
4111 #ifdef __LITTLE_ENDIAN__
4112 static __inline__ vector unsigned char __ATTRS_o_ai
4113     __attribute__((__deprecated__("use assignment for unaligned little endian \
4114 loads/stores"))) vec_lvsr(int __a, const unsigned int *__b) {
4115   vector unsigned char mask =
4116       (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4117   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4118                                   7,  6,  5,  4,  3,  2,  1, 0};
4119   return vec_perm(mask, mask, reverse);
4120 }
4121 #else
4122 static __inline__ vector unsigned char __ATTRS_o_ai
4123 vec_lvsr(int __a, const unsigned int *__b) {
4124   return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4125 }
4126 #endif
4127
4128 #ifdef __LITTLE_ENDIAN__
4129 static __inline__ vector unsigned char __ATTRS_o_ai
4130     __attribute__((__deprecated__("use assignment for unaligned little endian \
4131 loads/stores"))) vec_lvsr(int __a, const float *__b) {
4132   vector unsigned char mask =
4133       (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4134   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4135                                   7,  6,  5,  4,  3,  2,  1, 0};
4136   return vec_perm(mask, mask, reverse);
4137 }
4138 #else
4139 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsr(int __a,
4140                                                              const float *__b) {
4141   return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4142 }
4143 #endif
4144
4145 /* vec_madd */
4146 static __inline__ vector signed short __ATTRS_o_ai
4147 vec_mladd(vector signed short, vector signed short, vector signed short);
4148 static __inline__ vector signed short __ATTRS_o_ai
4149 vec_mladd(vector signed short, vector unsigned short, vector unsigned short);
4150 static __inline__ vector signed short __ATTRS_o_ai
4151 vec_mladd(vector unsigned short, vector signed short, vector signed short);
4152 static __inline__ vector unsigned short __ATTRS_o_ai
4153 vec_mladd(vector unsigned short, vector unsigned short, vector unsigned short);
4154
4155 static __inline__ vector signed short __ATTRS_o_ai vec_madd(
4156     vector signed short __a, vector signed short __b, vector signed short __c) {
4157   return vec_mladd(__a, __b, __c);
4158 }
4159
4160 static __inline__ vector signed short __ATTRS_o_ai
4161 vec_madd(vector signed short __a, vector unsigned short __b,
4162          vector unsigned short __c) {
4163   return vec_mladd(__a, __b, __c);
4164 }
4165
4166 static __inline__ vector signed short __ATTRS_o_ai
4167 vec_madd(vector unsigned short __a, vector signed short __b,
4168          vector signed short __c) {
4169   return vec_mladd(__a, __b, __c);
4170 }
4171
4172 static __inline__ vector unsigned short __ATTRS_o_ai
4173 vec_madd(vector unsigned short __a, vector unsigned short __b,
4174          vector unsigned short __c) {
4175   return vec_mladd(__a, __b, __c);
4176 }
4177
4178 static __inline__ vector float __ATTRS_o_ai vec_madd(vector float __a,
4179                                                      vector float __b,
4180                                                      vector float __c) {
4181 #ifdef __VSX__
4182   return __builtin_vsx_xvmaddasp(__a, __b, __c);
4183 #else
4184   return __builtin_altivec_vmaddfp(__a, __b, __c);
4185 #endif
4186 }
4187
4188 #ifdef __VSX__
4189 static __inline__ vector double __ATTRS_o_ai vec_madd(vector double __a,
4190                                                       vector double __b,
4191                                                       vector double __c) {
4192   return __builtin_vsx_xvmaddadp(__a, __b, __c);
4193 }
4194 #endif
4195
4196 /* vec_vmaddfp */
4197
4198 static __inline__ vector float __attribute__((__always_inline__))
4199 vec_vmaddfp(vector float __a, vector float __b, vector float __c) {
4200   return __builtin_altivec_vmaddfp(__a, __b, __c);
4201 }
4202
4203 /* vec_madds */
4204
4205 static __inline__ vector signed short __attribute__((__always_inline__))
4206 vec_madds(vector signed short __a, vector signed short __b,
4207           vector signed short __c) {
4208   return __builtin_altivec_vmhaddshs(__a, __b, __c);
4209 }
4210
4211 /* vec_vmhaddshs */
4212 static __inline__ vector signed short __attribute__((__always_inline__))
4213 vec_vmhaddshs(vector signed short __a, vector signed short __b,
4214               vector signed short __c) {
4215   return __builtin_altivec_vmhaddshs(__a, __b, __c);
4216 }
4217
4218 /* vec_msub */
4219
4220 #ifdef __VSX__
4221 static __inline__ vector float __ATTRS_o_ai vec_msub(vector float __a,
4222                                                      vector float __b,
4223                                                      vector float __c) {
4224   return __builtin_vsx_xvmsubasp(__a, __b, __c);
4225 }
4226
4227 static __inline__ vector double __ATTRS_o_ai vec_msub(vector double __a,
4228                                                       vector double __b,
4229                                                       vector double __c) {
4230   return __builtin_vsx_xvmsubadp(__a, __b, __c);
4231 }
4232 #endif
4233
4234 /* vec_max */
4235
4236 static __inline__ vector signed char __ATTRS_o_ai
4237 vec_max(vector signed char __a, vector signed char __b) {
4238   return __builtin_altivec_vmaxsb(__a, __b);
4239 }
4240
4241 static __inline__ vector signed char __ATTRS_o_ai
4242 vec_max(vector bool char __a, vector signed char __b) {
4243   return __builtin_altivec_vmaxsb((vector signed char)__a, __b);
4244 }
4245
4246 static __inline__ vector signed char __ATTRS_o_ai
4247 vec_max(vector signed char __a, vector bool char __b) {
4248   return __builtin_altivec_vmaxsb(__a, (vector signed char)__b);
4249 }
4250
4251 static __inline__ vector unsigned char __ATTRS_o_ai
4252 vec_max(vector unsigned char __a, vector unsigned char __b) {
4253   return __builtin_altivec_vmaxub(__a, __b);
4254 }
4255
4256 static __inline__ vector unsigned char __ATTRS_o_ai
4257 vec_max(vector bool char __a, vector unsigned char __b) {
4258   return __builtin_altivec_vmaxub((vector unsigned char)__a, __b);
4259 }
4260
4261 static __inline__ vector unsigned char __ATTRS_o_ai
4262 vec_max(vector unsigned char __a, vector bool char __b) {
4263   return __builtin_altivec_vmaxub(__a, (vector unsigned char)__b);
4264 }
4265
4266 static __inline__ vector short __ATTRS_o_ai vec_max(vector short __a,
4267                                                     vector short __b) {
4268   return __builtin_altivec_vmaxsh(__a, __b);
4269 }
4270
4271 static __inline__ vector short __ATTRS_o_ai vec_max(vector bool short __a,
4272                                                     vector short __b) {
4273   return __builtin_altivec_vmaxsh((vector short)__a, __b);
4274 }
4275
4276 static __inline__ vector short __ATTRS_o_ai vec_max(vector short __a,
4277                                                     vector bool short __b) {
4278   return __builtin_altivec_vmaxsh(__a, (vector short)__b);
4279 }
4280
4281 static __inline__ vector unsigned short __ATTRS_o_ai
4282 vec_max(vector unsigned short __a, vector unsigned short __b) {
4283   return __builtin_altivec_vmaxuh(__a, __b);
4284 }
4285
4286 static __inline__ vector unsigned short __ATTRS_o_ai
4287 vec_max(vector bool short __a, vector unsigned short __b) {
4288   return __builtin_altivec_vmaxuh((vector unsigned short)__a, __b);
4289 }
4290
4291 static __inline__ vector unsigned short __ATTRS_o_ai
4292 vec_max(vector unsigned short __a, vector bool short __b) {
4293   return __builtin_altivec_vmaxuh(__a, (vector unsigned short)__b);
4294 }
4295
4296 static __inline__ vector int __ATTRS_o_ai vec_max(vector int __a,
4297                                                   vector int __b) {
4298   return __builtin_altivec_vmaxsw(__a, __b);
4299 }
4300
4301 static __inline__ vector int __ATTRS_o_ai vec_max(vector bool int __a,
4302                                                   vector int __b) {
4303   return __builtin_altivec_vmaxsw((vector int)__a, __b);
4304 }
4305
4306 static __inline__ vector int __ATTRS_o_ai vec_max(vector int __a,
4307                                                   vector bool int __b) {
4308   return __builtin_altivec_vmaxsw(__a, (vector int)__b);
4309 }
4310
4311 static __inline__ vector unsigned int __ATTRS_o_ai
4312 vec_max(vector unsigned int __a, vector unsigned int __b) {
4313   return __builtin_altivec_vmaxuw(__a, __b);
4314 }
4315
4316 static __inline__ vector unsigned int __ATTRS_o_ai
4317 vec_max(vector bool int __a, vector unsigned int __b) {
4318   return __builtin_altivec_vmaxuw((vector unsigned int)__a, __b);
4319 }
4320
4321 static __inline__ vector unsigned int __ATTRS_o_ai
4322 vec_max(vector unsigned int __a, vector bool int __b) {
4323   return __builtin_altivec_vmaxuw(__a, (vector unsigned int)__b);
4324 }
4325
4326 #ifdef __POWER8_VECTOR__
4327 static __inline__ vector signed long long __ATTRS_o_ai
4328 vec_max(vector signed long long __a, vector signed long long __b) {
4329   return __builtin_altivec_vmaxsd(__a, __b);
4330 }
4331
4332 static __inline__ vector signed long long __ATTRS_o_ai
4333 vec_max(vector bool long long __a, vector signed long long __b) {
4334   return __builtin_altivec_vmaxsd((vector signed long long)__a, __b);
4335 }
4336
4337 static __inline__ vector signed long long __ATTRS_o_ai
4338 vec_max(vector signed long long __a, vector bool long long __b) {
4339   return __builtin_altivec_vmaxsd(__a, (vector signed long long)__b);
4340 }
4341
4342 static __inline__ vector unsigned long long __ATTRS_o_ai
4343 vec_max(vector unsigned long long __a, vector unsigned long long __b) {
4344   return __builtin_altivec_vmaxud(__a, __b);
4345 }
4346
4347 static __inline__ vector unsigned long long __ATTRS_o_ai
4348 vec_max(vector bool long long __a, vector unsigned long long __b) {
4349   return __builtin_altivec_vmaxud((vector unsigned long long)__a, __b);
4350 }
4351
4352 static __inline__ vector unsigned long long __ATTRS_o_ai
4353 vec_max(vector unsigned long long __a, vector bool long long __b) {
4354   return __builtin_altivec_vmaxud(__a, (vector unsigned long long)__b);
4355 }
4356 #endif
4357
4358 static __inline__ vector float __ATTRS_o_ai vec_max(vector float __a,
4359                                                     vector float __b) {
4360 #ifdef __VSX__
4361   return __builtin_vsx_xvmaxsp(__a, __b);
4362 #else
4363   return __builtin_altivec_vmaxfp(__a, __b);
4364 #endif
4365 }
4366
4367 #ifdef __VSX__
4368 static __inline__ vector double __ATTRS_o_ai vec_max(vector double __a,
4369                                                      vector double __b) {
4370   return __builtin_vsx_xvmaxdp(__a, __b);
4371 }
4372 #endif
4373
4374 /* vec_vmaxsb */
4375
4376 static __inline__ vector signed char __ATTRS_o_ai
4377 vec_vmaxsb(vector signed char __a, vector signed char __b) {
4378   return __builtin_altivec_vmaxsb(__a, __b);
4379 }
4380
4381 static __inline__ vector signed char __ATTRS_o_ai
4382 vec_vmaxsb(vector bool char __a, vector signed char __b) {
4383   return __builtin_altivec_vmaxsb((vector signed char)__a, __b);
4384 }
4385
4386 static __inline__ vector signed char __ATTRS_o_ai
4387 vec_vmaxsb(vector signed char __a, vector bool char __b) {
4388   return __builtin_altivec_vmaxsb(__a, (vector signed char)__b);
4389 }
4390
4391 /* vec_vmaxub */
4392
4393 static __inline__ vector unsigned char __ATTRS_o_ai
4394 vec_vmaxub(vector unsigned char __a, vector unsigned char __b) {
4395   return __builtin_altivec_vmaxub(__a, __b);
4396 }
4397
4398 static __inline__ vector unsigned char __ATTRS_o_ai
4399 vec_vmaxub(vector bool char __a, vector unsigned char __b) {
4400   return __builtin_altivec_vmaxub((vector unsigned char)__a, __b);
4401 }
4402
4403 static __inline__ vector unsigned char __ATTRS_o_ai
4404 vec_vmaxub(vector unsigned char __a, vector bool char __b) {
4405   return __builtin_altivec_vmaxub(__a, (vector unsigned char)__b);
4406 }
4407
4408 /* vec_vmaxsh */
4409
4410 static __inline__ vector short __ATTRS_o_ai vec_vmaxsh(vector short __a,
4411                                                        vector short __b) {
4412   return __builtin_altivec_vmaxsh(__a, __b);
4413 }
4414
4415 static __inline__ vector short __ATTRS_o_ai vec_vmaxsh(vector bool short __a,
4416                                                        vector short __b) {
4417   return __builtin_altivec_vmaxsh((vector short)__a, __b);
4418 }
4419
4420 static __inline__ vector short __ATTRS_o_ai vec_vmaxsh(vector short __a,
4421                                                        vector bool short __b) {
4422   return __builtin_altivec_vmaxsh(__a, (vector short)__b);
4423 }
4424
4425 /* vec_vmaxuh */
4426
4427 static __inline__ vector unsigned short __ATTRS_o_ai
4428 vec_vmaxuh(vector unsigned short __a, vector unsigned short __b) {
4429   return __builtin_altivec_vmaxuh(__a, __b);
4430 }
4431
4432 static __inline__ vector unsigned short __ATTRS_o_ai
4433 vec_vmaxuh(vector bool short __a, vector unsigned short __b) {
4434   return __builtin_altivec_vmaxuh((vector unsigned short)__a, __b);
4435 }
4436
4437 static __inline__ vector unsigned short __ATTRS_o_ai
4438 vec_vmaxuh(vector unsigned short __a, vector bool short __b) {
4439   return __builtin_altivec_vmaxuh(__a, (vector unsigned short)__b);
4440 }
4441
4442 /* vec_vmaxsw */
4443
4444 static __inline__ vector int __ATTRS_o_ai vec_vmaxsw(vector int __a,
4445                                                      vector int __b) {
4446   return __builtin_altivec_vmaxsw(__a, __b);
4447 }
4448
4449 static __inline__ vector int __ATTRS_o_ai vec_vmaxsw(vector bool int __a,
4450                                                      vector int __b) {
4451   return __builtin_altivec_vmaxsw((vector int)__a, __b);
4452 }
4453
4454 static __inline__ vector int __ATTRS_o_ai vec_vmaxsw(vector int __a,
4455                                                      vector bool int __b) {
4456   return __builtin_altivec_vmaxsw(__a, (vector int)__b);
4457 }
4458
4459 /* vec_vmaxuw */
4460
4461 static __inline__ vector unsigned int __ATTRS_o_ai
4462 vec_vmaxuw(vector unsigned int __a, vector unsigned int __b) {
4463   return __builtin_altivec_vmaxuw(__a, __b);
4464 }
4465
4466 static __inline__ vector unsigned int __ATTRS_o_ai
4467 vec_vmaxuw(vector bool int __a, vector unsigned int __b) {
4468   return __builtin_altivec_vmaxuw((vector unsigned int)__a, __b);
4469 }
4470
4471 static __inline__ vector unsigned int __ATTRS_o_ai
4472 vec_vmaxuw(vector unsigned int __a, vector bool int __b) {
4473   return __builtin_altivec_vmaxuw(__a, (vector unsigned int)__b);
4474 }
4475
4476 /* vec_vmaxfp */
4477
4478 static __inline__ vector float __attribute__((__always_inline__))
4479 vec_vmaxfp(vector float __a, vector float __b) {
4480 #ifdef __VSX__
4481   return __builtin_vsx_xvmaxsp(__a, __b);
4482 #else
4483   return __builtin_altivec_vmaxfp(__a, __b);
4484 #endif
4485 }
4486
4487 /* vec_mergeh */
4488
4489 static __inline__ vector signed char __ATTRS_o_ai
4490 vec_mergeh(vector signed char __a, vector signed char __b) {
4491   return vec_perm(__a, __b,
4492                   (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
4493                                          0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
4494                                          0x06, 0x16, 0x07, 0x17));
4495 }
4496
4497 static __inline__ vector unsigned char __ATTRS_o_ai
4498 vec_mergeh(vector unsigned char __a, vector unsigned char __b) {
4499   return vec_perm(__a, __b,
4500                   (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
4501                                          0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
4502                                          0x06, 0x16, 0x07, 0x17));
4503 }
4504
4505 static __inline__ vector bool char __ATTRS_o_ai
4506 vec_mergeh(vector bool char __a, vector bool char __b) {
4507   return vec_perm(__a, __b,
4508                   (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
4509                                          0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
4510                                          0x06, 0x16, 0x07, 0x17));
4511 }
4512
4513 static __inline__ vector short __ATTRS_o_ai vec_mergeh(vector short __a,
4514                                                        vector short __b) {
4515   return vec_perm(__a, __b,
4516                   (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
4517                                          0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
4518                                          0x06, 0x07, 0x16, 0x17));
4519 }
4520
4521 static __inline__ vector unsigned short __ATTRS_o_ai
4522 vec_mergeh(vector unsigned short __a, vector unsigned short __b) {
4523   return vec_perm(__a, __b,
4524                   (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
4525                                          0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
4526                                          0x06, 0x07, 0x16, 0x17));
4527 }
4528
4529 static __inline__ vector bool short __ATTRS_o_ai
4530 vec_mergeh(vector bool short __a, vector bool short __b) {
4531   return vec_perm(__a, __b,
4532                   (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
4533                                          0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
4534                                          0x06, 0x07, 0x16, 0x17));
4535 }
4536
4537 static __inline__ vector pixel __ATTRS_o_ai vec_mergeh(vector pixel __a,
4538                                                        vector pixel __b) {
4539   return vec_perm(__a, __b,
4540                   (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
4541                                          0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
4542                                          0x06, 0x07, 0x16, 0x17));
4543 }
4544
4545 static __inline__ vector int __ATTRS_o_ai vec_mergeh(vector int __a,
4546                                                      vector int __b) {
4547   return vec_perm(__a, __b,
4548                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
4549                                          0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
4550                                          0x14, 0x15, 0x16, 0x17));
4551 }
4552
4553 static __inline__ vector unsigned int __ATTRS_o_ai
4554 vec_mergeh(vector unsigned int __a, vector unsigned int __b) {
4555   return vec_perm(__a, __b,
4556                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
4557                                          0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
4558                                          0x14, 0x15, 0x16, 0x17));
4559 }
4560
4561 static __inline__ vector bool int __ATTRS_o_ai vec_mergeh(vector bool int __a,
4562                                                           vector bool int __b) {
4563   return vec_perm(__a, __b,
4564                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
4565                                          0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
4566                                          0x14, 0x15, 0x16, 0x17));
4567 }
4568
4569 static __inline__ vector float __ATTRS_o_ai vec_mergeh(vector float __a,
4570                                                        vector float __b) {
4571   return vec_perm(__a, __b,
4572                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
4573                                          0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
4574                                          0x14, 0x15, 0x16, 0x17));
4575 }
4576
4577 #ifdef __VSX__
4578 static __inline__ vector signed long long __ATTRS_o_ai
4579 vec_mergeh(vector signed long long __a, vector signed long long __b) {
4580   return vec_perm(__a, __b,
4581                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
4582                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
4583                                          0x14, 0x15, 0x16, 0x17));
4584 }
4585
4586 static __inline__ vector signed long long __ATTRS_o_ai
4587 vec_mergeh(vector signed long long __a, vector bool long long __b) {
4588   return vec_perm(__a, (vector signed long long)__b,
4589                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
4590                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
4591                                          0x14, 0x15, 0x16, 0x17));
4592 }
4593
4594 static __inline__ vector signed long long __ATTRS_o_ai
4595 vec_mergeh(vector bool long long __a, vector signed long long __b) {
4596   return vec_perm((vector signed long long)__a, __b,
4597                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
4598                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
4599                                          0x14, 0x15, 0x16, 0x17));
4600 }
4601
4602 static __inline__ vector unsigned long long __ATTRS_o_ai
4603 vec_mergeh(vector unsigned long long __a, vector unsigned long long __b) {
4604   return vec_perm(__a, __b,
4605                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
4606                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
4607                                          0x14, 0x15, 0x16, 0x17));
4608 }
4609
4610 static __inline__ vector unsigned long long __ATTRS_o_ai
4611 vec_mergeh(vector unsigned long long __a, vector bool long long __b) {
4612   return vec_perm(__a, (vector unsigned long long)__b,
4613                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
4614                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
4615                                          0x14, 0x15, 0x16, 0x17));
4616 }
4617
4618 static __inline__ vector unsigned long long __ATTRS_o_ai
4619 vec_mergeh(vector bool long long __a, vector unsigned long long __b) {
4620   return vec_perm((vector unsigned long long)__a, __b,
4621                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
4622                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
4623                                          0x14, 0x15, 0x16, 0x17));
4624 }
4625
4626 static __inline__ vector bool long long __ATTRS_o_ai
4627 vec_mergeh(vector bool long long __a, vector bool long long __b) {
4628   return vec_perm(__a, __b,
4629                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
4630                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
4631                                          0x14, 0x15, 0x16, 0x17));
4632 }
4633
4634 static __inline__ vector double __ATTRS_o_ai vec_mergeh(vector double __a,
4635                                                         vector double __b) {
4636   return vec_perm(__a, __b,
4637                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
4638                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
4639                                          0x14, 0x15, 0x16, 0x17));
4640 }
4641 static __inline__ vector double __ATTRS_o_ai
4642 vec_mergeh(vector double __a, vector bool long long __b) {
4643   return vec_perm(__a, (vector double)__b,
4644                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
4645                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
4646                                          0x14, 0x15, 0x16, 0x17));
4647 }
4648 static __inline__ vector double __ATTRS_o_ai
4649 vec_mergeh(vector bool long long __a, vector double __b) {
4650   return vec_perm((vector double)__a, __b,
4651                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
4652                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
4653                                          0x14, 0x15, 0x16, 0x17));
4654 }
4655 #endif
4656
4657 /* vec_vmrghb */
4658
4659 #define __builtin_altivec_vmrghb vec_vmrghb
4660
4661 static __inline__ vector signed char __ATTRS_o_ai
4662 vec_vmrghb(vector signed char __a, vector signed char __b) {
4663   return vec_perm(__a, __b,
4664                   (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
4665                                          0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
4666                                          0x06, 0x16, 0x07, 0x17));
4667 }
4668
4669 static __inline__ vector unsigned char __ATTRS_o_ai
4670 vec_vmrghb(vector unsigned char __a, vector unsigned char __b) {
4671   return vec_perm(__a, __b,
4672                   (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
4673                                          0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
4674                                          0x06, 0x16, 0x07, 0x17));
4675 }
4676
4677 static __inline__ vector bool char __ATTRS_o_ai
4678 vec_vmrghb(vector bool char __a, vector bool char __b) {
4679   return vec_perm(__a, __b,
4680                   (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
4681                                          0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
4682                                          0x06, 0x16, 0x07, 0x17));
4683 }
4684
4685 /* vec_vmrghh */
4686
4687 #define __builtin_altivec_vmrghh vec_vmrghh
4688
4689 static __inline__ vector short __ATTRS_o_ai vec_vmrghh(vector short __a,
4690                                                        vector short __b) {
4691   return vec_perm(__a, __b,
4692                   (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
4693                                          0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
4694                                          0x06, 0x07, 0x16, 0x17));
4695 }
4696
4697 static __inline__ vector unsigned short __ATTRS_o_ai
4698 vec_vmrghh(vector unsigned short __a, vector unsigned short __b) {
4699   return vec_perm(__a, __b,
4700                   (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
4701                                          0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
4702                                          0x06, 0x07, 0x16, 0x17));
4703 }
4704
4705 static __inline__ vector bool short __ATTRS_o_ai
4706 vec_vmrghh(vector bool short __a, vector bool short __b) {
4707   return vec_perm(__a, __b,
4708                   (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
4709                                          0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
4710                                          0x06, 0x07, 0x16, 0x17));
4711 }
4712
4713 static __inline__ vector pixel __ATTRS_o_ai vec_vmrghh(vector pixel __a,
4714                                                        vector pixel __b) {
4715   return vec_perm(__a, __b,
4716                   (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
4717                                          0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
4718                                          0x06, 0x07, 0x16, 0x17));
4719 }
4720
4721 /* vec_vmrghw */
4722
4723 #define __builtin_altivec_vmrghw vec_vmrghw
4724
4725 static __inline__ vector int __ATTRS_o_ai vec_vmrghw(vector int __a,
4726                                                      vector int __b) {
4727   return vec_perm(__a, __b,
4728                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
4729                                          0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
4730                                          0x14, 0x15, 0x16, 0x17));
4731 }
4732
4733 static __inline__ vector unsigned int __ATTRS_o_ai
4734 vec_vmrghw(vector unsigned int __a, vector unsigned int __b) {
4735   return vec_perm(__a, __b,
4736                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
4737                                          0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
4738                                          0x14, 0x15, 0x16, 0x17));
4739 }
4740
4741 static __inline__ vector bool int __ATTRS_o_ai vec_vmrghw(vector bool int __a,
4742                                                           vector bool int __b) {
4743   return vec_perm(__a, __b,
4744                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
4745                                          0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
4746                                          0x14, 0x15, 0x16, 0x17));
4747 }
4748
4749 static __inline__ vector float __ATTRS_o_ai vec_vmrghw(vector float __a,
4750                                                        vector float __b) {
4751   return vec_perm(__a, __b,
4752                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
4753                                          0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
4754                                          0x14, 0x15, 0x16, 0x17));
4755 }
4756
4757 /* vec_mergel */
4758
4759 static __inline__ vector signed char __ATTRS_o_ai
4760 vec_mergel(vector signed char __a, vector signed char __b) {
4761   return vec_perm(__a, __b,
4762                   (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
4763                                          0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
4764                                          0x0E, 0x1E, 0x0F, 0x1F));
4765 }
4766
4767 static __inline__ vector unsigned char __ATTRS_o_ai
4768 vec_mergel(vector unsigned char __a, vector unsigned char __b) {
4769   return vec_perm(__a, __b,
4770                   (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
4771                                          0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
4772                                          0x0E, 0x1E, 0x0F, 0x1F));
4773 }
4774
4775 static __inline__ vector bool char __ATTRS_o_ai
4776 vec_mergel(vector bool char __a, vector bool char __b) {
4777   return vec_perm(__a, __b,
4778                   (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
4779                                          0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
4780                                          0x0E, 0x1E, 0x0F, 0x1F));
4781 }
4782
4783 static __inline__ vector short __ATTRS_o_ai vec_mergel(vector short __a,
4784                                                        vector short __b) {
4785   return vec_perm(__a, __b,
4786                   (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
4787                                          0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
4788                                          0x0E, 0x0F, 0x1E, 0x1F));
4789 }
4790
4791 static __inline__ vector unsigned short __ATTRS_o_ai
4792 vec_mergel(vector unsigned short __a, vector unsigned short __b) {
4793   return vec_perm(__a, __b,
4794                   (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
4795                                          0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
4796                                          0x0E, 0x0F, 0x1E, 0x1F));
4797 }
4798
4799 static __inline__ vector bool short __ATTRS_o_ai
4800 vec_mergel(vector bool short __a, vector bool short __b) {
4801   return vec_perm(__a, __b,
4802                   (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
4803                                          0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
4804                                          0x0E, 0x0F, 0x1E, 0x1F));
4805 }
4806
4807 static __inline__ vector pixel __ATTRS_o_ai vec_mergel(vector pixel __a,
4808                                                        vector pixel __b) {
4809   return vec_perm(__a, __b,
4810                   (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
4811                                          0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
4812                                          0x0E, 0x0F, 0x1E, 0x1F));
4813 }
4814
4815 static __inline__ vector int __ATTRS_o_ai vec_mergel(vector int __a,
4816                                                      vector int __b) {
4817   return vec_perm(__a, __b,
4818                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
4819                                          0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
4820                                          0x1C, 0x1D, 0x1E, 0x1F));
4821 }
4822
4823 static __inline__ vector unsigned int __ATTRS_o_ai
4824 vec_mergel(vector unsigned int __a, vector unsigned int __b) {
4825   return vec_perm(__a, __b,
4826                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
4827                                          0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
4828                                          0x1C, 0x1D, 0x1E, 0x1F));
4829 }
4830
4831 static __inline__ vector bool int __ATTRS_o_ai vec_mergel(vector bool int __a,
4832                                                           vector bool int __b) {
4833   return vec_perm(__a, __b,
4834                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
4835                                          0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
4836                                          0x1C, 0x1D, 0x1E, 0x1F));
4837 }
4838
4839 static __inline__ vector float __ATTRS_o_ai vec_mergel(vector float __a,
4840                                                        vector float __b) {
4841   return vec_perm(__a, __b,
4842                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
4843                                          0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
4844                                          0x1C, 0x1D, 0x1E, 0x1F));
4845 }
4846
4847 #ifdef __VSX__
4848 static __inline__ vector signed long long __ATTRS_o_ai
4849 vec_mergel(vector signed long long __a, vector signed long long __b) {
4850   return vec_perm(__a, __b,
4851                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
4852                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
4853                                          0x1C, 0x1D, 0x1E, 0x1F));
4854 }
4855 static __inline__ vector signed long long __ATTRS_o_ai
4856 vec_mergel(vector signed long long __a, vector bool long long __b) {
4857   return vec_perm(__a, (vector signed long long)__b,
4858                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
4859                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
4860                                          0x1C, 0x1D, 0x1E, 0x1F));
4861 }
4862 static __inline__ vector signed long long __ATTRS_o_ai
4863 vec_mergel(vector bool long long __a, vector signed long long __b) {
4864   return vec_perm((vector signed long long)__a, __b,
4865                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
4866                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
4867                                          0x1C, 0x1D, 0x1E, 0x1F));
4868 }
4869 static __inline__ vector unsigned long long __ATTRS_o_ai
4870 vec_mergel(vector unsigned long long __a, vector unsigned long long __b) {
4871   return vec_perm(__a, __b,
4872                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
4873                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
4874                                          0x1C, 0x1D, 0x1E, 0x1F));
4875 }
4876 static __inline__ vector unsigned long long __ATTRS_o_ai
4877 vec_mergel(vector unsigned long long __a, vector bool long long __b) {
4878   return vec_perm(__a, (vector unsigned long long)__b,
4879                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
4880                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
4881                                          0x1C, 0x1D, 0x1E, 0x1F));
4882 }
4883 static __inline__ vector unsigned long long __ATTRS_o_ai
4884 vec_mergel(vector bool long long __a, vector unsigned long long __b) {
4885   return vec_perm((vector unsigned long long)__a, __b,
4886                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
4887                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
4888                                          0x1C, 0x1D, 0x1E, 0x1F));
4889 }
4890 static __inline__ vector bool long long __ATTRS_o_ai
4891 vec_mergel(vector bool long long __a, vector bool long long __b) {
4892   return vec_perm(__a, __b,
4893                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
4894                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
4895                                          0x1C, 0x1D, 0x1E, 0x1F));
4896 }
4897 static __inline__ vector double __ATTRS_o_ai vec_mergel(vector double __a,
4898                                                         vector double __b) {
4899   return vec_perm(__a, __b,
4900                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
4901                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
4902                                          0x1C, 0x1D, 0x1E, 0x1F));
4903 }
4904 static __inline__ vector double __ATTRS_o_ai
4905 vec_mergel(vector double __a, vector bool long long __b) {
4906   return vec_perm(__a, (vector double)__b,
4907                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
4908                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
4909                                          0x1C, 0x1D, 0x1E, 0x1F));
4910 }
4911 static __inline__ vector double __ATTRS_o_ai
4912 vec_mergel(vector bool long long __a, vector double __b) {
4913   return vec_perm((vector double)__a, __b,
4914                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
4915                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
4916                                          0x1C, 0x1D, 0x1E, 0x1F));
4917 }
4918 #endif
4919
4920 /* vec_vmrglb */
4921
4922 #define __builtin_altivec_vmrglb vec_vmrglb
4923
4924 static __inline__ vector signed char __ATTRS_o_ai
4925 vec_vmrglb(vector signed char __a, vector signed char __b) {
4926   return vec_perm(__a, __b,
4927                   (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
4928                                          0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
4929                                          0x0E, 0x1E, 0x0F, 0x1F));
4930 }
4931
4932 static __inline__ vector unsigned char __ATTRS_o_ai
4933 vec_vmrglb(vector unsigned char __a, vector unsigned char __b) {
4934   return vec_perm(__a, __b,
4935                   (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
4936                                          0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
4937                                          0x0E, 0x1E, 0x0F, 0x1F));
4938 }
4939
4940 static __inline__ vector bool char __ATTRS_o_ai
4941 vec_vmrglb(vector bool char __a, vector bool char __b) {
4942   return vec_perm(__a, __b,
4943                   (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
4944                                          0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
4945                                          0x0E, 0x1E, 0x0F, 0x1F));
4946 }
4947
4948 /* vec_vmrglh */
4949
4950 #define __builtin_altivec_vmrglh vec_vmrglh
4951
4952 static __inline__ vector short __ATTRS_o_ai vec_vmrglh(vector short __a,
4953                                                        vector short __b) {
4954   return vec_perm(__a, __b,
4955                   (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
4956                                          0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
4957                                          0x0E, 0x0F, 0x1E, 0x1F));
4958 }
4959
4960 static __inline__ vector unsigned short __ATTRS_o_ai
4961 vec_vmrglh(vector unsigned short __a, vector unsigned short __b) {
4962   return vec_perm(__a, __b,
4963                   (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
4964                                          0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
4965                                          0x0E, 0x0F, 0x1E, 0x1F));
4966 }
4967
4968 static __inline__ vector bool short __ATTRS_o_ai
4969 vec_vmrglh(vector bool short __a, vector bool short __b) {
4970   return vec_perm(__a, __b,
4971                   (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
4972                                          0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
4973                                          0x0E, 0x0F, 0x1E, 0x1F));
4974 }
4975
4976 static __inline__ vector pixel __ATTRS_o_ai vec_vmrglh(vector pixel __a,
4977                                                        vector pixel __b) {
4978   return vec_perm(__a, __b,
4979                   (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
4980                                          0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
4981                                          0x0E, 0x0F, 0x1E, 0x1F));
4982 }
4983
4984 /* vec_vmrglw */
4985
4986 #define __builtin_altivec_vmrglw vec_vmrglw
4987
4988 static __inline__ vector int __ATTRS_o_ai vec_vmrglw(vector int __a,
4989                                                      vector int __b) {
4990   return vec_perm(__a, __b,
4991                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
4992                                          0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
4993                                          0x1C, 0x1D, 0x1E, 0x1F));
4994 }
4995
4996 static __inline__ vector unsigned int __ATTRS_o_ai
4997 vec_vmrglw(vector unsigned int __a, vector unsigned int __b) {
4998   return vec_perm(__a, __b,
4999                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
5000                                          0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
5001                                          0x1C, 0x1D, 0x1E, 0x1F));
5002 }
5003
5004 static __inline__ vector bool int __ATTRS_o_ai vec_vmrglw(vector bool int __a,
5005                                                           vector bool int __b) {
5006   return vec_perm(__a, __b,
5007                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
5008                                          0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
5009                                          0x1C, 0x1D, 0x1E, 0x1F));
5010 }
5011
5012 static __inline__ vector float __ATTRS_o_ai vec_vmrglw(vector float __a,
5013                                                        vector float __b) {
5014   return vec_perm(__a, __b,
5015                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
5016                                          0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
5017                                          0x1C, 0x1D, 0x1E, 0x1F));
5018 }
5019
5020 #ifdef __POWER8_VECTOR__
5021 /* vec_mergee */
5022
5023 static __inline__ vector bool int __ATTRS_o_ai vec_mergee(vector bool int __a,
5024                                                           vector bool int __b) {
5025   return vec_perm(__a, __b,
5026                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5027                                          0x12, 0x13, 0x08, 0x09, 0x0A, 0x0B,
5028                                          0x18, 0x19, 0x1A, 0x1B));
5029 }
5030
5031 static __inline__ vector signed int __ATTRS_o_ai
5032 vec_mergee(vector signed int __a, vector signed int __b) {
5033   return vec_perm(__a, __b,
5034                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5035                                          0x12, 0x13, 0x08, 0x09, 0x0A, 0x0B,
5036                                          0x18, 0x19, 0x1A, 0x1B));
5037 }
5038
5039 static __inline__ vector unsigned int __ATTRS_o_ai
5040 vec_mergee(vector unsigned int __a, vector unsigned int __b) {
5041   return vec_perm(__a, __b,
5042                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5043                                          0x12, 0x13, 0x08, 0x09, 0x0A, 0x0B,
5044                                          0x18, 0x19, 0x1A, 0x1B));
5045 }
5046
5047 static __inline__ vector bool long long __ATTRS_o_ai
5048 vec_mergee(vector bool long long __a, vector bool long long __b) {
5049   return vec_mergeh(__a, __b);
5050 }
5051
5052 static __inline__ vector signed long long __ATTRS_o_ai
5053 vec_mergee(vector signed long long __a, vector signed long long __b) {
5054   return vec_mergeh(__a, __b);
5055 }
5056
5057 static __inline__ vector unsigned long long __ATTRS_o_ai
5058 vec_mergee(vector unsigned long long __a, vector unsigned long long __b) {
5059   return vec_mergeh(__a, __b);
5060 }
5061
5062 static __inline__ vector float __ATTRS_o_ai
5063 vec_mergee(vector float __a, vector float __b) {
5064   return vec_perm(__a, __b,
5065                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5066                                          0x12, 0x13, 0x08, 0x09, 0x0A, 0x0B,
5067                                          0x18, 0x19, 0x1A, 0x1B));
5068 }
5069
5070 static __inline__ vector double __ATTRS_o_ai
5071 vec_mergee(vector double __a, vector double __b) {
5072   return vec_mergeh(__a, __b);
5073 }
5074
5075 /* vec_mergeo */
5076
5077 static __inline__ vector bool int __ATTRS_o_ai vec_mergeo(vector bool int __a,
5078                                                           vector bool int __b) {
5079   return vec_perm(__a, __b,
5080                   (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x14, 0x15,
5081                                          0x16, 0x17, 0x0C, 0x0D, 0x0E, 0x0F,
5082                                          0x1C, 0x1D, 0x1E, 0x1F));
5083 }
5084
5085 static __inline__ vector signed int __ATTRS_o_ai
5086 vec_mergeo(vector signed int __a, vector signed int __b) {
5087   return vec_perm(__a, __b,
5088                   (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x14, 0x15,
5089                                          0x16, 0x17, 0x0C, 0x0D, 0x0E, 0x0F,
5090                                          0x1C, 0x1D, 0x1E, 0x1F));
5091 }
5092
5093 static __inline__ vector unsigned int __ATTRS_o_ai
5094 vec_mergeo(vector unsigned int __a, vector unsigned int __b) {
5095   return vec_perm(__a, __b,
5096                   (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x14, 0x15,
5097                                          0x16, 0x17, 0x0C, 0x0D, 0x0E, 0x0F,
5098                                          0x1C, 0x1D, 0x1E, 0x1F));
5099 }
5100
5101 static __inline__ vector bool long long __ATTRS_o_ai
5102 vec_mergeo(vector bool long long __a, vector bool long long __b) {
5103   return vec_mergel(__a, __b);
5104 }
5105
5106 static __inline__ vector signed long long __ATTRS_o_ai
5107 vec_mergeo(vector signed long long __a, vector signed long long __b) {
5108   return vec_mergel(__a, __b);
5109 }
5110
5111 static __inline__ vector unsigned long long __ATTRS_o_ai
5112 vec_mergeo(vector unsigned long long __a, vector unsigned long long __b) {
5113   return vec_mergel(__a, __b);
5114 }
5115
5116 static __inline__ vector float __ATTRS_o_ai
5117 vec_mergeo(vector float __a, vector float __b) {
5118   return vec_perm(__a, __b,
5119                   (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x14, 0x15,
5120                                          0x16, 0x17, 0x0C, 0x0D, 0x0E, 0x0F,
5121                                          0x1C, 0x1D, 0x1E, 0x1F));
5122 }
5123
5124 static __inline__ vector double __ATTRS_o_ai
5125 vec_mergeo(vector double __a, vector double __b) {
5126   return vec_mergel(__a, __b);
5127 }
5128
5129 #endif
5130
5131 /* vec_mfvscr */
5132
5133 static __inline__ vector unsigned short __attribute__((__always_inline__))
5134 vec_mfvscr(void) {
5135   return __builtin_altivec_mfvscr();
5136 }
5137
5138 /* vec_min */
5139
5140 static __inline__ vector signed char __ATTRS_o_ai
5141 vec_min(vector signed char __a, vector signed char __b) {
5142   return __builtin_altivec_vminsb(__a, __b);
5143 }
5144
5145 static __inline__ vector signed char __ATTRS_o_ai
5146 vec_min(vector bool char __a, vector signed char __b) {
5147   return __builtin_altivec_vminsb((vector signed char)__a, __b);
5148 }
5149
5150 static __inline__ vector signed char __ATTRS_o_ai
5151 vec_min(vector signed char __a, vector bool char __b) {
5152   return __builtin_altivec_vminsb(__a, (vector signed char)__b);
5153 }
5154
5155 static __inline__ vector unsigned char __ATTRS_o_ai
5156 vec_min(vector unsigned char __a, vector unsigned char __b) {
5157   return __builtin_altivec_vminub(__a, __b);
5158 }
5159
5160 static __inline__ vector unsigned char __ATTRS_o_ai
5161 vec_min(vector bool char __a, vector unsigned char __b) {
5162   return __builtin_altivec_vminub((vector unsigned char)__a, __b);
5163 }
5164
5165 static __inline__ vector unsigned char __ATTRS_o_ai
5166 vec_min(vector unsigned char __a, vector bool char __b) {
5167   return __builtin_altivec_vminub(__a, (vector unsigned char)__b);
5168 }
5169
5170 static __inline__ vector short __ATTRS_o_ai vec_min(vector short __a,
5171                                                     vector short __b) {
5172   return __builtin_altivec_vminsh(__a, __b);
5173 }
5174
5175 static __inline__ vector short __ATTRS_o_ai vec_min(vector bool short __a,
5176                                                     vector short __b) {
5177   return __builtin_altivec_vminsh((vector short)__a, __b);
5178 }
5179
5180 static __inline__ vector short __ATTRS_o_ai vec_min(vector short __a,
5181                                                     vector bool short __b) {
5182   return __builtin_altivec_vminsh(__a, (vector short)__b);
5183 }
5184
5185 static __inline__ vector unsigned short __ATTRS_o_ai
5186 vec_min(vector unsigned short __a, vector unsigned short __b) {
5187   return __builtin_altivec_vminuh(__a, __b);
5188 }
5189
5190 static __inline__ vector unsigned short __ATTRS_o_ai
5191 vec_min(vector bool short __a, vector unsigned short __b) {
5192   return __builtin_altivec_vminuh((vector unsigned short)__a, __b);
5193 }
5194
5195 static __inline__ vector unsigned short __ATTRS_o_ai
5196 vec_min(vector unsigned short __a, vector bool short __b) {
5197   return __builtin_altivec_vminuh(__a, (vector unsigned short)__b);
5198 }
5199
5200 static __inline__ vector int __ATTRS_o_ai vec_min(vector int __a,
5201                                                   vector int __b) {
5202   return __builtin_altivec_vminsw(__a, __b);
5203 }
5204
5205 static __inline__ vector int __ATTRS_o_ai vec_min(vector bool int __a,
5206                                                   vector int __b) {
5207   return __builtin_altivec_vminsw((vector int)__a, __b);
5208 }
5209
5210 static __inline__ vector int __ATTRS_o_ai vec_min(vector int __a,
5211                                                   vector bool int __b) {
5212   return __builtin_altivec_vminsw(__a, (vector int)__b);
5213 }
5214
5215 static __inline__ vector unsigned int __ATTRS_o_ai
5216 vec_min(vector unsigned int __a, vector unsigned int __b) {
5217   return __builtin_altivec_vminuw(__a, __b);
5218 }
5219
5220 static __inline__ vector unsigned int __ATTRS_o_ai
5221 vec_min(vector bool int __a, vector unsigned int __b) {
5222   return __builtin_altivec_vminuw((vector unsigned int)__a, __b);
5223 }
5224
5225 static __inline__ vector unsigned int __ATTRS_o_ai
5226 vec_min(vector unsigned int __a, vector bool int __b) {
5227   return __builtin_altivec_vminuw(__a, (vector unsigned int)__b);
5228 }
5229
5230 #ifdef __POWER8_VECTOR__
5231 static __inline__ vector signed long long __ATTRS_o_ai
5232 vec_min(vector signed long long __a, vector signed long long __b) {
5233   return __builtin_altivec_vminsd(__a, __b);
5234 }
5235
5236 static __inline__ vector signed long long __ATTRS_o_ai
5237 vec_min(vector bool long long __a, vector signed long long __b) {
5238   return __builtin_altivec_vminsd((vector signed long long)__a, __b);
5239 }
5240
5241 static __inline__ vector signed long long __ATTRS_o_ai
5242 vec_min(vector signed long long __a, vector bool long long __b) {
5243   return __builtin_altivec_vminsd(__a, (vector signed long long)__b);
5244 }
5245
5246 static __inline__ vector unsigned long long __ATTRS_o_ai
5247 vec_min(vector unsigned long long __a, vector unsigned long long __b) {
5248   return __builtin_altivec_vminud(__a, __b);
5249 }
5250
5251 static __inline__ vector unsigned long long __ATTRS_o_ai
5252 vec_min(vector bool long long __a, vector unsigned long long __b) {
5253   return __builtin_altivec_vminud((vector unsigned long long)__a, __b);
5254 }
5255
5256 static __inline__ vector unsigned long long __ATTRS_o_ai
5257 vec_min(vector unsigned long long __a, vector bool long long __b) {
5258   return __builtin_altivec_vminud(__a, (vector unsigned long long)__b);
5259 }
5260 #endif
5261
5262 static __inline__ vector float __ATTRS_o_ai vec_min(vector float __a,
5263                                                     vector float __b) {
5264 #ifdef __VSX__
5265   return __builtin_vsx_xvminsp(__a, __b);
5266 #else
5267   return __builtin_altivec_vminfp(__a, __b);
5268 #endif
5269 }
5270
5271 #ifdef __VSX__
5272 static __inline__ vector double __ATTRS_o_ai vec_min(vector double __a,
5273                                                      vector double __b) {
5274   return __builtin_vsx_xvmindp(__a, __b);
5275 }
5276 #endif
5277
5278 /* vec_vminsb */
5279
5280 static __inline__ vector signed char __ATTRS_o_ai
5281 vec_vminsb(vector signed char __a, vector signed char __b) {
5282   return __builtin_altivec_vminsb(__a, __b);
5283 }
5284
5285 static __inline__ vector signed char __ATTRS_o_ai
5286 vec_vminsb(vector bool char __a, vector signed char __b) {
5287   return __builtin_altivec_vminsb((vector signed char)__a, __b);
5288 }
5289
5290 static __inline__ vector signed char __ATTRS_o_ai
5291 vec_vminsb(vector signed char __a, vector bool char __b) {
5292   return __builtin_altivec_vminsb(__a, (vector signed char)__b);
5293 }
5294
5295 /* vec_vminub */
5296
5297 static __inline__ vector unsigned char __ATTRS_o_ai
5298 vec_vminub(vector unsigned char __a, vector unsigned char __b) {
5299   return __builtin_altivec_vminub(__a, __b);
5300 }
5301
5302 static __inline__ vector unsigned char __ATTRS_o_ai
5303 vec_vminub(vector bool char __a, vector unsigned char __b) {
5304   return __builtin_altivec_vminub((vector unsigned char)__a, __b);
5305 }
5306
5307 static __inline__ vector unsigned char __ATTRS_o_ai
5308 vec_vminub(vector unsigned char __a, vector bool char __b) {
5309   return __builtin_altivec_vminub(__a, (vector unsigned char)__b);
5310 }
5311
5312 /* vec_vminsh */
5313
5314 static __inline__ vector short __ATTRS_o_ai vec_vminsh(vector short __a,
5315                                                        vector short __b) {
5316   return __builtin_altivec_vminsh(__a, __b);
5317 }
5318
5319 static __inline__ vector short __ATTRS_o_ai vec_vminsh(vector bool short __a,
5320                                                        vector short __b) {
5321   return __builtin_altivec_vminsh((vector short)__a, __b);
5322 }
5323
5324 static __inline__ vector short __ATTRS_o_ai vec_vminsh(vector short __a,
5325                                                        vector bool short __b) {
5326   return __builtin_altivec_vminsh(__a, (vector short)__b);
5327 }
5328
5329 /* vec_vminuh */
5330
5331 static __inline__ vector unsigned short __ATTRS_o_ai
5332 vec_vminuh(vector unsigned short __a, vector unsigned short __b) {
5333   return __builtin_altivec_vminuh(__a, __b);
5334 }
5335
5336 static __inline__ vector unsigned short __ATTRS_o_ai
5337 vec_vminuh(vector bool short __a, vector unsigned short __b) {
5338   return __builtin_altivec_vminuh((vector unsigned short)__a, __b);
5339 }
5340
5341 static __inline__ vector unsigned short __ATTRS_o_ai
5342 vec_vminuh(vector unsigned short __a, vector bool short __b) {
5343   return __builtin_altivec_vminuh(__a, (vector unsigned short)__b);
5344 }
5345
5346 /* vec_vminsw */
5347
5348 static __inline__ vector int __ATTRS_o_ai vec_vminsw(vector int __a,
5349                                                      vector int __b) {
5350   return __builtin_altivec_vminsw(__a, __b);
5351 }
5352
5353 static __inline__ vector int __ATTRS_o_ai vec_vminsw(vector bool int __a,
5354                                                      vector int __b) {
5355   return __builtin_altivec_vminsw((vector int)__a, __b);
5356 }
5357
5358 static __inline__ vector int __ATTRS_o_ai vec_vminsw(vector int __a,
5359                                                      vector bool int __b) {
5360   return __builtin_altivec_vminsw(__a, (vector int)__b);
5361 }
5362
5363 /* vec_vminuw */
5364
5365 static __inline__ vector unsigned int __ATTRS_o_ai
5366 vec_vminuw(vector unsigned int __a, vector unsigned int __b) {
5367   return __builtin_altivec_vminuw(__a, __b);
5368 }
5369
5370 static __inline__ vector unsigned int __ATTRS_o_ai
5371 vec_vminuw(vector bool int __a, vector unsigned int __b) {
5372   return __builtin_altivec_vminuw((vector unsigned int)__a, __b);
5373 }
5374
5375 static __inline__ vector unsigned int __ATTRS_o_ai
5376 vec_vminuw(vector unsigned int __a, vector bool int __b) {
5377   return __builtin_altivec_vminuw(__a, (vector unsigned int)__b);
5378 }
5379
5380 /* vec_vminfp */
5381
5382 static __inline__ vector float __attribute__((__always_inline__))
5383 vec_vminfp(vector float __a, vector float __b) {
5384 #ifdef __VSX__
5385   return __builtin_vsx_xvminsp(__a, __b);
5386 #else
5387   return __builtin_altivec_vminfp(__a, __b);
5388 #endif
5389 }
5390
5391 /* vec_mladd */
5392
5393 #define __builtin_altivec_vmladduhm vec_mladd
5394
5395 static __inline__ vector short __ATTRS_o_ai vec_mladd(vector short __a,
5396                                                       vector short __b,
5397                                                       vector short __c) {
5398   return __a * __b + __c;
5399 }
5400
5401 static __inline__ vector short __ATTRS_o_ai vec_mladd(
5402     vector short __a, vector unsigned short __b, vector unsigned short __c) {
5403   return __a * (vector short)__b + (vector short)__c;
5404 }
5405
5406 static __inline__ vector short __ATTRS_o_ai vec_mladd(vector unsigned short __a,
5407                                                       vector short __b,
5408                                                       vector short __c) {
5409   return (vector short)__a * __b + __c;
5410 }
5411
5412 static __inline__ vector unsigned short __ATTRS_o_ai
5413 vec_mladd(vector unsigned short __a, vector unsigned short __b,
5414           vector unsigned short __c) {
5415   return __a * __b + __c;
5416 }
5417
5418 /* vec_vmladduhm */
5419
5420 static __inline__ vector short __ATTRS_o_ai vec_vmladduhm(vector short __a,
5421                                                           vector short __b,
5422                                                           vector short __c) {
5423   return __a * __b + __c;
5424 }
5425
5426 static __inline__ vector short __ATTRS_o_ai vec_vmladduhm(
5427     vector short __a, vector unsigned short __b, vector unsigned short __c) {
5428   return __a * (vector short)__b + (vector short)__c;
5429 }
5430
5431 static __inline__ vector short __ATTRS_o_ai
5432 vec_vmladduhm(vector unsigned short __a, vector short __b, vector short __c) {
5433   return (vector short)__a * __b + __c;
5434 }
5435
5436 static __inline__ vector unsigned short __ATTRS_o_ai
5437 vec_vmladduhm(vector unsigned short __a, vector unsigned short __b,
5438               vector unsigned short __c) {
5439   return __a * __b + __c;
5440 }
5441
5442 /* vec_mradds */
5443
5444 static __inline__ vector short __attribute__((__always_inline__))
5445 vec_mradds(vector short __a, vector short __b, vector short __c) {
5446   return __builtin_altivec_vmhraddshs(__a, __b, __c);
5447 }
5448
5449 /* vec_vmhraddshs */
5450
5451 static __inline__ vector short __attribute__((__always_inline__))
5452 vec_vmhraddshs(vector short __a, vector short __b, vector short __c) {
5453   return __builtin_altivec_vmhraddshs(__a, __b, __c);
5454 }
5455
5456 /* vec_msum */
5457
5458 static __inline__ vector int __ATTRS_o_ai vec_msum(vector signed char __a,
5459                                                    vector unsigned char __b,
5460                                                    vector int __c) {
5461   return __builtin_altivec_vmsummbm(__a, __b, __c);
5462 }
5463
5464 static __inline__ vector unsigned int __ATTRS_o_ai
5465 vec_msum(vector unsigned char __a, vector unsigned char __b,
5466          vector unsigned int __c) {
5467   return __builtin_altivec_vmsumubm(__a, __b, __c);
5468 }
5469
5470 static __inline__ vector int __ATTRS_o_ai vec_msum(vector short __a,
5471                                                    vector short __b,
5472                                                    vector int __c) {
5473   return __builtin_altivec_vmsumshm(__a, __b, __c);
5474 }
5475
5476 static __inline__ vector unsigned int __ATTRS_o_ai
5477 vec_msum(vector unsigned short __a, vector unsigned short __b,
5478          vector unsigned int __c) {
5479   return __builtin_altivec_vmsumuhm(__a, __b, __c);
5480 }
5481
5482 /* vec_vmsummbm */
5483
5484 static __inline__ vector int __attribute__((__always_inline__))
5485 vec_vmsummbm(vector signed char __a, vector unsigned char __b, vector int __c) {
5486   return __builtin_altivec_vmsummbm(__a, __b, __c);
5487 }
5488
5489 /* vec_vmsumubm */
5490
5491 static __inline__ vector unsigned int __attribute__((__always_inline__))
5492 vec_vmsumubm(vector unsigned char __a, vector unsigned char __b,
5493              vector unsigned int __c) {
5494   return __builtin_altivec_vmsumubm(__a, __b, __c);
5495 }
5496
5497 /* vec_vmsumshm */
5498
5499 static __inline__ vector int __attribute__((__always_inline__))
5500 vec_vmsumshm(vector short __a, vector short __b, vector int __c) {
5501   return __builtin_altivec_vmsumshm(__a, __b, __c);
5502 }
5503
5504 /* vec_vmsumuhm */
5505
5506 static __inline__ vector unsigned int __attribute__((__always_inline__))
5507 vec_vmsumuhm(vector unsigned short __a, vector unsigned short __b,
5508              vector unsigned int __c) {
5509   return __builtin_altivec_vmsumuhm(__a, __b, __c);
5510 }
5511
5512 /* vec_msums */
5513
5514 static __inline__ vector int __ATTRS_o_ai vec_msums(vector short __a,
5515                                                     vector short __b,
5516                                                     vector int __c) {
5517   return __builtin_altivec_vmsumshs(__a, __b, __c);
5518 }
5519
5520 static __inline__ vector unsigned int __ATTRS_o_ai
5521 vec_msums(vector unsigned short __a, vector unsigned short __b,
5522           vector unsigned int __c) {
5523   return __builtin_altivec_vmsumuhs(__a, __b, __c);
5524 }
5525
5526 /* vec_vmsumshs */
5527
5528 static __inline__ vector int __attribute__((__always_inline__))
5529 vec_vmsumshs(vector short __a, vector short __b, vector int __c) {
5530   return __builtin_altivec_vmsumshs(__a, __b, __c);
5531 }
5532
5533 /* vec_vmsumuhs */
5534
5535 static __inline__ vector unsigned int __attribute__((__always_inline__))
5536 vec_vmsumuhs(vector unsigned short __a, vector unsigned short __b,
5537              vector unsigned int __c) {
5538   return __builtin_altivec_vmsumuhs(__a, __b, __c);
5539 }
5540
5541 /* vec_mtvscr */
5542
5543 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector signed char __a) {
5544   __builtin_altivec_mtvscr((vector int)__a);
5545 }
5546
5547 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector unsigned char __a) {
5548   __builtin_altivec_mtvscr((vector int)__a);
5549 }
5550
5551 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector bool char __a) {
5552   __builtin_altivec_mtvscr((vector int)__a);
5553 }
5554
5555 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector short __a) {
5556   __builtin_altivec_mtvscr((vector int)__a);
5557 }
5558
5559 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector unsigned short __a) {
5560   __builtin_altivec_mtvscr((vector int)__a);
5561 }
5562
5563 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector bool short __a) {
5564   __builtin_altivec_mtvscr((vector int)__a);
5565 }
5566
5567 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector pixel __a) {
5568   __builtin_altivec_mtvscr((vector int)__a);
5569 }
5570
5571 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector int __a) {
5572   __builtin_altivec_mtvscr((vector int)__a);
5573 }
5574
5575 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector unsigned int __a) {
5576   __builtin_altivec_mtvscr((vector int)__a);
5577 }
5578
5579 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector bool int __a) {
5580   __builtin_altivec_mtvscr((vector int)__a);
5581 }
5582
5583 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector float __a) {
5584   __builtin_altivec_mtvscr((vector int)__a);
5585 }
5586
5587 /* vec_mul */
5588
5589 /* Integer vector multiplication will involve multiplication of the odd/even
5590    elements separately, then truncating the results and moving to the
5591    result vector.
5592 */
5593 static __inline__ vector signed char __ATTRS_o_ai
5594 vec_mul(vector signed char __a, vector signed char __b) {
5595   return __a * __b;
5596 }
5597
5598 static __inline__ vector unsigned char __ATTRS_o_ai
5599 vec_mul(vector unsigned char __a, vector unsigned char __b) {
5600   return __a * __b;
5601 }
5602
5603 static __inline__ vector signed short __ATTRS_o_ai
5604 vec_mul(vector signed short __a, vector signed short __b) {
5605   return __a * __b;
5606 }
5607
5608 static __inline__ vector unsigned short __ATTRS_o_ai
5609 vec_mul(vector unsigned short __a, vector unsigned short __b) {
5610   return __a * __b;
5611 }
5612
5613 static __inline__ vector signed int __ATTRS_o_ai
5614 vec_mul(vector signed int __a, vector signed int __b) {
5615   return __a * __b;
5616 }
5617
5618 static __inline__ vector unsigned int __ATTRS_o_ai
5619 vec_mul(vector unsigned int __a, vector unsigned int __b) {
5620   return __a * __b;
5621 }
5622
5623 #ifdef __VSX__
5624 static __inline__ vector signed long long __ATTRS_o_ai
5625 vec_mul(vector signed long long __a, vector signed long long __b) {
5626   return __a * __b;
5627 }
5628
5629 static __inline__ vector unsigned long long __ATTRS_o_ai
5630 vec_mul(vector unsigned long long __a, vector unsigned long long __b) {
5631   return __a * __b;
5632 }
5633 #endif
5634
5635 static __inline__ vector float __ATTRS_o_ai vec_mul(vector float __a,
5636                                                     vector float __b) {
5637   return __a * __b;
5638 }
5639
5640 #ifdef __VSX__
5641 static __inline__ vector double __ATTRS_o_ai vec_mul(vector double __a,
5642                                                      vector double __b) {
5643   return __a * __b;
5644 }
5645 #endif
5646
5647 /* The vmulos* and vmules* instructions have a big endian bias, so
5648    we must reverse the meaning of "even" and "odd" for little endian.  */
5649
5650 /* vec_mule */
5651
5652 static __inline__ vector short __ATTRS_o_ai vec_mule(vector signed char __a,
5653                                                      vector signed char __b) {
5654 #ifdef __LITTLE_ENDIAN__
5655   return __builtin_altivec_vmulosb(__a, __b);
5656 #else
5657   return __builtin_altivec_vmulesb(__a, __b);
5658 #endif
5659 }
5660
5661 static __inline__ vector unsigned short __ATTRS_o_ai
5662 vec_mule(vector unsigned char __a, vector unsigned char __b) {
5663 #ifdef __LITTLE_ENDIAN__
5664   return __builtin_altivec_vmuloub(__a, __b);
5665 #else
5666   return __builtin_altivec_vmuleub(__a, __b);
5667 #endif
5668 }
5669
5670 static __inline__ vector int __ATTRS_o_ai vec_mule(vector short __a,
5671                                                    vector short __b) {
5672 #ifdef __LITTLE_ENDIAN__
5673   return __builtin_altivec_vmulosh(__a, __b);
5674 #else
5675   return __builtin_altivec_vmulesh(__a, __b);
5676 #endif
5677 }
5678
5679 static __inline__ vector unsigned int __ATTRS_o_ai
5680 vec_mule(vector unsigned short __a, vector unsigned short __b) {
5681 #ifdef __LITTLE_ENDIAN__
5682   return __builtin_altivec_vmulouh(__a, __b);
5683 #else
5684   return __builtin_altivec_vmuleuh(__a, __b);
5685 #endif
5686 }
5687
5688 #ifdef __POWER8_VECTOR__
5689 static __inline__ vector signed long long __ATTRS_o_ai
5690 vec_mule(vector signed int __a, vector signed int __b) {
5691 #ifdef __LITTLE_ENDIAN__
5692   return __builtin_altivec_vmulosw(__a, __b);
5693 #else
5694   return __builtin_altivec_vmulesw(__a, __b);
5695 #endif
5696 }
5697
5698 static __inline__ vector unsigned long long __ATTRS_o_ai
5699 vec_mule(vector unsigned int __a, vector unsigned int __b) {
5700 #ifdef __LITTLE_ENDIAN__
5701   return __builtin_altivec_vmulouw(__a, __b);
5702 #else
5703   return __builtin_altivec_vmuleuw(__a, __b);
5704 #endif
5705 }
5706 #endif
5707
5708 /* vec_vmulesb */
5709
5710 static __inline__ vector short __attribute__((__always_inline__))
5711 vec_vmulesb(vector signed char __a, vector signed char __b) {
5712 #ifdef __LITTLE_ENDIAN__
5713   return __builtin_altivec_vmulosb(__a, __b);
5714 #else
5715   return __builtin_altivec_vmulesb(__a, __b);
5716 #endif
5717 }
5718
5719 /* vec_vmuleub */
5720
5721 static __inline__ vector unsigned short __attribute__((__always_inline__))
5722 vec_vmuleub(vector unsigned char __a, vector unsigned char __b) {
5723 #ifdef __LITTLE_ENDIAN__
5724   return __builtin_altivec_vmuloub(__a, __b);
5725 #else
5726   return __builtin_altivec_vmuleub(__a, __b);
5727 #endif
5728 }
5729
5730 /* vec_vmulesh */
5731
5732 static __inline__ vector int __attribute__((__always_inline__))
5733 vec_vmulesh(vector short __a, vector short __b) {
5734 #ifdef __LITTLE_ENDIAN__
5735   return __builtin_altivec_vmulosh(__a, __b);
5736 #else
5737   return __builtin_altivec_vmulesh(__a, __b);
5738 #endif
5739 }
5740
5741 /* vec_vmuleuh */
5742
5743 static __inline__ vector unsigned int __attribute__((__always_inline__))
5744 vec_vmuleuh(vector unsigned short __a, vector unsigned short __b) {
5745 #ifdef __LITTLE_ENDIAN__
5746   return __builtin_altivec_vmulouh(__a, __b);
5747 #else
5748   return __builtin_altivec_vmuleuh(__a, __b);
5749 #endif
5750 }
5751
5752 /* vec_mulo */
5753
5754 static __inline__ vector short __ATTRS_o_ai vec_mulo(vector signed char __a,
5755                                                      vector signed char __b) {
5756 #ifdef __LITTLE_ENDIAN__
5757   return __builtin_altivec_vmulesb(__a, __b);
5758 #else
5759   return __builtin_altivec_vmulosb(__a, __b);
5760 #endif
5761 }
5762
5763 static __inline__ vector unsigned short __ATTRS_o_ai
5764 vec_mulo(vector unsigned char __a, vector unsigned char __b) {
5765 #ifdef __LITTLE_ENDIAN__
5766   return __builtin_altivec_vmuleub(__a, __b);
5767 #else
5768   return __builtin_altivec_vmuloub(__a, __b);
5769 #endif
5770 }
5771
5772 static __inline__ vector int __ATTRS_o_ai vec_mulo(vector short __a,
5773                                                    vector short __b) {
5774 #ifdef __LITTLE_ENDIAN__
5775   return __builtin_altivec_vmulesh(__a, __b);
5776 #else
5777   return __builtin_altivec_vmulosh(__a, __b);
5778 #endif
5779 }
5780
5781 static __inline__ vector unsigned int __ATTRS_o_ai
5782 vec_mulo(vector unsigned short __a, vector unsigned short __b) {
5783 #ifdef __LITTLE_ENDIAN__
5784   return __builtin_altivec_vmuleuh(__a, __b);
5785 #else
5786   return __builtin_altivec_vmulouh(__a, __b);
5787 #endif
5788 }
5789
5790 #ifdef __POWER8_VECTOR__
5791 static __inline__ vector signed long long __ATTRS_o_ai
5792 vec_mulo(vector signed int __a, vector signed int __b) {
5793 #ifdef __LITTLE_ENDIAN__
5794   return __builtin_altivec_vmulesw(__a, __b);
5795 #else
5796   return __builtin_altivec_vmulosw(__a, __b);
5797 #endif
5798 }
5799
5800 static __inline__ vector unsigned long long __ATTRS_o_ai
5801 vec_mulo(vector unsigned int __a, vector unsigned int __b) {
5802 #ifdef __LITTLE_ENDIAN__
5803   return __builtin_altivec_vmuleuw(__a, __b);
5804 #else
5805   return __builtin_altivec_vmulouw(__a, __b);
5806 #endif
5807 }
5808 #endif
5809
5810 /* vec_vmulosb */
5811
5812 static __inline__ vector short __attribute__((__always_inline__))
5813 vec_vmulosb(vector signed char __a, vector signed char __b) {
5814 #ifdef __LITTLE_ENDIAN__
5815   return __builtin_altivec_vmulesb(__a, __b);
5816 #else
5817   return __builtin_altivec_vmulosb(__a, __b);
5818 #endif
5819 }
5820
5821 /* vec_vmuloub */
5822
5823 static __inline__ vector unsigned short __attribute__((__always_inline__))
5824 vec_vmuloub(vector unsigned char __a, vector unsigned char __b) {
5825 #ifdef __LITTLE_ENDIAN__
5826   return __builtin_altivec_vmuleub(__a, __b);
5827 #else
5828   return __builtin_altivec_vmuloub(__a, __b);
5829 #endif
5830 }
5831
5832 /* vec_vmulosh */
5833
5834 static __inline__ vector int __attribute__((__always_inline__))
5835 vec_vmulosh(vector short __a, vector short __b) {
5836 #ifdef __LITTLE_ENDIAN__
5837   return __builtin_altivec_vmulesh(__a, __b);
5838 #else
5839   return __builtin_altivec_vmulosh(__a, __b);
5840 #endif
5841 }
5842
5843 /* vec_vmulouh */
5844
5845 static __inline__ vector unsigned int __attribute__((__always_inline__))
5846 vec_vmulouh(vector unsigned short __a, vector unsigned short __b) {
5847 #ifdef __LITTLE_ENDIAN__
5848   return __builtin_altivec_vmuleuh(__a, __b);
5849 #else
5850   return __builtin_altivec_vmulouh(__a, __b);
5851 #endif
5852 }
5853
5854 /*  vec_nand */
5855
5856 #ifdef __POWER8_VECTOR__
5857 static __inline__ vector signed char __ATTRS_o_ai
5858 vec_nand(vector signed char __a, vector signed char __b) {
5859   return ~(__a & __b);
5860 }
5861
5862 static __inline__ vector signed char __ATTRS_o_ai
5863 vec_nand(vector signed char __a, vector bool char __b) {
5864   return ~(__a & __b);
5865 }
5866
5867 static __inline__ vector signed char __ATTRS_o_ai
5868 vec_nand(vector bool char __a, vector signed char __b) {
5869   return ~(__a & __b);
5870 }
5871
5872 static __inline__ vector unsigned char __ATTRS_o_ai
5873 vec_nand(vector unsigned char __a, vector unsigned char __b) {
5874   return ~(__a & __b);
5875 }
5876
5877 static __inline__ vector unsigned char __ATTRS_o_ai
5878 vec_nand(vector unsigned char __a, vector bool char __b) {
5879   return ~(__a & __b);
5880 }
5881
5882 static __inline__ vector unsigned char __ATTRS_o_ai
5883 vec_nand(vector bool char __a, vector unsigned char __b) {
5884   return ~(__a & __b);
5885 }
5886
5887 static __inline__ vector bool char __ATTRS_o_ai vec_nand(vector bool char __a,
5888                                                          vector bool char __b) {
5889   return ~(__a & __b);
5890 }
5891
5892 static __inline__ vector signed short __ATTRS_o_ai
5893 vec_nand(vector signed short __a, vector signed short __b) {
5894   return ~(__a & __b);
5895 }
5896
5897 static __inline__ vector signed short __ATTRS_o_ai
5898 vec_nand(vector signed short __a, vector bool short __b) {
5899   return ~(__a & __b);
5900 }
5901
5902 static __inline__ vector signed short __ATTRS_o_ai
5903 vec_nand(vector bool short __a, vector signed short __b) {
5904   return ~(__a & __b);
5905 }
5906
5907 static __inline__ vector unsigned short __ATTRS_o_ai
5908 vec_nand(vector unsigned short __a, vector unsigned short __b) {
5909   return ~(__a & __b);
5910 }
5911
5912 static __inline__ vector unsigned short __ATTRS_o_ai
5913 vec_nand(vector unsigned short __a, vector bool short __b) {
5914   return ~(__a & __b);
5915 }
5916
5917 static __inline__ vector bool short __ATTRS_o_ai
5918 vec_nand(vector bool short __a, vector bool short __b) {
5919   return ~(__a & __b);
5920 }
5921
5922 static __inline__ vector signed int __ATTRS_o_ai
5923 vec_nand(vector signed int __a, vector signed int __b) {
5924   return ~(__a & __b);
5925 }
5926
5927 static __inline__ vector signed int __ATTRS_o_ai vec_nand(vector signed int __a,
5928                                                           vector bool int __b) {
5929   return ~(__a & __b);
5930 }
5931
5932 static __inline__ vector signed int __ATTRS_o_ai
5933 vec_nand(vector bool int __a, vector signed int __b) {
5934   return ~(__a & __b);
5935 }
5936
5937 static __inline__ vector unsigned int __ATTRS_o_ai
5938 vec_nand(vector unsigned int __a, vector unsigned int __b) {
5939   return ~(__a & __b);
5940 }
5941
5942 static __inline__ vector unsigned int __ATTRS_o_ai
5943 vec_nand(vector unsigned int __a, vector bool int __b) {
5944   return ~(__a & __b);
5945 }
5946
5947 static __inline__ vector unsigned int __ATTRS_o_ai
5948 vec_nand(vector bool int __a, vector unsigned int __b) {
5949   return ~(__a & __b);
5950 }
5951
5952 static __inline__ vector bool int __ATTRS_o_ai vec_nand(vector bool int __a,
5953                                                         vector bool int __b) {
5954   return ~(__a & __b);
5955 }
5956
5957 static __inline__ vector float __ATTRS_o_ai
5958 vec_nand(vector float __a, vector float __b) {
5959   return (vector float)(~((vector unsigned int)__a &
5960                           (vector unsigned int)__b));
5961 }
5962
5963 static __inline__ vector signed long long __ATTRS_o_ai
5964 vec_nand(vector signed long long __a, vector signed long long __b) {
5965   return ~(__a & __b);
5966 }
5967
5968 static __inline__ vector signed long long __ATTRS_o_ai
5969 vec_nand(vector signed long long __a, vector bool long long __b) {
5970   return ~(__a & __b);
5971 }
5972
5973 static __inline__ vector signed long long __ATTRS_o_ai
5974 vec_nand(vector bool long long __a, vector signed long long __b) {
5975   return ~(__a & __b);
5976 }
5977
5978 static __inline__ vector unsigned long long __ATTRS_o_ai
5979 vec_nand(vector unsigned long long __a, vector unsigned long long __b) {
5980   return ~(__a & __b);
5981 }
5982
5983 static __inline__ vector unsigned long long __ATTRS_o_ai
5984 vec_nand(vector unsigned long long __a, vector bool long long __b) {
5985   return ~(__a & __b);
5986 }
5987
5988 static __inline__ vector unsigned long long __ATTRS_o_ai
5989 vec_nand(vector bool long long __a, vector unsigned long long __b) {
5990   return ~(__a & __b);
5991 }
5992
5993 static __inline__ vector bool long long __ATTRS_o_ai
5994 vec_nand(vector bool long long __a, vector bool long long __b) {
5995   return ~(__a & __b);
5996 }
5997
5998 static __inline__ vector double __ATTRS_o_ai
5999 vec_nand(vector double __a, vector double __b) {
6000   return (vector double)(~((vector unsigned long long)__a &
6001                            (vector unsigned long long)__b));
6002 }
6003
6004 #endif
6005
6006 /* vec_nmadd */
6007
6008 #ifdef __VSX__
6009 static __inline__ vector float __ATTRS_o_ai vec_nmadd(vector float __a,
6010                                                       vector float __b,
6011                                                       vector float __c) {
6012   return __builtin_vsx_xvnmaddasp(__a, __b, __c);
6013 }
6014
6015 static __inline__ vector double __ATTRS_o_ai vec_nmadd(vector double __a,
6016                                                        vector double __b,
6017                                                        vector double __c) {
6018   return __builtin_vsx_xvnmaddadp(__a, __b, __c);
6019 }
6020 #endif
6021
6022 /* vec_nmsub */
6023
6024 static __inline__ vector float __ATTRS_o_ai vec_nmsub(vector float __a,
6025                                                       vector float __b,
6026                                                       vector float __c) {
6027 #ifdef __VSX__
6028   return __builtin_vsx_xvnmsubasp(__a, __b, __c);
6029 #else
6030   return __builtin_altivec_vnmsubfp(__a, __b, __c);
6031 #endif
6032 }
6033
6034 #ifdef __VSX__
6035 static __inline__ vector double __ATTRS_o_ai vec_nmsub(vector double __a,
6036                                                        vector double __b,
6037                                                        vector double __c) {
6038   return __builtin_vsx_xvnmsubadp(__a, __b, __c);
6039 }
6040 #endif
6041
6042 /* vec_vnmsubfp */
6043
6044 static __inline__ vector float __attribute__((__always_inline__))
6045 vec_vnmsubfp(vector float __a, vector float __b, vector float __c) {
6046   return __builtin_altivec_vnmsubfp(__a, __b, __c);
6047 }
6048
6049 /* vec_nor */
6050
6051 #define __builtin_altivec_vnor vec_nor
6052
6053 static __inline__ vector signed char __ATTRS_o_ai
6054 vec_nor(vector signed char __a, vector signed char __b) {
6055   return ~(__a | __b);
6056 }
6057
6058 static __inline__ vector unsigned char __ATTRS_o_ai
6059 vec_nor(vector unsigned char __a, vector unsigned char __b) {
6060   return ~(__a | __b);
6061 }
6062
6063 static __inline__ vector bool char __ATTRS_o_ai vec_nor(vector bool char __a,
6064                                                         vector bool char __b) {
6065   return ~(__a | __b);
6066 }
6067
6068 static __inline__ vector short __ATTRS_o_ai vec_nor(vector short __a,
6069                                                     vector short __b) {
6070   return ~(__a | __b);
6071 }
6072
6073 static __inline__ vector unsigned short __ATTRS_o_ai
6074 vec_nor(vector unsigned short __a, vector unsigned short __b) {
6075   return ~(__a | __b);
6076 }
6077
6078 static __inline__ vector bool short __ATTRS_o_ai
6079 vec_nor(vector bool short __a, vector bool short __b) {
6080   return ~(__a | __b);
6081 }
6082
6083 static __inline__ vector int __ATTRS_o_ai vec_nor(vector int __a,
6084                                                   vector int __b) {
6085   return ~(__a | __b);
6086 }
6087
6088 static __inline__ vector unsigned int __ATTRS_o_ai
6089 vec_nor(vector unsigned int __a, vector unsigned int __b) {
6090   return ~(__a | __b);
6091 }
6092
6093 static __inline__ vector bool int __ATTRS_o_ai vec_nor(vector bool int __a,
6094                                                        vector bool int __b) {
6095   return ~(__a | __b);
6096 }
6097
6098 static __inline__ vector float __ATTRS_o_ai vec_nor(vector float __a,
6099                                                     vector float __b) {
6100   vector unsigned int __res =
6101       ~((vector unsigned int)__a | (vector unsigned int)__b);
6102   return (vector float)__res;
6103 }
6104
6105 #ifdef __VSX__
6106 static __inline__ vector double __ATTRS_o_ai vec_nor(vector double __a,
6107                                                      vector double __b) {
6108   vector unsigned long long __res =
6109       ~((vector unsigned long long)__a | (vector unsigned long long)__b);
6110   return (vector double)__res;
6111 }
6112 #endif
6113
6114 /* vec_vnor */
6115
6116 static __inline__ vector signed char __ATTRS_o_ai
6117 vec_vnor(vector signed char __a, vector signed char __b) {
6118   return ~(__a | __b);
6119 }
6120
6121 static __inline__ vector unsigned char __ATTRS_o_ai
6122 vec_vnor(vector unsigned char __a, vector unsigned char __b) {
6123   return ~(__a | __b);
6124 }
6125
6126 static __inline__ vector bool char __ATTRS_o_ai vec_vnor(vector bool char __a,
6127                                                          vector bool char __b) {
6128   return ~(__a | __b);
6129 }
6130
6131 static __inline__ vector short __ATTRS_o_ai vec_vnor(vector short __a,
6132                                                      vector short __b) {
6133   return ~(__a | __b);
6134 }
6135
6136 static __inline__ vector unsigned short __ATTRS_o_ai
6137 vec_vnor(vector unsigned short __a, vector unsigned short __b) {
6138   return ~(__a | __b);
6139 }
6140
6141 static __inline__ vector bool short __ATTRS_o_ai
6142 vec_vnor(vector bool short __a, vector bool short __b) {
6143   return ~(__a | __b);
6144 }
6145
6146 static __inline__ vector int __ATTRS_o_ai vec_vnor(vector int __a,
6147                                                    vector int __b) {
6148   return ~(__a | __b);
6149 }
6150
6151 static __inline__ vector unsigned int __ATTRS_o_ai
6152 vec_vnor(vector unsigned int __a, vector unsigned int __b) {
6153   return ~(__a | __b);
6154 }
6155
6156 static __inline__ vector bool int __ATTRS_o_ai vec_vnor(vector bool int __a,
6157                                                         vector bool int __b) {
6158   return ~(__a | __b);
6159 }
6160
6161 static __inline__ vector float __ATTRS_o_ai vec_vnor(vector float __a,
6162                                                      vector float __b) {
6163   vector unsigned int __res =
6164       ~((vector unsigned int)__a | (vector unsigned int)__b);
6165   return (vector float)__res;
6166 }
6167
6168 #ifdef __VSX__
6169 static __inline__ vector signed long long __ATTRS_o_ai
6170 vec_nor(vector signed long long __a, vector signed long long __b) {
6171   return ~(__a | __b);
6172 }
6173
6174 static __inline__ vector unsigned long long __ATTRS_o_ai
6175 vec_nor(vector unsigned long long __a, vector unsigned long long __b) {
6176   return ~(__a | __b);
6177 }
6178
6179 static __inline__ vector bool long long __ATTRS_o_ai
6180 vec_nor(vector bool long long __a, vector bool long long __b) {
6181   return ~(__a | __b);
6182 }
6183 #endif
6184
6185 /* vec_or */
6186
6187 #define __builtin_altivec_vor vec_or
6188
6189 static __inline__ vector signed char __ATTRS_o_ai
6190 vec_or(vector signed char __a, vector signed char __b) {
6191   return __a | __b;
6192 }
6193
6194 static __inline__ vector signed char __ATTRS_o_ai
6195 vec_or(vector bool char __a, vector signed char __b) {
6196   return (vector signed char)__a | __b;
6197 }
6198
6199 static __inline__ vector signed char __ATTRS_o_ai vec_or(vector signed char __a,
6200                                                          vector bool char __b) {
6201   return __a | (vector signed char)__b;
6202 }
6203
6204 static __inline__ vector unsigned char __ATTRS_o_ai
6205 vec_or(vector unsigned char __a, vector unsigned char __b) {
6206   return __a | __b;
6207 }
6208
6209 static __inline__ vector unsigned char __ATTRS_o_ai
6210 vec_or(vector bool char __a, vector unsigned char __b) {
6211   return (vector unsigned char)__a | __b;
6212 }
6213
6214 static __inline__ vector unsigned char __ATTRS_o_ai
6215 vec_or(vector unsigned char __a, vector bool char __b) {
6216   return __a | (vector unsigned char)__b;
6217 }
6218
6219 static __inline__ vector bool char __ATTRS_o_ai vec_or(vector bool char __a,
6220                                                        vector bool char __b) {
6221   return __a | __b;
6222 }
6223
6224 static __inline__ vector short __ATTRS_o_ai vec_or(vector short __a,
6225                                                    vector short __b) {
6226   return __a | __b;
6227 }
6228
6229 static __inline__ vector short __ATTRS_o_ai vec_or(vector bool short __a,
6230                                                    vector short __b) {
6231   return (vector short)__a | __b;
6232 }
6233
6234 static __inline__ vector short __ATTRS_o_ai vec_or(vector short __a,
6235                                                    vector bool short __b) {
6236   return __a | (vector short)__b;
6237 }
6238
6239 static __inline__ vector unsigned short __ATTRS_o_ai
6240 vec_or(vector unsigned short __a, vector unsigned short __b) {
6241   return __a | __b;
6242 }
6243
6244 static __inline__ vector unsigned short __ATTRS_o_ai
6245 vec_or(vector bool short __a, vector unsigned short __b) {
6246   return (vector unsigned short)__a | __b;
6247 }
6248
6249 static __inline__ vector unsigned short __ATTRS_o_ai
6250 vec_or(vector unsigned short __a, vector bool short __b) {
6251   return __a | (vector unsigned short)__b;
6252 }
6253
6254 static __inline__ vector bool short __ATTRS_o_ai vec_or(vector bool short __a,
6255                                                         vector bool short __b) {
6256   return __a | __b;
6257 }
6258
6259 static __inline__ vector int __ATTRS_o_ai vec_or(vector int __a,
6260                                                  vector int __b) {
6261   return __a | __b;
6262 }
6263
6264 static __inline__ vector int __ATTRS_o_ai vec_or(vector bool int __a,
6265                                                  vector int __b) {
6266   return (vector int)__a | __b;
6267 }
6268
6269 static __inline__ vector int __ATTRS_o_ai vec_or(vector int __a,
6270                                                  vector bool int __b) {
6271   return __a | (vector int)__b;
6272 }
6273
6274 static __inline__ vector unsigned int __ATTRS_o_ai
6275 vec_or(vector unsigned int __a, vector unsigned int __b) {
6276   return __a | __b;
6277 }
6278
6279 static __inline__ vector unsigned int __ATTRS_o_ai
6280 vec_or(vector bool int __a, vector unsigned int __b) {
6281   return (vector unsigned int)__a | __b;
6282 }
6283
6284 static __inline__ vector unsigned int __ATTRS_o_ai
6285 vec_or(vector unsigned int __a, vector bool int __b) {
6286   return __a | (vector unsigned int)__b;
6287 }
6288
6289 static __inline__ vector bool int __ATTRS_o_ai vec_or(vector bool int __a,
6290                                                       vector bool int __b) {
6291   return __a | __b;
6292 }
6293
6294 static __inline__ vector float __ATTRS_o_ai vec_or(vector float __a,
6295                                                    vector float __b) {
6296   vector unsigned int __res =
6297       (vector unsigned int)__a | (vector unsigned int)__b;
6298   return (vector float)__res;
6299 }
6300
6301 static __inline__ vector float __ATTRS_o_ai vec_or(vector bool int __a,
6302                                                    vector float __b) {
6303   vector unsigned int __res =
6304       (vector unsigned int)__a | (vector unsigned int)__b;
6305   return (vector float)__res;
6306 }
6307
6308 static __inline__ vector float __ATTRS_o_ai vec_or(vector float __a,
6309                                                    vector bool int __b) {
6310   vector unsigned int __res =
6311       (vector unsigned int)__a | (vector unsigned int)__b;
6312   return (vector float)__res;
6313 }
6314
6315 #ifdef __VSX__
6316 static __inline__ vector double __ATTRS_o_ai vec_or(vector bool long long __a,
6317                                                     vector double __b) {
6318   return (vector unsigned long long)__a | (vector unsigned long long)__b;
6319 }
6320
6321 static __inline__ vector double __ATTRS_o_ai vec_or(vector double __a,
6322                                                     vector bool long long __b) {
6323   return (vector unsigned long long)__a | (vector unsigned long long)__b;
6324 }
6325
6326 static __inline__ vector double __ATTRS_o_ai vec_or(vector double __a,
6327                                                     vector double __b) {
6328   vector unsigned long long __res =
6329       (vector unsigned long long)__a | (vector unsigned long long)__b;
6330   return (vector double)__res;
6331 }
6332
6333 static __inline__ vector signed long long __ATTRS_o_ai
6334 vec_or(vector signed long long __a, vector signed long long __b) {
6335   return __a | __b;
6336 }
6337
6338 static __inline__ vector signed long long __ATTRS_o_ai
6339 vec_or(vector bool long long __a, vector signed long long __b) {
6340   return (vector signed long long)__a | __b;
6341 }
6342
6343 static __inline__ vector signed long long __ATTRS_o_ai
6344 vec_or(vector signed long long __a, vector bool long long __b) {
6345   return __a | (vector signed long long)__b;
6346 }
6347
6348 static __inline__ vector unsigned long long __ATTRS_o_ai
6349 vec_or(vector unsigned long long __a, vector unsigned long long __b) {
6350   return __a | __b;
6351 }
6352
6353 static __inline__ vector unsigned long long __ATTRS_o_ai
6354 vec_or(vector bool long long __a, vector unsigned long long __b) {
6355   return (vector unsigned long long)__a | __b;
6356 }
6357
6358 static __inline__ vector unsigned long long __ATTRS_o_ai
6359 vec_or(vector unsigned long long __a, vector bool long long __b) {
6360   return __a | (vector unsigned long long)__b;
6361 }
6362
6363 static __inline__ vector bool long long __ATTRS_o_ai
6364 vec_or(vector bool long long __a, vector bool long long __b) {
6365   return __a | __b;
6366 }
6367 #endif
6368
6369 #ifdef __POWER8_VECTOR__
6370 static __inline__ vector signed char __ATTRS_o_ai
6371 vec_orc(vector signed char __a, vector signed char __b) {
6372   return __a | ~__b;
6373 }
6374
6375 static __inline__ vector signed char __ATTRS_o_ai
6376 vec_orc(vector signed char __a, vector bool char __b) {
6377   return __a | ~__b;
6378 }
6379
6380 static __inline__ vector signed char __ATTRS_o_ai
6381 vec_orc(vector bool char __a, vector signed char __b) {
6382   return __a | ~__b;
6383 }
6384
6385 static __inline__ vector unsigned char __ATTRS_o_ai
6386 vec_orc(vector unsigned char __a, vector unsigned char __b) {
6387   return __a | ~__b;
6388 }
6389
6390 static __inline__ vector unsigned char __ATTRS_o_ai
6391 vec_orc(vector unsigned char __a, vector bool char __b) {
6392   return __a | ~__b;
6393 }
6394
6395 static __inline__ vector unsigned char __ATTRS_o_ai
6396 vec_orc(vector bool char __a, vector unsigned char __b) {
6397   return __a | ~__b;
6398 }
6399
6400 static __inline__ vector bool char __ATTRS_o_ai vec_orc(vector bool char __a,
6401                                                         vector bool char __b) {
6402   return __a | ~__b;
6403 }
6404
6405 static __inline__ vector signed short __ATTRS_o_ai
6406 vec_orc(vector signed short __a, vector signed short __b) {
6407   return __a | ~__b;
6408 }
6409
6410 static __inline__ vector signed short __ATTRS_o_ai
6411 vec_orc(vector signed short __a, vector bool short __b) {
6412   return __a | ~__b;
6413 }
6414
6415 static __inline__ vector signed short __ATTRS_o_ai
6416 vec_orc(vector bool short __a, vector signed short __b) {
6417   return __a | ~__b;
6418 }
6419
6420 static __inline__ vector unsigned short __ATTRS_o_ai
6421 vec_orc(vector unsigned short __a, vector unsigned short __b) {
6422   return __a | ~__b;
6423 }
6424
6425 static __inline__ vector unsigned short __ATTRS_o_ai
6426 vec_orc(vector unsigned short __a, vector bool short __b) {
6427   return __a | ~__b;
6428 }
6429
6430 static __inline__ vector unsigned short __ATTRS_o_ai
6431 vec_orc(vector bool short __a, vector unsigned short __b) {
6432   return __a | ~__b;
6433 }
6434
6435 static __inline__ vector bool short __ATTRS_o_ai
6436 vec_orc(vector bool short __a, vector bool short __b) {
6437   return __a | ~__b;
6438 }
6439
6440 static __inline__ vector signed int __ATTRS_o_ai
6441 vec_orc(vector signed int __a, vector signed int __b) {
6442   return __a | ~__b;
6443 }
6444
6445 static __inline__ vector signed int __ATTRS_o_ai vec_orc(vector signed int __a,
6446                                                          vector bool int __b) {
6447   return __a | ~__b;
6448 }
6449
6450 static __inline__ vector signed int __ATTRS_o_ai
6451 vec_orc(vector bool int __a, vector signed int __b) {
6452   return __a | ~__b;
6453 }
6454
6455 static __inline__ vector unsigned int __ATTRS_o_ai
6456 vec_orc(vector unsigned int __a, vector unsigned int __b) {
6457   return __a | ~__b;
6458 }
6459
6460 static __inline__ vector unsigned int __ATTRS_o_ai
6461 vec_orc(vector unsigned int __a, vector bool int __b) {
6462   return __a | ~__b;
6463 }
6464
6465 static __inline__ vector unsigned int __ATTRS_o_ai
6466 vec_orc(vector bool int __a, vector unsigned int __b) {
6467   return __a | ~__b;
6468 }
6469
6470 static __inline__ vector bool int __ATTRS_o_ai vec_orc(vector bool int __a,
6471                                                        vector bool int __b) {
6472   return __a | ~__b;
6473 }
6474
6475 static __inline__ vector float __ATTRS_o_ai
6476 vec_orc(vector bool int __a, vector float __b) {
6477  return (vector float)(__a | ~(vector unsigned int)__b);
6478 }
6479
6480 static __inline__ vector float __ATTRS_o_ai
6481 vec_orc(vector float __a, vector bool int __b) {
6482   return (vector float)((vector unsigned int)__a | ~__b);
6483 }
6484
6485 static __inline__ vector signed long long __ATTRS_o_ai
6486 vec_orc(vector signed long long __a, vector signed long long __b) {
6487   return __a | ~__b;
6488 }
6489
6490 static __inline__ vector signed long long __ATTRS_o_ai
6491 vec_orc(vector signed long long __a, vector bool long long __b) {
6492   return __a | ~__b;
6493 }
6494
6495 static __inline__ vector signed long long __ATTRS_o_ai
6496 vec_orc(vector bool long long __a, vector signed long long __b) {
6497   return __a | ~__b;
6498 }
6499
6500 static __inline__ vector unsigned long long __ATTRS_o_ai
6501 vec_orc(vector unsigned long long __a, vector unsigned long long __b) {
6502   return __a | ~__b;
6503 }
6504
6505 static __inline__ vector unsigned long long __ATTRS_o_ai
6506 vec_orc(vector unsigned long long __a, vector bool long long __b) {
6507   return __a | ~__b;
6508 }
6509
6510 static __inline__ vector unsigned long long __ATTRS_o_ai
6511 vec_orc(vector bool long long __a, vector unsigned long long __b) {
6512   return __a | ~__b;
6513 }
6514
6515 static __inline__ vector bool long long __ATTRS_o_ai
6516 vec_orc(vector bool long long __a, vector bool long long __b) {
6517   return __a | ~__b;
6518 }
6519
6520 static __inline__ vector double __ATTRS_o_ai
6521 vec_orc(vector double __a, vector bool long long __b) {
6522   return (vector double)((vector unsigned long long)__a | ~__b);
6523 }
6524
6525 static __inline__ vector double __ATTRS_o_ai
6526 vec_orc(vector bool long long __a, vector double __b) {
6527   return (vector double)(__a | ~(vector unsigned long long)__b);
6528 }
6529 #endif
6530
6531 /* vec_vor */
6532
6533 static __inline__ vector signed char __ATTRS_o_ai
6534 vec_vor(vector signed char __a, vector signed char __b) {
6535   return __a | __b;
6536 }
6537
6538 static __inline__ vector signed char __ATTRS_o_ai
6539 vec_vor(vector bool char __a, vector signed char __b) {
6540   return (vector signed char)__a | __b;
6541 }
6542
6543 static __inline__ vector signed char __ATTRS_o_ai
6544 vec_vor(vector signed char __a, vector bool char __b) {
6545   return __a | (vector signed char)__b;
6546 }
6547
6548 static __inline__ vector unsigned char __ATTRS_o_ai
6549 vec_vor(vector unsigned char __a, vector unsigned char __b) {
6550   return __a | __b;
6551 }
6552
6553 static __inline__ vector unsigned char __ATTRS_o_ai
6554 vec_vor(vector bool char __a, vector unsigned char __b) {
6555   return (vector unsigned char)__a | __b;
6556 }
6557
6558 static __inline__ vector unsigned char __ATTRS_o_ai
6559 vec_vor(vector unsigned char __a, vector bool char __b) {
6560   return __a | (vector unsigned char)__b;
6561 }
6562
6563 static __inline__ vector bool char __ATTRS_o_ai vec_vor(vector bool char __a,
6564                                                         vector bool char __b) {
6565   return __a | __b;
6566 }
6567
6568 static __inline__ vector short __ATTRS_o_ai vec_vor(vector short __a,
6569                                                     vector short __b) {
6570   return __a | __b;
6571 }
6572
6573 static __inline__ vector short __ATTRS_o_ai vec_vor(vector bool short __a,
6574                                                     vector short __b) {
6575   return (vector short)__a | __b;
6576 }
6577
6578 static __inline__ vector short __ATTRS_o_ai vec_vor(vector short __a,
6579                                                     vector bool short __b) {
6580   return __a | (vector short)__b;
6581 }
6582
6583 static __inline__ vector unsigned short __ATTRS_o_ai
6584 vec_vor(vector unsigned short __a, vector unsigned short __b) {
6585   return __a | __b;
6586 }
6587
6588 static __inline__ vector unsigned short __ATTRS_o_ai
6589 vec_vor(vector bool short __a, vector unsigned short __b) {
6590   return (vector unsigned short)__a | __b;
6591 }
6592
6593 static __inline__ vector unsigned short __ATTRS_o_ai
6594 vec_vor(vector unsigned short __a, vector bool short __b) {
6595   return __a | (vector unsigned short)__b;
6596 }
6597
6598 static __inline__ vector bool short __ATTRS_o_ai
6599 vec_vor(vector bool short __a, vector bool short __b) {
6600   return __a | __b;
6601 }
6602
6603 static __inline__ vector int __ATTRS_o_ai vec_vor(vector int __a,
6604                                                   vector int __b) {
6605   return __a | __b;
6606 }
6607
6608 static __inline__ vector int __ATTRS_o_ai vec_vor(vector bool int __a,
6609                                                   vector int __b) {
6610   return (vector int)__a | __b;
6611 }
6612
6613 static __inline__ vector int __ATTRS_o_ai vec_vor(vector int __a,
6614                                                   vector bool int __b) {
6615   return __a | (vector int)__b;
6616 }
6617
6618 static __inline__ vector unsigned int __ATTRS_o_ai
6619 vec_vor(vector unsigned int __a, vector unsigned int __b) {
6620   return __a | __b;
6621 }
6622
6623 static __inline__ vector unsigned int __ATTRS_o_ai
6624 vec_vor(vector bool int __a, vector unsigned int __b) {
6625   return (vector unsigned int)__a | __b;
6626 }
6627
6628 static __inline__ vector unsigned int __ATTRS_o_ai
6629 vec_vor(vector unsigned int __a, vector bool int __b) {
6630   return __a | (vector unsigned int)__b;
6631 }
6632
6633 static __inline__ vector bool int __ATTRS_o_ai vec_vor(vector bool int __a,
6634                                                        vector bool int __b) {
6635   return __a | __b;
6636 }
6637
6638 static __inline__ vector float __ATTRS_o_ai vec_vor(vector float __a,
6639                                                     vector float __b) {
6640   vector unsigned int __res =
6641       (vector unsigned int)__a | (vector unsigned int)__b;
6642   return (vector float)__res;
6643 }
6644
6645 static __inline__ vector float __ATTRS_o_ai vec_vor(vector bool int __a,
6646                                                     vector float __b) {
6647   vector unsigned int __res =
6648       (vector unsigned int)__a | (vector unsigned int)__b;
6649   return (vector float)__res;
6650 }
6651
6652 static __inline__ vector float __ATTRS_o_ai vec_vor(vector float __a,
6653                                                     vector bool int __b) {
6654   vector unsigned int __res =
6655       (vector unsigned int)__a | (vector unsigned int)__b;
6656   return (vector float)__res;
6657 }
6658
6659 #ifdef __VSX__
6660 static __inline__ vector signed long long __ATTRS_o_ai
6661 vec_vor(vector signed long long __a, vector signed long long __b) {
6662   return __a | __b;
6663 }
6664
6665 static __inline__ vector signed long long __ATTRS_o_ai
6666 vec_vor(vector bool long long __a, vector signed long long __b) {
6667   return (vector signed long long)__a | __b;
6668 }
6669
6670 static __inline__ vector signed long long __ATTRS_o_ai
6671 vec_vor(vector signed long long __a, vector bool long long __b) {
6672   return __a | (vector signed long long)__b;
6673 }
6674
6675 static __inline__ vector unsigned long long __ATTRS_o_ai
6676 vec_vor(vector unsigned long long __a, vector unsigned long long __b) {
6677   return __a | __b;
6678 }
6679
6680 static __inline__ vector unsigned long long __ATTRS_o_ai
6681 vec_vor(vector bool long long __a, vector unsigned long long __b) {
6682   return (vector unsigned long long)__a | __b;
6683 }
6684
6685 static __inline__ vector unsigned long long __ATTRS_o_ai
6686 vec_vor(vector unsigned long long __a, vector bool long long __b) {
6687   return __a | (vector unsigned long long)__b;
6688 }
6689
6690 static __inline__ vector bool long long __ATTRS_o_ai
6691 vec_vor(vector bool long long __a, vector bool long long __b) {
6692   return __a | __b;
6693 }
6694 #endif
6695
6696 /* vec_pack */
6697
6698 /* The various vector pack instructions have a big-endian bias, so for
6699    little endian we must handle reversed element numbering.  */
6700
6701 static __inline__ vector signed char __ATTRS_o_ai
6702 vec_pack(vector signed short __a, vector signed short __b) {
6703 #ifdef __LITTLE_ENDIAN__
6704   return (vector signed char)vec_perm(
6705       __a, __b,
6706       (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
6707                              0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
6708 #else
6709   return (vector signed char)vec_perm(
6710       __a, __b,
6711       (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
6712                              0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
6713 #endif
6714 }
6715
6716 static __inline__ vector unsigned char __ATTRS_o_ai
6717 vec_pack(vector unsigned short __a, vector unsigned short __b) {
6718 #ifdef __LITTLE_ENDIAN__
6719   return (vector unsigned char)vec_perm(
6720       __a, __b,
6721       (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
6722                              0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
6723 #else
6724   return (vector unsigned char)vec_perm(
6725       __a, __b,
6726       (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
6727                              0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
6728 #endif
6729 }
6730
6731 static __inline__ vector bool char __ATTRS_o_ai
6732 vec_pack(vector bool short __a, vector bool short __b) {
6733 #ifdef __LITTLE_ENDIAN__
6734   return (vector bool char)vec_perm(
6735       __a, __b,
6736       (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
6737                              0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
6738 #else
6739   return (vector bool char)vec_perm(
6740       __a, __b,
6741       (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
6742                              0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
6743 #endif
6744 }
6745
6746 static __inline__ vector short __ATTRS_o_ai vec_pack(vector int __a,
6747                                                      vector int __b) {
6748 #ifdef __LITTLE_ENDIAN__
6749   return (vector short)vec_perm(
6750       __a, __b,
6751       (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
6752                              0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
6753 #else
6754   return (vector short)vec_perm(
6755       __a, __b,
6756       (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
6757                              0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
6758 #endif
6759 }
6760
6761 static __inline__ vector unsigned short __ATTRS_o_ai
6762 vec_pack(vector unsigned int __a, vector unsigned int __b) {
6763 #ifdef __LITTLE_ENDIAN__
6764   return (vector unsigned short)vec_perm(
6765       __a, __b,
6766       (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
6767                              0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
6768 #else
6769   return (vector unsigned short)vec_perm(
6770       __a, __b,
6771       (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
6772                              0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
6773 #endif
6774 }
6775
6776 static __inline__ vector bool short __ATTRS_o_ai vec_pack(vector bool int __a,
6777                                                           vector bool int __b) {
6778 #ifdef __LITTLE_ENDIAN__
6779   return (vector bool short)vec_perm(
6780       __a, __b,
6781       (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
6782                              0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
6783 #else
6784   return (vector bool short)vec_perm(
6785       __a, __b,
6786       (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
6787                              0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
6788 #endif
6789 }
6790
6791 #ifdef __VSX__
6792 static __inline__ vector signed int __ATTRS_o_ai
6793 vec_pack(vector signed long long __a, vector signed long long __b) {
6794 #ifdef __LITTLE_ENDIAN__
6795   return (vector signed int)vec_perm(
6796       __a, __b,
6797       (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
6798                              0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
6799 #else
6800   return (vector signed int)vec_perm(
6801       __a, __b,
6802       (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
6803                              0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
6804 #endif
6805 }
6806 static __inline__ vector unsigned int __ATTRS_o_ai
6807 vec_pack(vector unsigned long long __a, vector unsigned long long __b) {
6808 #ifdef __LITTLE_ENDIAN__
6809   return (vector unsigned int)vec_perm(
6810       __a, __b,
6811       (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
6812                              0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
6813 #else
6814   return (vector unsigned int)vec_perm(
6815       __a, __b,
6816       (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
6817                              0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
6818 #endif
6819 }
6820
6821 static __inline__ vector bool int __ATTRS_o_ai
6822 vec_pack(vector bool long long __a, vector bool long long __b) {
6823 #ifdef __LITTLE_ENDIAN__
6824   return (vector bool int)vec_perm(
6825       __a, __b,
6826       (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
6827                              0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
6828 #else
6829   return (vector bool int)vec_perm(
6830       __a, __b,
6831       (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
6832                              0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
6833 #endif
6834 }
6835
6836 static __inline__ vector float __ATTRS_o_ai
6837 vec_pack(vector double __a, vector double __b) {
6838   return (vector float) (__a[0], __a[1], __b[0], __b[1]);
6839 }
6840 #endif
6841
6842 #ifdef __POWER9_VECTOR__
6843 static __inline__ vector unsigned short __ATTRS_o_ai
6844 vec_pack_to_short_fp32(vector float __a, vector float __b) {
6845   vector float __resa = __builtin_vsx_xvcvsphp(__a);
6846   vector float __resb = __builtin_vsx_xvcvsphp(__b);
6847 #ifdef __LITTLE_ENDIAN__
6848   return (vector unsigned short)vec_mergee(__resa, __resb);
6849 #else
6850   return (vector unsigned short)vec_mergeo(__resa, __resb);
6851 #endif
6852 }
6853
6854 #endif
6855 /* vec_vpkuhum */
6856
6857 #define __builtin_altivec_vpkuhum vec_vpkuhum
6858
6859 static __inline__ vector signed char __ATTRS_o_ai
6860 vec_vpkuhum(vector signed short __a, vector signed short __b) {
6861 #ifdef __LITTLE_ENDIAN__
6862   return (vector signed char)vec_perm(
6863       __a, __b,
6864       (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
6865                              0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
6866 #else
6867   return (vector signed char)vec_perm(
6868       __a, __b,
6869       (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
6870                              0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
6871 #endif
6872 }
6873
6874 static __inline__ vector unsigned char __ATTRS_o_ai
6875 vec_vpkuhum(vector unsigned short __a, vector unsigned short __b) {
6876 #ifdef __LITTLE_ENDIAN__
6877   return (vector unsigned char)vec_perm(
6878       __a, __b,
6879       (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
6880                              0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
6881 #else
6882   return (vector unsigned char)vec_perm(
6883       __a, __b,
6884       (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
6885                              0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
6886 #endif
6887 }
6888
6889 static __inline__ vector bool char __ATTRS_o_ai
6890 vec_vpkuhum(vector bool short __a, vector bool short __b) {
6891 #ifdef __LITTLE_ENDIAN__
6892   return (vector bool char)vec_perm(
6893       __a, __b,
6894       (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
6895                              0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
6896 #else
6897   return (vector bool char)vec_perm(
6898       __a, __b,
6899       (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
6900                              0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
6901 #endif
6902 }
6903
6904 /* vec_vpkuwum */
6905
6906 #define __builtin_altivec_vpkuwum vec_vpkuwum
6907
6908 static __inline__ vector short __ATTRS_o_ai vec_vpkuwum(vector int __a,
6909                                                         vector int __b) {
6910 #ifdef __LITTLE_ENDIAN__
6911   return (vector short)vec_perm(
6912       __a, __b,
6913       (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
6914                              0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
6915 #else
6916   return (vector short)vec_perm(
6917       __a, __b,
6918       (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
6919                              0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
6920 #endif
6921 }
6922
6923 static __inline__ vector unsigned short __ATTRS_o_ai
6924 vec_vpkuwum(vector unsigned int __a, vector unsigned int __b) {
6925 #ifdef __LITTLE_ENDIAN__
6926   return (vector unsigned short)vec_perm(
6927       __a, __b,
6928       (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
6929                              0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
6930 #else
6931   return (vector unsigned short)vec_perm(
6932       __a, __b,
6933       (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
6934                              0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
6935 #endif
6936 }
6937
6938 static __inline__ vector bool short __ATTRS_o_ai
6939 vec_vpkuwum(vector bool int __a, vector bool int __b) {
6940 #ifdef __LITTLE_ENDIAN__
6941   return (vector bool short)vec_perm(
6942       __a, __b,
6943       (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
6944                              0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
6945 #else
6946   return (vector bool short)vec_perm(
6947       __a, __b,
6948       (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
6949                              0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
6950 #endif
6951 }
6952
6953 /* vec_vpkudum */
6954
6955 #ifdef __POWER8_VECTOR__
6956 #define __builtin_altivec_vpkudum vec_vpkudum
6957
6958 static __inline__ vector int __ATTRS_o_ai vec_vpkudum(vector long long __a,
6959                                                       vector long long __b) {
6960 #ifdef __LITTLE_ENDIAN__
6961   return (vector int)vec_perm(
6962       __a, __b,
6963       (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
6964                              0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
6965 #else
6966   return (vector int)vec_perm(
6967       __a, __b,
6968       (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
6969                              0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
6970 #endif
6971 }
6972
6973 static __inline__ vector unsigned int __ATTRS_o_ai
6974 vec_vpkudum(vector unsigned long long __a, vector unsigned long long __b) {
6975 #ifdef __LITTLE_ENDIAN__
6976   return (vector unsigned int)vec_perm(
6977       __a, __b,
6978       (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
6979                              0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
6980 #else
6981   return (vector unsigned int)vec_perm(
6982       __a, __b,
6983       (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
6984                              0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
6985 #endif
6986 }
6987
6988 static __inline__ vector bool int __ATTRS_o_ai
6989 vec_vpkudum(vector bool long long __a, vector bool long long __b) {
6990 #ifdef __LITTLE_ENDIAN__
6991   return (vector bool int)vec_perm(
6992       (vector long long)__a, (vector long long)__b,
6993       (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
6994                              0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
6995 #else
6996   return (vector bool int)vec_perm(
6997       (vector long long)__a, (vector long long)__b,
6998       (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
6999                              0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
7000 #endif
7001 }
7002 #endif
7003
7004 /* vec_packpx */
7005
7006 static __inline__ vector pixel __attribute__((__always_inline__))
7007 vec_packpx(vector unsigned int __a, vector unsigned int __b) {
7008 #ifdef __LITTLE_ENDIAN__
7009   return (vector pixel)__builtin_altivec_vpkpx(__b, __a);
7010 #else
7011   return (vector pixel)__builtin_altivec_vpkpx(__a, __b);
7012 #endif
7013 }
7014
7015 /* vec_vpkpx */
7016
7017 static __inline__ vector pixel __attribute__((__always_inline__))
7018 vec_vpkpx(vector unsigned int __a, vector unsigned int __b) {
7019 #ifdef __LITTLE_ENDIAN__
7020   return (vector pixel)__builtin_altivec_vpkpx(__b, __a);
7021 #else
7022   return (vector pixel)__builtin_altivec_vpkpx(__a, __b);
7023 #endif
7024 }
7025
7026 /* vec_packs */
7027
7028 static __inline__ vector signed char __ATTRS_o_ai vec_packs(vector short __a,
7029                                                             vector short __b) {
7030 #ifdef __LITTLE_ENDIAN__
7031   return __builtin_altivec_vpkshss(__b, __a);
7032 #else
7033   return __builtin_altivec_vpkshss(__a, __b);
7034 #endif
7035 }
7036
7037 static __inline__ vector unsigned char __ATTRS_o_ai
7038 vec_packs(vector unsigned short __a, vector unsigned short __b) {
7039 #ifdef __LITTLE_ENDIAN__
7040   return __builtin_altivec_vpkuhus(__b, __a);
7041 #else
7042   return __builtin_altivec_vpkuhus(__a, __b);
7043 #endif
7044 }
7045
7046 static __inline__ vector signed short __ATTRS_o_ai vec_packs(vector int __a,
7047                                                              vector int __b) {
7048 #ifdef __LITTLE_ENDIAN__
7049   return __builtin_altivec_vpkswss(__b, __a);
7050 #else
7051   return __builtin_altivec_vpkswss(__a, __b);
7052 #endif
7053 }
7054
7055 static __inline__ vector unsigned short __ATTRS_o_ai
7056 vec_packs(vector unsigned int __a, vector unsigned int __b) {
7057 #ifdef __LITTLE_ENDIAN__
7058   return __builtin_altivec_vpkuwus(__b, __a);
7059 #else
7060   return __builtin_altivec_vpkuwus(__a, __b);
7061 #endif
7062 }
7063
7064 #ifdef __POWER8_VECTOR__
7065 static __inline__ vector int __ATTRS_o_ai vec_packs(vector long long __a,
7066                                                     vector long long __b) {
7067 #ifdef __LITTLE_ENDIAN__
7068   return __builtin_altivec_vpksdss(__b, __a);
7069 #else
7070   return __builtin_altivec_vpksdss(__a, __b);
7071 #endif
7072 }
7073
7074 static __inline__ vector unsigned int __ATTRS_o_ai
7075 vec_packs(vector unsigned long long __a, vector unsigned long long __b) {
7076 #ifdef __LITTLE_ENDIAN__
7077   return __builtin_altivec_vpkudus(__b, __a);
7078 #else
7079   return __builtin_altivec_vpkudus(__a, __b);
7080 #endif
7081 }
7082 #endif
7083
7084 /* vec_vpkshss */
7085
7086 static __inline__ vector signed char __attribute__((__always_inline__))
7087 vec_vpkshss(vector short __a, vector short __b) {
7088 #ifdef __LITTLE_ENDIAN__
7089   return __builtin_altivec_vpkshss(__b, __a);
7090 #else
7091   return __builtin_altivec_vpkshss(__a, __b);
7092 #endif
7093 }
7094
7095 /* vec_vpksdss */
7096
7097 #ifdef __POWER8_VECTOR__
7098 static __inline__ vector int __ATTRS_o_ai vec_vpksdss(vector long long __a,
7099                                                       vector long long __b) {
7100 #ifdef __LITTLE_ENDIAN__
7101   return __builtin_altivec_vpksdss(__b, __a);
7102 #else
7103   return __builtin_altivec_vpksdss(__a, __b);
7104 #endif
7105 }
7106 #endif
7107
7108 /* vec_vpkuhus */
7109
7110 static __inline__ vector unsigned char __attribute__((__always_inline__))
7111 vec_vpkuhus(vector unsigned short __a, vector unsigned short __b) {
7112 #ifdef __LITTLE_ENDIAN__
7113   return __builtin_altivec_vpkuhus(__b, __a);
7114 #else
7115   return __builtin_altivec_vpkuhus(__a, __b);
7116 #endif
7117 }
7118
7119 /* vec_vpkudus */
7120
7121 #ifdef __POWER8_VECTOR__
7122 static __inline__ vector unsigned int __attribute__((__always_inline__))
7123 vec_vpkudus(vector unsigned long long __a, vector unsigned long long __b) {
7124 #ifdef __LITTLE_ENDIAN__
7125   return __builtin_altivec_vpkudus(__b, __a);
7126 #else
7127   return __builtin_altivec_vpkudus(__a, __b);
7128 #endif
7129 }
7130 #endif
7131
7132 /* vec_vpkswss */
7133
7134 static __inline__ vector signed short __attribute__((__always_inline__))
7135 vec_vpkswss(vector int __a, vector int __b) {
7136 #ifdef __LITTLE_ENDIAN__
7137   return __builtin_altivec_vpkswss(__b, __a);
7138 #else
7139   return __builtin_altivec_vpkswss(__a, __b);
7140 #endif
7141 }
7142
7143 /* vec_vpkuwus */
7144
7145 static __inline__ vector unsigned short __attribute__((__always_inline__))
7146 vec_vpkuwus(vector unsigned int __a, vector unsigned int __b) {
7147 #ifdef __LITTLE_ENDIAN__
7148   return __builtin_altivec_vpkuwus(__b, __a);
7149 #else
7150   return __builtin_altivec_vpkuwus(__a, __b);
7151 #endif
7152 }
7153
7154 /* vec_packsu */
7155
7156 static __inline__ vector unsigned char __ATTRS_o_ai
7157 vec_packsu(vector short __a, vector short __b) {
7158 #ifdef __LITTLE_ENDIAN__
7159   return __builtin_altivec_vpkshus(__b, __a);
7160 #else
7161   return __builtin_altivec_vpkshus(__a, __b);
7162 #endif
7163 }
7164
7165 static __inline__ vector unsigned char __ATTRS_o_ai
7166 vec_packsu(vector unsigned short __a, vector unsigned short __b) {
7167 #ifdef __LITTLE_ENDIAN__
7168   return __builtin_altivec_vpkuhus(__b, __a);
7169 #else
7170   return __builtin_altivec_vpkuhus(__a, __b);
7171 #endif
7172 }
7173
7174 static __inline__ vector unsigned short __ATTRS_o_ai
7175 vec_packsu(vector int __a, vector int __b) {
7176 #ifdef __LITTLE_ENDIAN__
7177   return __builtin_altivec_vpkswus(__b, __a);
7178 #else
7179   return __builtin_altivec_vpkswus(__a, __b);
7180 #endif
7181 }
7182
7183 static __inline__ vector unsigned short __ATTRS_o_ai
7184 vec_packsu(vector unsigned int __a, vector unsigned int __b) {
7185 #ifdef __LITTLE_ENDIAN__
7186   return __builtin_altivec_vpkuwus(__b, __a);
7187 #else
7188   return __builtin_altivec_vpkuwus(__a, __b);
7189 #endif
7190 }
7191
7192 #ifdef __POWER8_VECTOR__
7193 static __inline__ vector unsigned int __ATTRS_o_ai
7194 vec_packsu(vector long long __a, vector long long __b) {
7195 #ifdef __LITTLE_ENDIAN__
7196   return __builtin_altivec_vpksdus(__b, __a);
7197 #else
7198   return __builtin_altivec_vpksdus(__a, __b);
7199 #endif
7200 }
7201
7202 static __inline__ vector unsigned int __ATTRS_o_ai
7203 vec_packsu(vector unsigned long long __a, vector unsigned long long __b) {
7204 #ifdef __LITTLE_ENDIAN__
7205   return __builtin_altivec_vpkudus(__b, __a);
7206 #else
7207   return __builtin_altivec_vpkudus(__a, __b);
7208 #endif
7209 }
7210 #endif
7211
7212 /* vec_vpkshus */
7213
7214 static __inline__ vector unsigned char __ATTRS_o_ai
7215 vec_vpkshus(vector short __a, vector short __b) {
7216 #ifdef __LITTLE_ENDIAN__
7217   return __builtin_altivec_vpkshus(__b, __a);
7218 #else
7219   return __builtin_altivec_vpkshus(__a, __b);
7220 #endif
7221 }
7222
7223 static __inline__ vector unsigned char __ATTRS_o_ai
7224 vec_vpkshus(vector unsigned short __a, vector unsigned short __b) {
7225 #ifdef __LITTLE_ENDIAN__
7226   return __builtin_altivec_vpkuhus(__b, __a);
7227 #else
7228   return __builtin_altivec_vpkuhus(__a, __b);
7229 #endif
7230 }
7231
7232 /* vec_vpkswus */
7233
7234 static __inline__ vector unsigned short __ATTRS_o_ai
7235 vec_vpkswus(vector int __a, vector int __b) {
7236 #ifdef __LITTLE_ENDIAN__
7237   return __builtin_altivec_vpkswus(__b, __a);
7238 #else
7239   return __builtin_altivec_vpkswus(__a, __b);
7240 #endif
7241 }
7242
7243 static __inline__ vector unsigned short __ATTRS_o_ai
7244 vec_vpkswus(vector unsigned int __a, vector unsigned int __b) {
7245 #ifdef __LITTLE_ENDIAN__
7246   return __builtin_altivec_vpkuwus(__b, __a);
7247 #else
7248   return __builtin_altivec_vpkuwus(__a, __b);
7249 #endif
7250 }
7251
7252 /* vec_vpksdus */
7253
7254 #ifdef __POWER8_VECTOR__
7255 static __inline__ vector unsigned int __ATTRS_o_ai
7256 vec_vpksdus(vector long long __a, vector long long __b) {
7257 #ifdef __LITTLE_ENDIAN__
7258   return __builtin_altivec_vpksdus(__b, __a);
7259 #else
7260   return __builtin_altivec_vpksdus(__a, __b);
7261 #endif
7262 }
7263 #endif
7264
7265 /* vec_perm */
7266
7267 // The vperm instruction is defined architecturally with a big-endian bias.
7268 // For little endian, we swap the input operands and invert the permute
7269 // control vector.  Only the rightmost 5 bits matter, so we could use
7270 // a vector of all 31s instead of all 255s to perform the inversion.
7271 // However, when the PCV is not a constant, using 255 has an advantage
7272 // in that the vec_xor can be recognized as a vec_nor (and for P8 and
7273 // later, possibly a vec_nand).
7274
7275 static __inline__ vector signed char __ATTRS_o_ai vec_perm(
7276     vector signed char __a, vector signed char __b, vector unsigned char __c) {
7277 #ifdef __LITTLE_ENDIAN__
7278   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7279                               255, 255, 255, 255, 255, 255, 255, 255};
7280   __d = vec_xor(__c, __d);
7281   return (vector signed char)__builtin_altivec_vperm_4si((vector int)__b,
7282                                                          (vector int)__a, __d);
7283 #else
7284   return (vector signed char)__builtin_altivec_vperm_4si((vector int)__a,
7285                                                          (vector int)__b, __c);
7286 #endif
7287 }
7288
7289 static __inline__ vector unsigned char __ATTRS_o_ai
7290 vec_perm(vector unsigned char __a, vector unsigned char __b,
7291          vector unsigned char __c) {
7292 #ifdef __LITTLE_ENDIAN__
7293   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7294                               255, 255, 255, 255, 255, 255, 255, 255};
7295   __d = vec_xor(__c, __d);
7296   return (vector unsigned char)__builtin_altivec_vperm_4si(
7297       (vector int)__b, (vector int)__a, __d);
7298 #else
7299   return (vector unsigned char)__builtin_altivec_vperm_4si(
7300       (vector int)__a, (vector int)__b, __c);
7301 #endif
7302 }
7303
7304 static __inline__ vector bool char __ATTRS_o_ai
7305 vec_perm(vector bool char __a, vector bool char __b, vector unsigned char __c) {
7306 #ifdef __LITTLE_ENDIAN__
7307   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7308                               255, 255, 255, 255, 255, 255, 255, 255};
7309   __d = vec_xor(__c, __d);
7310   return (vector bool char)__builtin_altivec_vperm_4si((vector int)__b,
7311                                                        (vector int)__a, __d);
7312 #else
7313   return (vector bool char)__builtin_altivec_vperm_4si((vector int)__a,
7314                                                        (vector int)__b, __c);
7315 #endif
7316 }
7317
7318 static __inline__ vector short __ATTRS_o_ai vec_perm(vector signed short __a,
7319                                                      vector signed short __b,
7320                                                      vector unsigned char __c) {
7321 #ifdef __LITTLE_ENDIAN__
7322   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7323                               255, 255, 255, 255, 255, 255, 255, 255};
7324   __d = vec_xor(__c, __d);
7325   return (vector signed short)__builtin_altivec_vperm_4si((vector int)__b,
7326                                                           (vector int)__a, __d);
7327 #else
7328   return (vector signed short)__builtin_altivec_vperm_4si((vector int)__a,
7329                                                           (vector int)__b, __c);
7330 #endif
7331 }
7332
7333 static __inline__ vector unsigned short __ATTRS_o_ai
7334 vec_perm(vector unsigned short __a, vector unsigned short __b,
7335          vector unsigned char __c) {
7336 #ifdef __LITTLE_ENDIAN__
7337   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7338                               255, 255, 255, 255, 255, 255, 255, 255};
7339   __d = vec_xor(__c, __d);
7340   return (vector unsigned short)__builtin_altivec_vperm_4si(
7341       (vector int)__b, (vector int)__a, __d);
7342 #else
7343   return (vector unsigned short)__builtin_altivec_vperm_4si(
7344       (vector int)__a, (vector int)__b, __c);
7345 #endif
7346 }
7347
7348 static __inline__ vector bool short __ATTRS_o_ai vec_perm(
7349     vector bool short __a, vector bool short __b, vector unsigned char __c) {
7350 #ifdef __LITTLE_ENDIAN__
7351   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7352                               255, 255, 255, 255, 255, 255, 255, 255};
7353   __d = vec_xor(__c, __d);
7354   return (vector bool short)__builtin_altivec_vperm_4si((vector int)__b,
7355                                                         (vector int)__a, __d);
7356 #else
7357   return (vector bool short)__builtin_altivec_vperm_4si((vector int)__a,
7358                                                         (vector int)__b, __c);
7359 #endif
7360 }
7361
7362 static __inline__ vector pixel __ATTRS_o_ai vec_perm(vector pixel __a,
7363                                                      vector pixel __b,
7364                                                      vector unsigned char __c) {
7365 #ifdef __LITTLE_ENDIAN__
7366   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7367                               255, 255, 255, 255, 255, 255, 255, 255};
7368   __d = vec_xor(__c, __d);
7369   return (vector pixel)__builtin_altivec_vperm_4si((vector int)__b,
7370                                                    (vector int)__a, __d);
7371 #else
7372   return (vector pixel)__builtin_altivec_vperm_4si((vector int)__a,
7373                                                    (vector int)__b, __c);
7374 #endif
7375 }
7376
7377 static __inline__ vector int __ATTRS_o_ai vec_perm(vector signed int __a,
7378                                                    vector signed int __b,
7379                                                    vector unsigned char __c) {
7380 #ifdef __LITTLE_ENDIAN__
7381   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7382                               255, 255, 255, 255, 255, 255, 255, 255};
7383   __d = vec_xor(__c, __d);
7384   return (vector signed int)__builtin_altivec_vperm_4si(__b, __a, __d);
7385 #else
7386   return (vector signed int)__builtin_altivec_vperm_4si(__a, __b, __c);
7387 #endif
7388 }
7389
7390 static __inline__ vector unsigned int __ATTRS_o_ai
7391 vec_perm(vector unsigned int __a, vector unsigned int __b,
7392          vector unsigned char __c) {
7393 #ifdef __LITTLE_ENDIAN__
7394   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7395                               255, 255, 255, 255, 255, 255, 255, 255};
7396   __d = vec_xor(__c, __d);
7397   return (vector unsigned int)__builtin_altivec_vperm_4si((vector int)__b,
7398                                                           (vector int)__a, __d);
7399 #else
7400   return (vector unsigned int)__builtin_altivec_vperm_4si((vector int)__a,
7401                                                           (vector int)__b, __c);
7402 #endif
7403 }
7404
7405 static __inline__ vector bool int __ATTRS_o_ai
7406 vec_perm(vector bool int __a, vector bool int __b, vector unsigned char __c) {
7407 #ifdef __LITTLE_ENDIAN__
7408   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7409                               255, 255, 255, 255, 255, 255, 255, 255};
7410   __d = vec_xor(__c, __d);
7411   return (vector bool int)__builtin_altivec_vperm_4si((vector int)__b,
7412                                                       (vector int)__a, __d);
7413 #else
7414   return (vector bool int)__builtin_altivec_vperm_4si((vector int)__a,
7415                                                       (vector int)__b, __c);
7416 #endif
7417 }
7418
7419 static __inline__ vector float __ATTRS_o_ai vec_perm(vector float __a,
7420                                                      vector float __b,
7421                                                      vector unsigned char __c) {
7422 #ifdef __LITTLE_ENDIAN__
7423   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7424                               255, 255, 255, 255, 255, 255, 255, 255};
7425   __d = vec_xor(__c, __d);
7426   return (vector float)__builtin_altivec_vperm_4si((vector int)__b,
7427                                                    (vector int)__a, __d);
7428 #else
7429   return (vector float)__builtin_altivec_vperm_4si((vector int)__a,
7430                                                    (vector int)__b, __c);
7431 #endif
7432 }
7433
7434 #ifdef __VSX__
7435 static __inline__ vector long long __ATTRS_o_ai
7436 vec_perm(vector signed long long __a, vector signed long long __b,
7437          vector unsigned char __c) {
7438 #ifdef __LITTLE_ENDIAN__
7439   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7440                               255, 255, 255, 255, 255, 255, 255, 255};
7441   __d = vec_xor(__c, __d);
7442   return (vector signed long long)__builtin_altivec_vperm_4si(
7443       (vector int)__b, (vector int)__a, __d);
7444 #else
7445   return (vector signed long long)__builtin_altivec_vperm_4si(
7446       (vector int)__a, (vector int)__b, __c);
7447 #endif
7448 }
7449
7450 static __inline__ vector unsigned long long __ATTRS_o_ai
7451 vec_perm(vector unsigned long long __a, vector unsigned long long __b,
7452          vector unsigned char __c) {
7453 #ifdef __LITTLE_ENDIAN__
7454   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7455                               255, 255, 255, 255, 255, 255, 255, 255};
7456   __d = vec_xor(__c, __d);
7457   return (vector unsigned long long)__builtin_altivec_vperm_4si(
7458       (vector int)__b, (vector int)__a, __d);
7459 #else
7460   return (vector unsigned long long)__builtin_altivec_vperm_4si(
7461       (vector int)__a, (vector int)__b, __c);
7462 #endif
7463 }
7464
7465 static __inline__ vector bool long long __ATTRS_o_ai
7466 vec_perm(vector bool long long __a, vector bool long long __b,
7467          vector unsigned char __c) {
7468 #ifdef __LITTLE_ENDIAN__
7469   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7470                               255, 255, 255, 255, 255, 255, 255, 255};
7471   __d = vec_xor(__c, __d);
7472   return (vector bool long long)__builtin_altivec_vperm_4si(
7473       (vector int)__b, (vector int)__a, __d);
7474 #else
7475   return (vector bool long long)__builtin_altivec_vperm_4si(
7476       (vector int)__a, (vector int)__b, __c);
7477 #endif
7478 }
7479
7480 static __inline__ vector double __ATTRS_o_ai
7481 vec_perm(vector double __a, vector double __b, vector unsigned char __c) {
7482 #ifdef __LITTLE_ENDIAN__
7483   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7484                               255, 255, 255, 255, 255, 255, 255, 255};
7485   __d = vec_xor(__c, __d);
7486   return (vector double)__builtin_altivec_vperm_4si((vector int)__b,
7487                                                     (vector int)__a, __d);
7488 #else
7489   return (vector double)__builtin_altivec_vperm_4si((vector int)__a,
7490                                                     (vector int)__b, __c);
7491 #endif
7492 }
7493 #endif
7494
7495 /* vec_vperm */
7496
7497 static __inline__ vector signed char __ATTRS_o_ai vec_vperm(
7498     vector signed char __a, vector signed char __b, vector unsigned char __c) {
7499   return vec_perm(__a, __b, __c);
7500 }
7501
7502 static __inline__ vector unsigned char __ATTRS_o_ai
7503 vec_vperm(vector unsigned char __a, vector unsigned char __b,
7504           vector unsigned char __c) {
7505   return vec_perm(__a, __b, __c);
7506 }
7507
7508 static __inline__ vector bool char __ATTRS_o_ai vec_vperm(
7509     vector bool char __a, vector bool char __b, vector unsigned char __c) {
7510   return vec_perm(__a, __b, __c);
7511 }
7512
7513 static __inline__ vector short __ATTRS_o_ai
7514 vec_vperm(vector short __a, vector short __b, vector unsigned char __c) {
7515   return vec_perm(__a, __b, __c);
7516 }
7517
7518 static __inline__ vector unsigned short __ATTRS_o_ai
7519 vec_vperm(vector unsigned short __a, vector unsigned short __b,
7520           vector unsigned char __c) {
7521   return vec_perm(__a, __b, __c);
7522 }
7523
7524 static __inline__ vector bool short __ATTRS_o_ai vec_vperm(
7525     vector bool short __a, vector bool short __b, vector unsigned char __c) {
7526   return vec_perm(__a, __b, __c);
7527 }
7528
7529 static __inline__ vector pixel __ATTRS_o_ai
7530 vec_vperm(vector pixel __a, vector pixel __b, vector unsigned char __c) {
7531   return vec_perm(__a, __b, __c);
7532 }
7533
7534 static __inline__ vector int __ATTRS_o_ai vec_vperm(vector int __a,
7535                                                     vector int __b,
7536                                                     vector unsigned char __c) {
7537   return vec_perm(__a, __b, __c);
7538 }
7539
7540 static __inline__ vector unsigned int __ATTRS_o_ai
7541 vec_vperm(vector unsigned int __a, vector unsigned int __b,
7542           vector unsigned char __c) {
7543   return vec_perm(__a, __b, __c);
7544 }
7545
7546 static __inline__ vector bool int __ATTRS_o_ai
7547 vec_vperm(vector bool int __a, vector bool int __b, vector unsigned char __c) {
7548   return vec_perm(__a, __b, __c);
7549 }
7550
7551 static __inline__ vector float __ATTRS_o_ai
7552 vec_vperm(vector float __a, vector float __b, vector unsigned char __c) {
7553   return vec_perm(__a, __b, __c);
7554 }
7555
7556 #ifdef __VSX__
7557 static __inline__ vector long long __ATTRS_o_ai vec_vperm(
7558     vector long long __a, vector long long __b, vector unsigned char __c) {
7559   return vec_perm(__a, __b, __c);
7560 }
7561
7562 static __inline__ vector unsigned long long __ATTRS_o_ai
7563 vec_vperm(vector unsigned long long __a, vector unsigned long long __b,
7564           vector unsigned char __c) {
7565   return vec_perm(__a, __b, __c);
7566 }
7567
7568 static __inline__ vector double __ATTRS_o_ai
7569 vec_vperm(vector double __a, vector double __b, vector unsigned char __c) {
7570   return vec_perm(__a, __b, __c);
7571 }
7572 #endif
7573
7574 /* vec_re */
7575
7576 static __inline__ vector float __ATTRS_o_ai vec_re(vector float __a) {
7577 #ifdef __VSX__
7578   return __builtin_vsx_xvresp(__a);
7579 #else
7580   return __builtin_altivec_vrefp(__a);
7581 #endif
7582 }
7583
7584 #ifdef __VSX__
7585 static __inline__ vector double __ATTRS_o_ai vec_re(vector double __a) {
7586   return __builtin_vsx_xvredp(__a);
7587 }
7588 #endif
7589
7590 /* vec_vrefp */
7591
7592 static __inline__ vector float __attribute__((__always_inline__))
7593 vec_vrefp(vector float __a) {
7594   return __builtin_altivec_vrefp(__a);
7595 }
7596
7597 /* vec_rl */
7598
7599 static __inline__ vector signed char __ATTRS_o_ai
7600 vec_rl(vector signed char __a, vector unsigned char __b) {
7601   return (vector signed char)__builtin_altivec_vrlb((vector char)__a, __b);
7602 }
7603
7604 static __inline__ vector unsigned char __ATTRS_o_ai
7605 vec_rl(vector unsigned char __a, vector unsigned char __b) {
7606   return (vector unsigned char)__builtin_altivec_vrlb((vector char)__a, __b);
7607 }
7608
7609 static __inline__ vector short __ATTRS_o_ai vec_rl(vector short __a,
7610                                                    vector unsigned short __b) {
7611   return __builtin_altivec_vrlh(__a, __b);
7612 }
7613
7614 static __inline__ vector unsigned short __ATTRS_o_ai
7615 vec_rl(vector unsigned short __a, vector unsigned short __b) {
7616   return (vector unsigned short)__builtin_altivec_vrlh((vector short)__a, __b);
7617 }
7618
7619 static __inline__ vector int __ATTRS_o_ai vec_rl(vector int __a,
7620                                                  vector unsigned int __b) {
7621   return __builtin_altivec_vrlw(__a, __b);
7622 }
7623
7624 static __inline__ vector unsigned int __ATTRS_o_ai
7625 vec_rl(vector unsigned int __a, vector unsigned int __b) {
7626   return (vector unsigned int)__builtin_altivec_vrlw((vector int)__a, __b);
7627 }
7628
7629 #ifdef __POWER8_VECTOR__
7630 static __inline__ vector signed long long __ATTRS_o_ai
7631 vec_rl(vector signed long long __a, vector unsigned long long __b) {
7632   return __builtin_altivec_vrld(__a, __b);
7633 }
7634
7635 static __inline__ vector unsigned long long __ATTRS_o_ai
7636 vec_rl(vector unsigned long long __a, vector unsigned long long __b) {
7637   return __builtin_altivec_vrld(__a, __b);
7638 }
7639 #endif
7640
7641 /* vec_rlmi */
7642 #ifdef __POWER9_VECTOR__
7643 static __inline__ vector unsigned int __ATTRS_o_ai
7644 vec_rlmi(vector unsigned int __a, vector unsigned int __b,
7645          vector unsigned int __c) {
7646   return __builtin_altivec_vrlwmi(__a, __c, __b);
7647 }
7648
7649 static __inline__ vector unsigned long long __ATTRS_o_ai
7650 vec_rlmi(vector unsigned long long __a, vector unsigned long long __b,
7651          vector unsigned long long __c) {
7652   return __builtin_altivec_vrldmi(__a, __c, __b);
7653 }
7654
7655 /* vec_rlnm */
7656 static __inline__ vector unsigned int __ATTRS_o_ai
7657 vec_rlnm(vector unsigned int __a, vector unsigned int __b,
7658          vector unsigned int __c) {
7659   vector unsigned int OneByte = { 0x8, 0x8, 0x8, 0x8 };
7660   return __builtin_altivec_vrlwnm(__a, ((__c << OneByte) | __b));
7661 }
7662
7663 static __inline__ vector unsigned long long __ATTRS_o_ai
7664 vec_rlnm(vector unsigned long long __a, vector unsigned long long __b,
7665          vector unsigned long long __c) {
7666   vector unsigned long long OneByte = { 0x8, 0x8 };
7667   return __builtin_altivec_vrldnm(__a, ((__c << OneByte) | __b));
7668 }
7669 #endif
7670
7671 /* vec_vrlb */
7672
7673 static __inline__ vector signed char __ATTRS_o_ai
7674 vec_vrlb(vector signed char __a, vector unsigned char __b) {
7675   return (vector signed char)__builtin_altivec_vrlb((vector char)__a, __b);
7676 }
7677
7678 static __inline__ vector unsigned char __ATTRS_o_ai
7679 vec_vrlb(vector unsigned char __a, vector unsigned char __b) {
7680   return (vector unsigned char)__builtin_altivec_vrlb((vector char)__a, __b);
7681 }
7682
7683 /* vec_vrlh */
7684
7685 static __inline__ vector short __ATTRS_o_ai
7686 vec_vrlh(vector short __a, vector unsigned short __b) {
7687   return __builtin_altivec_vrlh(__a, __b);
7688 }
7689
7690 static __inline__ vector unsigned short __ATTRS_o_ai
7691 vec_vrlh(vector unsigned short __a, vector unsigned short __b) {
7692   return (vector unsigned short)__builtin_altivec_vrlh((vector short)__a, __b);
7693 }
7694
7695 /* vec_vrlw */
7696
7697 static __inline__ vector int __ATTRS_o_ai vec_vrlw(vector int __a,
7698                                                    vector unsigned int __b) {
7699   return __builtin_altivec_vrlw(__a, __b);
7700 }
7701
7702 static __inline__ vector unsigned int __ATTRS_o_ai
7703 vec_vrlw(vector unsigned int __a, vector unsigned int __b) {
7704   return (vector unsigned int)__builtin_altivec_vrlw((vector int)__a, __b);
7705 }
7706
7707 /* vec_round */
7708
7709 static __inline__ vector float __ATTRS_o_ai vec_round(vector float __a) {
7710 #ifdef __VSX__
7711   return __builtin_vsx_xvrspi(__a);
7712 #else
7713   return __builtin_altivec_vrfin(__a);
7714 #endif
7715 }
7716
7717 #ifdef __VSX__
7718 static __inline__ vector double __ATTRS_o_ai vec_round(vector double __a) {
7719   return __builtin_vsx_xvrdpi(__a);
7720 }
7721
7722 /* vec_rint */
7723
7724 static __inline__ vector float __ATTRS_o_ai vec_rint(vector float __a) {
7725   return __builtin_vsx_xvrspic(__a);
7726 }
7727
7728 static __inline__ vector double __ATTRS_o_ai vec_rint(vector double __a) {
7729   return __builtin_vsx_xvrdpic(__a);
7730 }
7731
7732 /* vec_nearbyint */
7733
7734 static __inline__ vector float __ATTRS_o_ai vec_nearbyint(vector float __a) {
7735   return __builtin_vsx_xvrspi(__a);
7736 }
7737
7738 static __inline__ vector double __ATTRS_o_ai vec_nearbyint(vector double __a) {
7739   return __builtin_vsx_xvrdpi(__a);
7740 }
7741 #endif
7742
7743 /* vec_vrfin */
7744
7745 static __inline__ vector float __attribute__((__always_inline__))
7746 vec_vrfin(vector float __a) {
7747   return __builtin_altivec_vrfin(__a);
7748 }
7749
7750 /* vec_sqrt */
7751
7752 #ifdef __VSX__
7753 static __inline__ vector float __ATTRS_o_ai vec_sqrt(vector float __a) {
7754   return __builtin_vsx_xvsqrtsp(__a);
7755 }
7756
7757 static __inline__ vector double __ATTRS_o_ai vec_sqrt(vector double __a) {
7758   return __builtin_vsx_xvsqrtdp(__a);
7759 }
7760 #endif
7761
7762 /* vec_rsqrte */
7763
7764 static __inline__ vector float __ATTRS_o_ai vec_rsqrte(vector float __a) {
7765 #ifdef __VSX__
7766   return __builtin_vsx_xvrsqrtesp(__a);
7767 #else
7768   return __builtin_altivec_vrsqrtefp(__a);
7769 #endif
7770 }
7771
7772 #ifdef __VSX__
7773 static __inline__ vector double __ATTRS_o_ai vec_rsqrte(vector double __a) {
7774   return __builtin_vsx_xvrsqrtedp(__a);
7775 }
7776 #endif
7777
7778 /* vec_vrsqrtefp */
7779
7780 static __inline__ __vector float __attribute__((__always_inline__))
7781 vec_vrsqrtefp(vector float __a) {
7782   return __builtin_altivec_vrsqrtefp(__a);
7783 }
7784
7785 /* vec_sel */
7786
7787 #define __builtin_altivec_vsel_4si vec_sel
7788
7789 static __inline__ vector signed char __ATTRS_o_ai vec_sel(
7790     vector signed char __a, vector signed char __b, vector unsigned char __c) {
7791   return (__a & ~(vector signed char)__c) | (__b & (vector signed char)__c);
7792 }
7793
7794 static __inline__ vector signed char __ATTRS_o_ai
7795 vec_sel(vector signed char __a, vector signed char __b, vector bool char __c) {
7796   return (__a & ~(vector signed char)__c) | (__b & (vector signed char)__c);
7797 }
7798
7799 static __inline__ vector unsigned char __ATTRS_o_ai
7800 vec_sel(vector unsigned char __a, vector unsigned char __b,
7801         vector unsigned char __c) {
7802   return (__a & ~__c) | (__b & __c);
7803 }
7804
7805 static __inline__ vector unsigned char __ATTRS_o_ai vec_sel(
7806     vector unsigned char __a, vector unsigned char __b, vector bool char __c) {
7807   return (__a & ~(vector unsigned char)__c) | (__b & (vector unsigned char)__c);
7808 }
7809
7810 static __inline__ vector bool char __ATTRS_o_ai
7811 vec_sel(vector bool char __a, vector bool char __b, vector unsigned char __c) {
7812   return (__a & ~(vector bool char)__c) | (__b & (vector bool char)__c);
7813 }
7814
7815 static __inline__ vector bool char __ATTRS_o_ai vec_sel(vector bool char __a,
7816                                                         vector bool char __b,
7817                                                         vector bool char __c) {
7818   return (__a & ~__c) | (__b & __c);
7819 }
7820
7821 static __inline__ vector short __ATTRS_o_ai vec_sel(vector short __a,
7822                                                     vector short __b,
7823                                                     vector unsigned short __c) {
7824   return (__a & ~(vector short)__c) | (__b & (vector short)__c);
7825 }
7826
7827 static __inline__ vector short __ATTRS_o_ai vec_sel(vector short __a,
7828                                                     vector short __b,
7829                                                     vector bool short __c) {
7830   return (__a & ~(vector short)__c) | (__b & (vector short)__c);
7831 }
7832
7833 static __inline__ vector unsigned short __ATTRS_o_ai
7834 vec_sel(vector unsigned short __a, vector unsigned short __b,
7835         vector unsigned short __c) {
7836   return (__a & ~__c) | (__b & __c);
7837 }
7838
7839 static __inline__ vector unsigned short __ATTRS_o_ai
7840 vec_sel(vector unsigned short __a, vector unsigned short __b,
7841         vector bool short __c) {
7842   return (__a & ~(vector unsigned short)__c) |
7843          (__b & (vector unsigned short)__c);
7844 }
7845
7846 static __inline__ vector bool short __ATTRS_o_ai vec_sel(
7847     vector bool short __a, vector bool short __b, vector unsigned short __c) {
7848   return (__a & ~(vector bool short)__c) | (__b & (vector bool short)__c);
7849 }
7850
7851 static __inline__ vector bool short __ATTRS_o_ai
7852 vec_sel(vector bool short __a, vector bool short __b, vector bool short __c) {
7853   return (__a & ~__c) | (__b & __c);
7854 }
7855
7856 static __inline__ vector int __ATTRS_o_ai vec_sel(vector int __a,
7857                                                   vector int __b,
7858                                                   vector unsigned int __c) {
7859   return (__a & ~(vector int)__c) | (__b & (vector int)__c);
7860 }
7861
7862 static __inline__ vector int __ATTRS_o_ai vec_sel(vector int __a,
7863                                                   vector int __b,
7864                                                   vector bool int __c) {
7865   return (__a & ~(vector int)__c) | (__b & (vector int)__c);
7866 }
7867
7868 static __inline__ vector unsigned int __ATTRS_o_ai vec_sel(
7869     vector unsigned int __a, vector unsigned int __b, vector unsigned int __c) {
7870   return (__a & ~__c) | (__b & __c);
7871 }
7872
7873 static __inline__ vector unsigned int __ATTRS_o_ai
7874 vec_sel(vector unsigned int __a, vector unsigned int __b, vector bool int __c) {
7875   return (__a & ~(vector unsigned int)__c) | (__b & (vector unsigned int)__c);
7876 }
7877
7878 static __inline__ vector bool int __ATTRS_o_ai
7879 vec_sel(vector bool int __a, vector bool int __b, vector unsigned int __c) {
7880   return (__a & ~(vector bool int)__c) | (__b & (vector bool int)__c);
7881 }
7882
7883 static __inline__ vector bool int __ATTRS_o_ai vec_sel(vector bool int __a,
7884                                                        vector bool int __b,
7885                                                        vector bool int __c) {
7886   return (__a & ~__c) | (__b & __c);
7887 }
7888
7889 static __inline__ vector float __ATTRS_o_ai vec_sel(vector float __a,
7890                                                     vector float __b,
7891                                                     vector unsigned int __c) {
7892   vector int __res = ((vector int)__a & ~(vector int)__c) |
7893                      ((vector int)__b & (vector int)__c);
7894   return (vector float)__res;
7895 }
7896
7897 static __inline__ vector float __ATTRS_o_ai vec_sel(vector float __a,
7898                                                     vector float __b,
7899                                                     vector bool int __c) {
7900   vector int __res = ((vector int)__a & ~(vector int)__c) |
7901                      ((vector int)__b & (vector int)__c);
7902   return (vector float)__res;
7903 }
7904
7905 #ifdef __VSX__
7906 static __inline__ vector double __ATTRS_o_ai
7907 vec_sel(vector double __a, vector double __b, vector bool long long __c) {
7908   vector long long __res = ((vector long long)__a & ~(vector long long)__c) |
7909                            ((vector long long)__b & (vector long long)__c);
7910   return (vector double)__res;
7911 }
7912
7913 static __inline__ vector double __ATTRS_o_ai
7914 vec_sel(vector double __a, vector double __b, vector unsigned long long __c) {
7915   vector long long __res = ((vector long long)__a & ~(vector long long)__c) |
7916                            ((vector long long)__b & (vector long long)__c);
7917   return (vector double)__res;
7918 }
7919 #endif
7920
7921 /* vec_vsel */
7922
7923 static __inline__ vector signed char __ATTRS_o_ai vec_vsel(
7924     vector signed char __a, vector signed char __b, vector unsigned char __c) {
7925   return (__a & ~(vector signed char)__c) | (__b & (vector signed char)__c);
7926 }
7927
7928 static __inline__ vector signed char __ATTRS_o_ai
7929 vec_vsel(vector signed char __a, vector signed char __b, vector bool char __c) {
7930   return (__a & ~(vector signed char)__c) | (__b & (vector signed char)__c);
7931 }
7932
7933 static __inline__ vector unsigned char __ATTRS_o_ai
7934 vec_vsel(vector unsigned char __a, vector unsigned char __b,
7935          vector unsigned char __c) {
7936   return (__a & ~__c) | (__b & __c);
7937 }
7938
7939 static __inline__ vector unsigned char __ATTRS_o_ai vec_vsel(
7940     vector unsigned char __a, vector unsigned char __b, vector bool char __c) {
7941   return (__a & ~(vector unsigned char)__c) | (__b & (vector unsigned char)__c);
7942 }
7943
7944 static __inline__ vector bool char __ATTRS_o_ai
7945 vec_vsel(vector bool char __a, vector bool char __b, vector unsigned char __c) {
7946   return (__a & ~(vector bool char)__c) | (__b & (vector bool char)__c);
7947 }
7948
7949 static __inline__ vector bool char __ATTRS_o_ai vec_vsel(vector bool char __a,
7950                                                          vector bool char __b,
7951                                                          vector bool char __c) {
7952   return (__a & ~__c) | (__b & __c);
7953 }
7954
7955 static __inline__ vector short __ATTRS_o_ai
7956 vec_vsel(vector short __a, vector short __b, vector unsigned short __c) {
7957   return (__a & ~(vector short)__c) | (__b & (vector short)__c);
7958 }
7959
7960 static __inline__ vector short __ATTRS_o_ai vec_vsel(vector short __a,
7961                                                      vector short __b,
7962                                                      vector bool short __c) {
7963   return (__a & ~(vector short)__c) | (__b & (vector short)__c);
7964 }
7965
7966 static __inline__ vector unsigned short __ATTRS_o_ai
7967 vec_vsel(vector unsigned short __a, vector unsigned short __b,
7968          vector unsigned short __c) {
7969   return (__a & ~__c) | (__b & __c);
7970 }
7971
7972 static __inline__ vector unsigned short __ATTRS_o_ai
7973 vec_vsel(vector unsigned short __a, vector unsigned short __b,
7974          vector bool short __c) {
7975   return (__a & ~(vector unsigned short)__c) |
7976          (__b & (vector unsigned short)__c);
7977 }
7978
7979 static __inline__ vector bool short __ATTRS_o_ai vec_vsel(
7980     vector bool short __a, vector bool short __b, vector unsigned short __c) {
7981   return (__a & ~(vector bool short)__c) | (__b & (vector bool short)__c);
7982 }
7983
7984 static __inline__ vector bool short __ATTRS_o_ai
7985 vec_vsel(vector bool short __a, vector bool short __b, vector bool short __c) {
7986   return (__a & ~__c) | (__b & __c);
7987 }
7988
7989 static __inline__ vector int __ATTRS_o_ai vec_vsel(vector int __a,
7990                                                    vector int __b,
7991                                                    vector unsigned int __c) {
7992   return (__a & ~(vector int)__c) | (__b & (vector int)__c);
7993 }
7994
7995 static __inline__ vector int __ATTRS_o_ai vec_vsel(vector int __a,
7996                                                    vector int __b,
7997                                                    vector bool int __c) {
7998   return (__a & ~(vector int)__c) | (__b & (vector int)__c);
7999 }
8000
8001 static __inline__ vector unsigned int __ATTRS_o_ai vec_vsel(
8002     vector unsigned int __a, vector unsigned int __b, vector unsigned int __c) {
8003   return (__a & ~__c) | (__b & __c);
8004 }
8005
8006 static __inline__ vector unsigned int __ATTRS_o_ai vec_vsel(
8007     vector unsigned int __a, vector unsigned int __b, vector bool int __c) {
8008   return (__a & ~(vector unsigned int)__c) | (__b & (vector unsigned int)__c);
8009 }
8010
8011 static __inline__ vector bool int __ATTRS_o_ai
8012 vec_vsel(vector bool int __a, vector bool int __b, vector unsigned int __c) {
8013   return (__a & ~(vector bool int)__c) | (__b & (vector bool int)__c);
8014 }
8015
8016 static __inline__ vector bool int __ATTRS_o_ai vec_vsel(vector bool int __a,
8017                                                         vector bool int __b,
8018                                                         vector bool int __c) {
8019   return (__a & ~__c) | (__b & __c);
8020 }
8021
8022 static __inline__ vector float __ATTRS_o_ai vec_vsel(vector float __a,
8023                                                      vector float __b,
8024                                                      vector unsigned int __c) {
8025   vector int __res = ((vector int)__a & ~(vector int)__c) |
8026                      ((vector int)__b & (vector int)__c);
8027   return (vector float)__res;
8028 }
8029
8030 static __inline__ vector float __ATTRS_o_ai vec_vsel(vector float __a,
8031                                                      vector float __b,
8032                                                      vector bool int __c) {
8033   vector int __res = ((vector int)__a & ~(vector int)__c) |
8034                      ((vector int)__b & (vector int)__c);
8035   return (vector float)__res;
8036 }
8037
8038 /* vec_sl */
8039
8040 // vec_sl does modulo arithmetic on __b first, so __b is allowed to be more
8041 // than the length of __a.
8042 static __inline__ vector unsigned char __ATTRS_o_ai
8043 vec_sl(vector unsigned char __a, vector unsigned char __b) {
8044   return __a << (__b %
8045                  (vector unsigned char)(sizeof(unsigned char) * __CHAR_BIT__));
8046 }
8047
8048 static __inline__ vector signed char __ATTRS_o_ai
8049 vec_sl(vector signed char __a, vector unsigned char __b) {
8050   return (vector signed char)vec_sl((vector unsigned char)__a, __b);
8051 }
8052
8053 static __inline__ vector unsigned short __ATTRS_o_ai
8054 vec_sl(vector unsigned short __a, vector unsigned short __b) {
8055   return __a << (__b % (vector unsigned short)(sizeof(unsigned short) *
8056                                                __CHAR_BIT__));
8057 }
8058
8059 static __inline__ vector short __ATTRS_o_ai vec_sl(vector short __a,
8060                                                    vector unsigned short __b) {
8061   return (vector short)vec_sl((vector unsigned short)__a, __b);
8062 }
8063
8064 static __inline__ vector unsigned int __ATTRS_o_ai
8065 vec_sl(vector unsigned int __a, vector unsigned int __b) {
8066   return __a << (__b %
8067                  (vector unsigned int)(sizeof(unsigned int) * __CHAR_BIT__));
8068 }
8069
8070 static __inline__ vector int __ATTRS_o_ai vec_sl(vector int __a,
8071                                                  vector unsigned int __b) {
8072   return (vector int)vec_sl((vector unsigned int)__a, __b);
8073 }
8074
8075 #ifdef __POWER8_VECTOR__
8076 static __inline__ vector unsigned long long __ATTRS_o_ai
8077 vec_sl(vector unsigned long long __a, vector unsigned long long __b) {
8078   return __a << (__b % (vector unsigned long long)(sizeof(unsigned long long) *
8079                                                    __CHAR_BIT__));
8080 }
8081
8082 static __inline__ vector long long __ATTRS_o_ai
8083 vec_sl(vector long long __a, vector unsigned long long __b) {
8084   return (vector long long)vec_sl((vector unsigned long long)__a, __b);
8085 }
8086 #endif
8087
8088 /* vec_vslb */
8089
8090 #define __builtin_altivec_vslb vec_vslb
8091
8092 static __inline__ vector signed char __ATTRS_o_ai
8093 vec_vslb(vector signed char __a, vector unsigned char __b) {
8094   return vec_sl(__a, __b);
8095 }
8096
8097 static __inline__ vector unsigned char __ATTRS_o_ai
8098 vec_vslb(vector unsigned char __a, vector unsigned char __b) {
8099   return vec_sl(__a, __b);
8100 }
8101
8102 /* vec_vslh */
8103
8104 #define __builtin_altivec_vslh vec_vslh
8105
8106 static __inline__ vector short __ATTRS_o_ai
8107 vec_vslh(vector short __a, vector unsigned short __b) {
8108   return vec_sl(__a, __b);
8109 }
8110
8111 static __inline__ vector unsigned short __ATTRS_o_ai
8112 vec_vslh(vector unsigned short __a, vector unsigned short __b) {
8113   return vec_sl(__a, __b);
8114 }
8115
8116 /* vec_vslw */
8117
8118 #define __builtin_altivec_vslw vec_vslw
8119
8120 static __inline__ vector int __ATTRS_o_ai vec_vslw(vector int __a,
8121                                                    vector unsigned int __b) {
8122   return vec_sl(__a, __b);
8123 }
8124
8125 static __inline__ vector unsigned int __ATTRS_o_ai
8126 vec_vslw(vector unsigned int __a, vector unsigned int __b) {
8127   return vec_sl(__a, __b);
8128 }
8129
8130 /* vec_sld */
8131
8132 #define __builtin_altivec_vsldoi_4si vec_sld
8133
8134 static __inline__ vector signed char __ATTRS_o_ai vec_sld(
8135     vector signed char __a, vector signed char __b, unsigned const int __c) {
8136   unsigned char __d = __c & 0x0F;
8137 #ifdef __LITTLE_ENDIAN__
8138   return vec_perm(
8139       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8140                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
8141                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
8142                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
8143 #else
8144   return vec_perm(
8145       __a, __b,
8146       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8147                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8148                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8149 #endif
8150 }
8151
8152 static __inline__ vector unsigned char __ATTRS_o_ai
8153 vec_sld(vector unsigned char __a, vector unsigned char __b,
8154         unsigned const int __c) {
8155   unsigned char __d = __c & 0x0F;
8156 #ifdef __LITTLE_ENDIAN__
8157   return vec_perm(
8158       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8159                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
8160                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
8161                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
8162 #else
8163   return vec_perm(
8164       __a, __b,
8165       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8166                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8167                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8168 #endif
8169 }
8170
8171 static __inline__ vector bool char __ATTRS_o_ai
8172 vec_sld(vector bool char __a, vector bool char __b, unsigned const int __c) {
8173   unsigned char __d = __c & 0x0F;
8174 #ifdef __LITTLE_ENDIAN__
8175   return vec_perm(
8176       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8177                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
8178                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
8179                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
8180 #else
8181   return vec_perm(
8182       __a, __b,
8183       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8184                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8185                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8186 #endif
8187 }
8188
8189 static __inline__ vector signed short __ATTRS_o_ai vec_sld(
8190     vector signed short __a, vector signed short __b, unsigned const int __c) {
8191   unsigned char __d = __c & 0x0F;
8192 #ifdef __LITTLE_ENDIAN__
8193   return vec_perm(
8194       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8195                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
8196                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
8197                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
8198 #else
8199   return vec_perm(
8200       __a, __b,
8201       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8202                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8203                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8204 #endif
8205 }
8206
8207 static __inline__ vector unsigned short __ATTRS_o_ai
8208 vec_sld(vector unsigned short __a, vector unsigned short __b,
8209         unsigned const int __c) {
8210   unsigned char __d = __c & 0x0F;
8211 #ifdef __LITTLE_ENDIAN__
8212   return vec_perm(
8213       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8214                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
8215                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
8216                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
8217 #else
8218   return vec_perm(
8219       __a, __b,
8220       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8221                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8222                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8223 #endif
8224 }
8225
8226 static __inline__ vector bool short __ATTRS_o_ai
8227 vec_sld(vector bool short __a, vector bool short __b, unsigned const int __c) {
8228   unsigned char __d = __c & 0x0F;
8229 #ifdef __LITTLE_ENDIAN__
8230   return vec_perm(
8231       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8232                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
8233                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
8234                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
8235 #else
8236   return vec_perm(
8237       __a, __b,
8238       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8239                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8240                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8241 #endif
8242 }
8243
8244 static __inline__ vector pixel __ATTRS_o_ai vec_sld(vector pixel __a,
8245                                                     vector pixel __b,
8246                                                     unsigned const int __c) {
8247   unsigned char __d = __c & 0x0F;
8248 #ifdef __LITTLE_ENDIAN__
8249   return vec_perm(
8250       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8251                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
8252                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
8253                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
8254 #else
8255   return vec_perm(
8256       __a, __b,
8257       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8258                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8259                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8260 #endif
8261 }
8262
8263 static __inline__ vector signed int __ATTRS_o_ai
8264 vec_sld(vector signed int __a, vector signed int __b, unsigned const int __c) {
8265   unsigned char __d = __c & 0x0F;
8266 #ifdef __LITTLE_ENDIAN__
8267   return vec_perm(
8268       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8269                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
8270                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
8271                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
8272 #else
8273   return vec_perm(
8274       __a, __b,
8275       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8276                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8277                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8278 #endif
8279 }
8280
8281 static __inline__ vector unsigned int __ATTRS_o_ai vec_sld(
8282     vector unsigned int __a, vector unsigned int __b, unsigned const int __c) {
8283   unsigned char __d = __c & 0x0F;
8284 #ifdef __LITTLE_ENDIAN__
8285   return vec_perm(
8286       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8287                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
8288                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
8289                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
8290 #else
8291   return vec_perm(
8292       __a, __b,
8293       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8294                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8295                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8296 #endif
8297 }
8298
8299 static __inline__ vector bool int __ATTRS_o_ai vec_sld(vector bool int __a,
8300                                                        vector bool int __b,
8301                                                        unsigned const int __c) {
8302   unsigned char __d = __c & 0x0F;
8303 #ifdef __LITTLE_ENDIAN__
8304   return vec_perm(
8305       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8306                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
8307                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
8308                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
8309 #else
8310   return vec_perm(
8311       __a, __b,
8312       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8313                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8314                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8315 #endif
8316 }
8317
8318 static __inline__ vector float __ATTRS_o_ai vec_sld(vector float __a,
8319                                                     vector float __b,
8320                                                     unsigned const int __c) {
8321   unsigned char __d = __c & 0x0F;
8322 #ifdef __LITTLE_ENDIAN__
8323   return vec_perm(
8324       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8325                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
8326                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
8327                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
8328 #else
8329   return vec_perm(
8330       __a, __b,
8331       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8332                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8333                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8334 #endif
8335 }
8336
8337 #ifdef __VSX__
8338 static __inline__ vector bool long long __ATTRS_o_ai
8339 vec_sld(vector bool long long __a, vector bool long long __b,
8340         unsigned const int __c) {
8341   unsigned char __d = __c & 0x0F;
8342 #ifdef __LITTLE_ENDIAN__
8343   return vec_perm(
8344       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8345                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
8346                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
8347                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
8348 #else
8349   return vec_perm(
8350       __a, __b,
8351       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8352                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8353                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8354 #endif
8355 }
8356
8357 static __inline__ vector signed long long __ATTRS_o_ai
8358 vec_sld(vector signed long long __a, vector signed long long __b,
8359         unsigned const int __c) {
8360   unsigned char __d = __c & 0x0F;
8361 #ifdef __LITTLE_ENDIAN__
8362   return vec_perm(
8363       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8364                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
8365                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
8366                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
8367 #else
8368   return vec_perm(
8369       __a, __b,
8370       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8371                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8372                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8373 #endif
8374 }
8375
8376 static __inline__ vector unsigned long long __ATTRS_o_ai
8377 vec_sld(vector unsigned long long __a, vector unsigned long long __b,
8378         unsigned const int __c) {
8379   unsigned char __d = __c & 0x0F;
8380 #ifdef __LITTLE_ENDIAN__
8381   return vec_perm(
8382       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8383                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
8384                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
8385                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
8386 #else
8387   return vec_perm(
8388       __a, __b,
8389       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8390                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8391                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8392 #endif
8393 }
8394
8395 static __inline__ vector double __ATTRS_o_ai vec_sld(vector double __a,
8396                                                      vector double __b,
8397                                                      unsigned const int __c) {
8398   unsigned char __d = __c & 0x0F;
8399 #ifdef __LITTLE_ENDIAN__
8400   return vec_perm(
8401       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8402                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
8403                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
8404                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
8405 #else
8406   return vec_perm(
8407       __a, __b,
8408       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8409                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8410                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8411 #endif
8412 }
8413 #endif
8414
8415 /* vec_sldw */
8416 static __inline__ vector signed char __ATTRS_o_ai vec_sldw(
8417     vector signed char __a, vector signed char __b, unsigned const int __c) {
8418   return vec_sld(__a, __b, ((__c << 2) & 0x0F));
8419 }
8420
8421 static __inline__ vector unsigned char __ATTRS_o_ai
8422 vec_sldw(vector unsigned char __a, vector unsigned char __b,
8423          unsigned const int __c) {
8424   return vec_sld(__a, __b, ((__c << 2) & 0x0F));
8425 }
8426
8427 static __inline__ vector signed short __ATTRS_o_ai vec_sldw(
8428     vector signed short __a, vector signed short __b, unsigned const int __c) {
8429   return vec_sld(__a, __b, ((__c << 2) & 0x0F));
8430 }
8431
8432 static __inline__ vector unsigned short __ATTRS_o_ai
8433 vec_sldw(vector unsigned short __a, vector unsigned short __b,
8434          unsigned const int __c) {
8435   return vec_sld(__a, __b, ((__c << 2) & 0x0F));
8436 }
8437
8438 static __inline__ vector signed int __ATTRS_o_ai
8439 vec_sldw(vector signed int __a, vector signed int __b, unsigned const int __c) {
8440   return vec_sld(__a, __b, ((__c << 2) & 0x0F));
8441 }
8442
8443 static __inline__ vector unsigned int __ATTRS_o_ai vec_sldw(
8444     vector unsigned int __a, vector unsigned int __b, unsigned const int __c) {
8445   return vec_sld(__a, __b, ((__c << 2) & 0x0F));
8446 }
8447
8448 #ifdef __VSX__
8449 static __inline__ vector signed long long __ATTRS_o_ai
8450 vec_sldw(vector signed long long __a, vector signed long long __b,
8451          unsigned const int __c) {
8452   return vec_sld(__a, __b, ((__c << 2) & 0x0F));
8453 }
8454
8455 static __inline__ vector unsigned long long __ATTRS_o_ai
8456 vec_sldw(vector unsigned long long __a, vector unsigned long long __b,
8457          unsigned const int __c) {
8458   return vec_sld(__a, __b, ((__c << 2) & 0x0F));
8459 }
8460 #endif
8461
8462 #ifdef __POWER9_VECTOR__
8463 /* vec_slv */
8464 static __inline__ vector unsigned char __ATTRS_o_ai
8465 vec_slv(vector unsigned char __a, vector unsigned char __b) {
8466   return __builtin_altivec_vslv(__a, __b);
8467 }
8468
8469 /* vec_srv */
8470 static __inline__ vector unsigned char __ATTRS_o_ai
8471 vec_srv(vector unsigned char __a, vector unsigned char __b) {
8472   return __builtin_altivec_vsrv(__a, __b);
8473 }
8474 #endif
8475
8476 /* vec_vsldoi */
8477
8478 static __inline__ vector signed char __ATTRS_o_ai
8479 vec_vsldoi(vector signed char __a, vector signed char __b, unsigned char __c) {
8480   unsigned char __d = __c & 0x0F;
8481 #ifdef __LITTLE_ENDIAN__
8482   return vec_perm(
8483       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8484                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
8485                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
8486                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
8487 #else
8488   return vec_perm(
8489       __a, __b,
8490       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8491                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8492                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8493 #endif
8494 }
8495
8496 static __inline__ vector unsigned char __ATTRS_o_ai vec_vsldoi(
8497     vector unsigned char __a, vector unsigned char __b, unsigned char __c) {
8498   unsigned char __d = __c & 0x0F;
8499 #ifdef __LITTLE_ENDIAN__
8500   return vec_perm(
8501       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8502                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
8503                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
8504                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
8505 #else
8506   return vec_perm(
8507       __a, __b,
8508       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8509                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8510                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8511 #endif
8512 }
8513
8514 static __inline__ vector short __ATTRS_o_ai vec_vsldoi(vector short __a,
8515                                                        vector short __b,
8516                                                        unsigned char __c) {
8517   unsigned char __d = __c & 0x0F;
8518 #ifdef __LITTLE_ENDIAN__
8519   return vec_perm(
8520       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8521                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
8522                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
8523                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
8524 #else
8525   return vec_perm(
8526       __a, __b,
8527       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8528                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8529                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8530 #endif
8531 }
8532
8533 static __inline__ vector unsigned short __ATTRS_o_ai vec_vsldoi(
8534     vector unsigned short __a, vector unsigned short __b, unsigned char __c) {
8535   unsigned char __d = __c & 0x0F;
8536 #ifdef __LITTLE_ENDIAN__
8537   return vec_perm(
8538       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8539                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
8540                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
8541                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
8542 #else
8543   return vec_perm(
8544       __a, __b,
8545       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8546                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8547                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8548 #endif
8549 }
8550
8551 static __inline__ vector pixel __ATTRS_o_ai vec_vsldoi(vector pixel __a,
8552                                                        vector pixel __b,
8553                                                        unsigned char __c) {
8554   unsigned char __d = __c & 0x0F;
8555 #ifdef __LITTLE_ENDIAN__
8556   return vec_perm(
8557       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8558                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
8559                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
8560                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
8561 #else
8562   return vec_perm(
8563       __a, __b,
8564       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8565                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8566                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8567 #endif
8568 }
8569
8570 static __inline__ vector int __ATTRS_o_ai vec_vsldoi(vector int __a,
8571                                                      vector int __b,
8572                                                      unsigned char __c) {
8573   unsigned char __d = __c & 0x0F;
8574 #ifdef __LITTLE_ENDIAN__
8575   return vec_perm(
8576       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8577                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
8578                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
8579                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
8580 #else
8581   return vec_perm(
8582       __a, __b,
8583       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8584                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8585                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8586 #endif
8587 }
8588
8589 static __inline__ vector unsigned int __ATTRS_o_ai vec_vsldoi(
8590     vector unsigned int __a, vector unsigned int __b, unsigned char __c) {
8591   unsigned char __d = __c & 0x0F;
8592 #ifdef __LITTLE_ENDIAN__
8593   return vec_perm(
8594       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8595                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
8596                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
8597                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
8598 #else
8599   return vec_perm(
8600       __a, __b,
8601       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8602                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8603                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8604 #endif
8605 }
8606
8607 static __inline__ vector float __ATTRS_o_ai vec_vsldoi(vector float __a,
8608                                                        vector float __b,
8609                                                        unsigned char __c) {
8610   unsigned char __d = __c & 0x0F;
8611 #ifdef __LITTLE_ENDIAN__
8612   return vec_perm(
8613       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8614                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
8615                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
8616                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
8617 #else
8618   return vec_perm(
8619       __a, __b,
8620       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8621                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8622                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8623 #endif
8624 }
8625
8626 /* vec_sll */
8627
8628 static __inline__ vector signed char __ATTRS_o_ai
8629 vec_sll(vector signed char __a, vector unsigned char __b) {
8630   return (vector signed char)__builtin_altivec_vsl((vector int)__a,
8631                                                    (vector int)__b);
8632 }
8633
8634 static __inline__ vector signed char __ATTRS_o_ai
8635 vec_sll(vector signed char __a, vector unsigned short __b) {
8636   return (vector signed char)__builtin_altivec_vsl((vector int)__a,
8637                                                    (vector int)__b);
8638 }
8639
8640 static __inline__ vector signed char __ATTRS_o_ai
8641 vec_sll(vector signed char __a, vector unsigned int __b) {
8642   return (vector signed char)__builtin_altivec_vsl((vector int)__a,
8643                                                    (vector int)__b);
8644 }
8645
8646 static __inline__ vector unsigned char __ATTRS_o_ai
8647 vec_sll(vector unsigned char __a, vector unsigned char __b) {
8648   return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
8649                                                      (vector int)__b);
8650 }
8651
8652 static __inline__ vector unsigned char __ATTRS_o_ai
8653 vec_sll(vector unsigned char __a, vector unsigned short __b) {
8654   return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
8655                                                      (vector int)__b);
8656 }
8657
8658 static __inline__ vector unsigned char __ATTRS_o_ai
8659 vec_sll(vector unsigned char __a, vector unsigned int __b) {
8660   return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
8661                                                      (vector int)__b);
8662 }
8663
8664 static __inline__ vector bool char __ATTRS_o_ai
8665 vec_sll(vector bool char __a, vector unsigned char __b) {
8666   return (vector bool char)__builtin_altivec_vsl((vector int)__a,
8667                                                  (vector int)__b);
8668 }
8669
8670 static __inline__ vector bool char __ATTRS_o_ai
8671 vec_sll(vector bool char __a, vector unsigned short __b) {
8672   return (vector bool char)__builtin_altivec_vsl((vector int)__a,
8673                                                  (vector int)__b);
8674 }
8675
8676 static __inline__ vector bool char __ATTRS_o_ai
8677 vec_sll(vector bool char __a, vector unsigned int __b) {
8678   return (vector bool char)__builtin_altivec_vsl((vector int)__a,
8679                                                  (vector int)__b);
8680 }
8681
8682 static __inline__ vector short __ATTRS_o_ai vec_sll(vector short __a,
8683                                                     vector unsigned char __b) {
8684   return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
8685 }
8686
8687 static __inline__ vector short __ATTRS_o_ai vec_sll(vector short __a,
8688                                                     vector unsigned short __b) {
8689   return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
8690 }
8691
8692 static __inline__ vector short __ATTRS_o_ai vec_sll(vector short __a,
8693                                                     vector unsigned int __b) {
8694   return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
8695 }
8696
8697 static __inline__ vector unsigned short __ATTRS_o_ai
8698 vec_sll(vector unsigned short __a, vector unsigned char __b) {
8699   return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
8700                                                       (vector int)__b);
8701 }
8702
8703 static __inline__ vector unsigned short __ATTRS_o_ai
8704 vec_sll(vector unsigned short __a, vector unsigned short __b) {
8705   return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
8706                                                       (vector int)__b);
8707 }
8708
8709 static __inline__ vector unsigned short __ATTRS_o_ai
8710 vec_sll(vector unsigned short __a, vector unsigned int __b) {
8711   return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
8712                                                       (vector int)__b);
8713 }
8714
8715 static __inline__ vector bool short __ATTRS_o_ai
8716 vec_sll(vector bool short __a, vector unsigned char __b) {
8717   return (vector bool short)__builtin_altivec_vsl((vector int)__a,
8718                                                   (vector int)__b);
8719 }
8720
8721 static __inline__ vector bool short __ATTRS_o_ai
8722 vec_sll(vector bool short __a, vector unsigned short __b) {
8723   return (vector bool short)__builtin_altivec_vsl((vector int)__a,
8724                                                   (vector int)__b);
8725 }
8726
8727 static __inline__ vector bool short __ATTRS_o_ai
8728 vec_sll(vector bool short __a, vector unsigned int __b) {
8729   return (vector bool short)__builtin_altivec_vsl((vector int)__a,
8730                                                   (vector int)__b);
8731 }
8732
8733 static __inline__ vector pixel __ATTRS_o_ai vec_sll(vector pixel __a,
8734                                                     vector unsigned char __b) {
8735   return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
8736 }
8737
8738 static __inline__ vector pixel __ATTRS_o_ai vec_sll(vector pixel __a,
8739                                                     vector unsigned short __b) {
8740   return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
8741 }
8742
8743 static __inline__ vector pixel __ATTRS_o_ai vec_sll(vector pixel __a,
8744                                                     vector unsigned int __b) {
8745   return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
8746 }
8747
8748 static __inline__ vector int __ATTRS_o_ai vec_sll(vector int __a,
8749                                                   vector unsigned char __b) {
8750   return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
8751 }
8752
8753 static __inline__ vector int __ATTRS_o_ai vec_sll(vector int __a,
8754                                                   vector unsigned short __b) {
8755   return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
8756 }
8757
8758 static __inline__ vector int __ATTRS_o_ai vec_sll(vector int __a,
8759                                                   vector unsigned int __b) {
8760   return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
8761 }
8762
8763 static __inline__ vector unsigned int __ATTRS_o_ai
8764 vec_sll(vector unsigned int __a, vector unsigned char __b) {
8765   return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
8766                                                     (vector int)__b);
8767 }
8768
8769 static __inline__ vector unsigned int __ATTRS_o_ai
8770 vec_sll(vector unsigned int __a, vector unsigned short __b) {
8771   return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
8772                                                     (vector int)__b);
8773 }
8774
8775 static __inline__ vector unsigned int __ATTRS_o_ai
8776 vec_sll(vector unsigned int __a, vector unsigned int __b) {
8777   return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
8778                                                     (vector int)__b);
8779 }
8780
8781 static __inline__ vector bool int __ATTRS_o_ai
8782 vec_sll(vector bool int __a, vector unsigned char __b) {
8783   return (vector bool int)__builtin_altivec_vsl((vector int)__a,
8784                                                 (vector int)__b);
8785 }
8786
8787 static __inline__ vector bool int __ATTRS_o_ai
8788 vec_sll(vector bool int __a, vector unsigned short __b) {
8789   return (vector bool int)__builtin_altivec_vsl((vector int)__a,
8790                                                 (vector int)__b);
8791 }
8792
8793 static __inline__ vector bool int __ATTRS_o_ai
8794 vec_sll(vector bool int __a, vector unsigned int __b) {
8795   return (vector bool int)__builtin_altivec_vsl((vector int)__a,
8796                                                 (vector int)__b);
8797 }
8798
8799 #ifdef __VSX__
8800 static __inline__ vector signed long long __ATTRS_o_ai
8801 vec_sll(vector signed long long __a, vector unsigned char __b) {
8802   return (vector signed long long)__builtin_altivec_vsl((vector int)__a,
8803                                                         (vector int)__b);
8804 }
8805
8806 static __inline__ vector unsigned long long __ATTRS_o_ai
8807 vec_sll(vector unsigned long long __a, vector unsigned char __b) {
8808   return (vector unsigned long long)__builtin_altivec_vsl((vector int)__a,
8809                                                           (vector int)__b);
8810 }
8811 #endif
8812
8813 /* vec_vsl */
8814
8815 static __inline__ vector signed char __ATTRS_o_ai
8816 vec_vsl(vector signed char __a, vector unsigned char __b) {
8817   return (vector signed char)__builtin_altivec_vsl((vector int)__a,
8818                                                    (vector int)__b);
8819 }
8820
8821 static __inline__ vector signed char __ATTRS_o_ai
8822 vec_vsl(vector signed char __a, vector unsigned short __b) {
8823   return (vector signed char)__builtin_altivec_vsl((vector int)__a,
8824                                                    (vector int)__b);
8825 }
8826
8827 static __inline__ vector signed char __ATTRS_o_ai
8828 vec_vsl(vector signed char __a, vector unsigned int __b) {
8829   return (vector signed char)__builtin_altivec_vsl((vector int)__a,
8830                                                    (vector int)__b);
8831 }
8832
8833 static __inline__ vector unsigned char __ATTRS_o_ai
8834 vec_vsl(vector unsigned char __a, vector unsigned char __b) {
8835   return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
8836                                                      (vector int)__b);
8837 }
8838
8839 static __inline__ vector unsigned char __ATTRS_o_ai
8840 vec_vsl(vector unsigned char __a, vector unsigned short __b) {
8841   return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
8842                                                      (vector int)__b);
8843 }
8844
8845 static __inline__ vector unsigned char __ATTRS_o_ai
8846 vec_vsl(vector unsigned char __a, vector unsigned int __b) {
8847   return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
8848                                                      (vector int)__b);
8849 }
8850
8851 static __inline__ vector bool char __ATTRS_o_ai
8852 vec_vsl(vector bool char __a, vector unsigned char __b) {
8853   return (vector bool char)__builtin_altivec_vsl((vector int)__a,
8854                                                  (vector int)__b);
8855 }
8856
8857 static __inline__ vector bool char __ATTRS_o_ai
8858 vec_vsl(vector bool char __a, vector unsigned short __b) {
8859   return (vector bool char)__builtin_altivec_vsl((vector int)__a,
8860                                                  (vector int)__b);
8861 }
8862
8863 static __inline__ vector bool char __ATTRS_o_ai
8864 vec_vsl(vector bool char __a, vector unsigned int __b) {
8865   return (vector bool char)__builtin_altivec_vsl((vector int)__a,
8866                                                  (vector int)__b);
8867 }
8868
8869 static __inline__ vector short __ATTRS_o_ai vec_vsl(vector short __a,
8870                                                     vector unsigned char __b) {
8871   return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
8872 }
8873
8874 static __inline__ vector short __ATTRS_o_ai vec_vsl(vector short __a,
8875                                                     vector unsigned short __b) {
8876   return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
8877 }
8878
8879 static __inline__ vector short __ATTRS_o_ai vec_vsl(vector short __a,
8880                                                     vector unsigned int __b) {
8881   return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
8882 }
8883
8884 static __inline__ vector unsigned short __ATTRS_o_ai
8885 vec_vsl(vector unsigned short __a, vector unsigned char __b) {
8886   return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
8887                                                       (vector int)__b);
8888 }
8889
8890 static __inline__ vector unsigned short __ATTRS_o_ai
8891 vec_vsl(vector unsigned short __a, vector unsigned short __b) {
8892   return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
8893                                                       (vector int)__b);
8894 }
8895
8896 static __inline__ vector unsigned short __ATTRS_o_ai
8897 vec_vsl(vector unsigned short __a, vector unsigned int __b) {
8898   return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
8899                                                       (vector int)__b);
8900 }
8901
8902 static __inline__ vector bool short __ATTRS_o_ai
8903 vec_vsl(vector bool short __a, vector unsigned char __b) {
8904   return (vector bool short)__builtin_altivec_vsl((vector int)__a,
8905                                                   (vector int)__b);
8906 }
8907
8908 static __inline__ vector bool short __ATTRS_o_ai
8909 vec_vsl(vector bool short __a, vector unsigned short __b) {
8910   return (vector bool short)__builtin_altivec_vsl((vector int)__a,
8911                                                   (vector int)__b);
8912 }
8913
8914 static __inline__ vector bool short __ATTRS_o_ai
8915 vec_vsl(vector bool short __a, vector unsigned int __b) {
8916   return (vector bool short)__builtin_altivec_vsl((vector int)__a,
8917                                                   (vector int)__b);
8918 }
8919
8920 static __inline__ vector pixel __ATTRS_o_ai vec_vsl(vector pixel __a,
8921                                                     vector unsigned char __b) {
8922   return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
8923 }
8924
8925 static __inline__ vector pixel __ATTRS_o_ai vec_vsl(vector pixel __a,
8926                                                     vector unsigned short __b) {
8927   return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
8928 }
8929
8930 static __inline__ vector pixel __ATTRS_o_ai vec_vsl(vector pixel __a,
8931                                                     vector unsigned int __b) {
8932   return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
8933 }
8934
8935 static __inline__ vector int __ATTRS_o_ai vec_vsl(vector int __a,
8936                                                   vector unsigned char __b) {
8937   return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
8938 }
8939
8940 static __inline__ vector int __ATTRS_o_ai vec_vsl(vector int __a,
8941                                                   vector unsigned short __b) {
8942   return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
8943 }
8944
8945 static __inline__ vector int __ATTRS_o_ai vec_vsl(vector int __a,
8946                                                   vector unsigned int __b) {
8947   return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
8948 }
8949
8950 static __inline__ vector unsigned int __ATTRS_o_ai
8951 vec_vsl(vector unsigned int __a, vector unsigned char __b) {
8952   return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
8953                                                     (vector int)__b);
8954 }
8955
8956 static __inline__ vector unsigned int __ATTRS_o_ai
8957 vec_vsl(vector unsigned int __a, vector unsigned short __b) {
8958   return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
8959                                                     (vector int)__b);
8960 }
8961
8962 static __inline__ vector unsigned int __ATTRS_o_ai
8963 vec_vsl(vector unsigned int __a, vector unsigned int __b) {
8964   return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
8965                                                     (vector int)__b);
8966 }
8967
8968 static __inline__ vector bool int __ATTRS_o_ai
8969 vec_vsl(vector bool int __a, vector unsigned char __b) {
8970   return (vector bool int)__builtin_altivec_vsl((vector int)__a,
8971                                                 (vector int)__b);
8972 }
8973
8974 static __inline__ vector bool int __ATTRS_o_ai
8975 vec_vsl(vector bool int __a, vector unsigned short __b) {
8976   return (vector bool int)__builtin_altivec_vsl((vector int)__a,
8977                                                 (vector int)__b);
8978 }
8979
8980 static __inline__ vector bool int __ATTRS_o_ai
8981 vec_vsl(vector bool int __a, vector unsigned int __b) {
8982   return (vector bool int)__builtin_altivec_vsl((vector int)__a,
8983                                                 (vector int)__b);
8984 }
8985
8986 /* vec_slo */
8987
8988 static __inline__ vector signed char __ATTRS_o_ai
8989 vec_slo(vector signed char __a, vector signed char __b) {
8990   return (vector signed char)__builtin_altivec_vslo((vector int)__a,
8991                                                     (vector int)__b);
8992 }
8993
8994 static __inline__ vector signed char __ATTRS_o_ai
8995 vec_slo(vector signed char __a, vector unsigned char __b) {
8996   return (vector signed char)__builtin_altivec_vslo((vector int)__a,
8997                                                     (vector int)__b);
8998 }
8999
9000 static __inline__ vector unsigned char __ATTRS_o_ai
9001 vec_slo(vector unsigned char __a, vector signed char __b) {
9002   return (vector unsigned char)__builtin_altivec_vslo((vector int)__a,
9003                                                       (vector int)__b);
9004 }
9005
9006 static __inline__ vector unsigned char __ATTRS_o_ai
9007 vec_slo(vector unsigned char __a, vector unsigned char __b) {
9008   return (vector unsigned char)__builtin_altivec_vslo((vector int)__a,
9009                                                       (vector int)__b);
9010 }
9011
9012 static __inline__ vector short __ATTRS_o_ai vec_slo(vector short __a,
9013                                                     vector signed char __b) {
9014   return (vector short)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9015 }
9016
9017 static __inline__ vector short __ATTRS_o_ai vec_slo(vector short __a,
9018                                                     vector unsigned char __b) {
9019   return (vector short)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9020 }
9021
9022 static __inline__ vector unsigned short __ATTRS_o_ai
9023 vec_slo(vector unsigned short __a, vector signed char __b) {
9024   return (vector unsigned short)__builtin_altivec_vslo((vector int)__a,
9025                                                        (vector int)__b);
9026 }
9027
9028 static __inline__ vector unsigned short __ATTRS_o_ai
9029 vec_slo(vector unsigned short __a, vector unsigned char __b) {
9030   return (vector unsigned short)__builtin_altivec_vslo((vector int)__a,
9031                                                        (vector int)__b);
9032 }
9033
9034 static __inline__ vector pixel __ATTRS_o_ai vec_slo(vector pixel __a,
9035                                                     vector signed char __b) {
9036   return (vector pixel)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9037 }
9038
9039 static __inline__ vector pixel __ATTRS_o_ai vec_slo(vector pixel __a,
9040                                                     vector unsigned char __b) {
9041   return (vector pixel)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9042 }
9043
9044 static __inline__ vector int __ATTRS_o_ai vec_slo(vector int __a,
9045                                                   vector signed char __b) {
9046   return (vector int)__builtin_altivec_vslo(__a, (vector int)__b);
9047 }
9048
9049 static __inline__ vector int __ATTRS_o_ai vec_slo(vector int __a,
9050                                                   vector unsigned char __b) {
9051   return (vector int)__builtin_altivec_vslo(__a, (vector int)__b);
9052 }
9053
9054 static __inline__ vector unsigned int __ATTRS_o_ai
9055 vec_slo(vector unsigned int __a, vector signed char __b) {
9056   return (vector unsigned int)__builtin_altivec_vslo((vector int)__a,
9057                                                      (vector int)__b);
9058 }
9059
9060 static __inline__ vector unsigned int __ATTRS_o_ai
9061 vec_slo(vector unsigned int __a, vector unsigned char __b) {
9062   return (vector unsigned int)__builtin_altivec_vslo((vector int)__a,
9063                                                      (vector int)__b);
9064 }
9065
9066 static __inline__ vector float __ATTRS_o_ai vec_slo(vector float __a,
9067                                                     vector signed char __b) {
9068   return (vector float)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9069 }
9070
9071 static __inline__ vector float __ATTRS_o_ai vec_slo(vector float __a,
9072                                                     vector unsigned char __b) {
9073   return (vector float)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9074 }
9075
9076 #ifdef __VSX__
9077 static __inline__ vector signed long long __ATTRS_o_ai
9078 vec_slo(vector signed long long __a, vector signed char __b) {
9079   return (vector signed long long)__builtin_altivec_vslo((vector int)__a,
9080                                                          (vector int)__b);
9081 }
9082
9083 static __inline__ vector signed long long __ATTRS_o_ai
9084 vec_slo(vector signed long long __a, vector unsigned char __b) {
9085   return (vector signed long long)__builtin_altivec_vslo((vector int)__a,
9086                                                          (vector int)__b);
9087 }
9088
9089 static __inline__ vector unsigned long long __ATTRS_o_ai
9090 vec_slo(vector unsigned long long __a, vector signed char __b) {
9091   return (vector unsigned long long)__builtin_altivec_vslo((vector int)__a,
9092                                                            (vector int)__b);
9093 }
9094
9095 static __inline__ vector unsigned long long __ATTRS_o_ai
9096 vec_slo(vector unsigned long long __a, vector unsigned char __b) {
9097   return (vector unsigned long long)__builtin_altivec_vslo((vector int)__a,
9098                                                            (vector int)__b);
9099 }
9100 #endif
9101
9102 /* vec_vslo */
9103
9104 static __inline__ vector signed char __ATTRS_o_ai
9105 vec_vslo(vector signed char __a, vector signed char __b) {
9106   return (vector signed char)__builtin_altivec_vslo((vector int)__a,
9107                                                     (vector int)__b);
9108 }
9109
9110 static __inline__ vector signed char __ATTRS_o_ai
9111 vec_vslo(vector signed char __a, vector unsigned char __b) {
9112   return (vector signed char)__builtin_altivec_vslo((vector int)__a,
9113                                                     (vector int)__b);
9114 }
9115
9116 static __inline__ vector unsigned char __ATTRS_o_ai
9117 vec_vslo(vector unsigned char __a, vector signed char __b) {
9118   return (vector unsigned char)__builtin_altivec_vslo((vector int)__a,
9119                                                       (vector int)__b);
9120 }
9121
9122 static __inline__ vector unsigned char __ATTRS_o_ai
9123 vec_vslo(vector unsigned char __a, vector unsigned char __b) {
9124   return (vector unsigned char)__builtin_altivec_vslo((vector int)__a,
9125                                                       (vector int)__b);
9126 }
9127
9128 static __inline__ vector short __ATTRS_o_ai vec_vslo(vector short __a,
9129                                                      vector signed char __b) {
9130   return (vector short)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9131 }
9132
9133 static __inline__ vector short __ATTRS_o_ai vec_vslo(vector short __a,
9134                                                      vector unsigned char __b) {
9135   return (vector short)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9136 }
9137
9138 static __inline__ vector unsigned short __ATTRS_o_ai
9139 vec_vslo(vector unsigned short __a, vector signed char __b) {
9140   return (vector unsigned short)__builtin_altivec_vslo((vector int)__a,
9141                                                        (vector int)__b);
9142 }
9143
9144 static __inline__ vector unsigned short __ATTRS_o_ai
9145 vec_vslo(vector unsigned short __a, vector unsigned char __b) {
9146   return (vector unsigned short)__builtin_altivec_vslo((vector int)__a,
9147                                                        (vector int)__b);
9148 }
9149
9150 static __inline__ vector pixel __ATTRS_o_ai vec_vslo(vector pixel __a,
9151                                                      vector signed char __b) {
9152   return (vector pixel)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9153 }
9154
9155 static __inline__ vector pixel __ATTRS_o_ai vec_vslo(vector pixel __a,
9156                                                      vector unsigned char __b) {
9157   return (vector pixel)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9158 }
9159
9160 static __inline__ vector int __ATTRS_o_ai vec_vslo(vector int __a,
9161                                                    vector signed char __b) {
9162   return (vector int)__builtin_altivec_vslo(__a, (vector int)__b);
9163 }
9164
9165 static __inline__ vector int __ATTRS_o_ai vec_vslo(vector int __a,
9166                                                    vector unsigned char __b) {
9167   return (vector int)__builtin_altivec_vslo(__a, (vector int)__b);
9168 }
9169
9170 static __inline__ vector unsigned int __ATTRS_o_ai
9171 vec_vslo(vector unsigned int __a, vector signed char __b) {
9172   return (vector unsigned int)__builtin_altivec_vslo((vector int)__a,
9173                                                      (vector int)__b);
9174 }
9175
9176 static __inline__ vector unsigned int __ATTRS_o_ai
9177 vec_vslo(vector unsigned int __a, vector unsigned char __b) {
9178   return (vector unsigned int)__builtin_altivec_vslo((vector int)__a,
9179                                                      (vector int)__b);
9180 }
9181
9182 static __inline__ vector float __ATTRS_o_ai vec_vslo(vector float __a,
9183                                                      vector signed char __b) {
9184   return (vector float)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9185 }
9186
9187 static __inline__ vector float __ATTRS_o_ai vec_vslo(vector float __a,
9188                                                      vector unsigned char __b) {
9189   return (vector float)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9190 }
9191
9192 /* vec_splat */
9193
9194 static __inline__ vector signed char __ATTRS_o_ai
9195 vec_splat(vector signed char __a, unsigned const int __b) {
9196   return vec_perm(__a, __a, (vector unsigned char)(__b & 0x0F));
9197 }
9198
9199 static __inline__ vector unsigned char __ATTRS_o_ai
9200 vec_splat(vector unsigned char __a, unsigned const int __b) {
9201   return vec_perm(__a, __a, (vector unsigned char)(__b & 0x0F));
9202 }
9203
9204 static __inline__ vector bool char __ATTRS_o_ai
9205 vec_splat(vector bool char __a, unsigned const int __b) {
9206   return vec_perm(__a, __a, (vector unsigned char)(__b & 0x0F));
9207 }
9208
9209 static __inline__ vector signed short __ATTRS_o_ai
9210 vec_splat(vector signed short __a, unsigned const int __b) {
9211   unsigned char b0 = (__b & 0x07) * 2;
9212   unsigned char b1 = b0 + 1;
9213   return vec_perm(__a, __a,
9214                   (vector unsigned char)(b0, b1, b0, b1, b0, b1, b0, b1, b0, b1,
9215                                          b0, b1, b0, b1, b0, b1));
9216 }
9217
9218 static __inline__ vector unsigned short __ATTRS_o_ai
9219 vec_splat(vector unsigned short __a, unsigned const int __b) {
9220   unsigned char b0 = (__b & 0x07) * 2;
9221   unsigned char b1 = b0 + 1;
9222   return vec_perm(__a, __a,
9223                   (vector unsigned char)(b0, b1, b0, b1, b0, b1, b0, b1, b0, b1,
9224                                          b0, b1, b0, b1, b0, b1));
9225 }
9226
9227 static __inline__ vector bool short __ATTRS_o_ai
9228 vec_splat(vector bool short __a, unsigned const int __b) {
9229   unsigned char b0 = (__b & 0x07) * 2;
9230   unsigned char b1 = b0 + 1;
9231   return vec_perm(__a, __a,
9232                   (vector unsigned char)(b0, b1, b0, b1, b0, b1, b0, b1, b0, b1,
9233                                          b0, b1, b0, b1, b0, b1));
9234 }
9235
9236 static __inline__ vector pixel __ATTRS_o_ai vec_splat(vector pixel __a,
9237                                                       unsigned const int __b) {
9238   unsigned char b0 = (__b & 0x07) * 2;
9239   unsigned char b1 = b0 + 1;
9240   return vec_perm(__a, __a,
9241                   (vector unsigned char)(b0, b1, b0, b1, b0, b1, b0, b1, b0, b1,
9242                                          b0, b1, b0, b1, b0, b1));
9243 }
9244
9245 static __inline__ vector signed int __ATTRS_o_ai
9246 vec_splat(vector signed int __a, unsigned const int __b) {
9247   unsigned char b0 = (__b & 0x03) * 4;
9248   unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3;
9249   return vec_perm(__a, __a,
9250                   (vector unsigned char)(b0, b1, b2, b3, b0, b1, b2, b3, b0, b1,
9251                                          b2, b3, b0, b1, b2, b3));
9252 }
9253
9254 static __inline__ vector unsigned int __ATTRS_o_ai
9255 vec_splat(vector unsigned int __a, unsigned const int __b) {
9256   unsigned char b0 = (__b & 0x03) * 4;
9257   unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3;
9258   return vec_perm(__a, __a,
9259                   (vector unsigned char)(b0, b1, b2, b3, b0, b1, b2, b3, b0, b1,
9260                                          b2, b3, b0, b1, b2, b3));
9261 }
9262
9263 static __inline__ vector bool int __ATTRS_o_ai
9264 vec_splat(vector bool int __a, unsigned const int __b) {
9265   unsigned char b0 = (__b & 0x03) * 4;
9266   unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3;
9267   return vec_perm(__a, __a,
9268                   (vector unsigned char)(b0, b1, b2, b3, b0, b1, b2, b3, b0, b1,
9269                                          b2, b3, b0, b1, b2, b3));
9270 }
9271
9272 static __inline__ vector float __ATTRS_o_ai vec_splat(vector float __a,
9273                                                       unsigned const int __b) {
9274   unsigned char b0 = (__b & 0x03) * 4;
9275   unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3;
9276   return vec_perm(__a, __a,
9277                   (vector unsigned char)(b0, b1, b2, b3, b0, b1, b2, b3, b0, b1,
9278                                          b2, b3, b0, b1, b2, b3));
9279 }
9280
9281 #ifdef __VSX__
9282 static __inline__ vector double __ATTRS_o_ai vec_splat(vector double __a,
9283                                                        unsigned const int __b) {
9284   unsigned char b0 = (__b & 0x01) * 8;
9285   unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3, b4 = b0 + 4, b5 = b0 + 5,
9286                 b6 = b0 + 6, b7 = b0 + 7;
9287   return vec_perm(__a, __a,
9288                   (vector unsigned char)(b0, b1, b2, b3, b4, b5, b6, b7, b0, b1,
9289                                          b2, b3, b4, b5, b6, b7));
9290 }
9291 static __inline__ vector bool long long __ATTRS_o_ai
9292 vec_splat(vector bool long long __a, unsigned const int __b) {
9293   unsigned char b0 = (__b & 0x01) * 8;
9294   unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3, b4 = b0 + 4, b5 = b0 + 5,
9295                 b6 = b0 + 6, b7 = b0 + 7;
9296   return vec_perm(__a, __a,
9297                   (vector unsigned char)(b0, b1, b2, b3, b4, b5, b6, b7, b0, b1,
9298                                          b2, b3, b4, b5, b6, b7));
9299 }
9300 static __inline__ vector signed long long __ATTRS_o_ai
9301 vec_splat(vector signed long long __a, unsigned const int __b) {
9302   unsigned char b0 = (__b & 0x01) * 8;
9303   unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3, b4 = b0 + 4, b5 = b0 + 5,
9304                 b6 = b0 + 6, b7 = b0 + 7;
9305   return vec_perm(__a, __a,
9306                   (vector unsigned char)(b0, b1, b2, b3, b4, b5, b6, b7, b0, b1,
9307                                          b2, b3, b4, b5, b6, b7));
9308 }
9309 static __inline__ vector unsigned long long __ATTRS_o_ai
9310 vec_splat(vector unsigned long long __a, unsigned const int __b) {
9311   unsigned char b0 = (__b & 0x01) * 8;
9312   unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3, b4 = b0 + 4, b5 = b0 + 5,
9313                 b6 = b0 + 6, b7 = b0 + 7;
9314   return vec_perm(__a, __a,
9315                   (vector unsigned char)(b0, b1, b2, b3, b4, b5, b6, b7, b0, b1,
9316                                          b2, b3, b4, b5, b6, b7));
9317 }
9318 #endif
9319
9320 /* vec_vspltb */
9321
9322 #define __builtin_altivec_vspltb vec_vspltb
9323
9324 static __inline__ vector signed char __ATTRS_o_ai
9325 vec_vspltb(vector signed char __a, unsigned char __b) {
9326   return vec_perm(__a, __a, (vector unsigned char)(__b));
9327 }
9328
9329 static __inline__ vector unsigned char __ATTRS_o_ai
9330 vec_vspltb(vector unsigned char __a, unsigned char __b) {
9331   return vec_perm(__a, __a, (vector unsigned char)(__b));
9332 }
9333
9334 static __inline__ vector bool char __ATTRS_o_ai vec_vspltb(vector bool char __a,
9335                                                            unsigned char __b) {
9336   return vec_perm(__a, __a, (vector unsigned char)(__b));
9337 }
9338
9339 /* vec_vsplth */
9340
9341 #define __builtin_altivec_vsplth vec_vsplth
9342
9343 static __inline__ vector short __ATTRS_o_ai vec_vsplth(vector short __a,
9344                                                        unsigned char __b) {
9345   __b *= 2;
9346   unsigned char b1 = __b + 1;
9347   return vec_perm(__a, __a,
9348                   (vector unsigned char)(__b, b1, __b, b1, __b, b1, __b, b1,
9349                                          __b, b1, __b, b1, __b, b1, __b, b1));
9350 }
9351
9352 static __inline__ vector unsigned short __ATTRS_o_ai
9353 vec_vsplth(vector unsigned short __a, unsigned char __b) {
9354   __b *= 2;
9355   unsigned char b1 = __b + 1;
9356   return vec_perm(__a, __a,
9357                   (vector unsigned char)(__b, b1, __b, b1, __b, b1, __b, b1,
9358                                          __b, b1, __b, b1, __b, b1, __b, b1));
9359 }
9360
9361 static __inline__ vector bool short __ATTRS_o_ai
9362 vec_vsplth(vector bool short __a, unsigned char __b) {
9363   __b *= 2;
9364   unsigned char b1 = __b + 1;
9365   return vec_perm(__a, __a,
9366                   (vector unsigned char)(__b, b1, __b, b1, __b, b1, __b, b1,
9367                                          __b, b1, __b, b1, __b, b1, __b, b1));
9368 }
9369
9370 static __inline__ vector pixel __ATTRS_o_ai vec_vsplth(vector pixel __a,
9371                                                        unsigned char __b) {
9372   __b *= 2;
9373   unsigned char b1 = __b + 1;
9374   return vec_perm(__a, __a,
9375                   (vector unsigned char)(__b, b1, __b, b1, __b, b1, __b, b1,
9376                                          __b, b1, __b, b1, __b, b1, __b, b1));
9377 }
9378
9379 /* vec_vspltw */
9380
9381 #define __builtin_altivec_vspltw vec_vspltw
9382
9383 static __inline__ vector int __ATTRS_o_ai vec_vspltw(vector int __a,
9384                                                      unsigned char __b) {
9385   __b *= 4;
9386   unsigned char b1 = __b + 1, b2 = __b + 2, b3 = __b + 3;
9387   return vec_perm(__a, __a,
9388                   (vector unsigned char)(__b, b1, b2, b3, __b, b1, b2, b3, __b,
9389                                          b1, b2, b3, __b, b1, b2, b3));
9390 }
9391
9392 static __inline__ vector unsigned int __ATTRS_o_ai
9393 vec_vspltw(vector unsigned int __a, unsigned char __b) {
9394   __b *= 4;
9395   unsigned char b1 = __b + 1, b2 = __b + 2, b3 = __b + 3;
9396   return vec_perm(__a, __a,
9397                   (vector unsigned char)(__b, b1, b2, b3, __b, b1, b2, b3, __b,
9398                                          b1, b2, b3, __b, b1, b2, b3));
9399 }
9400
9401 static __inline__ vector bool int __ATTRS_o_ai vec_vspltw(vector bool int __a,
9402                                                           unsigned char __b) {
9403   __b *= 4;
9404   unsigned char b1 = __b + 1, b2 = __b + 2, b3 = __b + 3;
9405   return vec_perm(__a, __a,
9406                   (vector unsigned char)(__b, b1, b2, b3, __b, b1, b2, b3, __b,
9407                                          b1, b2, b3, __b, b1, b2, b3));
9408 }
9409
9410 static __inline__ vector float __ATTRS_o_ai vec_vspltw(vector float __a,
9411                                                        unsigned char __b) {
9412   __b *= 4;
9413   unsigned char b1 = __b + 1, b2 = __b + 2, b3 = __b + 3;
9414   return vec_perm(__a, __a,
9415                   (vector unsigned char)(__b, b1, b2, b3, __b, b1, b2, b3, __b,
9416                                          b1, b2, b3, __b, b1, b2, b3));
9417 }
9418
9419 /* vec_splat_s8 */
9420
9421 #define __builtin_altivec_vspltisb vec_splat_s8
9422
9423 // FIXME: parameter should be treated as 5-bit signed literal
9424 static __inline__ vector signed char __ATTRS_o_ai
9425 vec_splat_s8(signed char __a) {
9426   return (vector signed char)(__a);
9427 }
9428
9429 /* vec_vspltisb */
9430
9431 // FIXME: parameter should be treated as 5-bit signed literal
9432 static __inline__ vector signed char __ATTRS_o_ai
9433 vec_vspltisb(signed char __a) {
9434   return (vector signed char)(__a);
9435 }
9436
9437 /* vec_splat_s16 */
9438
9439 #define __builtin_altivec_vspltish vec_splat_s16
9440
9441 // FIXME: parameter should be treated as 5-bit signed literal
9442 static __inline__ vector short __ATTRS_o_ai vec_splat_s16(signed char __a) {
9443   return (vector short)(__a);
9444 }
9445
9446 /* vec_vspltish */
9447
9448 // FIXME: parameter should be treated as 5-bit signed literal
9449 static __inline__ vector short __ATTRS_o_ai vec_vspltish(signed char __a) {
9450   return (vector short)(__a);
9451 }
9452
9453 /* vec_splat_s32 */
9454
9455 #define __builtin_altivec_vspltisw vec_splat_s32
9456
9457 // FIXME: parameter should be treated as 5-bit signed literal
9458 static __inline__ vector int __ATTRS_o_ai vec_splat_s32(signed char __a) {
9459   return (vector int)(__a);
9460 }
9461
9462 /* vec_vspltisw */
9463
9464 // FIXME: parameter should be treated as 5-bit signed literal
9465 static __inline__ vector int __ATTRS_o_ai vec_vspltisw(signed char __a) {
9466   return (vector int)(__a);
9467 }
9468
9469 /* vec_splat_u8 */
9470
9471 // FIXME: parameter should be treated as 5-bit signed literal
9472 static __inline__ vector unsigned char __ATTRS_o_ai
9473 vec_splat_u8(unsigned char __a) {
9474   return (vector unsigned char)(__a);
9475 }
9476
9477 /* vec_splat_u16 */
9478
9479 // FIXME: parameter should be treated as 5-bit signed literal
9480 static __inline__ vector unsigned short __ATTRS_o_ai
9481 vec_splat_u16(signed char __a) {
9482   return (vector unsigned short)(__a);
9483 }
9484
9485 /* vec_splat_u32 */
9486
9487 // FIXME: parameter should be treated as 5-bit signed literal
9488 static __inline__ vector unsigned int __ATTRS_o_ai
9489 vec_splat_u32(signed char __a) {
9490   return (vector unsigned int)(__a);
9491 }
9492
9493 /* vec_sr */
9494
9495 static __inline__ vector signed char __ATTRS_o_ai
9496 vec_sr(vector signed char __a, vector unsigned char __b) {
9497   vector unsigned char __res = (vector unsigned char)__a >> __b;
9498   return (vector signed char)__res;
9499 }
9500
9501 static __inline__ vector unsigned char __ATTRS_o_ai
9502 vec_sr(vector unsigned char __a, vector unsigned char __b) {
9503   return __a >> __b;
9504 }
9505
9506 static __inline__ vector signed short __ATTRS_o_ai
9507 vec_sr(vector signed short __a, vector unsigned short __b) {
9508   vector unsigned short __res = (vector unsigned short)__a >> __b;
9509   return (vector signed short)__res;
9510 }
9511
9512 static __inline__ vector unsigned short __ATTRS_o_ai
9513 vec_sr(vector unsigned short __a, vector unsigned short __b) {
9514   return __a >> __b;
9515 }
9516
9517 static __inline__ vector signed int __ATTRS_o_ai
9518 vec_sr(vector signed int __a, vector unsigned int __b) {
9519   vector unsigned int __res = (vector unsigned int)__a >> __b;
9520   return (vector signed int)__res;
9521 }
9522
9523 static __inline__ vector unsigned int __ATTRS_o_ai
9524 vec_sr(vector unsigned int __a, vector unsigned int __b) {
9525   return __a >> __b;
9526 }
9527
9528 #ifdef __POWER8_VECTOR__
9529 static __inline__ vector signed long long __ATTRS_o_ai
9530 vec_sr(vector signed long long __a, vector unsigned long long __b) {
9531   vector unsigned long long __res = (vector unsigned long long)__a >> __b;
9532   return (vector signed long long)__res;
9533 }
9534
9535 static __inline__ vector unsigned long long __ATTRS_o_ai
9536 vec_sr(vector unsigned long long __a, vector unsigned long long __b) {
9537   return __a >> __b;
9538 }
9539 #endif
9540
9541 /* vec_vsrb */
9542
9543 #define __builtin_altivec_vsrb vec_vsrb
9544
9545 static __inline__ vector signed char __ATTRS_o_ai
9546 vec_vsrb(vector signed char __a, vector unsigned char __b) {
9547   return __a >> (vector signed char)__b;
9548 }
9549
9550 static __inline__ vector unsigned char __ATTRS_o_ai
9551 vec_vsrb(vector unsigned char __a, vector unsigned char __b) {
9552   return __a >> __b;
9553 }
9554
9555 /* vec_vsrh */
9556
9557 #define __builtin_altivec_vsrh vec_vsrh
9558
9559 static __inline__ vector short __ATTRS_o_ai
9560 vec_vsrh(vector short __a, vector unsigned short __b) {
9561   return __a >> (vector short)__b;
9562 }
9563
9564 static __inline__ vector unsigned short __ATTRS_o_ai
9565 vec_vsrh(vector unsigned short __a, vector unsigned short __b) {
9566   return __a >> __b;
9567 }
9568
9569 /* vec_vsrw */
9570
9571 #define __builtin_altivec_vsrw vec_vsrw
9572
9573 static __inline__ vector int __ATTRS_o_ai vec_vsrw(vector int __a,
9574                                                    vector unsigned int __b) {
9575   return __a >> (vector int)__b;
9576 }
9577
9578 static __inline__ vector unsigned int __ATTRS_o_ai
9579 vec_vsrw(vector unsigned int __a, vector unsigned int __b) {
9580   return __a >> __b;
9581 }
9582
9583 /* vec_sra */
9584
9585 static __inline__ vector signed char __ATTRS_o_ai
9586 vec_sra(vector signed char __a, vector unsigned char __b) {
9587   return (vector signed char)__builtin_altivec_vsrab((vector char)__a, __b);
9588 }
9589
9590 static __inline__ vector unsigned char __ATTRS_o_ai
9591 vec_sra(vector unsigned char __a, vector unsigned char __b) {
9592   return (vector unsigned char)__builtin_altivec_vsrab((vector char)__a, __b);
9593 }
9594
9595 static __inline__ vector short __ATTRS_o_ai vec_sra(vector short __a,
9596                                                     vector unsigned short __b) {
9597   return __builtin_altivec_vsrah(__a, (vector unsigned short)__b);
9598 }
9599
9600 static __inline__ vector unsigned short __ATTRS_o_ai
9601 vec_sra(vector unsigned short __a, vector unsigned short __b) {
9602   return (vector unsigned short)__builtin_altivec_vsrah((vector short)__a, __b);
9603 }
9604
9605 static __inline__ vector int __ATTRS_o_ai vec_sra(vector int __a,
9606                                                   vector unsigned int __b) {
9607   return __builtin_altivec_vsraw(__a, __b);
9608 }
9609
9610 static __inline__ vector unsigned int __ATTRS_o_ai
9611 vec_sra(vector unsigned int __a, vector unsigned int __b) {
9612   return (vector unsigned int)__builtin_altivec_vsraw((vector int)__a, __b);
9613 }
9614
9615 #ifdef __POWER8_VECTOR__
9616 static __inline__ vector signed long long __ATTRS_o_ai
9617 vec_sra(vector signed long long __a, vector unsigned long long __b) {
9618   return __a >> __b;
9619 }
9620
9621 static __inline__ vector unsigned long long __ATTRS_o_ai
9622 vec_sra(vector unsigned long long __a, vector unsigned long long __b) {
9623   return (vector unsigned long long)((vector signed long long)__a >> __b);
9624 }
9625 #endif
9626
9627 /* vec_vsrab */
9628
9629 static __inline__ vector signed char __ATTRS_o_ai
9630 vec_vsrab(vector signed char __a, vector unsigned char __b) {
9631   return (vector signed char)__builtin_altivec_vsrab((vector char)__a, __b);
9632 }
9633
9634 static __inline__ vector unsigned char __ATTRS_o_ai
9635 vec_vsrab(vector unsigned char __a, vector unsigned char __b) {
9636   return (vector unsigned char)__builtin_altivec_vsrab((vector char)__a, __b);
9637 }
9638
9639 /* vec_vsrah */
9640
9641 static __inline__ vector short __ATTRS_o_ai
9642 vec_vsrah(vector short __a, vector unsigned short __b) {
9643   return __builtin_altivec_vsrah(__a, (vector unsigned short)__b);
9644 }
9645
9646 static __inline__ vector unsigned short __ATTRS_o_ai
9647 vec_vsrah(vector unsigned short __a, vector unsigned short __b) {
9648   return (vector unsigned short)__builtin_altivec_vsrah((vector short)__a, __b);
9649 }
9650
9651 /* vec_vsraw */
9652
9653 static __inline__ vector int __ATTRS_o_ai vec_vsraw(vector int __a,
9654                                                     vector unsigned int __b) {
9655   return __builtin_altivec_vsraw(__a, __b);
9656 }
9657
9658 static __inline__ vector unsigned int __ATTRS_o_ai
9659 vec_vsraw(vector unsigned int __a, vector unsigned int __b) {
9660   return (vector unsigned int)__builtin_altivec_vsraw((vector int)__a, __b);
9661 }
9662
9663 /* vec_srl */
9664
9665 static __inline__ vector signed char __ATTRS_o_ai
9666 vec_srl(vector signed char __a, vector unsigned char __b) {
9667   return (vector signed char)__builtin_altivec_vsr((vector int)__a,
9668                                                    (vector int)__b);
9669 }
9670
9671 static __inline__ vector signed char __ATTRS_o_ai
9672 vec_srl(vector signed char __a, vector unsigned short __b) {
9673   return (vector signed char)__builtin_altivec_vsr((vector int)__a,
9674                                                    (vector int)__b);
9675 }
9676
9677 static __inline__ vector signed char __ATTRS_o_ai
9678 vec_srl(vector signed char __a, vector unsigned int __b) {
9679   return (vector signed char)__builtin_altivec_vsr((vector int)__a,
9680                                                    (vector int)__b);
9681 }
9682
9683 static __inline__ vector unsigned char __ATTRS_o_ai
9684 vec_srl(vector unsigned char __a, vector unsigned char __b) {
9685   return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
9686                                                      (vector int)__b);
9687 }
9688
9689 static __inline__ vector unsigned char __ATTRS_o_ai
9690 vec_srl(vector unsigned char __a, vector unsigned short __b) {
9691   return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
9692                                                      (vector int)__b);
9693 }
9694
9695 static __inline__ vector unsigned char __ATTRS_o_ai
9696 vec_srl(vector unsigned char __a, vector unsigned int __b) {
9697   return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
9698                                                      (vector int)__b);
9699 }
9700
9701 static __inline__ vector bool char __ATTRS_o_ai
9702 vec_srl(vector bool char __a, vector unsigned char __b) {
9703   return (vector bool char)__builtin_altivec_vsr((vector int)__a,
9704                                                  (vector int)__b);
9705 }
9706
9707 static __inline__ vector bool char __ATTRS_o_ai
9708 vec_srl(vector bool char __a, vector unsigned short __b) {
9709   return (vector bool char)__builtin_altivec_vsr((vector int)__a,
9710                                                  (vector int)__b);
9711 }
9712
9713 static __inline__ vector bool char __ATTRS_o_ai
9714 vec_srl(vector bool char __a, vector unsigned int __b) {
9715   return (vector bool char)__builtin_altivec_vsr((vector int)__a,
9716                                                  (vector int)__b);
9717 }
9718
9719 static __inline__ vector short __ATTRS_o_ai vec_srl(vector short __a,
9720                                                     vector unsigned char __b) {
9721   return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9722 }
9723
9724 static __inline__ vector short __ATTRS_o_ai vec_srl(vector short __a,
9725                                                     vector unsigned short __b) {
9726   return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9727 }
9728
9729 static __inline__ vector short __ATTRS_o_ai vec_srl(vector short __a,
9730                                                     vector unsigned int __b) {
9731   return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9732 }
9733
9734 static __inline__ vector unsigned short __ATTRS_o_ai
9735 vec_srl(vector unsigned short __a, vector unsigned char __b) {
9736   return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
9737                                                       (vector int)__b);
9738 }
9739
9740 static __inline__ vector unsigned short __ATTRS_o_ai
9741 vec_srl(vector unsigned short __a, vector unsigned short __b) {
9742   return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
9743                                                       (vector int)__b);
9744 }
9745
9746 static __inline__ vector unsigned short __ATTRS_o_ai
9747 vec_srl(vector unsigned short __a, vector unsigned int __b) {
9748   return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
9749                                                       (vector int)__b);
9750 }
9751
9752 static __inline__ vector bool short __ATTRS_o_ai
9753 vec_srl(vector bool short __a, vector unsigned char __b) {
9754   return (vector bool short)__builtin_altivec_vsr((vector int)__a,
9755                                                   (vector int)__b);
9756 }
9757
9758 static __inline__ vector bool short __ATTRS_o_ai
9759 vec_srl(vector bool short __a, vector unsigned short __b) {
9760   return (vector bool short)__builtin_altivec_vsr((vector int)__a,
9761                                                   (vector int)__b);
9762 }
9763
9764 static __inline__ vector bool short __ATTRS_o_ai
9765 vec_srl(vector bool short __a, vector unsigned int __b) {
9766   return (vector bool short)__builtin_altivec_vsr((vector int)__a,
9767                                                   (vector int)__b);
9768 }
9769
9770 static __inline__ vector pixel __ATTRS_o_ai vec_srl(vector pixel __a,
9771                                                     vector unsigned char __b) {
9772   return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9773 }
9774
9775 static __inline__ vector pixel __ATTRS_o_ai vec_srl(vector pixel __a,
9776                                                     vector unsigned short __b) {
9777   return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9778 }
9779
9780 static __inline__ vector pixel __ATTRS_o_ai vec_srl(vector pixel __a,
9781                                                     vector unsigned int __b) {
9782   return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9783 }
9784
9785 static __inline__ vector int __ATTRS_o_ai vec_srl(vector int __a,
9786                                                   vector unsigned char __b) {
9787   return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
9788 }
9789
9790 static __inline__ vector int __ATTRS_o_ai vec_srl(vector int __a,
9791                                                   vector unsigned short __b) {
9792   return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
9793 }
9794
9795 static __inline__ vector int __ATTRS_o_ai vec_srl(vector int __a,
9796                                                   vector unsigned int __b) {
9797   return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
9798 }
9799
9800 static __inline__ vector unsigned int __ATTRS_o_ai
9801 vec_srl(vector unsigned int __a, vector unsigned char __b) {
9802   return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
9803                                                     (vector int)__b);
9804 }
9805
9806 static __inline__ vector unsigned int __ATTRS_o_ai
9807 vec_srl(vector unsigned int __a, vector unsigned short __b) {
9808   return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
9809                                                     (vector int)__b);
9810 }
9811
9812 static __inline__ vector unsigned int __ATTRS_o_ai
9813 vec_srl(vector unsigned int __a, vector unsigned int __b) {
9814   return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
9815                                                     (vector int)__b);
9816 }
9817
9818 static __inline__ vector bool int __ATTRS_o_ai
9819 vec_srl(vector bool int __a, vector unsigned char __b) {
9820   return (vector bool int)__builtin_altivec_vsr((vector int)__a,
9821                                                 (vector int)__b);
9822 }
9823
9824 static __inline__ vector bool int __ATTRS_o_ai
9825 vec_srl(vector bool int __a, vector unsigned short __b) {
9826   return (vector bool int)__builtin_altivec_vsr((vector int)__a,
9827                                                 (vector int)__b);
9828 }
9829
9830 static __inline__ vector bool int __ATTRS_o_ai
9831 vec_srl(vector bool int __a, vector unsigned int __b) {
9832   return (vector bool int)__builtin_altivec_vsr((vector int)__a,
9833                                                 (vector int)__b);
9834 }
9835
9836 #ifdef __VSX__
9837 static __inline__ vector signed long long __ATTRS_o_ai
9838 vec_srl(vector signed long long __a, vector unsigned char __b) {
9839   return (vector signed long long)__builtin_altivec_vsr((vector int)__a,
9840                                                         (vector int)__b);
9841 }
9842
9843 static __inline__ vector unsigned long long __ATTRS_o_ai
9844 vec_srl(vector unsigned long long __a, vector unsigned char __b) {
9845   return (vector unsigned long long)__builtin_altivec_vsr((vector int)__a,
9846                                                           (vector int)__b);
9847 }
9848 #endif
9849
9850 /* vec_vsr */
9851
9852 static __inline__ vector signed char __ATTRS_o_ai
9853 vec_vsr(vector signed char __a, vector unsigned char __b) {
9854   return (vector signed char)__builtin_altivec_vsr((vector int)__a,
9855                                                    (vector int)__b);
9856 }
9857
9858 static __inline__ vector signed char __ATTRS_o_ai
9859 vec_vsr(vector signed char __a, vector unsigned short __b) {
9860   return (vector signed char)__builtin_altivec_vsr((vector int)__a,
9861                                                    (vector int)__b);
9862 }
9863
9864 static __inline__ vector signed char __ATTRS_o_ai
9865 vec_vsr(vector signed char __a, vector unsigned int __b) {
9866   return (vector signed char)__builtin_altivec_vsr((vector int)__a,
9867                                                    (vector int)__b);
9868 }
9869
9870 static __inline__ vector unsigned char __ATTRS_o_ai
9871 vec_vsr(vector unsigned char __a, vector unsigned char __b) {
9872   return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
9873                                                      (vector int)__b);
9874 }
9875
9876 static __inline__ vector unsigned char __ATTRS_o_ai
9877 vec_vsr(vector unsigned char __a, vector unsigned short __b) {
9878   return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
9879                                                      (vector int)__b);
9880 }
9881
9882 static __inline__ vector unsigned char __ATTRS_o_ai
9883 vec_vsr(vector unsigned char __a, vector unsigned int __b) {
9884   return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
9885                                                      (vector int)__b);
9886 }
9887
9888 static __inline__ vector bool char __ATTRS_o_ai
9889 vec_vsr(vector bool char __a, vector unsigned char __b) {
9890   return (vector bool char)__builtin_altivec_vsr((vector int)__a,
9891                                                  (vector int)__b);
9892 }
9893
9894 static __inline__ vector bool char __ATTRS_o_ai
9895 vec_vsr(vector bool char __a, vector unsigned short __b) {
9896   return (vector bool char)__builtin_altivec_vsr((vector int)__a,
9897                                                  (vector int)__b);
9898 }
9899
9900 static __inline__ vector bool char __ATTRS_o_ai
9901 vec_vsr(vector bool char __a, vector unsigned int __b) {
9902   return (vector bool char)__builtin_altivec_vsr((vector int)__a,
9903                                                  (vector int)__b);
9904 }
9905
9906 static __inline__ vector short __ATTRS_o_ai vec_vsr(vector short __a,
9907                                                     vector unsigned char __b) {
9908   return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9909 }
9910
9911 static __inline__ vector short __ATTRS_o_ai vec_vsr(vector short __a,
9912                                                     vector unsigned short __b) {
9913   return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9914 }
9915
9916 static __inline__ vector short __ATTRS_o_ai vec_vsr(vector short __a,
9917                                                     vector unsigned int __b) {
9918   return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9919 }
9920
9921 static __inline__ vector unsigned short __ATTRS_o_ai
9922 vec_vsr(vector unsigned short __a, vector unsigned char __b) {
9923   return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
9924                                                       (vector int)__b);
9925 }
9926
9927 static __inline__ vector unsigned short __ATTRS_o_ai
9928 vec_vsr(vector unsigned short __a, vector unsigned short __b) {
9929   return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
9930                                                       (vector int)__b);
9931 }
9932
9933 static __inline__ vector unsigned short __ATTRS_o_ai
9934 vec_vsr(vector unsigned short __a, vector unsigned int __b) {
9935   return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
9936                                                       (vector int)__b);
9937 }
9938
9939 static __inline__ vector bool short __ATTRS_o_ai
9940 vec_vsr(vector bool short __a, vector unsigned char __b) {
9941   return (vector bool short)__builtin_altivec_vsr((vector int)__a,
9942                                                   (vector int)__b);
9943 }
9944
9945 static __inline__ vector bool short __ATTRS_o_ai
9946 vec_vsr(vector bool short __a, vector unsigned short __b) {
9947   return (vector bool short)__builtin_altivec_vsr((vector int)__a,
9948                                                   (vector int)__b);
9949 }
9950
9951 static __inline__ vector bool short __ATTRS_o_ai
9952 vec_vsr(vector bool short __a, vector unsigned int __b) {
9953   return (vector bool short)__builtin_altivec_vsr((vector int)__a,
9954                                                   (vector int)__b);
9955 }
9956
9957 static __inline__ vector pixel __ATTRS_o_ai vec_vsr(vector pixel __a,
9958                                                     vector unsigned char __b) {
9959   return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9960 }
9961
9962 static __inline__ vector pixel __ATTRS_o_ai vec_vsr(vector pixel __a,
9963                                                     vector unsigned short __b) {
9964   return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9965 }
9966
9967 static __inline__ vector pixel __ATTRS_o_ai vec_vsr(vector pixel __a,
9968                                                     vector unsigned int __b) {
9969   return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9970 }
9971
9972 static __inline__ vector int __ATTRS_o_ai vec_vsr(vector int __a,
9973                                                   vector unsigned char __b) {
9974   return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
9975 }
9976
9977 static __inline__ vector int __ATTRS_o_ai vec_vsr(vector int __a,
9978                                                   vector unsigned short __b) {
9979   return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
9980 }
9981
9982 static __inline__ vector int __ATTRS_o_ai vec_vsr(vector int __a,
9983                                                   vector unsigned int __b) {
9984   return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
9985 }
9986
9987 static __inline__ vector unsigned int __ATTRS_o_ai
9988 vec_vsr(vector unsigned int __a, vector unsigned char __b) {
9989   return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
9990                                                     (vector int)__b);
9991 }
9992
9993 static __inline__ vector unsigned int __ATTRS_o_ai
9994 vec_vsr(vector unsigned int __a, vector unsigned short __b) {
9995   return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
9996                                                     (vector int)__b);
9997 }
9998
9999 static __inline__ vector unsigned int __ATTRS_o_ai
10000 vec_vsr(vector unsigned int __a, vector unsigned int __b) {
10001   return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
10002                                                     (vector int)__b);
10003 }
10004
10005 static __inline__ vector bool int __ATTRS_o_ai
10006 vec_vsr(vector bool int __a, vector unsigned char __b) {
10007   return (vector bool int)__builtin_altivec_vsr((vector int)__a,
10008                                                 (vector int)__b);
10009 }
10010
10011 static __inline__ vector bool int __ATTRS_o_ai
10012 vec_vsr(vector bool int __a, vector unsigned short __b) {
10013   return (vector bool int)__builtin_altivec_vsr((vector int)__a,
10014                                                 (vector int)__b);
10015 }
10016
10017 static __inline__ vector bool int __ATTRS_o_ai
10018 vec_vsr(vector bool int __a, vector unsigned int __b) {
10019   return (vector bool int)__builtin_altivec_vsr((vector int)__a,
10020                                                 (vector int)__b);
10021 }
10022
10023 /* vec_sro */
10024
10025 static __inline__ vector signed char __ATTRS_o_ai
10026 vec_sro(vector signed char __a, vector signed char __b) {
10027   return (vector signed char)__builtin_altivec_vsro((vector int)__a,
10028                                                     (vector int)__b);
10029 }
10030
10031 static __inline__ vector signed char __ATTRS_o_ai
10032 vec_sro(vector signed char __a, vector unsigned char __b) {
10033   return (vector signed char)__builtin_altivec_vsro((vector int)__a,
10034                                                     (vector int)__b);
10035 }
10036
10037 static __inline__ vector unsigned char __ATTRS_o_ai
10038 vec_sro(vector unsigned char __a, vector signed char __b) {
10039   return (vector unsigned char)__builtin_altivec_vsro((vector int)__a,
10040                                                       (vector int)__b);
10041 }
10042
10043 static __inline__ vector unsigned char __ATTRS_o_ai
10044 vec_sro(vector unsigned char __a, vector unsigned char __b) {
10045   return (vector unsigned char)__builtin_altivec_vsro((vector int)__a,
10046                                                       (vector int)__b);
10047 }
10048
10049 static __inline__ vector short __ATTRS_o_ai vec_sro(vector short __a,
10050                                                     vector signed char __b) {
10051   return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10052 }
10053
10054 static __inline__ vector short __ATTRS_o_ai vec_sro(vector short __a,
10055                                                     vector unsigned char __b) {
10056   return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10057 }
10058
10059 static __inline__ vector unsigned short __ATTRS_o_ai
10060 vec_sro(vector unsigned short __a, vector signed char __b) {
10061   return (vector unsigned short)__builtin_altivec_vsro((vector int)__a,
10062                                                        (vector int)__b);
10063 }
10064
10065 static __inline__ vector unsigned short __ATTRS_o_ai
10066 vec_sro(vector unsigned short __a, vector unsigned char __b) {
10067   return (vector unsigned short)__builtin_altivec_vsro((vector int)__a,
10068                                                        (vector int)__b);
10069 }
10070
10071 static __inline__ vector pixel __ATTRS_o_ai vec_sro(vector pixel __a,
10072                                                     vector signed char __b) {
10073   return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10074 }
10075
10076 static __inline__ vector pixel __ATTRS_o_ai vec_sro(vector pixel __a,
10077                                                     vector unsigned char __b) {
10078   return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10079 }
10080
10081 static __inline__ vector int __ATTRS_o_ai vec_sro(vector int __a,
10082                                                   vector signed char __b) {
10083   return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
10084 }
10085
10086 static __inline__ vector int __ATTRS_o_ai vec_sro(vector int __a,
10087                                                   vector unsigned char __b) {
10088   return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
10089 }
10090
10091 static __inline__ vector unsigned int __ATTRS_o_ai
10092 vec_sro(vector unsigned int __a, vector signed char __b) {
10093   return (vector unsigned int)__builtin_altivec_vsro((vector int)__a,
10094                                                      (vector int)__b);
10095 }
10096
10097 static __inline__ vector unsigned int __ATTRS_o_ai
10098 vec_sro(vector unsigned int __a, vector unsigned char __b) {
10099   return (vector unsigned int)__builtin_altivec_vsro((vector int)__a,
10100                                                      (vector int)__b);
10101 }
10102
10103 static __inline__ vector float __ATTRS_o_ai vec_sro(vector float __a,
10104                                                     vector signed char __b) {
10105   return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10106 }
10107
10108 static __inline__ vector float __ATTRS_o_ai vec_sro(vector float __a,
10109                                                     vector unsigned char __b) {
10110   return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10111 }
10112
10113 #ifdef __VSX__
10114 static __inline__ vector signed long long __ATTRS_o_ai
10115 vec_sro(vector signed long long __a, vector signed char __b) {
10116   return (vector signed long long)__builtin_altivec_vsro((vector int)__a,
10117                                                          (vector int)__b);
10118 }
10119
10120 static __inline__ vector signed long long __ATTRS_o_ai
10121 vec_sro(vector signed long long __a, vector unsigned char __b) {
10122   return (vector signed long long)__builtin_altivec_vsro((vector int)__a,
10123                                                          (vector int)__b);
10124 }
10125
10126 static __inline__ vector unsigned long long __ATTRS_o_ai
10127 vec_sro(vector unsigned long long __a, vector signed char __b) {
10128   return (vector unsigned long long)__builtin_altivec_vsro((vector int)__a,
10129                                                            (vector int)__b);
10130 }
10131
10132 static __inline__ vector unsigned long long __ATTRS_o_ai
10133 vec_sro(vector unsigned long long __a, vector unsigned char __b) {
10134   return (vector unsigned long long)__builtin_altivec_vsro((vector int)__a,
10135                                                            (vector int)__b);
10136 }
10137 #endif
10138
10139 /* vec_vsro */
10140
10141 static __inline__ vector signed char __ATTRS_o_ai
10142 vec_vsro(vector signed char __a, vector signed char __b) {
10143   return (vector signed char)__builtin_altivec_vsro((vector int)__a,
10144                                                     (vector int)__b);
10145 }
10146
10147 static __inline__ vector signed char __ATTRS_o_ai
10148 vec_vsro(vector signed char __a, vector unsigned char __b) {
10149   return (vector signed char)__builtin_altivec_vsro((vector int)__a,
10150                                                     (vector int)__b);
10151 }
10152
10153 static __inline__ vector unsigned char __ATTRS_o_ai
10154 vec_vsro(vector unsigned char __a, vector signed char __b) {
10155   return (vector unsigned char)__builtin_altivec_vsro((vector int)__a,
10156                                                       (vector int)__b);
10157 }
10158
10159 static __inline__ vector unsigned char __ATTRS_o_ai
10160 vec_vsro(vector unsigned char __a, vector unsigned char __b) {
10161   return (vector unsigned char)__builtin_altivec_vsro((vector int)__a,
10162                                                       (vector int)__b);
10163 }
10164
10165 static __inline__ vector short __ATTRS_o_ai vec_vsro(vector short __a,
10166                                                      vector signed char __b) {
10167   return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10168 }
10169
10170 static __inline__ vector short __ATTRS_o_ai vec_vsro(vector short __a,
10171                                                      vector unsigned char __b) {
10172   return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10173 }
10174
10175 static __inline__ vector unsigned short __ATTRS_o_ai
10176 vec_vsro(vector unsigned short __a, vector signed char __b) {
10177   return (vector unsigned short)__builtin_altivec_vsro((vector int)__a,
10178                                                        (vector int)__b);
10179 }
10180
10181 static __inline__ vector unsigned short __ATTRS_o_ai
10182 vec_vsro(vector unsigned short __a, vector unsigned char __b) {
10183   return (vector unsigned short)__builtin_altivec_vsro((vector int)__a,
10184                                                        (vector int)__b);
10185 }
10186
10187 static __inline__ vector pixel __ATTRS_o_ai vec_vsro(vector pixel __a,
10188                                                      vector signed char __b) {
10189   return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10190 }
10191
10192 static __inline__ vector pixel __ATTRS_o_ai vec_vsro(vector pixel __a,
10193                                                      vector unsigned char __b) {
10194   return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10195 }
10196
10197 static __inline__ vector int __ATTRS_o_ai vec_vsro(vector int __a,
10198                                                    vector signed char __b) {
10199   return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
10200 }
10201
10202 static __inline__ vector int __ATTRS_o_ai vec_vsro(vector int __a,
10203                                                    vector unsigned char __b) {
10204   return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
10205 }
10206
10207 static __inline__ vector unsigned int __ATTRS_o_ai
10208 vec_vsro(vector unsigned int __a, vector signed char __b) {
10209   return (vector unsigned int)__builtin_altivec_vsro((vector int)__a,
10210                                                      (vector int)__b);
10211 }
10212
10213 static __inline__ vector unsigned int __ATTRS_o_ai
10214 vec_vsro(vector unsigned int __a, vector unsigned char __b) {
10215   return (vector unsigned int)__builtin_altivec_vsro((vector int)__a,
10216                                                      (vector int)__b);
10217 }
10218
10219 static __inline__ vector float __ATTRS_o_ai vec_vsro(vector float __a,
10220                                                      vector signed char __b) {
10221   return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10222 }
10223
10224 static __inline__ vector float __ATTRS_o_ai vec_vsro(vector float __a,
10225                                                      vector unsigned char __b) {
10226   return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10227 }
10228
10229 /* vec_st */
10230
10231 static __inline__ void __ATTRS_o_ai vec_st(vector signed char __a, int __b,
10232                                            vector signed char *__c) {
10233   __builtin_altivec_stvx((vector int)__a, __b, __c);
10234 }
10235
10236 static __inline__ void __ATTRS_o_ai vec_st(vector signed char __a, int __b,
10237                                            signed char *__c) {
10238   __builtin_altivec_stvx((vector int)__a, __b, __c);
10239 }
10240
10241 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned char __a, int __b,
10242                                            vector unsigned char *__c) {
10243   __builtin_altivec_stvx((vector int)__a, __b, __c);
10244 }
10245
10246 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned char __a, int __b,
10247                                            unsigned char *__c) {
10248   __builtin_altivec_stvx((vector int)__a, __b, __c);
10249 }
10250
10251 static __inline__ void __ATTRS_o_ai vec_st(vector bool char __a, int __b,
10252                                            signed char *__c) {
10253   __builtin_altivec_stvx((vector int)__a, __b, __c);
10254 }
10255
10256 static __inline__ void __ATTRS_o_ai vec_st(vector bool char __a, int __b,
10257                                            unsigned char *__c) {
10258   __builtin_altivec_stvx((vector int)__a, __b, __c);
10259 }
10260
10261 static __inline__ void __ATTRS_o_ai vec_st(vector bool char __a, int __b,
10262                                            vector bool char *__c) {
10263   __builtin_altivec_stvx((vector int)__a, __b, __c);
10264 }
10265
10266 static __inline__ void __ATTRS_o_ai vec_st(vector short __a, int __b,
10267                                            vector short *__c) {
10268   __builtin_altivec_stvx((vector int)__a, __b, __c);
10269 }
10270
10271 static __inline__ void __ATTRS_o_ai vec_st(vector short __a, int __b,
10272                                            short *__c) {
10273   __builtin_altivec_stvx((vector int)__a, __b, __c);
10274 }
10275
10276 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned short __a, int __b,
10277                                            vector unsigned short *__c) {
10278   __builtin_altivec_stvx((vector int)__a, __b, __c);
10279 }
10280
10281 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned short __a, int __b,
10282                                            unsigned short *__c) {
10283   __builtin_altivec_stvx((vector int)__a, __b, __c);
10284 }
10285
10286 static __inline__ void __ATTRS_o_ai vec_st(vector bool short __a, int __b,
10287                                            short *__c) {
10288   __builtin_altivec_stvx((vector int)__a, __b, __c);
10289 }
10290
10291 static __inline__ void __ATTRS_o_ai vec_st(vector bool short __a, int __b,
10292                                            unsigned short *__c) {
10293   __builtin_altivec_stvx((vector int)__a, __b, __c);
10294 }
10295
10296 static __inline__ void __ATTRS_o_ai vec_st(vector bool short __a, int __b,
10297                                            vector bool short *__c) {
10298   __builtin_altivec_stvx((vector int)__a, __b, __c);
10299 }
10300
10301 static __inline__ void __ATTRS_o_ai vec_st(vector pixel __a, int __b,
10302                                            short *__c) {
10303   __builtin_altivec_stvx((vector int)__a, __b, __c);
10304 }
10305
10306 static __inline__ void __ATTRS_o_ai vec_st(vector pixel __a, int __b,
10307                                            unsigned short *__c) {
10308   __builtin_altivec_stvx((vector int)__a, __b, __c);
10309 }
10310
10311 static __inline__ void __ATTRS_o_ai vec_st(vector pixel __a, int __b,
10312                                            vector pixel *__c) {
10313   __builtin_altivec_stvx((vector int)__a, __b, __c);
10314 }
10315
10316 static __inline__ void __ATTRS_o_ai vec_st(vector int __a, int __b,
10317                                            vector int *__c) {
10318   __builtin_altivec_stvx(__a, __b, __c);
10319 }
10320
10321 static __inline__ void __ATTRS_o_ai vec_st(vector int __a, int __b, int *__c) {
10322   __builtin_altivec_stvx(__a, __b, __c);
10323 }
10324
10325 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned int __a, int __b,
10326                                            vector unsigned int *__c) {
10327   __builtin_altivec_stvx((vector int)__a, __b, __c);
10328 }
10329
10330 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned int __a, int __b,
10331                                            unsigned int *__c) {
10332   __builtin_altivec_stvx((vector int)__a, __b, __c);
10333 }
10334
10335 static __inline__ void __ATTRS_o_ai vec_st(vector bool int __a, int __b,
10336                                            int *__c) {
10337   __builtin_altivec_stvx((vector int)__a, __b, __c);
10338 }
10339
10340 static __inline__ void __ATTRS_o_ai vec_st(vector bool int __a, int __b,
10341                                            unsigned int *__c) {
10342   __builtin_altivec_stvx((vector int)__a, __b, __c);
10343 }
10344
10345 static __inline__ void __ATTRS_o_ai vec_st(vector bool int __a, int __b,
10346                                            vector bool int *__c) {
10347   __builtin_altivec_stvx((vector int)__a, __b, __c);
10348 }
10349
10350 static __inline__ void __ATTRS_o_ai vec_st(vector float __a, int __b,
10351                                            vector float *__c) {
10352   __builtin_altivec_stvx((vector int)__a, __b, __c);
10353 }
10354
10355 static __inline__ void __ATTRS_o_ai vec_st(vector float __a, int __b,
10356                                            float *__c) {
10357   __builtin_altivec_stvx((vector int)__a, __b, __c);
10358 }
10359
10360 /* vec_stvx */
10361
10362 static __inline__ void __ATTRS_o_ai vec_stvx(vector signed char __a, int __b,
10363                                              vector signed char *__c) {
10364   __builtin_altivec_stvx((vector int)__a, __b, __c);
10365 }
10366
10367 static __inline__ void __ATTRS_o_ai vec_stvx(vector signed char __a, int __b,
10368                                              signed char *__c) {
10369   __builtin_altivec_stvx((vector int)__a, __b, __c);
10370 }
10371
10372 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned char __a, int __b,
10373                                              vector unsigned char *__c) {
10374   __builtin_altivec_stvx((vector int)__a, __b, __c);
10375 }
10376
10377 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned char __a, int __b,
10378                                              unsigned char *__c) {
10379   __builtin_altivec_stvx((vector int)__a, __b, __c);
10380 }
10381
10382 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool char __a, int __b,
10383                                              signed char *__c) {
10384   __builtin_altivec_stvx((vector int)__a, __b, __c);
10385 }
10386
10387 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool char __a, int __b,
10388                                              unsigned char *__c) {
10389   __builtin_altivec_stvx((vector int)__a, __b, __c);
10390 }
10391
10392 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool char __a, int __b,
10393                                              vector bool char *__c) {
10394   __builtin_altivec_stvx((vector int)__a, __b, __c);
10395 }
10396
10397 static __inline__ void __ATTRS_o_ai vec_stvx(vector short __a, int __b,
10398                                              vector short *__c) {
10399   __builtin_altivec_stvx((vector int)__a, __b, __c);
10400 }
10401
10402 static __inline__ void __ATTRS_o_ai vec_stvx(vector short __a, int __b,
10403                                              short *__c) {
10404   __builtin_altivec_stvx((vector int)__a, __b, __c);
10405 }
10406
10407 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned short __a, int __b,
10408                                              vector unsigned short *__c) {
10409   __builtin_altivec_stvx((vector int)__a, __b, __c);
10410 }
10411
10412 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned short __a, int __b,
10413                                              unsigned short *__c) {
10414   __builtin_altivec_stvx((vector int)__a, __b, __c);
10415 }
10416
10417 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool short __a, int __b,
10418                                              short *__c) {
10419   __builtin_altivec_stvx((vector int)__a, __b, __c);
10420 }
10421
10422 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool short __a, int __b,
10423                                              unsigned short *__c) {
10424   __builtin_altivec_stvx((vector int)__a, __b, __c);
10425 }
10426
10427 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool short __a, int __b,
10428                                              vector bool short *__c) {
10429   __builtin_altivec_stvx((vector int)__a, __b, __c);
10430 }
10431
10432 static __inline__ void __ATTRS_o_ai vec_stvx(vector pixel __a, int __b,
10433                                              short *__c) {
10434   __builtin_altivec_stvx((vector int)__a, __b, __c);
10435 }
10436
10437 static __inline__ void __ATTRS_o_ai vec_stvx(vector pixel __a, int __b,
10438                                              unsigned short *__c) {
10439   __builtin_altivec_stvx((vector int)__a, __b, __c);
10440 }
10441
10442 static __inline__ void __ATTRS_o_ai vec_stvx(vector pixel __a, int __b,
10443                                              vector pixel *__c) {
10444   __builtin_altivec_stvx((vector int)__a, __b, __c);
10445 }
10446
10447 static __inline__ void __ATTRS_o_ai vec_stvx(vector int __a, int __b,
10448                                              vector int *__c) {
10449   __builtin_altivec_stvx(__a, __b, __c);
10450 }
10451
10452 static __inline__ void __ATTRS_o_ai vec_stvx(vector int __a, int __b,
10453                                              int *__c) {
10454   __builtin_altivec_stvx(__a, __b, __c);
10455 }
10456
10457 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned int __a, int __b,
10458                                              vector unsigned int *__c) {
10459   __builtin_altivec_stvx((vector int)__a, __b, __c);
10460 }
10461
10462 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned int __a, int __b,
10463                                              unsigned int *__c) {
10464   __builtin_altivec_stvx((vector int)__a, __b, __c);
10465 }
10466
10467 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool int __a, int __b,
10468                                              int *__c) {
10469   __builtin_altivec_stvx((vector int)__a, __b, __c);
10470 }
10471
10472 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool int __a, int __b,
10473                                              unsigned int *__c) {
10474   __builtin_altivec_stvx((vector int)__a, __b, __c);
10475 }
10476
10477 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool int __a, int __b,
10478                                              vector bool int *__c) {
10479   __builtin_altivec_stvx((vector int)__a, __b, __c);
10480 }
10481
10482 static __inline__ void __ATTRS_o_ai vec_stvx(vector float __a, int __b,
10483                                              vector float *__c) {
10484   __builtin_altivec_stvx((vector int)__a, __b, __c);
10485 }
10486
10487 static __inline__ void __ATTRS_o_ai vec_stvx(vector float __a, int __b,
10488                                              float *__c) {
10489   __builtin_altivec_stvx((vector int)__a, __b, __c);
10490 }
10491
10492 /* vec_ste */
10493
10494 static __inline__ void __ATTRS_o_ai vec_ste(vector signed char __a, int __b,
10495                                             signed char *__c) {
10496   __builtin_altivec_stvebx((vector char)__a, __b, __c);
10497 }
10498
10499 static __inline__ void __ATTRS_o_ai vec_ste(vector unsigned char __a, int __b,
10500                                             unsigned char *__c) {
10501   __builtin_altivec_stvebx((vector char)__a, __b, __c);
10502 }
10503
10504 static __inline__ void __ATTRS_o_ai vec_ste(vector bool char __a, int __b,
10505                                             signed char *__c) {
10506   __builtin_altivec_stvebx((vector char)__a, __b, __c);
10507 }
10508
10509 static __inline__ void __ATTRS_o_ai vec_ste(vector bool char __a, int __b,
10510                                             unsigned char *__c) {
10511   __builtin_altivec_stvebx((vector char)__a, __b, __c);
10512 }
10513
10514 static __inline__ void __ATTRS_o_ai vec_ste(vector short __a, int __b,
10515                                             short *__c) {
10516   __builtin_altivec_stvehx(__a, __b, __c);
10517 }
10518
10519 static __inline__ void __ATTRS_o_ai vec_ste(vector unsigned short __a, int __b,
10520                                             unsigned short *__c) {
10521   __builtin_altivec_stvehx((vector short)__a, __b, __c);
10522 }
10523
10524 static __inline__ void __ATTRS_o_ai vec_ste(vector bool short __a, int __b,
10525                                             short *__c) {
10526   __builtin_altivec_stvehx((vector short)__a, __b, __c);
10527 }
10528
10529 static __inline__ void __ATTRS_o_ai vec_ste(vector bool short __a, int __b,
10530                                             unsigned short *__c) {
10531   __builtin_altivec_stvehx((vector short)__a, __b, __c);
10532 }
10533
10534 static __inline__ void __ATTRS_o_ai vec_ste(vector pixel __a, int __b,
10535                                             short *__c) {
10536   __builtin_altivec_stvehx((vector short)__a, __b, __c);
10537 }
10538
10539 static __inline__ void __ATTRS_o_ai vec_ste(vector pixel __a, int __b,
10540                                             unsigned short *__c) {
10541   __builtin_altivec_stvehx((vector short)__a, __b, __c);
10542 }
10543
10544 static __inline__ void __ATTRS_o_ai vec_ste(vector int __a, int __b, int *__c) {
10545   __builtin_altivec_stvewx(__a, __b, __c);
10546 }
10547
10548 static __inline__ void __ATTRS_o_ai vec_ste(vector unsigned int __a, int __b,
10549                                             unsigned int *__c) {
10550   __builtin_altivec_stvewx((vector int)__a, __b, __c);
10551 }
10552
10553 static __inline__ void __ATTRS_o_ai vec_ste(vector bool int __a, int __b,
10554                                             int *__c) {
10555   __builtin_altivec_stvewx((vector int)__a, __b, __c);
10556 }
10557
10558 static __inline__ void __ATTRS_o_ai vec_ste(vector bool int __a, int __b,
10559                                             unsigned int *__c) {
10560   __builtin_altivec_stvewx((vector int)__a, __b, __c);
10561 }
10562
10563 static __inline__ void __ATTRS_o_ai vec_ste(vector float __a, int __b,
10564                                             float *__c) {
10565   __builtin_altivec_stvewx((vector int)__a, __b, __c);
10566 }
10567
10568 /* vec_stvebx */
10569
10570 static __inline__ void __ATTRS_o_ai vec_stvebx(vector signed char __a, int __b,
10571                                                signed char *__c) {
10572   __builtin_altivec_stvebx((vector char)__a, __b, __c);
10573 }
10574
10575 static __inline__ void __ATTRS_o_ai vec_stvebx(vector unsigned char __a,
10576                                                int __b, unsigned char *__c) {
10577   __builtin_altivec_stvebx((vector char)__a, __b, __c);
10578 }
10579
10580 static __inline__ void __ATTRS_o_ai vec_stvebx(vector bool char __a, int __b,
10581                                                signed char *__c) {
10582   __builtin_altivec_stvebx((vector char)__a, __b, __c);
10583 }
10584
10585 static __inline__ void __ATTRS_o_ai vec_stvebx(vector bool char __a, int __b,
10586                                                unsigned char *__c) {
10587   __builtin_altivec_stvebx((vector char)__a, __b, __c);
10588 }
10589
10590 /* vec_stvehx */
10591
10592 static __inline__ void __ATTRS_o_ai vec_stvehx(vector short __a, int __b,
10593                                                short *__c) {
10594   __builtin_altivec_stvehx(__a, __b, __c);
10595 }
10596
10597 static __inline__ void __ATTRS_o_ai vec_stvehx(vector unsigned short __a,
10598                                                int __b, unsigned short *__c) {
10599   __builtin_altivec_stvehx((vector short)__a, __b, __c);
10600 }
10601
10602 static __inline__ void __ATTRS_o_ai vec_stvehx(vector bool short __a, int __b,
10603                                                short *__c) {
10604   __builtin_altivec_stvehx((vector short)__a, __b, __c);
10605 }
10606
10607 static __inline__ void __ATTRS_o_ai vec_stvehx(vector bool short __a, int __b,
10608                                                unsigned short *__c) {
10609   __builtin_altivec_stvehx((vector short)__a, __b, __c);
10610 }
10611
10612 static __inline__ void __ATTRS_o_ai vec_stvehx(vector pixel __a, int __b,
10613                                                short *__c) {
10614   __builtin_altivec_stvehx((vector short)__a, __b, __c);
10615 }
10616
10617 static __inline__ void __ATTRS_o_ai vec_stvehx(vector pixel __a, int __b,
10618                                                unsigned short *__c) {
10619   __builtin_altivec_stvehx((vector short)__a, __b, __c);
10620 }
10621
10622 /* vec_stvewx */
10623
10624 static __inline__ void __ATTRS_o_ai vec_stvewx(vector int __a, int __b,
10625                                                int *__c) {
10626   __builtin_altivec_stvewx(__a, __b, __c);
10627 }
10628
10629 static __inline__ void __ATTRS_o_ai vec_stvewx(vector unsigned int __a, int __b,
10630                                                unsigned int *__c) {
10631   __builtin_altivec_stvewx((vector int)__a, __b, __c);
10632 }
10633
10634 static __inline__ void __ATTRS_o_ai vec_stvewx(vector bool int __a, int __b,
10635                                                int *__c) {
10636   __builtin_altivec_stvewx((vector int)__a, __b, __c);
10637 }
10638
10639 static __inline__ void __ATTRS_o_ai vec_stvewx(vector bool int __a, int __b,
10640                                                unsigned int *__c) {
10641   __builtin_altivec_stvewx((vector int)__a, __b, __c);
10642 }
10643
10644 static __inline__ void __ATTRS_o_ai vec_stvewx(vector float __a, int __b,
10645                                                float *__c) {
10646   __builtin_altivec_stvewx((vector int)__a, __b, __c);
10647 }
10648
10649 /* vec_stl */
10650
10651 static __inline__ void __ATTRS_o_ai vec_stl(vector signed char __a, int __b,
10652                                             vector signed char *__c) {
10653   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10654 }
10655
10656 static __inline__ void __ATTRS_o_ai vec_stl(vector signed char __a, int __b,
10657                                             signed char *__c) {
10658   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10659 }
10660
10661 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned char __a, int __b,
10662                                             vector unsigned char *__c) {
10663   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10664 }
10665
10666 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned char __a, int __b,
10667                                             unsigned char *__c) {
10668   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10669 }
10670
10671 static __inline__ void __ATTRS_o_ai vec_stl(vector bool char __a, int __b,
10672                                             signed char *__c) {
10673   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10674 }
10675
10676 static __inline__ void __ATTRS_o_ai vec_stl(vector bool char __a, int __b,
10677                                             unsigned char *__c) {
10678   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10679 }
10680
10681 static __inline__ void __ATTRS_o_ai vec_stl(vector bool char __a, int __b,
10682                                             vector bool char *__c) {
10683   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10684 }
10685
10686 static __inline__ void __ATTRS_o_ai vec_stl(vector short __a, int __b,
10687                                             vector short *__c) {
10688   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10689 }
10690
10691 static __inline__ void __ATTRS_o_ai vec_stl(vector short __a, int __b,
10692                                             short *__c) {
10693   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10694 }
10695
10696 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned short __a, int __b,
10697                                             vector unsigned short *__c) {
10698   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10699 }
10700
10701 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned short __a, int __b,
10702                                             unsigned short *__c) {
10703   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10704 }
10705
10706 static __inline__ void __ATTRS_o_ai vec_stl(vector bool short __a, int __b,
10707                                             short *__c) {
10708   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10709 }
10710
10711 static __inline__ void __ATTRS_o_ai vec_stl(vector bool short __a, int __b,
10712                                             unsigned short *__c) {
10713   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10714 }
10715
10716 static __inline__ void __ATTRS_o_ai vec_stl(vector bool short __a, int __b,
10717                                             vector bool short *__c) {
10718   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10719 }
10720
10721 static __inline__ void __ATTRS_o_ai vec_stl(vector pixel __a, int __b,
10722                                             short *__c) {
10723   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10724 }
10725
10726 static __inline__ void __ATTRS_o_ai vec_stl(vector pixel __a, int __b,
10727                                             unsigned short *__c) {
10728   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10729 }
10730
10731 static __inline__ void __ATTRS_o_ai vec_stl(vector pixel __a, int __b,
10732                                             vector pixel *__c) {
10733   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10734 }
10735
10736 static __inline__ void __ATTRS_o_ai vec_stl(vector int __a, int __b,
10737                                             vector int *__c) {
10738   __builtin_altivec_stvxl(__a, __b, __c);
10739 }
10740
10741 static __inline__ void __ATTRS_o_ai vec_stl(vector int __a, int __b, int *__c) {
10742   __builtin_altivec_stvxl(__a, __b, __c);
10743 }
10744
10745 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned int __a, int __b,
10746                                             vector unsigned int *__c) {
10747   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10748 }
10749
10750 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned int __a, int __b,
10751                                             unsigned int *__c) {
10752   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10753 }
10754
10755 static __inline__ void __ATTRS_o_ai vec_stl(vector bool int __a, int __b,
10756                                             int *__c) {
10757   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10758 }
10759
10760 static __inline__ void __ATTRS_o_ai vec_stl(vector bool int __a, int __b,
10761                                             unsigned int *__c) {
10762   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10763 }
10764
10765 static __inline__ void __ATTRS_o_ai vec_stl(vector bool int __a, int __b,
10766                                             vector bool int *__c) {
10767   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10768 }
10769
10770 static __inline__ void __ATTRS_o_ai vec_stl(vector float __a, int __b,
10771                                             vector float *__c) {
10772   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10773 }
10774
10775 static __inline__ void __ATTRS_o_ai vec_stl(vector float __a, int __b,
10776                                             float *__c) {
10777   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10778 }
10779
10780 /* vec_stvxl */
10781
10782 static __inline__ void __ATTRS_o_ai vec_stvxl(vector signed char __a, int __b,
10783                                               vector signed char *__c) {
10784   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10785 }
10786
10787 static __inline__ void __ATTRS_o_ai vec_stvxl(vector signed char __a, int __b,
10788                                               signed char *__c) {
10789   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10790 }
10791
10792 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned char __a, int __b,
10793                                               vector unsigned char *__c) {
10794   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10795 }
10796
10797 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned char __a, int __b,
10798                                               unsigned char *__c) {
10799   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10800 }
10801
10802 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool char __a, int __b,
10803                                               signed char *__c) {
10804   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10805 }
10806
10807 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool char __a, int __b,
10808                                               unsigned char *__c) {
10809   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10810 }
10811
10812 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool char __a, int __b,
10813                                               vector bool char *__c) {
10814   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10815 }
10816
10817 static __inline__ void __ATTRS_o_ai vec_stvxl(vector short __a, int __b,
10818                                               vector short *__c) {
10819   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10820 }
10821
10822 static __inline__ void __ATTRS_o_ai vec_stvxl(vector short __a, int __b,
10823                                               short *__c) {
10824   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10825 }
10826
10827 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned short __a,
10828                                               int __b,
10829                                               vector unsigned short *__c) {
10830   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10831 }
10832
10833 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned short __a,
10834                                               int __b, unsigned short *__c) {
10835   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10836 }
10837
10838 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool short __a, int __b,
10839                                               short *__c) {
10840   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10841 }
10842
10843 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool short __a, int __b,
10844                                               unsigned short *__c) {
10845   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10846 }
10847
10848 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool short __a, int __b,
10849                                               vector bool short *__c) {
10850   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10851 }
10852
10853 static __inline__ void __ATTRS_o_ai vec_stvxl(vector pixel __a, int __b,
10854                                               short *__c) {
10855   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10856 }
10857
10858 static __inline__ void __ATTRS_o_ai vec_stvxl(vector pixel __a, int __b,
10859                                               unsigned short *__c) {
10860   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10861 }
10862
10863 static __inline__ void __ATTRS_o_ai vec_stvxl(vector pixel __a, int __b,
10864                                               vector pixel *__c) {
10865   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10866 }
10867
10868 static __inline__ void __ATTRS_o_ai vec_stvxl(vector int __a, int __b,
10869                                               vector int *__c) {
10870   __builtin_altivec_stvxl(__a, __b, __c);
10871 }
10872
10873 static __inline__ void __ATTRS_o_ai vec_stvxl(vector int __a, int __b,
10874                                               int *__c) {
10875   __builtin_altivec_stvxl(__a, __b, __c);
10876 }
10877
10878 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned int __a, int __b,
10879                                               vector unsigned int *__c) {
10880   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10881 }
10882
10883 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned int __a, int __b,
10884                                               unsigned int *__c) {
10885   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10886 }
10887
10888 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool int __a, int __b,
10889                                               int *__c) {
10890   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10891 }
10892
10893 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool int __a, int __b,
10894                                               unsigned int *__c) {
10895   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10896 }
10897
10898 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool int __a, int __b,
10899                                               vector bool int *__c) {
10900   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10901 }
10902
10903 static __inline__ void __ATTRS_o_ai vec_stvxl(vector float __a, int __b,
10904                                               vector float *__c) {
10905   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10906 }
10907
10908 static __inline__ void __ATTRS_o_ai vec_stvxl(vector float __a, int __b,
10909                                               float *__c) {
10910   __builtin_altivec_stvxl((vector int)__a, __b, __c);
10911 }
10912
10913 /* vec_sub */
10914
10915 static __inline__ vector signed char __ATTRS_o_ai
10916 vec_sub(vector signed char __a, vector signed char __b) {
10917   return __a - __b;
10918 }
10919
10920 static __inline__ vector signed char __ATTRS_o_ai
10921 vec_sub(vector bool char __a, vector signed char __b) {
10922   return (vector signed char)__a - __b;
10923 }
10924
10925 static __inline__ vector signed char __ATTRS_o_ai
10926 vec_sub(vector signed char __a, vector bool char __b) {
10927   return __a - (vector signed char)__b;
10928 }
10929
10930 static __inline__ vector unsigned char __ATTRS_o_ai
10931 vec_sub(vector unsigned char __a, vector unsigned char __b) {
10932   return __a - __b;
10933 }
10934
10935 static __inline__ vector unsigned char __ATTRS_o_ai
10936 vec_sub(vector bool char __a, vector unsigned char __b) {
10937   return (vector unsigned char)__a - __b;
10938 }
10939
10940 static __inline__ vector unsigned char __ATTRS_o_ai
10941 vec_sub(vector unsigned char __a, vector bool char __b) {
10942   return __a - (vector unsigned char)__b;
10943 }
10944
10945 static __inline__ vector short __ATTRS_o_ai vec_sub(vector short __a,
10946                                                     vector short __b) {
10947   return __a - __b;
10948 }
10949
10950 static __inline__ vector short __ATTRS_o_ai vec_sub(vector bool short __a,
10951                                                     vector short __b) {
10952   return (vector short)__a - __b;
10953 }
10954
10955 static __inline__ vector short __ATTRS_o_ai vec_sub(vector short __a,
10956                                                     vector bool short __b) {
10957   return __a - (vector short)__b;
10958 }
10959
10960 static __inline__ vector unsigned short __ATTRS_o_ai
10961 vec_sub(vector unsigned short __a, vector unsigned short __b) {
10962   return __a - __b;
10963 }
10964
10965 static __inline__ vector unsigned short __ATTRS_o_ai
10966 vec_sub(vector bool short __a, vector unsigned short __b) {
10967   return (vector unsigned short)__a - __b;
10968 }
10969
10970 static __inline__ vector unsigned short __ATTRS_o_ai
10971 vec_sub(vector unsigned short __a, vector bool short __b) {
10972   return __a - (vector unsigned short)__b;
10973 }
10974
10975 static __inline__ vector int __ATTRS_o_ai vec_sub(vector int __a,
10976                                                   vector int __b) {
10977   return __a - __b;
10978 }
10979
10980 static __inline__ vector int __ATTRS_o_ai vec_sub(vector bool int __a,
10981                                                   vector int __b) {
10982   return (vector int)__a - __b;
10983 }
10984
10985 static __inline__ vector int __ATTRS_o_ai vec_sub(vector int __a,
10986                                                   vector bool int __b) {
10987   return __a - (vector int)__b;
10988 }
10989
10990 static __inline__ vector unsigned int __ATTRS_o_ai
10991 vec_sub(vector unsigned int __a, vector unsigned int __b) {
10992   return __a - __b;
10993 }
10994
10995 static __inline__ vector unsigned int __ATTRS_o_ai
10996 vec_sub(vector bool int __a, vector unsigned int __b) {
10997   return (vector unsigned int)__a - __b;
10998 }
10999
11000 static __inline__ vector unsigned int __ATTRS_o_ai
11001 vec_sub(vector unsigned int __a, vector bool int __b) {
11002   return __a - (vector unsigned int)__b;
11003 }
11004
11005 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
11006 static __inline__ vector signed __int128 __ATTRS_o_ai
11007 vec_sub(vector signed __int128 __a, vector signed __int128 __b) {
11008   return __a - __b;
11009 }
11010
11011 static __inline__ vector unsigned __int128 __ATTRS_o_ai
11012 vec_sub(vector unsigned __int128 __a, vector unsigned __int128 __b) {
11013   return __a - __b;
11014 }
11015 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
11016
11017 #ifdef __VSX__
11018 static __inline__ vector signed long long __ATTRS_o_ai
11019 vec_sub(vector signed long long __a, vector signed long long __b) {
11020   return __a - __b;
11021 }
11022
11023 static __inline__ vector unsigned long long __ATTRS_o_ai
11024 vec_sub(vector unsigned long long __a, vector unsigned long long __b) {
11025   return __a - __b;
11026 }
11027
11028 static __inline__ vector double __ATTRS_o_ai vec_sub(vector double __a,
11029                                                      vector double __b) {
11030   return __a - __b;
11031 }
11032 #endif
11033
11034 static __inline__ vector float __ATTRS_o_ai vec_sub(vector float __a,
11035                                                     vector float __b) {
11036   return __a - __b;
11037 }
11038
11039 /* vec_vsububm */
11040
11041 #define __builtin_altivec_vsububm vec_vsububm
11042
11043 static __inline__ vector signed char __ATTRS_o_ai
11044 vec_vsububm(vector signed char __a, vector signed char __b) {
11045   return __a - __b;
11046 }
11047
11048 static __inline__ vector signed char __ATTRS_o_ai
11049 vec_vsububm(vector bool char __a, vector signed char __b) {
11050   return (vector signed char)__a - __b;
11051 }
11052
11053 static __inline__ vector signed char __ATTRS_o_ai
11054 vec_vsububm(vector signed char __a, vector bool char __b) {
11055   return __a - (vector signed char)__b;
11056 }
11057
11058 static __inline__ vector unsigned char __ATTRS_o_ai
11059 vec_vsububm(vector unsigned char __a, vector unsigned char __b) {
11060   return __a - __b;
11061 }
11062
11063 static __inline__ vector unsigned char __ATTRS_o_ai
11064 vec_vsububm(vector bool char __a, vector unsigned char __b) {
11065   return (vector unsigned char)__a - __b;
11066 }
11067
11068 static __inline__ vector unsigned char __ATTRS_o_ai
11069 vec_vsububm(vector unsigned char __a, vector bool char __b) {
11070   return __a - (vector unsigned char)__b;
11071 }
11072
11073 /* vec_vsubuhm */
11074
11075 #define __builtin_altivec_vsubuhm vec_vsubuhm
11076
11077 static __inline__ vector short __ATTRS_o_ai vec_vsubuhm(vector short __a,
11078                                                         vector short __b) {
11079   return __a - __b;
11080 }
11081
11082 static __inline__ vector short __ATTRS_o_ai vec_vsubuhm(vector bool short __a,
11083                                                         vector short __b) {
11084   return (vector short)__a - __b;
11085 }
11086
11087 static __inline__ vector short __ATTRS_o_ai vec_vsubuhm(vector short __a,
11088                                                         vector bool short __b) {
11089   return __a - (vector short)__b;
11090 }
11091
11092 static __inline__ vector unsigned short __ATTRS_o_ai
11093 vec_vsubuhm(vector unsigned short __a, vector unsigned short __b) {
11094   return __a - __b;
11095 }
11096
11097 static __inline__ vector unsigned short __ATTRS_o_ai
11098 vec_vsubuhm(vector bool short __a, vector unsigned short __b) {
11099   return (vector unsigned short)__a - __b;
11100 }
11101
11102 static __inline__ vector unsigned short __ATTRS_o_ai
11103 vec_vsubuhm(vector unsigned short __a, vector bool short __b) {
11104   return __a - (vector unsigned short)__b;
11105 }
11106
11107 /* vec_vsubuwm */
11108
11109 #define __builtin_altivec_vsubuwm vec_vsubuwm
11110
11111 static __inline__ vector int __ATTRS_o_ai vec_vsubuwm(vector int __a,
11112                                                       vector int __b) {
11113   return __a - __b;
11114 }
11115
11116 static __inline__ vector int __ATTRS_o_ai vec_vsubuwm(vector bool int __a,
11117                                                       vector int __b) {
11118   return (vector int)__a - __b;
11119 }
11120
11121 static __inline__ vector int __ATTRS_o_ai vec_vsubuwm(vector int __a,
11122                                                       vector bool int __b) {
11123   return __a - (vector int)__b;
11124 }
11125
11126 static __inline__ vector unsigned int __ATTRS_o_ai
11127 vec_vsubuwm(vector unsigned int __a, vector unsigned int __b) {
11128   return __a - __b;
11129 }
11130
11131 static __inline__ vector unsigned int __ATTRS_o_ai
11132 vec_vsubuwm(vector bool int __a, vector unsigned int __b) {
11133   return (vector unsigned int)__a - __b;
11134 }
11135
11136 static __inline__ vector unsigned int __ATTRS_o_ai
11137 vec_vsubuwm(vector unsigned int __a, vector bool int __b) {
11138   return __a - (vector unsigned int)__b;
11139 }
11140
11141 /* vec_vsubfp */
11142
11143 #define __builtin_altivec_vsubfp vec_vsubfp
11144
11145 static __inline__ vector float __attribute__((__always_inline__))
11146 vec_vsubfp(vector float __a, vector float __b) {
11147   return __a - __b;
11148 }
11149
11150 /* vec_subc */
11151
11152 static __inline__ vector signed int __ATTRS_o_ai
11153 vec_subc(vector signed int __a, vector signed int __b) {
11154   return (vector signed int)__builtin_altivec_vsubcuw((vector unsigned int)__a,
11155                                                       (vector unsigned int) __b);
11156 }
11157
11158 static __inline__ vector unsigned int __ATTRS_o_ai
11159 vec_subc(vector unsigned int __a, vector unsigned int __b) {
11160   return __builtin_altivec_vsubcuw(__a, __b);
11161 }
11162
11163 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
11164 static __inline__ vector unsigned __int128 __ATTRS_o_ai
11165 vec_subc(vector unsigned __int128 __a, vector unsigned __int128 __b) {
11166   return __builtin_altivec_vsubcuq(__a, __b);
11167 }
11168
11169 static __inline__ vector signed __int128 __ATTRS_o_ai
11170 vec_subc(vector signed __int128 __a, vector signed __int128 __b) {
11171   return __builtin_altivec_vsubcuq(__a, __b);
11172 }
11173 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
11174
11175 /* vec_vsubcuw */
11176
11177 static __inline__ vector unsigned int __attribute__((__always_inline__))
11178 vec_vsubcuw(vector unsigned int __a, vector unsigned int __b) {
11179   return __builtin_altivec_vsubcuw(__a, __b);
11180 }
11181
11182 /* vec_subs */
11183
11184 static __inline__ vector signed char __ATTRS_o_ai
11185 vec_subs(vector signed char __a, vector signed char __b) {
11186   return __builtin_altivec_vsubsbs(__a, __b);
11187 }
11188
11189 static __inline__ vector signed char __ATTRS_o_ai
11190 vec_subs(vector bool char __a, vector signed char __b) {
11191   return __builtin_altivec_vsubsbs((vector signed char)__a, __b);
11192 }
11193
11194 static __inline__ vector signed char __ATTRS_o_ai
11195 vec_subs(vector signed char __a, vector bool char __b) {
11196   return __builtin_altivec_vsubsbs(__a, (vector signed char)__b);
11197 }
11198
11199 static __inline__ vector unsigned char __ATTRS_o_ai
11200 vec_subs(vector unsigned char __a, vector unsigned char __b) {
11201   return __builtin_altivec_vsububs(__a, __b);
11202 }
11203
11204 static __inline__ vector unsigned char __ATTRS_o_ai
11205 vec_subs(vector bool char __a, vector unsigned char __b) {
11206   return __builtin_altivec_vsububs((vector unsigned char)__a, __b);
11207 }
11208
11209 static __inline__ vector unsigned char __ATTRS_o_ai
11210 vec_subs(vector unsigned char __a, vector bool char __b) {
11211   return __builtin_altivec_vsububs(__a, (vector unsigned char)__b);
11212 }
11213
11214 static __inline__ vector short __ATTRS_o_ai vec_subs(vector short __a,
11215                                                      vector short __b) {
11216   return __builtin_altivec_vsubshs(__a, __b);
11217 }
11218
11219 static __inline__ vector short __ATTRS_o_ai vec_subs(vector bool short __a,
11220                                                      vector short __b) {
11221   return __builtin_altivec_vsubshs((vector short)__a, __b);
11222 }
11223
11224 static __inline__ vector short __ATTRS_o_ai vec_subs(vector short __a,
11225                                                      vector bool short __b) {
11226   return __builtin_altivec_vsubshs(__a, (vector short)__b);
11227 }
11228
11229 static __inline__ vector unsigned short __ATTRS_o_ai
11230 vec_subs(vector unsigned short __a, vector unsigned short __b) {
11231   return __builtin_altivec_vsubuhs(__a, __b);
11232 }
11233
11234 static __inline__ vector unsigned short __ATTRS_o_ai
11235 vec_subs(vector bool short __a, vector unsigned short __b) {
11236   return __builtin_altivec_vsubuhs((vector unsigned short)__a, __b);
11237 }
11238
11239 static __inline__ vector unsigned short __ATTRS_o_ai
11240 vec_subs(vector unsigned short __a, vector bool short __b) {
11241   return __builtin_altivec_vsubuhs(__a, (vector unsigned short)__b);
11242 }
11243
11244 static __inline__ vector int __ATTRS_o_ai vec_subs(vector int __a,
11245                                                    vector int __b) {
11246   return __builtin_altivec_vsubsws(__a, __b);
11247 }
11248
11249 static __inline__ vector int __ATTRS_o_ai vec_subs(vector bool int __a,
11250                                                    vector int __b) {
11251   return __builtin_altivec_vsubsws((vector int)__a, __b);
11252 }
11253
11254 static __inline__ vector int __ATTRS_o_ai vec_subs(vector int __a,
11255                                                    vector bool int __b) {
11256   return __builtin_altivec_vsubsws(__a, (vector int)__b);
11257 }
11258
11259 static __inline__ vector unsigned int __ATTRS_o_ai
11260 vec_subs(vector unsigned int __a, vector unsigned int __b) {
11261   return __builtin_altivec_vsubuws(__a, __b);
11262 }
11263
11264 static __inline__ vector unsigned int __ATTRS_o_ai
11265 vec_subs(vector bool int __a, vector unsigned int __b) {
11266   return __builtin_altivec_vsubuws((vector unsigned int)__a, __b);
11267 }
11268
11269 static __inline__ vector unsigned int __ATTRS_o_ai
11270 vec_subs(vector unsigned int __a, vector bool int __b) {
11271   return __builtin_altivec_vsubuws(__a, (vector unsigned int)__b);
11272 }
11273
11274 /* vec_vsubsbs */
11275
11276 static __inline__ vector signed char __ATTRS_o_ai
11277 vec_vsubsbs(vector signed char __a, vector signed char __b) {
11278   return __builtin_altivec_vsubsbs(__a, __b);
11279 }
11280
11281 static __inline__ vector signed char __ATTRS_o_ai
11282 vec_vsubsbs(vector bool char __a, vector signed char __b) {
11283   return __builtin_altivec_vsubsbs((vector signed char)__a, __b);
11284 }
11285
11286 static __inline__ vector signed char __ATTRS_o_ai
11287 vec_vsubsbs(vector signed char __a, vector bool char __b) {
11288   return __builtin_altivec_vsubsbs(__a, (vector signed char)__b);
11289 }
11290
11291 /* vec_vsububs */
11292
11293 static __inline__ vector unsigned char __ATTRS_o_ai
11294 vec_vsububs(vector unsigned char __a, vector unsigned char __b) {
11295   return __builtin_altivec_vsububs(__a, __b);
11296 }
11297
11298 static __inline__ vector unsigned char __ATTRS_o_ai
11299 vec_vsububs(vector bool char __a, vector unsigned char __b) {
11300   return __builtin_altivec_vsububs((vector unsigned char)__a, __b);
11301 }
11302
11303 static __inline__ vector unsigned char __ATTRS_o_ai
11304 vec_vsububs(vector unsigned char __a, vector bool char __b) {
11305   return __builtin_altivec_vsububs(__a, (vector unsigned char)__b);
11306 }
11307
11308 /* vec_vsubshs */
11309
11310 static __inline__ vector short __ATTRS_o_ai vec_vsubshs(vector short __a,
11311                                                         vector short __b) {
11312   return __builtin_altivec_vsubshs(__a, __b);
11313 }
11314
11315 static __inline__ vector short __ATTRS_o_ai vec_vsubshs(vector bool short __a,
11316                                                         vector short __b) {
11317   return __builtin_altivec_vsubshs((vector short)__a, __b);
11318 }
11319
11320 static __inline__ vector short __ATTRS_o_ai vec_vsubshs(vector short __a,
11321                                                         vector bool short __b) {
11322   return __builtin_altivec_vsubshs(__a, (vector short)__b);
11323 }
11324
11325 /* vec_vsubuhs */
11326
11327 static __inline__ vector unsigned short __ATTRS_o_ai
11328 vec_vsubuhs(vector unsigned short __a, vector unsigned short __b) {
11329   return __builtin_altivec_vsubuhs(__a, __b);
11330 }
11331
11332 static __inline__ vector unsigned short __ATTRS_o_ai
11333 vec_vsubuhs(vector bool short __a, vector unsigned short __b) {
11334   return __builtin_altivec_vsubuhs((vector unsigned short)__a, __b);
11335 }
11336
11337 static __inline__ vector unsigned short __ATTRS_o_ai
11338 vec_vsubuhs(vector unsigned short __a, vector bool short __b) {
11339   return __builtin_altivec_vsubuhs(__a, (vector unsigned short)__b);
11340 }
11341
11342 /* vec_vsubsws */
11343
11344 static __inline__ vector int __ATTRS_o_ai vec_vsubsws(vector int __a,
11345                                                       vector int __b) {
11346   return __builtin_altivec_vsubsws(__a, __b);
11347 }
11348
11349 static __inline__ vector int __ATTRS_o_ai vec_vsubsws(vector bool int __a,
11350                                                       vector int __b) {
11351   return __builtin_altivec_vsubsws((vector int)__a, __b);
11352 }
11353
11354 static __inline__ vector int __ATTRS_o_ai vec_vsubsws(vector int __a,
11355                                                       vector bool int __b) {
11356   return __builtin_altivec_vsubsws(__a, (vector int)__b);
11357 }
11358
11359 /* vec_vsubuws */
11360
11361 static __inline__ vector unsigned int __ATTRS_o_ai
11362 vec_vsubuws(vector unsigned int __a, vector unsigned int __b) {
11363   return __builtin_altivec_vsubuws(__a, __b);
11364 }
11365
11366 static __inline__ vector unsigned int __ATTRS_o_ai
11367 vec_vsubuws(vector bool int __a, vector unsigned int __b) {
11368   return __builtin_altivec_vsubuws((vector unsigned int)__a, __b);
11369 }
11370
11371 static __inline__ vector unsigned int __ATTRS_o_ai
11372 vec_vsubuws(vector unsigned int __a, vector bool int __b) {
11373   return __builtin_altivec_vsubuws(__a, (vector unsigned int)__b);
11374 }
11375
11376 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
11377 /* vec_vsubuqm */
11378
11379 static __inline__ vector signed __int128 __ATTRS_o_ai
11380 vec_vsubuqm(vector signed __int128 __a, vector signed __int128 __b) {
11381   return __a - __b;
11382 }
11383
11384 static __inline__ vector unsigned __int128 __ATTRS_o_ai
11385 vec_vsubuqm(vector unsigned __int128 __a, vector unsigned __int128 __b) {
11386   return __a - __b;
11387 }
11388
11389 /* vec_vsubeuqm */
11390
11391
11392 static __inline__ vector signed __int128 __ATTRS_o_ai
11393 vec_vsubeuqm(vector signed __int128 __a, vector signed __int128 __b,
11394              vector signed __int128 __c) {
11395   return __builtin_altivec_vsubeuqm(__a, __b, __c);
11396 }
11397
11398 static __inline__ vector unsigned __int128 __ATTRS_o_ai
11399 vec_vsubeuqm(vector unsigned __int128 __a, vector unsigned __int128 __b,
11400              vector unsigned __int128 __c) {
11401   return __builtin_altivec_vsubeuqm(__a, __b, __c);
11402 }
11403
11404 static __inline__ vector signed __int128 __ATTRS_o_ai
11405 vec_sube(vector signed __int128 __a, vector signed __int128 __b,
11406              vector signed __int128 __c) {
11407   return __builtin_altivec_vsubeuqm(__a, __b, __c);
11408 }
11409
11410 static __inline__ vector unsigned __int128 __ATTRS_o_ai
11411 vec_sube(vector unsigned __int128 __a, vector unsigned __int128 __b,
11412              vector unsigned __int128 __c) {
11413   return __builtin_altivec_vsubeuqm(__a, __b, __c);
11414 }
11415
11416 /* vec_vsubcuq */
11417
11418 static __inline__ vector signed __int128 __ATTRS_o_ai
11419 vec_vsubcuq(vector signed __int128 __a, vector signed __int128 __b) {
11420   return __builtin_altivec_vsubcuq(__a, __b);
11421 }
11422
11423 static __inline__ vector unsigned __int128 __ATTRS_o_ai
11424 vec_vsubcuq(vector unsigned __int128 __a, vector unsigned __int128 __b) {
11425   return __builtin_altivec_vsubcuq(__a, __b);
11426 }
11427
11428 /* vec_vsubecuq */
11429
11430 static __inline__ vector signed __int128 __ATTRS_o_ai
11431 vec_vsubecuq(vector signed __int128 __a, vector signed __int128 __b,
11432              vector signed __int128 __c) {
11433   return __builtin_altivec_vsubecuq(__a, __b, __c);
11434 }
11435
11436 static __inline__ vector unsigned __int128 __ATTRS_o_ai
11437 vec_vsubecuq(vector unsigned __int128 __a, vector unsigned __int128 __b,
11438              vector unsigned __int128 __c) {
11439   return __builtin_altivec_vsubecuq(__a, __b, __c);
11440 }
11441
11442 static __inline__ vector signed int __ATTRS_o_ai
11443 vec_subec(vector signed int __a, vector signed int __b,
11444              vector signed int __c) {
11445   return vec_addec(__a, ~__b, __c);
11446 }
11447
11448 static __inline__ vector unsigned int __ATTRS_o_ai
11449 vec_subec(vector unsigned int __a, vector unsigned int __b,
11450              vector unsigned int __c) {
11451   return vec_addec(__a, ~__b, __c);
11452 }
11453
11454 static __inline__ vector signed __int128 __ATTRS_o_ai
11455 vec_subec(vector signed __int128 __a, vector signed __int128 __b,
11456              vector signed __int128 __c) {
11457   return __builtin_altivec_vsubecuq(__a, __b, __c);
11458 }
11459
11460 static __inline__ vector unsigned __int128 __ATTRS_o_ai
11461 vec_subec(vector unsigned __int128 __a, vector unsigned __int128 __b,
11462              vector unsigned __int128 __c) {
11463   return __builtin_altivec_vsubecuq(__a, __b, __c);
11464 }
11465 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
11466
11467 static __inline__ vector signed int __ATTRS_o_ai
11468 vec_sube(vector signed int __a, vector signed int __b,
11469          vector signed int __c) {
11470   vector signed int __mask = {1, 1, 1, 1};
11471   vector signed int __carry = __c & __mask;
11472   return vec_adde(__a, ~__b, __carry);
11473 }
11474
11475 static __inline__ vector unsigned int __ATTRS_o_ai
11476 vec_sube(vector unsigned int __a, vector unsigned int __b,
11477          vector unsigned int __c) {
11478   vector unsigned int __mask = {1, 1, 1, 1};
11479   vector unsigned int __carry = __c & __mask;
11480   return vec_adde(__a, ~__b, __carry);
11481 }
11482 /* vec_sum4s */
11483
11484 static __inline__ vector int __ATTRS_o_ai vec_sum4s(vector signed char __a,
11485                                                     vector int __b) {
11486   return __builtin_altivec_vsum4sbs(__a, __b);
11487 }
11488
11489 static __inline__ vector unsigned int __ATTRS_o_ai
11490 vec_sum4s(vector unsigned char __a, vector unsigned int __b) {
11491   return __builtin_altivec_vsum4ubs(__a, __b);
11492 }
11493
11494 static __inline__ vector int __ATTRS_o_ai vec_sum4s(vector signed short __a,
11495                                                     vector int __b) {
11496   return __builtin_altivec_vsum4shs(__a, __b);
11497 }
11498
11499 /* vec_vsum4sbs */
11500
11501 static __inline__ vector int __attribute__((__always_inline__))
11502 vec_vsum4sbs(vector signed char __a, vector int __b) {
11503   return __builtin_altivec_vsum4sbs(__a, __b);
11504 }
11505
11506 /* vec_vsum4ubs */
11507
11508 static __inline__ vector unsigned int __attribute__((__always_inline__))
11509 vec_vsum4ubs(vector unsigned char __a, vector unsigned int __b) {
11510   return __builtin_altivec_vsum4ubs(__a, __b);
11511 }
11512
11513 /* vec_vsum4shs */
11514
11515 static __inline__ vector int __attribute__((__always_inline__))
11516 vec_vsum4shs(vector signed short __a, vector int __b) {
11517   return __builtin_altivec_vsum4shs(__a, __b);
11518 }
11519
11520 /* vec_sum2s */
11521
11522 /* The vsum2sws instruction has a big-endian bias, so that the second
11523    input vector and the result always reference big-endian elements
11524    1 and 3 (little-endian element 0 and 2).  For ease of porting the
11525    programmer wants elements 1 and 3 in both cases, so for little
11526    endian we must perform some permutes.  */
11527
11528 static __inline__ vector signed int __attribute__((__always_inline__))
11529 vec_sum2s(vector int __a, vector int __b) {
11530 #ifdef __LITTLE_ENDIAN__
11531   vector int __c = (vector signed int)vec_perm(
11532       __b, __b, (vector unsigned char)(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15,
11533                                        8, 9, 10, 11));
11534   __c = __builtin_altivec_vsum2sws(__a, __c);
11535   return (vector signed int)vec_perm(
11536       __c, __c, (vector unsigned char)(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15,
11537                                        8, 9, 10, 11));
11538 #else
11539   return __builtin_altivec_vsum2sws(__a, __b);
11540 #endif
11541 }
11542
11543 /* vec_vsum2sws */
11544
11545 static __inline__ vector signed int __attribute__((__always_inline__))
11546 vec_vsum2sws(vector int __a, vector int __b) {
11547 #ifdef __LITTLE_ENDIAN__
11548   vector int __c = (vector signed int)vec_perm(
11549       __b, __b, (vector unsigned char)(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15,
11550                                        8, 9, 10, 11));
11551   __c = __builtin_altivec_vsum2sws(__a, __c);
11552   return (vector signed int)vec_perm(
11553       __c, __c, (vector unsigned char)(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15,
11554                                        8, 9, 10, 11));
11555 #else
11556   return __builtin_altivec_vsum2sws(__a, __b);
11557 #endif
11558 }
11559
11560 /* vec_sums */
11561
11562 /* The vsumsws instruction has a big-endian bias, so that the second
11563    input vector and the result always reference big-endian element 3
11564    (little-endian element 0).  For ease of porting the programmer
11565    wants element 3 in both cases, so for little endian we must perform
11566    some permutes.  */
11567
11568 static __inline__ vector signed int __attribute__((__always_inline__))
11569 vec_sums(vector signed int __a, vector signed int __b) {
11570 #ifdef __LITTLE_ENDIAN__
11571   __b = (vector signed int)vec_splat(__b, 3);
11572   __b = __builtin_altivec_vsumsws(__a, __b);
11573   return (vector signed int)(0, 0, 0, __b[0]);
11574 #else
11575   return __builtin_altivec_vsumsws(__a, __b);
11576 #endif
11577 }
11578
11579 /* vec_vsumsws */
11580
11581 static __inline__ vector signed int __attribute__((__always_inline__))
11582 vec_vsumsws(vector signed int __a, vector signed int __b) {
11583 #ifdef __LITTLE_ENDIAN__
11584   __b = (vector signed int)vec_splat(__b, 3);
11585   __b = __builtin_altivec_vsumsws(__a, __b);
11586   return (vector signed int)(0, 0, 0, __b[0]);
11587 #else
11588   return __builtin_altivec_vsumsws(__a, __b);
11589 #endif
11590 }
11591
11592 /* vec_trunc */
11593
11594 static __inline__ vector float __ATTRS_o_ai vec_trunc(vector float __a) {
11595 #ifdef __VSX__
11596   return __builtin_vsx_xvrspiz(__a);
11597 #else
11598   return __builtin_altivec_vrfiz(__a);
11599 #endif
11600 }
11601
11602 #ifdef __VSX__
11603 static __inline__ vector double __ATTRS_o_ai vec_trunc(vector double __a) {
11604   return __builtin_vsx_xvrdpiz(__a);
11605 }
11606 #endif
11607
11608 /* vec_vrfiz */
11609
11610 static __inline__ vector float __attribute__((__always_inline__))
11611 vec_vrfiz(vector float __a) {
11612   return __builtin_altivec_vrfiz(__a);
11613 }
11614
11615 /* vec_unpackh */
11616
11617 /* The vector unpack instructions all have a big-endian bias, so for
11618    little endian we must reverse the meanings of "high" and "low."  */
11619
11620 static __inline__ vector short __ATTRS_o_ai
11621 vec_unpackh(vector signed char __a) {
11622 #ifdef __LITTLE_ENDIAN__
11623   return __builtin_altivec_vupklsb((vector char)__a);
11624 #else
11625   return __builtin_altivec_vupkhsb((vector char)__a);
11626 #endif
11627 }
11628
11629 static __inline__ vector bool short __ATTRS_o_ai
11630 vec_unpackh(vector bool char __a) {
11631 #ifdef __LITTLE_ENDIAN__
11632   return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
11633 #else
11634   return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
11635 #endif
11636 }
11637
11638 static __inline__ vector int __ATTRS_o_ai vec_unpackh(vector short __a) {
11639 #ifdef __LITTLE_ENDIAN__
11640   return __builtin_altivec_vupklsh(__a);
11641 #else
11642   return __builtin_altivec_vupkhsh(__a);
11643 #endif
11644 }
11645
11646 static __inline__ vector bool int __ATTRS_o_ai
11647 vec_unpackh(vector bool short __a) {
11648 #ifdef __LITTLE_ENDIAN__
11649   return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
11650 #else
11651   return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
11652 #endif
11653 }
11654
11655 static __inline__ vector unsigned int __ATTRS_o_ai
11656 vec_unpackh(vector pixel __a) {
11657 #ifdef __LITTLE_ENDIAN__
11658   return (vector unsigned int)__builtin_altivec_vupklpx((vector short)__a);
11659 #else
11660   return (vector unsigned int)__builtin_altivec_vupkhpx((vector short)__a);
11661 #endif
11662 }
11663
11664 #ifdef __POWER8_VECTOR__
11665 static __inline__ vector long long __ATTRS_o_ai vec_unpackh(vector int __a) {
11666 #ifdef __LITTLE_ENDIAN__
11667   return __builtin_altivec_vupklsw(__a);
11668 #else
11669   return __builtin_altivec_vupkhsw(__a);
11670 #endif
11671 }
11672
11673 static __inline__ vector bool long long __ATTRS_o_ai
11674 vec_unpackh(vector bool int __a) {
11675 #ifdef __LITTLE_ENDIAN__
11676   return (vector bool long long)__builtin_altivec_vupklsw((vector int)__a);
11677 #else
11678   return (vector bool long long)__builtin_altivec_vupkhsw((vector int)__a);
11679 #endif
11680 }
11681
11682 static __inline__ vector double __ATTRS_o_ai
11683 vec_unpackh(vector float __a) {
11684   return (vector double)(__a[0], __a[1]);
11685 }
11686 #endif
11687
11688 /* vec_vupkhsb */
11689
11690 static __inline__ vector short __ATTRS_o_ai
11691 vec_vupkhsb(vector signed char __a) {
11692 #ifdef __LITTLE_ENDIAN__
11693   return __builtin_altivec_vupklsb((vector char)__a);
11694 #else
11695   return __builtin_altivec_vupkhsb((vector char)__a);
11696 #endif
11697 }
11698
11699 static __inline__ vector bool short __ATTRS_o_ai
11700 vec_vupkhsb(vector bool char __a) {
11701 #ifdef __LITTLE_ENDIAN__
11702   return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
11703 #else
11704   return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
11705 #endif
11706 }
11707
11708 /* vec_vupkhsh */
11709
11710 static __inline__ vector int __ATTRS_o_ai vec_vupkhsh(vector short __a) {
11711 #ifdef __LITTLE_ENDIAN__
11712   return __builtin_altivec_vupklsh(__a);
11713 #else
11714   return __builtin_altivec_vupkhsh(__a);
11715 #endif
11716 }
11717
11718 static __inline__ vector bool int __ATTRS_o_ai
11719 vec_vupkhsh(vector bool short __a) {
11720 #ifdef __LITTLE_ENDIAN__
11721   return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
11722 #else
11723   return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
11724 #endif
11725 }
11726
11727 static __inline__ vector unsigned int __ATTRS_o_ai
11728 vec_vupkhsh(vector pixel __a) {
11729 #ifdef __LITTLE_ENDIAN__
11730   return (vector unsigned int)__builtin_altivec_vupklpx((vector short)__a);
11731 #else
11732   return (vector unsigned int)__builtin_altivec_vupkhpx((vector short)__a);
11733 #endif
11734 }
11735
11736 /* vec_vupkhsw */
11737
11738 #ifdef __POWER8_VECTOR__
11739 static __inline__ vector long long __ATTRS_o_ai vec_vupkhsw(vector int __a) {
11740 #ifdef __LITTLE_ENDIAN__
11741   return __builtin_altivec_vupklsw(__a);
11742 #else
11743   return __builtin_altivec_vupkhsw(__a);
11744 #endif
11745 }
11746
11747 static __inline__ vector bool long long __ATTRS_o_ai
11748 vec_vupkhsw(vector bool int __a) {
11749 #ifdef __LITTLE_ENDIAN__
11750   return (vector bool long long)__builtin_altivec_vupklsw((vector int)__a);
11751 #else
11752   return (vector bool long long)__builtin_altivec_vupkhsw((vector int)__a);
11753 #endif
11754 }
11755 #endif
11756
11757 /* vec_unpackl */
11758
11759 static __inline__ vector short __ATTRS_o_ai
11760 vec_unpackl(vector signed char __a) {
11761 #ifdef __LITTLE_ENDIAN__
11762   return __builtin_altivec_vupkhsb((vector char)__a);
11763 #else
11764   return __builtin_altivec_vupklsb((vector char)__a);
11765 #endif
11766 }
11767
11768 static __inline__ vector bool short __ATTRS_o_ai
11769 vec_unpackl(vector bool char __a) {
11770 #ifdef __LITTLE_ENDIAN__
11771   return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
11772 #else
11773   return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
11774 #endif
11775 }
11776
11777 static __inline__ vector int __ATTRS_o_ai vec_unpackl(vector short __a) {
11778 #ifdef __LITTLE_ENDIAN__
11779   return __builtin_altivec_vupkhsh(__a);
11780 #else
11781   return __builtin_altivec_vupklsh(__a);
11782 #endif
11783 }
11784
11785 static __inline__ vector bool int __ATTRS_o_ai
11786 vec_unpackl(vector bool short __a) {
11787 #ifdef __LITTLE_ENDIAN__
11788   return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
11789 #else
11790   return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
11791 #endif
11792 }
11793
11794 static __inline__ vector unsigned int __ATTRS_o_ai
11795 vec_unpackl(vector pixel __a) {
11796 #ifdef __LITTLE_ENDIAN__
11797   return (vector unsigned int)__builtin_altivec_vupkhpx((vector short)__a);
11798 #else
11799   return (vector unsigned int)__builtin_altivec_vupklpx((vector short)__a);
11800 #endif
11801 }
11802
11803 #ifdef __POWER8_VECTOR__
11804 static __inline__ vector long long __ATTRS_o_ai vec_unpackl(vector int __a) {
11805 #ifdef __LITTLE_ENDIAN__
11806   return __builtin_altivec_vupkhsw(__a);
11807 #else
11808   return __builtin_altivec_vupklsw(__a);
11809 #endif
11810 }
11811
11812 static __inline__ vector bool long long __ATTRS_o_ai
11813 vec_unpackl(vector bool int __a) {
11814 #ifdef __LITTLE_ENDIAN__
11815   return (vector bool long long)__builtin_altivec_vupkhsw((vector int)__a);
11816 #else
11817   return (vector bool long long)__builtin_altivec_vupklsw((vector int)__a);
11818 #endif
11819 }
11820
11821 static __inline__ vector double __ATTRS_o_ai
11822 vec_unpackl(vector float __a) {
11823   return (vector double)(__a[2], __a[3]);
11824 }
11825 #endif
11826
11827 /* vec_vupklsb */
11828
11829 static __inline__ vector short __ATTRS_o_ai
11830 vec_vupklsb(vector signed char __a) {
11831 #ifdef __LITTLE_ENDIAN__
11832   return __builtin_altivec_vupkhsb((vector char)__a);
11833 #else
11834   return __builtin_altivec_vupklsb((vector char)__a);
11835 #endif
11836 }
11837
11838 static __inline__ vector bool short __ATTRS_o_ai
11839 vec_vupklsb(vector bool char __a) {
11840 #ifdef __LITTLE_ENDIAN__
11841   return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
11842 #else
11843   return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
11844 #endif
11845 }
11846
11847 /* vec_vupklsh */
11848
11849 static __inline__ vector int __ATTRS_o_ai vec_vupklsh(vector short __a) {
11850 #ifdef __LITTLE_ENDIAN__
11851   return __builtin_altivec_vupkhsh(__a);
11852 #else
11853   return __builtin_altivec_vupklsh(__a);
11854 #endif
11855 }
11856
11857 static __inline__ vector bool int __ATTRS_o_ai
11858 vec_vupklsh(vector bool short __a) {
11859 #ifdef __LITTLE_ENDIAN__
11860   return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
11861 #else
11862   return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
11863 #endif
11864 }
11865
11866 static __inline__ vector unsigned int __ATTRS_o_ai
11867 vec_vupklsh(vector pixel __a) {
11868 #ifdef __LITTLE_ENDIAN__
11869   return (vector unsigned int)__builtin_altivec_vupkhpx((vector short)__a);
11870 #else
11871   return (vector unsigned int)__builtin_altivec_vupklpx((vector short)__a);
11872 #endif
11873 }
11874
11875 /* vec_vupklsw */
11876
11877 #ifdef __POWER8_VECTOR__
11878 static __inline__ vector long long __ATTRS_o_ai vec_vupklsw(vector int __a) {
11879 #ifdef __LITTLE_ENDIAN__
11880   return __builtin_altivec_vupkhsw(__a);
11881 #else
11882   return __builtin_altivec_vupklsw(__a);
11883 #endif
11884 }
11885
11886 static __inline__ vector bool long long __ATTRS_o_ai
11887 vec_vupklsw(vector bool int __a) {
11888 #ifdef __LITTLE_ENDIAN__
11889   return (vector bool long long)__builtin_altivec_vupkhsw((vector int)__a);
11890 #else
11891   return (vector bool long long)__builtin_altivec_vupklsw((vector int)__a);
11892 #endif
11893 }
11894 #endif
11895
11896 /* vec_vsx_ld */
11897
11898 #ifdef __VSX__
11899
11900 static __inline__ vector bool int __ATTRS_o_ai
11901 vec_vsx_ld(int __a, const vector bool int *__b) {
11902   return (vector bool int)__builtin_vsx_lxvw4x(__a, __b);
11903 }
11904
11905 static __inline__ vector signed int __ATTRS_o_ai
11906 vec_vsx_ld(int __a, const vector signed int *__b) {
11907   return (vector signed int)__builtin_vsx_lxvw4x(__a, __b);
11908 }
11909
11910 static __inline__ vector signed int __ATTRS_o_ai
11911 vec_vsx_ld(int __a, const signed int *__b) {
11912   return (vector signed int)__builtin_vsx_lxvw4x(__a, __b);
11913 }
11914
11915 static __inline__ vector unsigned int __ATTRS_o_ai
11916 vec_vsx_ld(int __a, const vector unsigned int *__b) {
11917   return (vector unsigned int)__builtin_vsx_lxvw4x(__a, __b);
11918 }
11919
11920 static __inline__ vector unsigned int __ATTRS_o_ai
11921 vec_vsx_ld(int __a, const unsigned int *__b) {
11922   return (vector unsigned int)__builtin_vsx_lxvw4x(__a, __b);
11923 }
11924
11925 static __inline__ vector float __ATTRS_o_ai
11926 vec_vsx_ld(int __a, const vector float *__b) {
11927   return (vector float)__builtin_vsx_lxvw4x(__a, __b);
11928 }
11929
11930 static __inline__ vector float __ATTRS_o_ai vec_vsx_ld(int __a,
11931                                                        const float *__b) {
11932   return (vector float)__builtin_vsx_lxvw4x(__a, __b);
11933 }
11934
11935 static __inline__ vector signed long long __ATTRS_o_ai
11936 vec_vsx_ld(int __a, const vector signed long long *__b) {
11937   return (vector signed long long)__builtin_vsx_lxvd2x(__a, __b);
11938 }
11939
11940 static __inline__ vector unsigned long long __ATTRS_o_ai
11941 vec_vsx_ld(int __a, const vector unsigned long long *__b) {
11942   return (vector unsigned long long)__builtin_vsx_lxvd2x(__a, __b);
11943 }
11944
11945 static __inline__ vector double __ATTRS_o_ai
11946 vec_vsx_ld(int __a, const vector double *__b) {
11947   return (vector double)__builtin_vsx_lxvd2x(__a, __b);
11948 }
11949
11950 static __inline__ vector double __ATTRS_o_ai
11951 vec_vsx_ld(int __a, const double *__b) {
11952   return (vector double)__builtin_vsx_lxvd2x(__a, __b);
11953 }
11954
11955 static __inline__ vector bool short __ATTRS_o_ai
11956 vec_vsx_ld(int __a, const vector bool short *__b) {
11957   return (vector bool short)__builtin_vsx_lxvw4x(__a, __b);
11958 }
11959
11960 static __inline__ vector signed short __ATTRS_o_ai
11961 vec_vsx_ld(int __a, const vector signed short *__b) {
11962   return (vector signed short)__builtin_vsx_lxvw4x(__a, __b);
11963 }
11964
11965 static __inline__ vector signed short __ATTRS_o_ai
11966 vec_vsx_ld(int __a, const signed short *__b) {
11967   return (vector signed short)__builtin_vsx_lxvw4x(__a, __b);
11968 }
11969
11970 static __inline__ vector unsigned short __ATTRS_o_ai
11971 vec_vsx_ld(int __a, const vector unsigned short *__b) {
11972   return (vector unsigned short)__builtin_vsx_lxvw4x(__a, __b);
11973 }
11974
11975 static __inline__ vector unsigned short __ATTRS_o_ai
11976 vec_vsx_ld(int __a, const unsigned short *__b) {
11977   return (vector unsigned short)__builtin_vsx_lxvw4x(__a, __b);
11978 }
11979
11980 static __inline__ vector bool char __ATTRS_o_ai
11981 vec_vsx_ld(int __a, const vector bool char *__b) {
11982   return (vector bool char)__builtin_vsx_lxvw4x(__a, __b);
11983 }
11984
11985 static __inline__ vector signed char __ATTRS_o_ai
11986 vec_vsx_ld(int __a, const vector signed char *__b) {
11987   return (vector signed char)__builtin_vsx_lxvw4x(__a, __b);
11988 }
11989
11990 static __inline__ vector signed char __ATTRS_o_ai
11991 vec_vsx_ld(int __a, const signed char *__b) {
11992   return (vector signed char)__builtin_vsx_lxvw4x(__a, __b);
11993 }
11994
11995 static __inline__ vector unsigned char __ATTRS_o_ai
11996 vec_vsx_ld(int __a, const vector unsigned char *__b) {
11997   return (vector unsigned char)__builtin_vsx_lxvw4x(__a, __b);
11998 }
11999
12000 static __inline__ vector unsigned char __ATTRS_o_ai
12001 vec_vsx_ld(int __a, const unsigned char *__b) {
12002   return (vector unsigned char)__builtin_vsx_lxvw4x(__a, __b);
12003 }
12004
12005 #endif
12006
12007 /* vec_vsx_st */
12008
12009 #ifdef __VSX__
12010
12011 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool int __a, int __b,
12012                                                vector bool int *__c) {
12013   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12014 }
12015
12016 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool int __a, int __b,
12017                                                signed int *__c) {
12018   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12019 }
12020
12021 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool int __a, int __b,
12022                                                unsigned int *__c) {
12023   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12024 }
12025
12026 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed int __a, int __b,
12027                                                vector signed int *__c) {
12028   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12029 }
12030
12031 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed int __a, int __b,
12032                                                signed int *__c) {
12033   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12034 }
12035
12036 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned int __a, int __b,
12037                                                vector unsigned int *__c) {
12038   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12039 }
12040
12041 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned int __a, int __b,
12042                                                unsigned int *__c) {
12043   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12044 }
12045
12046 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector float __a, int __b,
12047                                                vector float *__c) {
12048   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12049 }
12050
12051 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector float __a, int __b,
12052                                                float *__c) {
12053   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12054 }
12055
12056 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed long long __a,
12057                                                int __b,
12058                                                vector signed long long *__c) {
12059   __builtin_vsx_stxvd2x((vector double)__a, __b, __c);
12060 }
12061
12062 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned long long __a,
12063                                                int __b,
12064                                                vector unsigned long long *__c) {
12065   __builtin_vsx_stxvd2x((vector double)__a, __b, __c);
12066 }
12067
12068 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector double __a, int __b,
12069                                                vector double *__c) {
12070   __builtin_vsx_stxvd2x((vector double)__a, __b, __c);
12071 }
12072
12073 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector double __a, int __b,
12074                                                double *__c) {
12075   __builtin_vsx_stxvd2x((vector double)__a, __b, __c);
12076 }
12077
12078 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool short __a, int __b,
12079                                                vector bool short *__c) {
12080   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12081 }
12082
12083 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool short __a, int __b,
12084                                                signed short *__c) {
12085   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12086 }
12087
12088 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool short __a, int __b,
12089                                                unsigned short *__c) {
12090   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12091 }
12092 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed short __a, int __b,
12093                                                vector signed short *__c) {
12094   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12095 }
12096
12097 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed short __a, int __b,
12098                                                signed short *__c) {
12099   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12100 }
12101
12102 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned short __a,
12103                                                int __b,
12104                                                vector unsigned short *__c) {
12105   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12106 }
12107
12108 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned short __a,
12109                                                int __b, unsigned short *__c) {
12110   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12111 }
12112
12113 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool char __a, int __b,
12114                                                vector bool char *__c) {
12115   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12116 }
12117
12118 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool char __a, int __b,
12119                                                signed char *__c) {
12120   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12121 }
12122
12123 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool char __a, int __b,
12124                                                unsigned char *__c) {
12125   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12126 }
12127
12128 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed char __a, int __b,
12129                                                vector signed char *__c) {
12130   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12131 }
12132
12133 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed char __a, int __b,
12134                                                signed char *__c) {
12135   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12136 }
12137
12138 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned char __a,
12139                                                int __b,
12140                                                vector unsigned char *__c) {
12141   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12142 }
12143
12144 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned char __a,
12145                                                int __b, unsigned char *__c) {
12146   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12147 }
12148
12149 #endif
12150
12151 #ifdef __VSX__
12152 #define vec_xxpermdi __builtin_vsx_xxpermdi
12153 #define vec_xxsldwi __builtin_vsx_xxsldwi
12154 #endif
12155
12156 /* vec_xor */
12157
12158 #define __builtin_altivec_vxor vec_xor
12159
12160 static __inline__ vector signed char __ATTRS_o_ai
12161 vec_xor(vector signed char __a, vector signed char __b) {
12162   return __a ^ __b;
12163 }
12164
12165 static __inline__ vector signed char __ATTRS_o_ai
12166 vec_xor(vector bool char __a, vector signed char __b) {
12167   return (vector signed char)__a ^ __b;
12168 }
12169
12170 static __inline__ vector signed char __ATTRS_o_ai
12171 vec_xor(vector signed char __a, vector bool char __b) {
12172   return __a ^ (vector signed char)__b;
12173 }
12174
12175 static __inline__ vector unsigned char __ATTRS_o_ai
12176 vec_xor(vector unsigned char __a, vector unsigned char __b) {
12177   return __a ^ __b;
12178 }
12179
12180 static __inline__ vector unsigned char __ATTRS_o_ai
12181 vec_xor(vector bool char __a, vector unsigned char __b) {
12182   return (vector unsigned char)__a ^ __b;
12183 }
12184
12185 static __inline__ vector unsigned char __ATTRS_o_ai
12186 vec_xor(vector unsigned char __a, vector bool char __b) {
12187   return __a ^ (vector unsigned char)__b;
12188 }
12189
12190 static __inline__ vector bool char __ATTRS_o_ai vec_xor(vector bool char __a,
12191                                                         vector bool char __b) {
12192   return __a ^ __b;
12193 }
12194
12195 static __inline__ vector short __ATTRS_o_ai vec_xor(vector short __a,
12196                                                     vector short __b) {
12197   return __a ^ __b;
12198 }
12199
12200 static __inline__ vector short __ATTRS_o_ai vec_xor(vector bool short __a,
12201                                                     vector short __b) {
12202   return (vector short)__a ^ __b;
12203 }
12204
12205 static __inline__ vector short __ATTRS_o_ai vec_xor(vector short __a,
12206                                                     vector bool short __b) {
12207   return __a ^ (vector short)__b;
12208 }
12209
12210 static __inline__ vector unsigned short __ATTRS_o_ai
12211 vec_xor(vector unsigned short __a, vector unsigned short __b) {
12212   return __a ^ __b;
12213 }
12214
12215 static __inline__ vector unsigned short __ATTRS_o_ai
12216 vec_xor(vector bool short __a, vector unsigned short __b) {
12217   return (vector unsigned short)__a ^ __b;
12218 }
12219
12220 static __inline__ vector unsigned short __ATTRS_o_ai
12221 vec_xor(vector unsigned short __a, vector bool short __b) {
12222   return __a ^ (vector unsigned short)__b;
12223 }
12224
12225 static __inline__ vector bool short __ATTRS_o_ai
12226 vec_xor(vector bool short __a, vector bool short __b) {
12227   return __a ^ __b;
12228 }
12229
12230 static __inline__ vector int __ATTRS_o_ai vec_xor(vector int __a,
12231                                                   vector int __b) {
12232   return __a ^ __b;
12233 }
12234
12235 static __inline__ vector int __ATTRS_o_ai vec_xor(vector bool int __a,
12236                                                   vector int __b) {
12237   return (vector int)__a ^ __b;
12238 }
12239
12240 static __inline__ vector int __ATTRS_o_ai vec_xor(vector int __a,
12241                                                   vector bool int __b) {
12242   return __a ^ (vector int)__b;
12243 }
12244
12245 static __inline__ vector unsigned int __ATTRS_o_ai
12246 vec_xor(vector unsigned int __a, vector unsigned int __b) {
12247   return __a ^ __b;
12248 }
12249
12250 static __inline__ vector unsigned int __ATTRS_o_ai
12251 vec_xor(vector bool int __a, vector unsigned int __b) {
12252   return (vector unsigned int)__a ^ __b;
12253 }
12254
12255 static __inline__ vector unsigned int __ATTRS_o_ai
12256 vec_xor(vector unsigned int __a, vector bool int __b) {
12257   return __a ^ (vector unsigned int)__b;
12258 }
12259
12260 static __inline__ vector bool int __ATTRS_o_ai vec_xor(vector bool int __a,
12261                                                        vector bool int __b) {
12262   return __a ^ __b;
12263 }
12264
12265 static __inline__ vector float __ATTRS_o_ai vec_xor(vector float __a,
12266                                                     vector float __b) {
12267   vector unsigned int __res =
12268       (vector unsigned int)__a ^ (vector unsigned int)__b;
12269   return (vector float)__res;
12270 }
12271
12272 static __inline__ vector float __ATTRS_o_ai vec_xor(vector bool int __a,
12273                                                     vector float __b) {
12274   vector unsigned int __res =
12275       (vector unsigned int)__a ^ (vector unsigned int)__b;
12276   return (vector float)__res;
12277 }
12278
12279 static __inline__ vector float __ATTRS_o_ai vec_xor(vector float __a,
12280                                                     vector bool int __b) {
12281   vector unsigned int __res =
12282       (vector unsigned int)__a ^ (vector unsigned int)__b;
12283   return (vector float)__res;
12284 }
12285
12286 #ifdef __VSX__
12287 static __inline__ vector signed long long __ATTRS_o_ai
12288 vec_xor(vector signed long long __a, vector signed long long __b) {
12289   return __a ^ __b;
12290 }
12291
12292 static __inline__ vector signed long long __ATTRS_o_ai
12293 vec_xor(vector bool long long __a, vector signed long long __b) {
12294   return (vector signed long long)__a ^ __b;
12295 }
12296
12297 static __inline__ vector signed long long __ATTRS_o_ai
12298 vec_xor(vector signed long long __a, vector bool long long __b) {
12299   return __a ^ (vector signed long long)__b;
12300 }
12301
12302 static __inline__ vector unsigned long long __ATTRS_o_ai
12303 vec_xor(vector unsigned long long __a, vector unsigned long long __b) {
12304   return __a ^ __b;
12305 }
12306
12307 static __inline__ vector unsigned long long __ATTRS_o_ai
12308 vec_xor(vector bool long long __a, vector unsigned long long __b) {
12309   return (vector unsigned long long)__a ^ __b;
12310 }
12311
12312 static __inline__ vector unsigned long long __ATTRS_o_ai
12313 vec_xor(vector unsigned long long __a, vector bool long long __b) {
12314   return __a ^ (vector unsigned long long)__b;
12315 }
12316
12317 static __inline__ vector bool long long __ATTRS_o_ai
12318 vec_xor(vector bool long long __a, vector bool long long __b) {
12319   return __a ^ __b;
12320 }
12321
12322 static __inline__ vector double __ATTRS_o_ai vec_xor(vector double __a,
12323                                                      vector double __b) {
12324   return (vector double)((vector unsigned long long)__a ^
12325                          (vector unsigned long long)__b);
12326 }
12327
12328 static __inline__ vector double __ATTRS_o_ai
12329 vec_xor(vector double __a, vector bool long long __b) {
12330   return (vector double)((vector unsigned long long)__a ^
12331                          (vector unsigned long long)__b);
12332 }
12333
12334 static __inline__ vector double __ATTRS_o_ai vec_xor(vector bool long long __a,
12335                                                      vector double __b) {
12336   return (vector double)((vector unsigned long long)__a ^
12337                          (vector unsigned long long)__b);
12338 }
12339 #endif
12340
12341 /* vec_vxor */
12342
12343 static __inline__ vector signed char __ATTRS_o_ai
12344 vec_vxor(vector signed char __a, vector signed char __b) {
12345   return __a ^ __b;
12346 }
12347
12348 static __inline__ vector signed char __ATTRS_o_ai
12349 vec_vxor(vector bool char __a, vector signed char __b) {
12350   return (vector signed char)__a ^ __b;
12351 }
12352
12353 static __inline__ vector signed char __ATTRS_o_ai
12354 vec_vxor(vector signed char __a, vector bool char __b) {
12355   return __a ^ (vector signed char)__b;
12356 }
12357
12358 static __inline__ vector unsigned char __ATTRS_o_ai
12359 vec_vxor(vector unsigned char __a, vector unsigned char __b) {
12360   return __a ^ __b;
12361 }
12362
12363 static __inline__ vector unsigned char __ATTRS_o_ai
12364 vec_vxor(vector bool char __a, vector unsigned char __b) {
12365   return (vector unsigned char)__a ^ __b;
12366 }
12367
12368 static __inline__ vector unsigned char __ATTRS_o_ai
12369 vec_vxor(vector unsigned char __a, vector bool char __b) {
12370   return __a ^ (vector unsigned char)__b;
12371 }
12372
12373 static __inline__ vector bool char __ATTRS_o_ai vec_vxor(vector bool char __a,
12374                                                          vector bool char __b) {
12375   return __a ^ __b;
12376 }
12377
12378 static __inline__ vector short __ATTRS_o_ai vec_vxor(vector short __a,
12379                                                      vector short __b) {
12380   return __a ^ __b;
12381 }
12382
12383 static __inline__ vector short __ATTRS_o_ai vec_vxor(vector bool short __a,
12384                                                      vector short __b) {
12385   return (vector short)__a ^ __b;
12386 }
12387
12388 static __inline__ vector short __ATTRS_o_ai vec_vxor(vector short __a,
12389                                                      vector bool short __b) {
12390   return __a ^ (vector short)__b;
12391 }
12392
12393 static __inline__ vector unsigned short __ATTRS_o_ai
12394 vec_vxor(vector unsigned short __a, vector unsigned short __b) {
12395   return __a ^ __b;
12396 }
12397
12398 static __inline__ vector unsigned short __ATTRS_o_ai
12399 vec_vxor(vector bool short __a, vector unsigned short __b) {
12400   return (vector unsigned short)__a ^ __b;
12401 }
12402
12403 static __inline__ vector unsigned short __ATTRS_o_ai
12404 vec_vxor(vector unsigned short __a, vector bool short __b) {
12405   return __a ^ (vector unsigned short)__b;
12406 }
12407
12408 static __inline__ vector bool short __ATTRS_o_ai
12409 vec_vxor(vector bool short __a, vector bool short __b) {
12410   return __a ^ __b;
12411 }
12412
12413 static __inline__ vector int __ATTRS_o_ai vec_vxor(vector int __a,
12414                                                    vector int __b) {
12415   return __a ^ __b;
12416 }
12417
12418 static __inline__ vector int __ATTRS_o_ai vec_vxor(vector bool int __a,
12419                                                    vector int __b) {
12420   return (vector int)__a ^ __b;
12421 }
12422
12423 static __inline__ vector int __ATTRS_o_ai vec_vxor(vector int __a,
12424                                                    vector bool int __b) {
12425   return __a ^ (vector int)__b;
12426 }
12427
12428 static __inline__ vector unsigned int __ATTRS_o_ai
12429 vec_vxor(vector unsigned int __a, vector unsigned int __b) {
12430   return __a ^ __b;
12431 }
12432
12433 static __inline__ vector unsigned int __ATTRS_o_ai
12434 vec_vxor(vector bool int __a, vector unsigned int __b) {
12435   return (vector unsigned int)__a ^ __b;
12436 }
12437
12438 static __inline__ vector unsigned int __ATTRS_o_ai
12439 vec_vxor(vector unsigned int __a, vector bool int __b) {
12440   return __a ^ (vector unsigned int)__b;
12441 }
12442
12443 static __inline__ vector bool int __ATTRS_o_ai vec_vxor(vector bool int __a,
12444                                                         vector bool int __b) {
12445   return __a ^ __b;
12446 }
12447
12448 static __inline__ vector float __ATTRS_o_ai vec_vxor(vector float __a,
12449                                                      vector float __b) {
12450   vector unsigned int __res =
12451       (vector unsigned int)__a ^ (vector unsigned int)__b;
12452   return (vector float)__res;
12453 }
12454
12455 static __inline__ vector float __ATTRS_o_ai vec_vxor(vector bool int __a,
12456                                                      vector float __b) {
12457   vector unsigned int __res =
12458       (vector unsigned int)__a ^ (vector unsigned int)__b;
12459   return (vector float)__res;
12460 }
12461
12462 static __inline__ vector float __ATTRS_o_ai vec_vxor(vector float __a,
12463                                                      vector bool int __b) {
12464   vector unsigned int __res =
12465       (vector unsigned int)__a ^ (vector unsigned int)__b;
12466   return (vector float)__res;
12467 }
12468
12469 #ifdef __VSX__
12470 static __inline__ vector signed long long __ATTRS_o_ai
12471 vec_vxor(vector signed long long __a, vector signed long long __b) {
12472   return __a ^ __b;
12473 }
12474
12475 static __inline__ vector signed long long __ATTRS_o_ai
12476 vec_vxor(vector bool long long __a, vector signed long long __b) {
12477   return (vector signed long long)__a ^ __b;
12478 }
12479
12480 static __inline__ vector signed long long __ATTRS_o_ai
12481 vec_vxor(vector signed long long __a, vector bool long long __b) {
12482   return __a ^ (vector signed long long)__b;
12483 }
12484
12485 static __inline__ vector unsigned long long __ATTRS_o_ai
12486 vec_vxor(vector unsigned long long __a, vector unsigned long long __b) {
12487   return __a ^ __b;
12488 }
12489
12490 static __inline__ vector unsigned long long __ATTRS_o_ai
12491 vec_vxor(vector bool long long __a, vector unsigned long long __b) {
12492   return (vector unsigned long long)__a ^ __b;
12493 }
12494
12495 static __inline__ vector unsigned long long __ATTRS_o_ai
12496 vec_vxor(vector unsigned long long __a, vector bool long long __b) {
12497   return __a ^ (vector unsigned long long)__b;
12498 }
12499
12500 static __inline__ vector bool long long __ATTRS_o_ai
12501 vec_vxor(vector bool long long __a, vector bool long long __b) {
12502   return __a ^ __b;
12503 }
12504 #endif
12505
12506 /* ------------------------ extensions for CBEA ----------------------------- */
12507
12508 /* vec_extract */
12509
12510 static __inline__ signed char __ATTRS_o_ai vec_extract(vector signed char __a,
12511                                                        int __b) {
12512   return __a[__b];
12513 }
12514
12515 static __inline__ unsigned char __ATTRS_o_ai
12516 vec_extract(vector unsigned char __a, int __b) {
12517   return __a[__b];
12518 }
12519
12520 static __inline__ unsigned char __ATTRS_o_ai vec_extract(vector bool char __a,
12521                                                          int __b) {
12522   return __a[__b];
12523 }
12524
12525 static __inline__ signed short __ATTRS_o_ai vec_extract(vector signed short __a,
12526                                                         int __b) {
12527   return __a[__b];
12528 }
12529
12530 static __inline__ unsigned short __ATTRS_o_ai
12531 vec_extract(vector unsigned short __a, int __b) {
12532   return __a[__b];
12533 }
12534
12535 static __inline__ unsigned short __ATTRS_o_ai vec_extract(vector bool short __a,
12536                                                           int __b) {
12537   return __a[__b];
12538 }
12539
12540 static __inline__ signed int __ATTRS_o_ai vec_extract(vector signed int __a,
12541                                                       int __b) {
12542   return __a[__b];
12543 }
12544
12545 static __inline__ unsigned int __ATTRS_o_ai vec_extract(vector unsigned int __a,
12546                                                         int __b) {
12547   return __a[__b];
12548 }
12549
12550 static __inline__ unsigned int __ATTRS_o_ai vec_extract(vector bool int __a,
12551                                                         int __b) {
12552   return __a[__b];
12553 }
12554
12555 #ifdef __VSX__
12556 static __inline__ signed long long __ATTRS_o_ai
12557 vec_extract(vector signed long long __a, int __b) {
12558   return __a[__b];
12559 }
12560
12561 static __inline__ unsigned long long __ATTRS_o_ai
12562 vec_extract(vector unsigned long long __a, int __b) {
12563   return __a[__b];
12564 }
12565
12566 static __inline__ unsigned long long __ATTRS_o_ai
12567 vec_extract(vector bool long long __a, int __b) {
12568   return __a[__b];
12569 }
12570
12571 static __inline__ double __ATTRS_o_ai vec_extract(vector double __a, int __b) {
12572   return __a[__b];
12573 }
12574 #endif
12575
12576 static __inline__ float __ATTRS_o_ai vec_extract(vector float __a, int __b) {
12577   return __a[__b];
12578 }
12579
12580 #ifdef __POWER9_VECTOR__
12581
12582 #define vec_insert4b __builtin_vsx_insertword
12583 #define vec_extract4b __builtin_vsx_extractuword
12584
12585 /* vec_extract_exp */
12586
12587 static __inline__ vector unsigned int __ATTRS_o_ai
12588 vec_extract_exp(vector float __a) {
12589   return __builtin_vsx_xvxexpsp(__a);
12590 }
12591
12592 static __inline__ vector unsigned long long __ATTRS_o_ai
12593 vec_extract_exp(vector double __a) {
12594   return __builtin_vsx_xvxexpdp(__a);
12595 }
12596
12597 /* vec_extract_sig */
12598
12599 static __inline__ vector unsigned int __ATTRS_o_ai
12600 vec_extract_sig(vector float __a) {
12601   return __builtin_vsx_xvxsigsp(__a);
12602 }
12603
12604 static __inline__ vector unsigned long long __ATTRS_o_ai
12605 vec_extract_sig (vector double __a) {
12606   return __builtin_vsx_xvxsigdp(__a);
12607 }
12608
12609 static __inline__ vector float __ATTRS_o_ai
12610 vec_extract_fp32_from_shorth(vector unsigned short __a) {
12611   vector unsigned short __b =
12612 #ifdef __LITTLE_ENDIAN__
12613             __builtin_shufflevector(__a, __a, 0, -1, 1, -1, 2, -1, 3, -1);
12614 #else
12615             __builtin_shufflevector(__a, __a, -1, 0, -1, 1, -1, 2, -1, 3);
12616 #endif
12617   return __builtin_vsx_xvcvhpsp(__b);
12618 }
12619
12620 static __inline__ vector float __ATTRS_o_ai
12621 vec_extract_fp32_from_shortl(vector unsigned short __a) {
12622   vector unsigned short __b =
12623 #ifdef __LITTLE_ENDIAN__
12624             __builtin_shufflevector(__a, __a, 4, -1, 5, -1, 6, -1, 7, -1);
12625 #else
12626             __builtin_shufflevector(__a, __a, -1, 4, -1, 5, -1, 6, -1, 7);
12627 #endif
12628   return __builtin_vsx_xvcvhpsp(__b);
12629 }
12630 #endif /* __POWER9_VECTOR__ */
12631
12632 /* vec_insert */
12633
12634 static __inline__ vector signed char __ATTRS_o_ai
12635 vec_insert(signed char __a, vector signed char __b, int __c) {
12636   __b[__c] = __a;
12637   return __b;
12638 }
12639
12640 static __inline__ vector unsigned char __ATTRS_o_ai
12641 vec_insert(unsigned char __a, vector unsigned char __b, int __c) {
12642   __b[__c] = __a;
12643   return __b;
12644 }
12645
12646 static __inline__ vector bool char __ATTRS_o_ai vec_insert(unsigned char __a,
12647                                                            vector bool char __b,
12648                                                            int __c) {
12649   __b[__c] = __a;
12650   return __b;
12651 }
12652
12653 static __inline__ vector signed short __ATTRS_o_ai
12654 vec_insert(signed short __a, vector signed short __b, int __c) {
12655   __b[__c] = __a;
12656   return __b;
12657 }
12658
12659 static __inline__ vector unsigned short __ATTRS_o_ai
12660 vec_insert(unsigned short __a, vector unsigned short __b, int __c) {
12661   __b[__c] = __a;
12662   return __b;
12663 }
12664
12665 static __inline__ vector bool short __ATTRS_o_ai
12666 vec_insert(unsigned short __a, vector bool short __b, int __c) {
12667   __b[__c] = __a;
12668   return __b;
12669 }
12670
12671 static __inline__ vector signed int __ATTRS_o_ai
12672 vec_insert(signed int __a, vector signed int __b, int __c) {
12673   __b[__c] = __a;
12674   return __b;
12675 }
12676
12677 static __inline__ vector unsigned int __ATTRS_o_ai
12678 vec_insert(unsigned int __a, vector unsigned int __b, int __c) {
12679   __b[__c] = __a;
12680   return __b;
12681 }
12682
12683 static __inline__ vector bool int __ATTRS_o_ai vec_insert(unsigned int __a,
12684                                                           vector bool int __b,
12685                                                           int __c) {
12686   __b[__c] = __a;
12687   return __b;
12688 }
12689
12690 #ifdef __VSX__
12691 static __inline__ vector signed long long __ATTRS_o_ai
12692 vec_insert(signed long long __a, vector signed long long __b, int __c) {
12693   __b[__c] = __a;
12694   return __b;
12695 }
12696
12697 static __inline__ vector unsigned long long __ATTRS_o_ai
12698 vec_insert(unsigned long long __a, vector unsigned long long __b, int __c) {
12699   __b[__c] = __a;
12700   return __b;
12701 }
12702
12703 static __inline__ vector bool long long __ATTRS_o_ai
12704 vec_insert(unsigned long long __a, vector bool long long __b, int __c) {
12705   __b[__c] = __a;
12706   return __b;
12707 }
12708 static __inline__ vector double __ATTRS_o_ai vec_insert(double __a,
12709                                                         vector double __b,
12710                                                         int __c) {
12711   __b[__c] = __a;
12712   return __b;
12713 }
12714 #endif
12715
12716 static __inline__ vector float __ATTRS_o_ai vec_insert(float __a,
12717                                                        vector float __b,
12718                                                        int __c) {
12719   __b[__c] = __a;
12720   return __b;
12721 }
12722
12723 /* vec_lvlx */
12724
12725 static __inline__ vector signed char __ATTRS_o_ai
12726 vec_lvlx(int __a, const signed char *__b) {
12727   return vec_perm(vec_ld(__a, __b), (vector signed char)(0),
12728                   vec_lvsl(__a, __b));
12729 }
12730
12731 static __inline__ vector signed char __ATTRS_o_ai
12732 vec_lvlx(int __a, const vector signed char *__b) {
12733   return vec_perm(vec_ld(__a, __b), (vector signed char)(0),
12734                   vec_lvsl(__a, (unsigned char *)__b));
12735 }
12736
12737 static __inline__ vector unsigned char __ATTRS_o_ai
12738 vec_lvlx(int __a, const unsigned char *__b) {
12739   return vec_perm(vec_ld(__a, __b), (vector unsigned char)(0),
12740                   vec_lvsl(__a, __b));
12741 }
12742
12743 static __inline__ vector unsigned char __ATTRS_o_ai
12744 vec_lvlx(int __a, const vector unsigned char *__b) {
12745   return vec_perm(vec_ld(__a, __b), (vector unsigned char)(0),
12746                   vec_lvsl(__a, (unsigned char *)__b));
12747 }
12748
12749 static __inline__ vector bool char __ATTRS_o_ai
12750 vec_lvlx(int __a, const vector bool char *__b) {
12751   return vec_perm(vec_ld(__a, __b), (vector bool char)(0),
12752                   vec_lvsl(__a, (unsigned char *)__b));
12753 }
12754
12755 static __inline__ vector short __ATTRS_o_ai vec_lvlx(int __a,
12756                                                      const short *__b) {
12757   return vec_perm(vec_ld(__a, __b), (vector short)(0), vec_lvsl(__a, __b));
12758 }
12759
12760 static __inline__ vector short __ATTRS_o_ai vec_lvlx(int __a,
12761                                                      const vector short *__b) {
12762   return vec_perm(vec_ld(__a, __b), (vector short)(0),
12763                   vec_lvsl(__a, (unsigned char *)__b));
12764 }
12765
12766 static __inline__ vector unsigned short __ATTRS_o_ai
12767 vec_lvlx(int __a, const unsigned short *__b) {
12768   return vec_perm(vec_ld(__a, __b), (vector unsigned short)(0),
12769                   vec_lvsl(__a, __b));
12770 }
12771
12772 static __inline__ vector unsigned short __ATTRS_o_ai
12773 vec_lvlx(int __a, const vector unsigned short *__b) {
12774   return vec_perm(vec_ld(__a, __b), (vector unsigned short)(0),
12775                   vec_lvsl(__a, (unsigned char *)__b));
12776 }
12777
12778 static __inline__ vector bool short __ATTRS_o_ai
12779 vec_lvlx(int __a, const vector bool short *__b) {
12780   return vec_perm(vec_ld(__a, __b), (vector bool short)(0),
12781                   vec_lvsl(__a, (unsigned char *)__b));
12782 }
12783
12784 static __inline__ vector pixel __ATTRS_o_ai vec_lvlx(int __a,
12785                                                      const vector pixel *__b) {
12786   return vec_perm(vec_ld(__a, __b), (vector pixel)(0),
12787                   vec_lvsl(__a, (unsigned char *)__b));
12788 }
12789
12790 static __inline__ vector int __ATTRS_o_ai vec_lvlx(int __a, const int *__b) {
12791   return vec_perm(vec_ld(__a, __b), (vector int)(0), vec_lvsl(__a, __b));
12792 }
12793
12794 static __inline__ vector int __ATTRS_o_ai vec_lvlx(int __a,
12795                                                    const vector int *__b) {
12796   return vec_perm(vec_ld(__a, __b), (vector int)(0),
12797                   vec_lvsl(__a, (unsigned char *)__b));
12798 }
12799
12800 static __inline__ vector unsigned int __ATTRS_o_ai
12801 vec_lvlx(int __a, const unsigned int *__b) {
12802   return vec_perm(vec_ld(__a, __b), (vector unsigned int)(0),
12803                   vec_lvsl(__a, __b));
12804 }
12805
12806 static __inline__ vector unsigned int __ATTRS_o_ai
12807 vec_lvlx(int __a, const vector unsigned int *__b) {
12808   return vec_perm(vec_ld(__a, __b), (vector unsigned int)(0),
12809                   vec_lvsl(__a, (unsigned char *)__b));
12810 }
12811
12812 static __inline__ vector bool int __ATTRS_o_ai
12813 vec_lvlx(int __a, const vector bool int *__b) {
12814   return vec_perm(vec_ld(__a, __b), (vector bool int)(0),
12815                   vec_lvsl(__a, (unsigned char *)__b));
12816 }
12817
12818 static __inline__ vector float __ATTRS_o_ai vec_lvlx(int __a,
12819                                                      const float *__b) {
12820   return vec_perm(vec_ld(__a, __b), (vector float)(0), vec_lvsl(__a, __b));
12821 }
12822
12823 static __inline__ vector float __ATTRS_o_ai vec_lvlx(int __a,
12824                                                      const vector float *__b) {
12825   return vec_perm(vec_ld(__a, __b), (vector float)(0),
12826                   vec_lvsl(__a, (unsigned char *)__b));
12827 }
12828
12829 /* vec_lvlxl */
12830
12831 static __inline__ vector signed char __ATTRS_o_ai
12832 vec_lvlxl(int __a, const signed char *__b) {
12833   return vec_perm(vec_ldl(__a, __b), (vector signed char)(0),
12834                   vec_lvsl(__a, __b));
12835 }
12836
12837 static __inline__ vector signed char __ATTRS_o_ai
12838 vec_lvlxl(int __a, const vector signed char *__b) {
12839   return vec_perm(vec_ldl(__a, __b), (vector signed char)(0),
12840                   vec_lvsl(__a, (unsigned char *)__b));
12841 }
12842
12843 static __inline__ vector unsigned char __ATTRS_o_ai
12844 vec_lvlxl(int __a, const unsigned char *__b) {
12845   return vec_perm(vec_ldl(__a, __b), (vector unsigned char)(0),
12846                   vec_lvsl(__a, __b));
12847 }
12848
12849 static __inline__ vector unsigned char __ATTRS_o_ai
12850 vec_lvlxl(int __a, const vector unsigned char *__b) {
12851   return vec_perm(vec_ldl(__a, __b), (vector unsigned char)(0),
12852                   vec_lvsl(__a, (unsigned char *)__b));
12853 }
12854
12855 static __inline__ vector bool char __ATTRS_o_ai
12856 vec_lvlxl(int __a, const vector bool char *__b) {
12857   return vec_perm(vec_ldl(__a, __b), (vector bool char)(0),
12858                   vec_lvsl(__a, (unsigned char *)__b));
12859 }
12860
12861 static __inline__ vector short __ATTRS_o_ai vec_lvlxl(int __a,
12862                                                       const short *__b) {
12863   return vec_perm(vec_ldl(__a, __b), (vector short)(0), vec_lvsl(__a, __b));
12864 }
12865
12866 static __inline__ vector short __ATTRS_o_ai vec_lvlxl(int __a,
12867                                                       const vector short *__b) {
12868   return vec_perm(vec_ldl(__a, __b), (vector short)(0),
12869                   vec_lvsl(__a, (unsigned char *)__b));
12870 }
12871
12872 static __inline__ vector unsigned short __ATTRS_o_ai
12873 vec_lvlxl(int __a, const unsigned short *__b) {
12874   return vec_perm(vec_ldl(__a, __b), (vector unsigned short)(0),
12875                   vec_lvsl(__a, __b));
12876 }
12877
12878 static __inline__ vector unsigned short __ATTRS_o_ai
12879 vec_lvlxl(int __a, const vector unsigned short *__b) {
12880   return vec_perm(vec_ldl(__a, __b), (vector unsigned short)(0),
12881                   vec_lvsl(__a, (unsigned char *)__b));
12882 }
12883
12884 static __inline__ vector bool short __ATTRS_o_ai
12885 vec_lvlxl(int __a, const vector bool short *__b) {
12886   return vec_perm(vec_ldl(__a, __b), (vector bool short)(0),
12887                   vec_lvsl(__a, (unsigned char *)__b));
12888 }
12889
12890 static __inline__ vector pixel __ATTRS_o_ai vec_lvlxl(int __a,
12891                                                       const vector pixel *__b) {
12892   return vec_perm(vec_ldl(__a, __b), (vector pixel)(0),
12893                   vec_lvsl(__a, (unsigned char *)__b));
12894 }
12895
12896 static __inline__ vector int __ATTRS_o_ai vec_lvlxl(int __a, const int *__b) {
12897   return vec_perm(vec_ldl(__a, __b), (vector int)(0), vec_lvsl(__a, __b));
12898 }
12899
12900 static __inline__ vector int __ATTRS_o_ai vec_lvlxl(int __a,
12901                                                     const vector int *__b) {
12902   return vec_perm(vec_ldl(__a, __b), (vector int)(0),
12903                   vec_lvsl(__a, (unsigned char *)__b));
12904 }
12905
12906 static __inline__ vector unsigned int __ATTRS_o_ai
12907 vec_lvlxl(int __a, const unsigned int *__b) {
12908   return vec_perm(vec_ldl(__a, __b), (vector unsigned int)(0),
12909                   vec_lvsl(__a, __b));
12910 }
12911
12912 static __inline__ vector unsigned int __ATTRS_o_ai
12913 vec_lvlxl(int __a, const vector unsigned int *__b) {
12914   return vec_perm(vec_ldl(__a, __b), (vector unsigned int)(0),
12915                   vec_lvsl(__a, (unsigned char *)__b));
12916 }
12917
12918 static __inline__ vector bool int __ATTRS_o_ai
12919 vec_lvlxl(int __a, const vector bool int *__b) {
12920   return vec_perm(vec_ldl(__a, __b), (vector bool int)(0),
12921                   vec_lvsl(__a, (unsigned char *)__b));
12922 }
12923
12924 static __inline__ vector float __ATTRS_o_ai vec_lvlxl(int __a,
12925                                                       const float *__b) {
12926   return vec_perm(vec_ldl(__a, __b), (vector float)(0), vec_lvsl(__a, __b));
12927 }
12928
12929 static __inline__ vector float __ATTRS_o_ai vec_lvlxl(int __a,
12930                                                       vector float *__b) {
12931   return vec_perm(vec_ldl(__a, __b), (vector float)(0),
12932                   vec_lvsl(__a, (unsigned char *)__b));
12933 }
12934
12935 /* vec_lvrx */
12936
12937 static __inline__ vector signed char __ATTRS_o_ai
12938 vec_lvrx(int __a, const signed char *__b) {
12939   return vec_perm((vector signed char)(0), vec_ld(__a, __b),
12940                   vec_lvsl(__a, __b));
12941 }
12942
12943 static __inline__ vector signed char __ATTRS_o_ai
12944 vec_lvrx(int __a, const vector signed char *__b) {
12945   return vec_perm((vector signed char)(0), vec_ld(__a, __b),
12946                   vec_lvsl(__a, (unsigned char *)__b));
12947 }
12948
12949 static __inline__ vector unsigned char __ATTRS_o_ai
12950 vec_lvrx(int __a, const unsigned char *__b) {
12951   return vec_perm((vector unsigned char)(0), vec_ld(__a, __b),
12952                   vec_lvsl(__a, __b));
12953 }
12954
12955 static __inline__ vector unsigned char __ATTRS_o_ai
12956 vec_lvrx(int __a, const vector unsigned char *__b) {
12957   return vec_perm((vector unsigned char)(0), vec_ld(__a, __b),
12958                   vec_lvsl(__a, (unsigned char *)__b));
12959 }
12960
12961 static __inline__ vector bool char __ATTRS_o_ai
12962 vec_lvrx(int __a, const vector bool char *__b) {
12963   return vec_perm((vector bool char)(0), vec_ld(__a, __b),
12964                   vec_lvsl(__a, (unsigned char *)__b));
12965 }
12966
12967 static __inline__ vector short __ATTRS_o_ai vec_lvrx(int __a,
12968                                                      const short *__b) {
12969   return vec_perm((vector short)(0), vec_ld(__a, __b), vec_lvsl(__a, __b));
12970 }
12971
12972 static __inline__ vector short __ATTRS_o_ai vec_lvrx(int __a,
12973                                                      const vector short *__b) {
12974   return vec_perm((vector short)(0), vec_ld(__a, __b),
12975                   vec_lvsl(__a, (unsigned char *)__b));
12976 }
12977
12978 static __inline__ vector unsigned short __ATTRS_o_ai
12979 vec_lvrx(int __a, const unsigned short *__b) {
12980   return vec_perm((vector unsigned short)(0), vec_ld(__a, __b),
12981                   vec_lvsl(__a, __b));
12982 }
12983
12984 static __inline__ vector unsigned short __ATTRS_o_ai
12985 vec_lvrx(int __a, const vector unsigned short *__b) {
12986   return vec_perm((vector unsigned short)(0), vec_ld(__a, __b),
12987                   vec_lvsl(__a, (unsigned char *)__b));
12988 }
12989
12990 static __inline__ vector bool short __ATTRS_o_ai
12991 vec_lvrx(int __a, const vector bool short *__b) {
12992   return vec_perm((vector bool short)(0), vec_ld(__a, __b),
12993                   vec_lvsl(__a, (unsigned char *)__b));
12994 }
12995
12996 static __inline__ vector pixel __ATTRS_o_ai vec_lvrx(int __a,
12997                                                      const vector pixel *__b) {
12998   return vec_perm((vector pixel)(0), vec_ld(__a, __b),
12999                   vec_lvsl(__a, (unsigned char *)__b));
13000 }
13001
13002 static __inline__ vector int __ATTRS_o_ai vec_lvrx(int __a, const int *__b) {
13003   return vec_perm((vector int)(0), vec_ld(__a, __b), vec_lvsl(__a, __b));
13004 }
13005
13006 static __inline__ vector int __ATTRS_o_ai vec_lvrx(int __a,
13007                                                    const vector int *__b) {
13008   return vec_perm((vector int)(0), vec_ld(__a, __b),
13009                   vec_lvsl(__a, (unsigned char *)__b));
13010 }
13011
13012 static __inline__ vector unsigned int __ATTRS_o_ai
13013 vec_lvrx(int __a, const unsigned int *__b) {
13014   return vec_perm((vector unsigned int)(0), vec_ld(__a, __b),
13015                   vec_lvsl(__a, __b));
13016 }
13017
13018 static __inline__ vector unsigned int __ATTRS_o_ai
13019 vec_lvrx(int __a, const vector unsigned int *__b) {
13020   return vec_perm((vector unsigned int)(0), vec_ld(__a, __b),
13021                   vec_lvsl(__a, (unsigned char *)__b));
13022 }
13023
13024 static __inline__ vector bool int __ATTRS_o_ai
13025 vec_lvrx(int __a, const vector bool int *__b) {
13026   return vec_perm((vector bool int)(0), vec_ld(__a, __b),
13027                   vec_lvsl(__a, (unsigned char *)__b));
13028 }
13029
13030 static __inline__ vector float __ATTRS_o_ai vec_lvrx(int __a,
13031                                                      const float *__b) {
13032   return vec_perm((vector float)(0), vec_ld(__a, __b), vec_lvsl(__a, __b));
13033 }
13034
13035 static __inline__ vector float __ATTRS_o_ai vec_lvrx(int __a,
13036                                                      const vector float *__b) {
13037   return vec_perm((vector float)(0), vec_ld(__a, __b),
13038                   vec_lvsl(__a, (unsigned char *)__b));
13039 }
13040
13041 /* vec_lvrxl */
13042
13043 static __inline__ vector signed char __ATTRS_o_ai
13044 vec_lvrxl(int __a, const signed char *__b) {
13045   return vec_perm((vector signed char)(0), vec_ldl(__a, __b),
13046                   vec_lvsl(__a, __b));
13047 }
13048
13049 static __inline__ vector signed char __ATTRS_o_ai
13050 vec_lvrxl(int __a, const vector signed char *__b) {
13051   return vec_perm((vector signed char)(0), vec_ldl(__a, __b),
13052                   vec_lvsl(__a, (unsigned char *)__b));
13053 }
13054
13055 static __inline__ vector unsigned char __ATTRS_o_ai
13056 vec_lvrxl(int __a, const unsigned char *__b) {
13057   return vec_perm((vector unsigned char)(0), vec_ldl(__a, __b),
13058                   vec_lvsl(__a, __b));
13059 }
13060
13061 static __inline__ vector unsigned char __ATTRS_o_ai
13062 vec_lvrxl(int __a, const vector unsigned char *__b) {
13063   return vec_perm((vector unsigned char)(0), vec_ldl(__a, __b),
13064                   vec_lvsl(__a, (unsigned char *)__b));
13065 }
13066
13067 static __inline__ vector bool char __ATTRS_o_ai
13068 vec_lvrxl(int __a, const vector bool char *__b) {
13069   return vec_perm((vector bool char)(0), vec_ldl(__a, __b),
13070                   vec_lvsl(__a, (unsigned char *)__b));
13071 }
13072
13073 static __inline__ vector short __ATTRS_o_ai vec_lvrxl(int __a,
13074                                                       const short *__b) {
13075   return vec_perm((vector short)(0), vec_ldl(__a, __b), vec_lvsl(__a, __b));
13076 }
13077
13078 static __inline__ vector short __ATTRS_o_ai vec_lvrxl(int __a,
13079                                                       const vector short *__b) {
13080   return vec_perm((vector short)(0), vec_ldl(__a, __b),
13081                   vec_lvsl(__a, (unsigned char *)__b));
13082 }
13083
13084 static __inline__ vector unsigned short __ATTRS_o_ai
13085 vec_lvrxl(int __a, const unsigned short *__b) {
13086   return vec_perm((vector unsigned short)(0), vec_ldl(__a, __b),
13087                   vec_lvsl(__a, __b));
13088 }
13089
13090 static __inline__ vector unsigned short __ATTRS_o_ai
13091 vec_lvrxl(int __a, const vector unsigned short *__b) {
13092   return vec_perm((vector unsigned short)(0), vec_ldl(__a, __b),
13093                   vec_lvsl(__a, (unsigned char *)__b));
13094 }
13095
13096 static __inline__ vector bool short __ATTRS_o_ai
13097 vec_lvrxl(int __a, const vector bool short *__b) {
13098   return vec_perm((vector bool short)(0), vec_ldl(__a, __b),
13099                   vec_lvsl(__a, (unsigned char *)__b));
13100 }
13101
13102 static __inline__ vector pixel __ATTRS_o_ai vec_lvrxl(int __a,
13103                                                       const vector pixel *__b) {
13104   return vec_perm((vector pixel)(0), vec_ldl(__a, __b),
13105                   vec_lvsl(__a, (unsigned char *)__b));
13106 }
13107
13108 static __inline__ vector int __ATTRS_o_ai vec_lvrxl(int __a, const int *__b) {
13109   return vec_perm((vector int)(0), vec_ldl(__a, __b), vec_lvsl(__a, __b));
13110 }
13111
13112 static __inline__ vector int __ATTRS_o_ai vec_lvrxl(int __a,
13113                                                     const vector int *__b) {
13114   return vec_perm((vector int)(0), vec_ldl(__a, __b),
13115                   vec_lvsl(__a, (unsigned char *)__b));
13116 }
13117
13118 static __inline__ vector unsigned int __ATTRS_o_ai
13119 vec_lvrxl(int __a, const unsigned int *__b) {
13120   return vec_perm((vector unsigned int)(0), vec_ldl(__a, __b),
13121                   vec_lvsl(__a, __b));
13122 }
13123
13124 static __inline__ vector unsigned int __ATTRS_o_ai
13125 vec_lvrxl(int __a, const vector unsigned int *__b) {
13126   return vec_perm((vector unsigned int)(0), vec_ldl(__a, __b),
13127                   vec_lvsl(__a, (unsigned char *)__b));
13128 }
13129
13130 static __inline__ vector bool int __ATTRS_o_ai
13131 vec_lvrxl(int __a, const vector bool int *__b) {
13132   return vec_perm((vector bool int)(0), vec_ldl(__a, __b),
13133                   vec_lvsl(__a, (unsigned char *)__b));
13134 }
13135
13136 static __inline__ vector float __ATTRS_o_ai vec_lvrxl(int __a,
13137                                                       const float *__b) {
13138   return vec_perm((vector float)(0), vec_ldl(__a, __b), vec_lvsl(__a, __b));
13139 }
13140
13141 static __inline__ vector float __ATTRS_o_ai vec_lvrxl(int __a,
13142                                                       const vector float *__b) {
13143   return vec_perm((vector float)(0), vec_ldl(__a, __b),
13144                   vec_lvsl(__a, (unsigned char *)__b));
13145 }
13146
13147 /* vec_stvlx */
13148
13149 static __inline__ void __ATTRS_o_ai vec_stvlx(vector signed char __a, int __b,
13150                                               signed char *__c) {
13151   return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13152                 __c);
13153 }
13154
13155 static __inline__ void __ATTRS_o_ai vec_stvlx(vector signed char __a, int __b,
13156                                               vector signed char *__c) {
13157   return vec_st(
13158       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13159       __b, __c);
13160 }
13161
13162 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned char __a, int __b,
13163                                               unsigned char *__c) {
13164   return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13165                 __c);
13166 }
13167
13168 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned char __a, int __b,
13169                                               vector unsigned char *__c) {
13170   return vec_st(
13171       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13172       __b, __c);
13173 }
13174
13175 static __inline__ void __ATTRS_o_ai vec_stvlx(vector bool char __a, int __b,
13176                                               vector bool char *__c) {
13177   return vec_st(
13178       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13179       __b, __c);
13180 }
13181
13182 static __inline__ void __ATTRS_o_ai vec_stvlx(vector short __a, int __b,
13183                                               short *__c) {
13184   return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13185                 __c);
13186 }
13187
13188 static __inline__ void __ATTRS_o_ai vec_stvlx(vector short __a, int __b,
13189                                               vector short *__c) {
13190   return vec_st(
13191       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13192       __b, __c);
13193 }
13194
13195 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned short __a,
13196                                               int __b, unsigned short *__c) {
13197   return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13198                 __c);
13199 }
13200
13201 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned short __a,
13202                                               int __b,
13203                                               vector unsigned short *__c) {
13204   return vec_st(
13205       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13206       __b, __c);
13207 }
13208
13209 static __inline__ void __ATTRS_o_ai vec_stvlx(vector bool short __a, int __b,
13210                                               vector bool short *__c) {
13211   return vec_st(
13212       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13213       __b, __c);
13214 }
13215
13216 static __inline__ void __ATTRS_o_ai vec_stvlx(vector pixel __a, int __b,
13217                                               vector pixel *__c) {
13218   return vec_st(
13219       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13220       __b, __c);
13221 }
13222
13223 static __inline__ void __ATTRS_o_ai vec_stvlx(vector int __a, int __b,
13224                                               int *__c) {
13225   return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13226                 __c);
13227 }
13228
13229 static __inline__ void __ATTRS_o_ai vec_stvlx(vector int __a, int __b,
13230                                               vector int *__c) {
13231   return vec_st(
13232       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13233       __b, __c);
13234 }
13235
13236 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned int __a, int __b,
13237                                               unsigned int *__c) {
13238   return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13239                 __c);
13240 }
13241
13242 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned int __a, int __b,
13243                                               vector unsigned int *__c) {
13244   return vec_st(
13245       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13246       __b, __c);
13247 }
13248
13249 static __inline__ void __ATTRS_o_ai vec_stvlx(vector bool int __a, int __b,
13250                                               vector bool int *__c) {
13251   return vec_st(
13252       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13253       __b, __c);
13254 }
13255
13256 static __inline__ void __ATTRS_o_ai vec_stvlx(vector float __a, int __b,
13257                                               vector float *__c) {
13258   return vec_st(
13259       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13260       __b, __c);
13261 }
13262
13263 /* vec_stvlxl */
13264
13265 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector signed char __a, int __b,
13266                                                signed char *__c) {
13267   return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13268                  __c);
13269 }
13270
13271 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector signed char __a, int __b,
13272                                                vector signed char *__c) {
13273   return vec_stl(
13274       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13275       __b, __c);
13276 }
13277
13278 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned char __a,
13279                                                int __b, unsigned char *__c) {
13280   return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13281                  __c);
13282 }
13283
13284 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned char __a,
13285                                                int __b,
13286                                                vector unsigned char *__c) {
13287   return vec_stl(
13288       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13289       __b, __c);
13290 }
13291
13292 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector bool char __a, int __b,
13293                                                vector bool char *__c) {
13294   return vec_stl(
13295       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13296       __b, __c);
13297 }
13298
13299 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector short __a, int __b,
13300                                                short *__c) {
13301   return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13302                  __c);
13303 }
13304
13305 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector short __a, int __b,
13306                                                vector short *__c) {
13307   return vec_stl(
13308       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13309       __b, __c);
13310 }
13311
13312 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned short __a,
13313                                                int __b, unsigned short *__c) {
13314   return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13315                  __c);
13316 }
13317
13318 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned short __a,
13319                                                int __b,
13320                                                vector unsigned short *__c) {
13321   return vec_stl(
13322       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13323       __b, __c);
13324 }
13325
13326 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector bool short __a, int __b,
13327                                                vector bool short *__c) {
13328   return vec_stl(
13329       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13330       __b, __c);
13331 }
13332
13333 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector pixel __a, int __b,
13334                                                vector pixel *__c) {
13335   return vec_stl(
13336       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13337       __b, __c);
13338 }
13339
13340 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector int __a, int __b,
13341                                                int *__c) {
13342   return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13343                  __c);
13344 }
13345
13346 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector int __a, int __b,
13347                                                vector int *__c) {
13348   return vec_stl(
13349       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13350       __b, __c);
13351 }
13352
13353 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned int __a, int __b,
13354                                                unsigned int *__c) {
13355   return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13356                  __c);
13357 }
13358
13359 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned int __a, int __b,
13360                                                vector unsigned int *__c) {
13361   return vec_stl(
13362       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13363       __b, __c);
13364 }
13365
13366 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector bool int __a, int __b,
13367                                                vector bool int *__c) {
13368   return vec_stl(
13369       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13370       __b, __c);
13371 }
13372
13373 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector float __a, int __b,
13374                                                vector float *__c) {
13375   return vec_stl(
13376       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13377       __b, __c);
13378 }
13379
13380 /* vec_stvrx */
13381
13382 static __inline__ void __ATTRS_o_ai vec_stvrx(vector signed char __a, int __b,
13383                                               signed char *__c) {
13384   return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13385                 __c);
13386 }
13387
13388 static __inline__ void __ATTRS_o_ai vec_stvrx(vector signed char __a, int __b,
13389                                               vector signed char *__c) {
13390   return vec_st(
13391       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13392       __b, __c);
13393 }
13394
13395 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned char __a, int __b,
13396                                               unsigned char *__c) {
13397   return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13398                 __c);
13399 }
13400
13401 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned char __a, int __b,
13402                                               vector unsigned char *__c) {
13403   return vec_st(
13404       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13405       __b, __c);
13406 }
13407
13408 static __inline__ void __ATTRS_o_ai vec_stvrx(vector bool char __a, int __b,
13409                                               vector bool char *__c) {
13410   return vec_st(
13411       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13412       __b, __c);
13413 }
13414
13415 static __inline__ void __ATTRS_o_ai vec_stvrx(vector short __a, int __b,
13416                                               short *__c) {
13417   return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13418                 __c);
13419 }
13420
13421 static __inline__ void __ATTRS_o_ai vec_stvrx(vector short __a, int __b,
13422                                               vector short *__c) {
13423   return vec_st(
13424       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13425       __b, __c);
13426 }
13427
13428 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned short __a,
13429                                               int __b, unsigned short *__c) {
13430   return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13431                 __c);
13432 }
13433
13434 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned short __a,
13435                                               int __b,
13436                                               vector unsigned short *__c) {
13437   return vec_st(
13438       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13439       __b, __c);
13440 }
13441
13442 static __inline__ void __ATTRS_o_ai vec_stvrx(vector bool short __a, int __b,
13443                                               vector bool short *__c) {
13444   return vec_st(
13445       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13446       __b, __c);
13447 }
13448
13449 static __inline__ void __ATTRS_o_ai vec_stvrx(vector pixel __a, int __b,
13450                                               vector pixel *__c) {
13451   return vec_st(
13452       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13453       __b, __c);
13454 }
13455
13456 static __inline__ void __ATTRS_o_ai vec_stvrx(vector int __a, int __b,
13457                                               int *__c) {
13458   return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13459                 __c);
13460 }
13461
13462 static __inline__ void __ATTRS_o_ai vec_stvrx(vector int __a, int __b,
13463                                               vector int *__c) {
13464   return vec_st(
13465       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13466       __b, __c);
13467 }
13468
13469 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned int __a, int __b,
13470                                               unsigned int *__c) {
13471   return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13472                 __c);
13473 }
13474
13475 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned int __a, int __b,
13476                                               vector unsigned int *__c) {
13477   return vec_st(
13478       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13479       __b, __c);
13480 }
13481
13482 static __inline__ void __ATTRS_o_ai vec_stvrx(vector bool int __a, int __b,
13483                                               vector bool int *__c) {
13484   return vec_st(
13485       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13486       __b, __c);
13487 }
13488
13489 static __inline__ void __ATTRS_o_ai vec_stvrx(vector float __a, int __b,
13490                                               vector float *__c) {
13491   return vec_st(
13492       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13493       __b, __c);
13494 }
13495
13496 /* vec_stvrxl */
13497
13498 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector signed char __a, int __b,
13499                                                signed char *__c) {
13500   return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13501                  __c);
13502 }
13503
13504 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector signed char __a, int __b,
13505                                                vector signed char *__c) {
13506   return vec_stl(
13507       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13508       __b, __c);
13509 }
13510
13511 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned char __a,
13512                                                int __b, unsigned char *__c) {
13513   return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13514                  __c);
13515 }
13516
13517 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned char __a,
13518                                                int __b,
13519                                                vector unsigned char *__c) {
13520   return vec_stl(
13521       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13522       __b, __c);
13523 }
13524
13525 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector bool char __a, int __b,
13526                                                vector bool char *__c) {
13527   return vec_stl(
13528       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13529       __b, __c);
13530 }
13531
13532 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector short __a, int __b,
13533                                                short *__c) {
13534   return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13535                  __c);
13536 }
13537
13538 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector short __a, int __b,
13539                                                vector short *__c) {
13540   return vec_stl(
13541       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13542       __b, __c);
13543 }
13544
13545 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned short __a,
13546                                                int __b, unsigned short *__c) {
13547   return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13548                  __c);
13549 }
13550
13551 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned short __a,
13552                                                int __b,
13553                                                vector unsigned short *__c) {
13554   return vec_stl(
13555       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13556       __b, __c);
13557 }
13558
13559 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector bool short __a, int __b,
13560                                                vector bool short *__c) {
13561   return vec_stl(
13562       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13563       __b, __c);
13564 }
13565
13566 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector pixel __a, int __b,
13567                                                vector pixel *__c) {
13568   return vec_stl(
13569       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13570       __b, __c);
13571 }
13572
13573 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector int __a, int __b,
13574                                                int *__c) {
13575   return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13576                  __c);
13577 }
13578
13579 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector int __a, int __b,
13580                                                vector int *__c) {
13581   return vec_stl(
13582       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13583       __b, __c);
13584 }
13585
13586 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned int __a, int __b,
13587                                                unsigned int *__c) {
13588   return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13589                  __c);
13590 }
13591
13592 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned int __a, int __b,
13593                                                vector unsigned int *__c) {
13594   return vec_stl(
13595       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13596       __b, __c);
13597 }
13598
13599 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector bool int __a, int __b,
13600                                                vector bool int *__c) {
13601   return vec_stl(
13602       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13603       __b, __c);
13604 }
13605
13606 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector float __a, int __b,
13607                                                vector float *__c) {
13608   return vec_stl(
13609       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13610       __b, __c);
13611 }
13612
13613 /* vec_promote */
13614
13615 static __inline__ vector signed char __ATTRS_o_ai vec_promote(signed char __a,
13616                                                               int __b) {
13617   vector signed char __res = (vector signed char)(0);
13618   __res[__b] = __a;
13619   return __res;
13620 }
13621
13622 static __inline__ vector unsigned char __ATTRS_o_ai
13623 vec_promote(unsigned char __a, int __b) {
13624   vector unsigned char __res = (vector unsigned char)(0);
13625   __res[__b] = __a;
13626   return __res;
13627 }
13628
13629 static __inline__ vector short __ATTRS_o_ai vec_promote(short __a, int __b) {
13630   vector short __res = (vector short)(0);
13631   __res[__b] = __a;
13632   return __res;
13633 }
13634
13635 static __inline__ vector unsigned short __ATTRS_o_ai
13636 vec_promote(unsigned short __a, int __b) {
13637   vector unsigned short __res = (vector unsigned short)(0);
13638   __res[__b] = __a;
13639   return __res;
13640 }
13641
13642 static __inline__ vector int __ATTRS_o_ai vec_promote(int __a, int __b) {
13643   vector int __res = (vector int)(0);
13644   __res[__b] = __a;
13645   return __res;
13646 }
13647
13648 static __inline__ vector unsigned int __ATTRS_o_ai vec_promote(unsigned int __a,
13649                                                                int __b) {
13650   vector unsigned int __res = (vector unsigned int)(0);
13651   __res[__b] = __a;
13652   return __res;
13653 }
13654
13655 static __inline__ vector float __ATTRS_o_ai vec_promote(float __a, int __b) {
13656   vector float __res = (vector float)(0);
13657   __res[__b] = __a;
13658   return __res;
13659 }
13660
13661 /* vec_splats */
13662
13663 static __inline__ vector signed char __ATTRS_o_ai vec_splats(signed char __a) {
13664   return (vector signed char)(__a);
13665 }
13666
13667 static __inline__ vector unsigned char __ATTRS_o_ai
13668 vec_splats(unsigned char __a) {
13669   return (vector unsigned char)(__a);
13670 }
13671
13672 static __inline__ vector short __ATTRS_o_ai vec_splats(short __a) {
13673   return (vector short)(__a);
13674 }
13675
13676 static __inline__ vector unsigned short __ATTRS_o_ai
13677 vec_splats(unsigned short __a) {
13678   return (vector unsigned short)(__a);
13679 }
13680
13681 static __inline__ vector int __ATTRS_o_ai vec_splats(int __a) {
13682   return (vector int)(__a);
13683 }
13684
13685 static __inline__ vector unsigned int __ATTRS_o_ai
13686 vec_splats(unsigned int __a) {
13687   return (vector unsigned int)(__a);
13688 }
13689
13690 #ifdef __VSX__
13691 static __inline__ vector signed long long __ATTRS_o_ai
13692 vec_splats(signed long long __a) {
13693   return (vector signed long long)(__a);
13694 }
13695
13696 static __inline__ vector unsigned long long __ATTRS_o_ai
13697 vec_splats(unsigned long long __a) {
13698   return (vector unsigned long long)(__a);
13699 }
13700
13701 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
13702 static __inline__ vector signed __int128 __ATTRS_o_ai
13703 vec_splats(signed __int128 __a) {
13704   return (vector signed __int128)(__a);
13705 }
13706
13707 static __inline__ vector unsigned __int128 __ATTRS_o_ai
13708 vec_splats(unsigned __int128 __a) {
13709   return (vector unsigned __int128)(__a);
13710 }
13711
13712 #endif
13713
13714 static __inline__ vector double __ATTRS_o_ai vec_splats(double __a) {
13715   return (vector double)(__a);
13716 }
13717 #endif
13718
13719 static __inline__ vector float __ATTRS_o_ai vec_splats(float __a) {
13720   return (vector float)(__a);
13721 }
13722
13723 /* ----------------------------- predicates --------------------------------- */
13724
13725 /* vec_all_eq */
13726
13727 static __inline__ int __ATTRS_o_ai vec_all_eq(vector signed char __a,
13728                                               vector signed char __b) {
13729   return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
13730                                       (vector char)__b);
13731 }
13732
13733 static __inline__ int __ATTRS_o_ai vec_all_eq(vector signed char __a,
13734                                               vector bool char __b) {
13735   return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
13736                                       (vector char)__b);
13737 }
13738
13739 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned char __a,
13740                                               vector unsigned char __b) {
13741   return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
13742                                       (vector char)__b);
13743 }
13744
13745 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned char __a,
13746                                               vector bool char __b) {
13747   return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
13748                                       (vector char)__b);
13749 }
13750
13751 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool char __a,
13752                                               vector signed char __b) {
13753   return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
13754                                       (vector char)__b);
13755 }
13756
13757 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool char __a,
13758                                               vector unsigned char __b) {
13759   return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
13760                                       (vector char)__b);
13761 }
13762
13763 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool char __a,
13764                                               vector bool char __b) {
13765   return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
13766                                       (vector char)__b);
13767 }
13768
13769 static __inline__ int __ATTRS_o_ai vec_all_eq(vector short __a,
13770                                               vector short __b) {
13771   return __builtin_altivec_vcmpequh_p(__CR6_LT, __a, __b);
13772 }
13773
13774 static __inline__ int __ATTRS_o_ai vec_all_eq(vector short __a,
13775                                               vector bool short __b) {
13776   return __builtin_altivec_vcmpequh_p(__CR6_LT, __a, (vector short)__b);
13777 }
13778
13779 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned short __a,
13780                                               vector unsigned short __b) {
13781   return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
13782                                       (vector short)__b);
13783 }
13784
13785 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned short __a,
13786                                               vector bool short __b) {
13787   return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
13788                                       (vector short)__b);
13789 }
13790
13791 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool short __a,
13792                                               vector short __b) {
13793   return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
13794                                       (vector short)__b);
13795 }
13796
13797 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool short __a,
13798                                               vector unsigned short __b) {
13799   return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
13800                                       (vector short)__b);
13801 }
13802
13803 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool short __a,
13804                                               vector bool short __b) {
13805   return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
13806                                       (vector short)__b);
13807 }
13808
13809 static __inline__ int __ATTRS_o_ai vec_all_eq(vector pixel __a,
13810                                               vector pixel __b) {
13811   return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
13812                                       (vector short)__b);
13813 }
13814
13815 static __inline__ int __ATTRS_o_ai vec_all_eq(vector int __a, vector int __b) {
13816   return __builtin_altivec_vcmpequw_p(__CR6_LT, __a, __b);
13817 }
13818
13819 static __inline__ int __ATTRS_o_ai vec_all_eq(vector int __a,
13820                                               vector bool int __b) {
13821   return __builtin_altivec_vcmpequw_p(__CR6_LT, __a, (vector int)__b);
13822 }
13823
13824 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned int __a,
13825                                               vector unsigned int __b) {
13826   return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
13827                                       (vector int)__b);
13828 }
13829
13830 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned int __a,
13831                                               vector bool int __b) {
13832   return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
13833                                       (vector int)__b);
13834 }
13835
13836 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool int __a,
13837                                               vector int __b) {
13838   return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
13839                                       (vector int)__b);
13840 }
13841
13842 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool int __a,
13843                                               vector unsigned int __b) {
13844   return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
13845                                       (vector int)__b);
13846 }
13847
13848 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool int __a,
13849                                               vector bool int __b) {
13850   return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
13851                                       (vector int)__b);
13852 }
13853
13854 #ifdef __POWER8_VECTOR__
13855 static __inline__ int __ATTRS_o_ai vec_all_eq(vector signed long long __a,
13856                                               vector signed long long __b) {
13857   return __builtin_altivec_vcmpequd_p(__CR6_LT, __a, __b);
13858 }
13859
13860 static __inline__ int __ATTRS_o_ai vec_all_eq(vector long long __a,
13861                                               vector bool long long __b) {
13862   return __builtin_altivec_vcmpequd_p(__CR6_LT, __a, (vector long long)__b);
13863 }
13864
13865 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned long long __a,
13866                                               vector unsigned long long __b) {
13867   return __builtin_altivec_vcmpequd_p(__CR6_LT, (vector long long)__a,
13868                                       (vector long long)__b);
13869 }
13870
13871 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned long long __a,
13872                                               vector bool long long __b) {
13873   return __builtin_altivec_vcmpequd_p(__CR6_LT, (vector long long)__a,
13874                                       (vector long long)__b);
13875 }
13876
13877 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool long long __a,
13878                                               vector long long __b) {
13879   return __builtin_altivec_vcmpequd_p(__CR6_LT, (vector long long)__a,
13880                                       (vector long long)__b);
13881 }
13882
13883 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool long long __a,
13884                                               vector unsigned long long __b) {
13885   return __builtin_altivec_vcmpequd_p(__CR6_LT, (vector long long)__a,
13886                                       (vector long long)__b);
13887 }
13888
13889 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool long long __a,
13890                                               vector bool long long __b) {
13891   return __builtin_altivec_vcmpequd_p(__CR6_LT, (vector long long)__a,
13892                                       (vector long long)__b);
13893 }
13894 #endif
13895
13896 static __inline__ int __ATTRS_o_ai vec_all_eq(vector float __a,
13897                                               vector float __b) {
13898 #ifdef __VSX__
13899   return __builtin_vsx_xvcmpeqsp_p(__CR6_LT, __a, __b);
13900 #else
13901   return __builtin_altivec_vcmpeqfp_p(__CR6_LT, __a, __b);
13902 #endif
13903 }
13904
13905 #ifdef __VSX__
13906 static __inline__ int __ATTRS_o_ai vec_all_eq(vector double __a,
13907                                               vector double __b) {
13908   return __builtin_vsx_xvcmpeqdp_p(__CR6_LT, __a, __b);
13909 }
13910 #endif
13911
13912 /* vec_all_ge */
13913
13914 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed char __a,
13915                                               vector signed char __b) {
13916   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, __b, __a);
13917 }
13918
13919 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed char __a,
13920                                               vector bool char __b) {
13921   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, (vector signed char)__b, __a);
13922 }
13923
13924 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned char __a,
13925                                               vector unsigned char __b) {
13926   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __b, __a);
13927 }
13928
13929 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned char __a,
13930                                               vector bool char __b) {
13931   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__b, __a);
13932 }
13933
13934 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool char __a,
13935                                               vector signed char __b) {
13936   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__b,
13937                                       (vector unsigned char)__a);
13938 }
13939
13940 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool char __a,
13941                                               vector unsigned char __b) {
13942   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __b, (vector unsigned char)__a);
13943 }
13944
13945 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool char __a,
13946                                               vector bool char __b) {
13947   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__b,
13948                                       (vector unsigned char)__a);
13949 }
13950
13951 static __inline__ int __ATTRS_o_ai vec_all_ge(vector short __a,
13952                                               vector short __b) {
13953   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, __b, __a);
13954 }
13955
13956 static __inline__ int __ATTRS_o_ai vec_all_ge(vector short __a,
13957                                               vector bool short __b) {
13958   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, (vector short)__b, __a);
13959 }
13960
13961 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned short __a,
13962                                               vector unsigned short __b) {
13963   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __b, __a);
13964 }
13965
13966 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned short __a,
13967                                               vector bool short __b) {
13968   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__b,
13969                                       __a);
13970 }
13971
13972 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool short __a,
13973                                               vector short __b) {
13974   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__b,
13975                                       (vector unsigned short)__a);
13976 }
13977
13978 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool short __a,
13979                                               vector unsigned short __b) {
13980   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __b,
13981                                       (vector unsigned short)__a);
13982 }
13983
13984 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool short __a,
13985                                               vector bool short __b) {
13986   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__b,
13987                                       (vector unsigned short)__a);
13988 }
13989
13990 static __inline__ int __ATTRS_o_ai vec_all_ge(vector int __a, vector int __b) {
13991   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, __b, __a);
13992 }
13993
13994 static __inline__ int __ATTRS_o_ai vec_all_ge(vector int __a,
13995                                               vector bool int __b) {
13996   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, (vector int)__b, __a);
13997 }
13998
13999 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned int __a,
14000                                               vector unsigned int __b) {
14001   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __b, __a);
14002 }
14003
14004 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned int __a,
14005                                               vector bool int __b) {
14006   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__b, __a);
14007 }
14008
14009 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool int __a,
14010                                               vector int __b) {
14011   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__b,
14012                                       (vector unsigned int)__a);
14013 }
14014
14015 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool int __a,
14016                                               vector unsigned int __b) {
14017   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __b, (vector unsigned int)__a);
14018 }
14019
14020 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool int __a,
14021                                               vector bool int __b) {
14022   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__b,
14023                                       (vector unsigned int)__a);
14024 }
14025
14026 #ifdef __POWER8_VECTOR__
14027 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed long long __a,
14028                                               vector signed long long __b) {
14029   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, __b, __a);
14030 }
14031 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed long long __a,
14032                                               vector bool long long __b) {
14033   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, (vector signed long long)__b,
14034                                       __a);
14035 }
14036
14037 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned long long __a,
14038                                               vector unsigned long long __b) {
14039   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __b, __a);
14040 }
14041
14042 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned long long __a,
14043                                               vector bool long long __b) {
14044   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__b,
14045                                       __a);
14046 }
14047
14048 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool long long __a,
14049                                               vector signed long long __b) {
14050   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__b,
14051                                       (vector unsigned long long)__a);
14052 }
14053
14054 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool long long __a,
14055                                               vector unsigned long long __b) {
14056   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __b,
14057                                       (vector unsigned long long)__a);
14058 }
14059
14060 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool long long __a,
14061                                               vector bool long long __b) {
14062   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__b,
14063                                       (vector unsigned long long)__a);
14064 }
14065 #endif
14066
14067 static __inline__ int __ATTRS_o_ai vec_all_ge(vector float __a,
14068                                               vector float __b) {
14069 #ifdef __VSX__
14070   return __builtin_vsx_xvcmpgesp_p(__CR6_LT, __a, __b);
14071 #else
14072   return __builtin_altivec_vcmpgefp_p(__CR6_LT, __a, __b);
14073 #endif
14074 }
14075
14076 #ifdef __VSX__
14077 static __inline__ int __ATTRS_o_ai vec_all_ge(vector double __a,
14078                                               vector double __b) {
14079   return __builtin_vsx_xvcmpgedp_p(__CR6_LT, __a, __b);
14080 }
14081 #endif
14082
14083 /* vec_all_gt */
14084
14085 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed char __a,
14086                                               vector signed char __b) {
14087   return __builtin_altivec_vcmpgtsb_p(__CR6_LT, __a, __b);
14088 }
14089
14090 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed char __a,
14091                                               vector bool char __b) {
14092   return __builtin_altivec_vcmpgtsb_p(__CR6_LT, __a, (vector signed char)__b);
14093 }
14094
14095 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned char __a,
14096                                               vector unsigned char __b) {
14097   return __builtin_altivec_vcmpgtub_p(__CR6_LT, __a, __b);
14098 }
14099
14100 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned char __a,
14101                                               vector bool char __b) {
14102   return __builtin_altivec_vcmpgtub_p(__CR6_LT, __a, (vector unsigned char)__b);
14103 }
14104
14105 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool char __a,
14106                                               vector signed char __b) {
14107   return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__a,
14108                                       (vector unsigned char)__b);
14109 }
14110
14111 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool char __a,
14112                                               vector unsigned char __b) {
14113   return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__a, __b);
14114 }
14115
14116 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool char __a,
14117                                               vector bool char __b) {
14118   return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__a,
14119                                       (vector unsigned char)__b);
14120 }
14121
14122 static __inline__ int __ATTRS_o_ai vec_all_gt(vector short __a,
14123                                               vector short __b) {
14124   return __builtin_altivec_vcmpgtsh_p(__CR6_LT, __a, __b);
14125 }
14126
14127 static __inline__ int __ATTRS_o_ai vec_all_gt(vector short __a,
14128                                               vector bool short __b) {
14129   return __builtin_altivec_vcmpgtsh_p(__CR6_LT, __a, (vector short)__b);
14130 }
14131
14132 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned short __a,
14133                                               vector unsigned short __b) {
14134   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __a, __b);
14135 }
14136
14137 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned short __a,
14138                                               vector bool short __b) {
14139   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __a,
14140                                       (vector unsigned short)__b);
14141 }
14142
14143 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool short __a,
14144                                               vector short __b) {
14145   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__a,
14146                                       (vector unsigned short)__b);
14147 }
14148
14149 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool short __a,
14150                                               vector unsigned short __b) {
14151   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__a,
14152                                       __b);
14153 }
14154
14155 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool short __a,
14156                                               vector bool short __b) {
14157   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__a,
14158                                       (vector unsigned short)__b);
14159 }
14160
14161 static __inline__ int __ATTRS_o_ai vec_all_gt(vector int __a, vector int __b) {
14162   return __builtin_altivec_vcmpgtsw_p(__CR6_LT, __a, __b);
14163 }
14164
14165 static __inline__ int __ATTRS_o_ai vec_all_gt(vector int __a,
14166                                               vector bool int __b) {
14167   return __builtin_altivec_vcmpgtsw_p(__CR6_LT, __a, (vector int)__b);
14168 }
14169
14170 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned int __a,
14171                                               vector unsigned int __b) {
14172   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __a, __b);
14173 }
14174
14175 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned int __a,
14176                                               vector bool int __b) {
14177   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __a, (vector unsigned int)__b);
14178 }
14179
14180 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool int __a,
14181                                               vector int __b) {
14182   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__a,
14183                                       (vector unsigned int)__b);
14184 }
14185
14186 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool int __a,
14187                                               vector unsigned int __b) {
14188   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__a, __b);
14189 }
14190
14191 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool int __a,
14192                                               vector bool int __b) {
14193   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__a,
14194                                       (vector unsigned int)__b);
14195 }
14196
14197 #ifdef __POWER8_VECTOR__
14198 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed long long __a,
14199                                               vector signed long long __b) {
14200   return __builtin_altivec_vcmpgtsd_p(__CR6_LT, __a, __b);
14201 }
14202 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed long long __a,
14203                                               vector bool long long __b) {
14204   return __builtin_altivec_vcmpgtsd_p(__CR6_LT, __a,
14205                                       (vector signed long long)__b);
14206 }
14207
14208 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned long long __a,
14209                                               vector unsigned long long __b) {
14210   return __builtin_altivec_vcmpgtud_p(__CR6_LT, __a, __b);
14211 }
14212
14213 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned long long __a,
14214                                               vector bool long long __b) {
14215   return __builtin_altivec_vcmpgtud_p(__CR6_LT, __a,
14216                                       (vector unsigned long long)__b);
14217 }
14218
14219 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool long long __a,
14220                                               vector signed long long __b) {
14221   return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__a,
14222                                       (vector unsigned long long)__b);
14223 }
14224
14225 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool long long __a,
14226                                               vector unsigned long long __b) {
14227   return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__a,
14228                                       __b);
14229 }
14230
14231 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool long long __a,
14232                                               vector bool long long __b) {
14233   return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__a,
14234                                       (vector unsigned long long)__b);
14235 }
14236 #endif
14237
14238 static __inline__ int __ATTRS_o_ai vec_all_gt(vector float __a,
14239                                               vector float __b) {
14240 #ifdef __VSX__
14241   return __builtin_vsx_xvcmpgtsp_p(__CR6_LT, __a, __b);
14242 #else
14243   return __builtin_altivec_vcmpgtfp_p(__CR6_LT, __a, __b);
14244 #endif
14245 }
14246
14247 #ifdef __VSX__
14248 static __inline__ int __ATTRS_o_ai vec_all_gt(vector double __a,
14249                                               vector double __b) {
14250   return __builtin_vsx_xvcmpgtdp_p(__CR6_LT, __a, __b);
14251 }
14252 #endif
14253
14254 /* vec_all_in */
14255
14256 static __inline__ int __attribute__((__always_inline__))
14257 vec_all_in(vector float __a, vector float __b) {
14258   return __builtin_altivec_vcmpbfp_p(__CR6_EQ, __a, __b);
14259 }
14260
14261 /* vec_all_le */
14262
14263 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed char __a,
14264                                               vector signed char __b) {
14265   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, __a, __b);
14266 }
14267
14268 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed char __a,
14269                                               vector bool char __b) {
14270   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, __a, (vector signed char)__b);
14271 }
14272
14273 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned char __a,
14274                                               vector unsigned char __b) {
14275   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __a, __b);
14276 }
14277
14278 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned char __a,
14279                                               vector bool char __b) {
14280   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __a, (vector unsigned char)__b);
14281 }
14282
14283 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool char __a,
14284                                               vector signed char __b) {
14285   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__a,
14286                                       (vector unsigned char)__b);
14287 }
14288
14289 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool char __a,
14290                                               vector unsigned char __b) {
14291   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__a, __b);
14292 }
14293
14294 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool char __a,
14295                                               vector bool char __b) {
14296   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__a,
14297                                       (vector unsigned char)__b);
14298 }
14299
14300 static __inline__ int __ATTRS_o_ai vec_all_le(vector short __a,
14301                                               vector short __b) {
14302   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, __a, __b);
14303 }
14304
14305 static __inline__ int __ATTRS_o_ai vec_all_le(vector short __a,
14306                                               vector bool short __b) {
14307   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, __a, (vector short)__b);
14308 }
14309
14310 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned short __a,
14311                                               vector unsigned short __b) {
14312   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __a, __b);
14313 }
14314
14315 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned short __a,
14316                                               vector bool short __b) {
14317   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __a,
14318                                       (vector unsigned short)__b);
14319 }
14320
14321 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool short __a,
14322                                               vector short __b) {
14323   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__a,
14324                                       (vector unsigned short)__b);
14325 }
14326
14327 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool short __a,
14328                                               vector unsigned short __b) {
14329   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__a,
14330                                       __b);
14331 }
14332
14333 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool short __a,
14334                                               vector bool short __b) {
14335   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__a,
14336                                       (vector unsigned short)__b);
14337 }
14338
14339 static __inline__ int __ATTRS_o_ai vec_all_le(vector int __a, vector int __b) {
14340   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, __a, __b);
14341 }
14342
14343 static __inline__ int __ATTRS_o_ai vec_all_le(vector int __a,
14344                                               vector bool int __b) {
14345   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, __a, (vector int)__b);
14346 }
14347
14348 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned int __a,
14349                                               vector unsigned int __b) {
14350   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __a, __b);
14351 }
14352
14353 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned int __a,
14354                                               vector bool int __b) {
14355   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __a, (vector unsigned int)__b);
14356 }
14357
14358 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool int __a,
14359                                               vector int __b) {
14360   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__a,
14361                                       (vector unsigned int)__b);
14362 }
14363
14364 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool int __a,
14365                                               vector unsigned int __b) {
14366   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__a, __b);
14367 }
14368
14369 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool int __a,
14370                                               vector bool int __b) {
14371   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__a,
14372                                       (vector unsigned int)__b);
14373 }
14374
14375 #ifdef __POWER8_VECTOR__
14376 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed long long __a,
14377                                               vector signed long long __b) {
14378   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, __a, __b);
14379 }
14380
14381 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned long long __a,
14382                                               vector unsigned long long __b) {
14383   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __a, __b);
14384 }
14385
14386 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed long long __a,
14387                                               vector bool long long __b) {
14388   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, __a,
14389                                       (vector signed long long)__b);
14390 }
14391
14392 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned long long __a,
14393                                               vector bool long long __b) {
14394   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __a,
14395                                       (vector unsigned long long)__b);
14396 }
14397
14398 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool long long __a,
14399                                               vector signed long long __b) {
14400   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__a,
14401                                       (vector unsigned long long)__b);
14402 }
14403
14404 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool long long __a,
14405                                               vector unsigned long long __b) {
14406   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__a,
14407                                       __b);
14408 }
14409
14410 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool long long __a,
14411                                               vector bool long long __b) {
14412   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__a,
14413                                       (vector unsigned long long)__b);
14414 }
14415 #endif
14416
14417 static __inline__ int __ATTRS_o_ai vec_all_le(vector float __a,
14418                                               vector float __b) {
14419 #ifdef __VSX__
14420   return __builtin_vsx_xvcmpgesp_p(__CR6_LT, __b, __a);
14421 #else
14422   return __builtin_altivec_vcmpgefp_p(__CR6_LT, __b, __a);
14423 #endif
14424 }
14425
14426 #ifdef __VSX__
14427 static __inline__ int __ATTRS_o_ai vec_all_le(vector double __a,
14428                                               vector double __b) {
14429   return __builtin_vsx_xvcmpgedp_p(__CR6_LT, __b, __a);
14430 }
14431 #endif
14432
14433 /* vec_all_lt */
14434
14435 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed char __a,
14436                                               vector signed char __b) {
14437   return __builtin_altivec_vcmpgtsb_p(__CR6_LT, __b, __a);
14438 }
14439
14440 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed char __a,
14441                                               vector bool char __b) {
14442   return __builtin_altivec_vcmpgtsb_p(__CR6_LT, (vector signed char)__b, __a);
14443 }
14444
14445 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned char __a,
14446                                               vector unsigned char __b) {
14447   return __builtin_altivec_vcmpgtub_p(__CR6_LT, __b, __a);
14448 }
14449
14450 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned char __a,
14451                                               vector bool char __b) {
14452   return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__b, __a);
14453 }
14454
14455 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool char __a,
14456                                               vector signed char __b) {
14457   return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__b,
14458                                       (vector unsigned char)__a);
14459 }
14460
14461 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool char __a,
14462                                               vector unsigned char __b) {
14463   return __builtin_altivec_vcmpgtub_p(__CR6_LT, __b, (vector unsigned char)__a);
14464 }
14465
14466 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool char __a,
14467                                               vector bool char __b) {
14468   return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__b,
14469                                       (vector unsigned char)__a);
14470 }
14471
14472 static __inline__ int __ATTRS_o_ai vec_all_lt(vector short __a,
14473                                               vector short __b) {
14474   return __builtin_altivec_vcmpgtsh_p(__CR6_LT, __b, __a);
14475 }
14476
14477 static __inline__ int __ATTRS_o_ai vec_all_lt(vector short __a,
14478                                               vector bool short __b) {
14479   return __builtin_altivec_vcmpgtsh_p(__CR6_LT, (vector short)__b, __a);
14480 }
14481
14482 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned short __a,
14483                                               vector unsigned short __b) {
14484   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __b, __a);
14485 }
14486
14487 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned short __a,
14488                                               vector bool short __b) {
14489   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__b,
14490                                       __a);
14491 }
14492
14493 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool short __a,
14494                                               vector short __b) {
14495   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__b,
14496                                       (vector unsigned short)__a);
14497 }
14498
14499 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool short __a,
14500                                               vector unsigned short __b) {
14501   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __b,
14502                                       (vector unsigned short)__a);
14503 }
14504
14505 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool short __a,
14506                                               vector bool short __b) {
14507   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__b,
14508                                       (vector unsigned short)__a);
14509 }
14510
14511 static __inline__ int __ATTRS_o_ai vec_all_lt(vector int __a, vector int __b) {
14512   return __builtin_altivec_vcmpgtsw_p(__CR6_LT, __b, __a);
14513 }
14514
14515 static __inline__ int __ATTRS_o_ai vec_all_lt(vector int __a,
14516                                               vector bool int __b) {
14517   return __builtin_altivec_vcmpgtsw_p(__CR6_LT, (vector int)__b, __a);
14518 }
14519
14520 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned int __a,
14521                                               vector unsigned int __b) {
14522   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __b, __a);
14523 }
14524
14525 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned int __a,
14526                                               vector bool int __b) {
14527   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__b, __a);
14528 }
14529
14530 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool int __a,
14531                                               vector int __b) {
14532   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__b,
14533                                       (vector unsigned int)__a);
14534 }
14535
14536 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool int __a,
14537                                               vector unsigned int __b) {
14538   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __b, (vector unsigned int)__a);
14539 }
14540
14541 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool int __a,
14542                                               vector bool int __b) {
14543   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__b,
14544                                       (vector unsigned int)__a);
14545 }
14546
14547 #ifdef __POWER8_VECTOR__
14548 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed long long __a,
14549                                               vector signed long long __b) {
14550   return __builtin_altivec_vcmpgtsd_p(__CR6_LT, __b, __a);
14551 }
14552
14553 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned long long __a,
14554                                               vector unsigned long long __b) {
14555   return __builtin_altivec_vcmpgtud_p(__CR6_LT, __b, __a);
14556 }
14557
14558 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed long long __a,
14559                                               vector bool long long __b) {
14560   return __builtin_altivec_vcmpgtsd_p(__CR6_LT, (vector signed long long)__b,
14561                                       __a);
14562 }
14563
14564 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned long long __a,
14565                                               vector bool long long __b) {
14566   return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__b,
14567                                       __a);
14568 }
14569
14570 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool long long __a,
14571                                               vector signed long long __b) {
14572   return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__b,
14573                                       (vector unsigned long long)__a);
14574 }
14575
14576 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool long long __a,
14577                                               vector unsigned long long __b) {
14578   return __builtin_altivec_vcmpgtud_p(__CR6_LT, __b,
14579                                       (vector unsigned long long)__a);
14580 }
14581
14582 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool long long __a,
14583                                               vector bool long long __b) {
14584   return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__b,
14585                                       (vector unsigned long long)__a);
14586 }
14587 #endif
14588
14589 static __inline__ int __ATTRS_o_ai vec_all_lt(vector float __a,
14590                                               vector float __b) {
14591 #ifdef __VSX__
14592   return __builtin_vsx_xvcmpgtsp_p(__CR6_LT, __b, __a);
14593 #else
14594   return __builtin_altivec_vcmpgtfp_p(__CR6_LT, __b, __a);
14595 #endif
14596 }
14597
14598 #ifdef __VSX__
14599 static __inline__ int __ATTRS_o_ai vec_all_lt(vector double __a,
14600                                               vector double __b) {
14601   return __builtin_vsx_xvcmpgtdp_p(__CR6_LT, __b, __a);
14602 }
14603 #endif
14604
14605 /* vec_all_nan */
14606
14607 static __inline__ int __ATTRS_o_ai vec_all_nan(vector float __a) {
14608 #ifdef __VSX__
14609   return __builtin_vsx_xvcmpeqsp_p(__CR6_EQ, __a, __a);
14610 #else
14611   return __builtin_altivec_vcmpeqfp_p(__CR6_EQ, __a, __a);
14612 #endif
14613 }
14614
14615 #ifdef __VSX__
14616 static __inline__ int __ATTRS_o_ai vec_all_nan(vector double __a) {
14617   return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ, __a, __a);
14618 }
14619 #endif
14620
14621 /* vec_all_ne */
14622
14623 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed char __a,
14624                                               vector signed char __b) {
14625   return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
14626                                       (vector char)__b);
14627 }
14628
14629 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed char __a,
14630                                               vector bool char __b) {
14631   return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
14632                                       (vector char)__b);
14633 }
14634
14635 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned char __a,
14636                                               vector unsigned char __b) {
14637   return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
14638                                       (vector char)__b);
14639 }
14640
14641 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned char __a,
14642                                               vector bool char __b) {
14643   return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
14644                                       (vector char)__b);
14645 }
14646
14647 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool char __a,
14648                                               vector signed char __b) {
14649   return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
14650                                       (vector char)__b);
14651 }
14652
14653 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool char __a,
14654                                               vector unsigned char __b) {
14655   return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
14656                                       (vector char)__b);
14657 }
14658
14659 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool char __a,
14660                                               vector bool char __b) {
14661   return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
14662                                       (vector char)__b);
14663 }
14664
14665 static __inline__ int __ATTRS_o_ai vec_all_ne(vector short __a,
14666                                               vector short __b) {
14667   return __builtin_altivec_vcmpequh_p(__CR6_EQ, __a, __b);
14668 }
14669
14670 static __inline__ int __ATTRS_o_ai vec_all_ne(vector short __a,
14671                                               vector bool short __b) {
14672   return __builtin_altivec_vcmpequh_p(__CR6_EQ, __a, (vector short)__b);
14673 }
14674
14675 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned short __a,
14676                                               vector unsigned short __b) {
14677   return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
14678                                       (vector short)__b);
14679 }
14680
14681 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned short __a,
14682                                               vector bool short __b) {
14683   return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
14684                                       (vector short)__b);
14685 }
14686
14687 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool short __a,
14688                                               vector short __b) {
14689   return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
14690                                       (vector short)__b);
14691 }
14692
14693 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool short __a,
14694                                               vector unsigned short __b) {
14695   return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
14696                                       (vector short)__b);
14697 }
14698
14699 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool short __a,
14700                                               vector bool short __b) {
14701   return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
14702                                       (vector short)__b);
14703 }
14704
14705 static __inline__ int __ATTRS_o_ai vec_all_ne(vector pixel __a,
14706                                               vector pixel __b) {
14707   return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
14708                                       (vector short)__b);
14709 }
14710
14711 static __inline__ int __ATTRS_o_ai vec_all_ne(vector int __a, vector int __b) {
14712   return __builtin_altivec_vcmpequw_p(__CR6_EQ, __a, __b);
14713 }
14714
14715 static __inline__ int __ATTRS_o_ai vec_all_ne(vector int __a,
14716                                               vector bool int __b) {
14717   return __builtin_altivec_vcmpequw_p(__CR6_EQ, __a, (vector int)__b);
14718 }
14719
14720 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned int __a,
14721                                               vector unsigned int __b) {
14722   return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
14723                                       (vector int)__b);
14724 }
14725
14726 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned int __a,
14727                                               vector bool int __b) {
14728   return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
14729                                       (vector int)__b);
14730 }
14731
14732 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool int __a,
14733                                               vector int __b) {
14734   return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
14735                                       (vector int)__b);
14736 }
14737
14738 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool int __a,
14739                                               vector unsigned int __b) {
14740   return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
14741                                       (vector int)__b);
14742 }
14743
14744 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool int __a,
14745                                               vector bool int __b) {
14746   return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
14747                                       (vector int)__b);
14748 }
14749
14750 #ifdef __POWER8_VECTOR__
14751 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed long long __a,
14752                                               vector signed long long __b) {
14753   return __builtin_altivec_vcmpequd_p(__CR6_EQ, __a, __b);
14754 }
14755
14756 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned long long __a,
14757                                               vector unsigned long long __b) {
14758   return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector long long)__a,
14759                                       (vector long long)__b);
14760 }
14761
14762 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed long long __a,
14763                                               vector bool long long __b) {
14764   return __builtin_altivec_vcmpequd_p(__CR6_EQ, __a,
14765                                       (vector signed long long)__b);
14766 }
14767
14768 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned long long __a,
14769                                               vector bool long long __b) {
14770   return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector signed long long)__a,
14771                                       (vector signed long long)__b);
14772 }
14773
14774 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool long long __a,
14775                                               vector signed long long __b) {
14776   return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector signed long long)__a,
14777                                       (vector signed long long)__b);
14778 }
14779
14780 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool long long __a,
14781                                               vector unsigned long long __b) {
14782   return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector signed long long)__a,
14783                                       (vector signed long long)__b);
14784 }
14785
14786 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool long long __a,
14787                                               vector bool long long __b) {
14788   return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector signed long long)__a,
14789                                       (vector signed long long)__b);
14790 }
14791 #endif
14792
14793 static __inline__ int __ATTRS_o_ai vec_all_ne(vector float __a,
14794                                               vector float __b) {
14795 #ifdef __VSX__
14796   return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ, __a, __b);
14797 #else
14798   return __builtin_altivec_vcmpeqfp_p(__CR6_EQ, __a, __b);
14799 #endif
14800 }
14801
14802 #ifdef __VSX__
14803 static __inline__ int __ATTRS_o_ai vec_all_ne(vector double __a,
14804                                               vector double __b) {
14805   return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ, __a, __b);
14806 }
14807 #endif
14808
14809 /* vec_all_nge */
14810
14811 static __inline__ int __ATTRS_o_ai vec_all_nge(vector float __a,
14812                                                vector float __b) {
14813 #ifdef __VSX__
14814   return __builtin_vsx_xvcmpgesp_p(__CR6_EQ, __a, __b);
14815 #else
14816   return __builtin_altivec_vcmpgefp_p(__CR6_EQ, __a, __b);
14817 #endif
14818 }
14819
14820 #ifdef __VSX__
14821 static __inline__ int __ATTRS_o_ai vec_all_nge(vector double __a,
14822                                                vector double __b) {
14823   return __builtin_vsx_xvcmpgedp_p(__CR6_EQ, __a, __b);
14824 }
14825 #endif
14826
14827 /* vec_all_ngt */
14828
14829 static __inline__ int __ATTRS_o_ai vec_all_ngt(vector float __a,
14830                                                vector float __b) {
14831 #ifdef __VSX__
14832   return __builtin_vsx_xvcmpgtsp_p(__CR6_EQ, __a, __b);
14833 #else
14834   return __builtin_altivec_vcmpgtfp_p(__CR6_EQ, __a, __b);
14835 #endif
14836 }
14837
14838 #ifdef __VSX__
14839 static __inline__ int __ATTRS_o_ai vec_all_ngt(vector double __a,
14840                                                vector double __b) {
14841   return __builtin_vsx_xvcmpgtdp_p(__CR6_EQ, __a, __b);
14842 }
14843 #endif
14844
14845 /* vec_all_nle */
14846
14847 static __inline__ int __attribute__((__always_inline__))
14848 vec_all_nle(vector float __a, vector float __b) {
14849   return __builtin_altivec_vcmpgefp_p(__CR6_EQ, __b, __a);
14850 }
14851
14852 /* vec_all_nlt */
14853
14854 static __inline__ int __attribute__((__always_inline__))
14855 vec_all_nlt(vector float __a, vector float __b) {
14856   return __builtin_altivec_vcmpgtfp_p(__CR6_EQ, __b, __a);
14857 }
14858
14859 /* vec_all_numeric */
14860
14861 static __inline__ int __attribute__((__always_inline__))
14862 vec_all_numeric(vector float __a) {
14863   return __builtin_altivec_vcmpeqfp_p(__CR6_LT, __a, __a);
14864 }
14865
14866 /* vec_any_eq */
14867
14868 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed char __a,
14869                                               vector signed char __b) {
14870   return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
14871                                       (vector char)__b);
14872 }
14873
14874 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed char __a,
14875                                               vector bool char __b) {
14876   return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
14877                                       (vector char)__b);
14878 }
14879
14880 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned char __a,
14881                                               vector unsigned char __b) {
14882   return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
14883                                       (vector char)__b);
14884 }
14885
14886 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned char __a,
14887                                               vector bool char __b) {
14888   return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
14889                                       (vector char)__b);
14890 }
14891
14892 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool char __a,
14893                                               vector signed char __b) {
14894   return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
14895                                       (vector char)__b);
14896 }
14897
14898 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool char __a,
14899                                               vector unsigned char __b) {
14900   return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
14901                                       (vector char)__b);
14902 }
14903
14904 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool char __a,
14905                                               vector bool char __b) {
14906   return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
14907                                       (vector char)__b);
14908 }
14909
14910 static __inline__ int __ATTRS_o_ai vec_any_eq(vector short __a,
14911                                               vector short __b) {
14912   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, __a, __b);
14913 }
14914
14915 static __inline__ int __ATTRS_o_ai vec_any_eq(vector short __a,
14916                                               vector bool short __b) {
14917   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, __a, (vector short)__b);
14918 }
14919
14920 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned short __a,
14921                                               vector unsigned short __b) {
14922   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
14923                                       (vector short)__b);
14924 }
14925
14926 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned short __a,
14927                                               vector bool short __b) {
14928   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
14929                                       (vector short)__b);
14930 }
14931
14932 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool short __a,
14933                                               vector short __b) {
14934   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
14935                                       (vector short)__b);
14936 }
14937
14938 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool short __a,
14939                                               vector unsigned short __b) {
14940   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
14941                                       (vector short)__b);
14942 }
14943
14944 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool short __a,
14945                                               vector bool short __b) {
14946   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
14947                                       (vector short)__b);
14948 }
14949
14950 static __inline__ int __ATTRS_o_ai vec_any_eq(vector pixel __a,
14951                                               vector pixel __b) {
14952   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
14953                                       (vector short)__b);
14954 }
14955
14956 static __inline__ int __ATTRS_o_ai vec_any_eq(vector int __a, vector int __b) {
14957   return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, __a, __b);
14958 }
14959
14960 static __inline__ int __ATTRS_o_ai vec_any_eq(vector int __a,
14961                                               vector bool int __b) {
14962   return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, __a, (vector int)__b);
14963 }
14964
14965 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned int __a,
14966                                               vector unsigned int __b) {
14967   return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
14968                                       (vector int)__b);
14969 }
14970
14971 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned int __a,
14972                                               vector bool int __b) {
14973   return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
14974                                       (vector int)__b);
14975 }
14976
14977 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool int __a,
14978                                               vector int __b) {
14979   return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
14980                                       (vector int)__b);
14981 }
14982
14983 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool int __a,
14984                                               vector unsigned int __b) {
14985   return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
14986                                       (vector int)__b);
14987 }
14988
14989 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool int __a,
14990                                               vector bool int __b) {
14991   return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
14992                                       (vector int)__b);
14993 }
14994
14995 #ifdef __POWER8_VECTOR__
14996 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed long long __a,
14997                                               vector signed long long __b) {
14998   return __builtin_altivec_vcmpequd_p(__CR6_EQ_REV, __a, __b);
14999 }
15000
15001 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned long long __a,
15002                                               vector unsigned long long __b) {
15003   return __builtin_altivec_vcmpequd_p(__CR6_EQ_REV, (vector long long)__a,
15004                                       (vector long long)__b);
15005 }
15006
15007 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed long long __a,
15008                                               vector bool long long __b) {
15009   return __builtin_altivec_vcmpequd_p(__CR6_EQ_REV, __a,
15010                                       (vector signed long long)__b);
15011 }
15012
15013 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned long long __a,
15014                                               vector bool long long __b) {
15015   return __builtin_altivec_vcmpequd_p(
15016       __CR6_EQ_REV, (vector signed long long)__a, (vector signed long long)__b);
15017 }
15018
15019 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool long long __a,
15020                                               vector signed long long __b) {
15021   return __builtin_altivec_vcmpequd_p(
15022       __CR6_EQ_REV, (vector signed long long)__a, (vector signed long long)__b);
15023 }
15024
15025 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool long long __a,
15026                                               vector unsigned long long __b) {
15027   return __builtin_altivec_vcmpequd_p(
15028       __CR6_EQ_REV, (vector signed long long)__a, (vector signed long long)__b);
15029 }
15030
15031 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool long long __a,
15032                                               vector bool long long __b) {
15033   return __builtin_altivec_vcmpequd_p(
15034       __CR6_EQ_REV, (vector signed long long)__a, (vector signed long long)__b);
15035 }
15036 #endif
15037
15038 static __inline__ int __ATTRS_o_ai vec_any_eq(vector float __a,
15039                                               vector float __b) {
15040 #ifdef __VSX__
15041   return __builtin_vsx_xvcmpeqsp_p(__CR6_EQ_REV, __a, __b);
15042 #else
15043   return __builtin_altivec_vcmpeqfp_p(__CR6_EQ_REV, __a, __b);
15044 #endif
15045 }
15046
15047 #ifdef __VSX__
15048 static __inline__ int __ATTRS_o_ai vec_any_eq(vector double __a,
15049                                               vector double __b) {
15050   return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ_REV, __a, __b);
15051 }
15052 #endif
15053
15054 /* vec_any_ge */
15055
15056 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed char __a,
15057                                               vector signed char __b) {
15058   return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, __b, __a);
15059 }
15060
15061 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed char __a,
15062                                               vector bool char __b) {
15063   return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, (vector signed char)__b,
15064                                       __a);
15065 }
15066
15067 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned char __a,
15068                                               vector unsigned char __b) {
15069   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __b, __a);
15070 }
15071
15072 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned char __a,
15073                                               vector bool char __b) {
15074   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__b,
15075                                       __a);
15076 }
15077
15078 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool char __a,
15079                                               vector signed char __b) {
15080   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__b,
15081                                       (vector unsigned char)__a);
15082 }
15083
15084 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool char __a,
15085                                               vector unsigned char __b) {
15086   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __b,
15087                                       (vector unsigned char)__a);
15088 }
15089
15090 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool char __a,
15091                                               vector bool char __b) {
15092   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__b,
15093                                       (vector unsigned char)__a);
15094 }
15095
15096 static __inline__ int __ATTRS_o_ai vec_any_ge(vector short __a,
15097                                               vector short __b) {
15098   return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, __b, __a);
15099 }
15100
15101 static __inline__ int __ATTRS_o_ai vec_any_ge(vector short __a,
15102                                               vector bool short __b) {
15103   return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, (vector short)__b, __a);
15104 }
15105
15106 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned short __a,
15107                                               vector unsigned short __b) {
15108   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __b, __a);
15109 }
15110
15111 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned short __a,
15112                                               vector bool short __b) {
15113   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__b,
15114                                       __a);
15115 }
15116
15117 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool short __a,
15118                                               vector short __b) {
15119   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__b,
15120                                       (vector unsigned short)__a);
15121 }
15122
15123 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool short __a,
15124                                               vector unsigned short __b) {
15125   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __b,
15126                                       (vector unsigned short)__a);
15127 }
15128
15129 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool short __a,
15130                                               vector bool short __b) {
15131   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__b,
15132                                       (vector unsigned short)__a);
15133 }
15134
15135 static __inline__ int __ATTRS_o_ai vec_any_ge(vector int __a, vector int __b) {
15136   return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, __b, __a);
15137 }
15138
15139 static __inline__ int __ATTRS_o_ai vec_any_ge(vector int __a,
15140                                               vector bool int __b) {
15141   return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, (vector int)__b, __a);
15142 }
15143
15144 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned int __a,
15145                                               vector unsigned int __b) {
15146   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __b, __a);
15147 }
15148
15149 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned int __a,
15150                                               vector bool int __b) {
15151   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__b,
15152                                       __a);
15153 }
15154
15155 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool int __a,
15156                                               vector int __b) {
15157   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__b,
15158                                       (vector unsigned int)__a);
15159 }
15160
15161 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool int __a,
15162                                               vector unsigned int __b) {
15163   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __b,
15164                                       (vector unsigned int)__a);
15165 }
15166
15167 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool int __a,
15168                                               vector bool int __b) {
15169   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__b,
15170                                       (vector unsigned int)__a);
15171 }
15172
15173 #ifdef __POWER8_VECTOR__
15174 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed long long __a,
15175                                               vector signed long long __b) {
15176   return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV, __b, __a);
15177 }
15178
15179 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned long long __a,
15180                                               vector unsigned long long __b) {
15181   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __b, __a);
15182 }
15183
15184 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed long long __a,
15185                                               vector bool long long __b) {
15186   return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV,
15187                                       (vector signed long long)__b, __a);
15188 }
15189
15190 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned long long __a,
15191                                               vector bool long long __b) {
15192   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
15193                                       (vector unsigned long long)__b, __a);
15194 }
15195
15196 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool long long __a,
15197                                               vector signed long long __b) {
15198   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
15199                                       (vector unsigned long long)__b,
15200                                       (vector unsigned long long)__a);
15201 }
15202
15203 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool long long __a,
15204                                               vector unsigned long long __b) {
15205   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __b,
15206                                       (vector unsigned long long)__a);
15207 }
15208
15209 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool long long __a,
15210                                               vector bool long long __b) {
15211   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
15212                                       (vector unsigned long long)__b,
15213                                       (vector unsigned long long)__a);
15214 }
15215 #endif
15216
15217 static __inline__ int __ATTRS_o_ai vec_any_ge(vector float __a,
15218                                               vector float __b) {
15219 #ifdef __VSX__
15220   return __builtin_vsx_xvcmpgesp_p(__CR6_EQ_REV, __a, __b);
15221 #else
15222   return __builtin_altivec_vcmpgefp_p(__CR6_EQ_REV, __a, __b);
15223 #endif
15224 }
15225
15226 #ifdef __VSX__
15227 static __inline__ int __ATTRS_o_ai vec_any_ge(vector double __a,
15228                                               vector double __b) {
15229   return __builtin_vsx_xvcmpgedp_p(__CR6_EQ_REV, __a, __b);
15230 }
15231 #endif
15232
15233 /* vec_any_gt */
15234
15235 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed char __a,
15236                                               vector signed char __b) {
15237   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, __a, __b);
15238 }
15239
15240 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed char __a,
15241                                               vector bool char __b) {
15242   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, __a,
15243                                       (vector signed char)__b);
15244 }
15245
15246 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned char __a,
15247                                               vector unsigned char __b) {
15248   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __a, __b);
15249 }
15250
15251 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned char __a,
15252                                               vector bool char __b) {
15253   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __a,
15254                                       (vector unsigned char)__b);
15255 }
15256
15257 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool char __a,
15258                                               vector signed char __b) {
15259   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__a,
15260                                       (vector unsigned char)__b);
15261 }
15262
15263 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool char __a,
15264                                               vector unsigned char __b) {
15265   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__a,
15266                                       __b);
15267 }
15268
15269 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool char __a,
15270                                               vector bool char __b) {
15271   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__a,
15272                                       (vector unsigned char)__b);
15273 }
15274
15275 static __inline__ int __ATTRS_o_ai vec_any_gt(vector short __a,
15276                                               vector short __b) {
15277   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, __a, __b);
15278 }
15279
15280 static __inline__ int __ATTRS_o_ai vec_any_gt(vector short __a,
15281                                               vector bool short __b) {
15282   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, __a, (vector short)__b);
15283 }
15284
15285 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned short __a,
15286                                               vector unsigned short __b) {
15287   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __a, __b);
15288 }
15289
15290 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned short __a,
15291                                               vector bool short __b) {
15292   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __a,
15293                                       (vector unsigned short)__b);
15294 }
15295
15296 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool short __a,
15297                                               vector short __b) {
15298   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__a,
15299                                       (vector unsigned short)__b);
15300 }
15301
15302 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool short __a,
15303                                               vector unsigned short __b) {
15304   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__a,
15305                                       __b);
15306 }
15307
15308 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool short __a,
15309                                               vector bool short __b) {
15310   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__a,
15311                                       (vector unsigned short)__b);
15312 }
15313
15314 static __inline__ int __ATTRS_o_ai vec_any_gt(vector int __a, vector int __b) {
15315   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, __a, __b);
15316 }
15317
15318 static __inline__ int __ATTRS_o_ai vec_any_gt(vector int __a,
15319                                               vector bool int __b) {
15320   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, __a, (vector int)__b);
15321 }
15322
15323 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned int __a,
15324                                               vector unsigned int __b) {
15325   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __a, __b);
15326 }
15327
15328 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned int __a,
15329                                               vector bool int __b) {
15330   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __a,
15331                                       (vector unsigned int)__b);
15332 }
15333
15334 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool int __a,
15335                                               vector int __b) {
15336   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__a,
15337                                       (vector unsigned int)__b);
15338 }
15339
15340 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool int __a,
15341                                               vector unsigned int __b) {
15342   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__a,
15343                                       __b);
15344 }
15345
15346 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool int __a,
15347                                               vector bool int __b) {
15348   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__a,
15349                                       (vector unsigned int)__b);
15350 }
15351
15352 #ifdef __POWER8_VECTOR__
15353 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed long long __a,
15354                                               vector signed long long __b) {
15355   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV, __a, __b);
15356 }
15357
15358 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned long long __a,
15359                                               vector unsigned long long __b) {
15360   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __a, __b);
15361 }
15362
15363 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed long long __a,
15364                                               vector bool long long __b) {
15365   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV, __a,
15366                                       (vector signed long long)__b);
15367 }
15368
15369 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned long long __a,
15370                                               vector bool long long __b) {
15371   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __a,
15372                                       (vector unsigned long long)__b);
15373 }
15374
15375 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool long long __a,
15376                                               vector signed long long __b) {
15377   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
15378                                       (vector unsigned long long)__a,
15379                                       (vector unsigned long long)__b);
15380 }
15381
15382 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool long long __a,
15383                                               vector unsigned long long __b) {
15384   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
15385                                       (vector unsigned long long)__a, __b);
15386 }
15387
15388 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool long long __a,
15389                                               vector bool long long __b) {
15390   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
15391                                       (vector unsigned long long)__a,
15392                                       (vector unsigned long long)__b);
15393 }
15394 #endif
15395
15396 static __inline__ int __ATTRS_o_ai vec_any_gt(vector float __a,
15397                                               vector float __b) {
15398 #ifdef __VSX__
15399   return __builtin_vsx_xvcmpgtsp_p(__CR6_EQ_REV, __a, __b);
15400 #else
15401   return __builtin_altivec_vcmpgtfp_p(__CR6_EQ_REV, __a, __b);
15402 #endif
15403 }
15404
15405 #ifdef __VSX__
15406 static __inline__ int __ATTRS_o_ai vec_any_gt(vector double __a,
15407                                               vector double __b) {
15408   return __builtin_vsx_xvcmpgtdp_p(__CR6_EQ_REV, __a, __b);
15409 }
15410 #endif
15411
15412 /* vec_any_le */
15413
15414 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed char __a,
15415                                               vector signed char __b) {
15416   return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, __a, __b);
15417 }
15418
15419 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed char __a,
15420                                               vector bool char __b) {
15421   return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, __a,
15422                                       (vector signed char)__b);
15423 }
15424
15425 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned char __a,
15426                                               vector unsigned char __b) {
15427   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __a, __b);
15428 }
15429
15430 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned char __a,
15431                                               vector bool char __b) {
15432   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __a,
15433                                       (vector unsigned char)__b);
15434 }
15435
15436 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool char __a,
15437                                               vector signed char __b) {
15438   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__a,
15439                                       (vector unsigned char)__b);
15440 }
15441
15442 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool char __a,
15443                                               vector unsigned char __b) {
15444   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__a,
15445                                       __b);
15446 }
15447
15448 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool char __a,
15449                                               vector bool char __b) {
15450   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__a,
15451                                       (vector unsigned char)__b);
15452 }
15453
15454 static __inline__ int __ATTRS_o_ai vec_any_le(vector short __a,
15455                                               vector short __b) {
15456   return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, __a, __b);
15457 }
15458
15459 static __inline__ int __ATTRS_o_ai vec_any_le(vector short __a,
15460                                               vector bool short __b) {
15461   return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, __a, (vector short)__b);
15462 }
15463
15464 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned short __a,
15465                                               vector unsigned short __b) {
15466   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __a, __b);
15467 }
15468
15469 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned short __a,
15470                                               vector bool short __b) {
15471   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __a,
15472                                       (vector unsigned short)__b);
15473 }
15474
15475 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool short __a,
15476                                               vector short __b) {
15477   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__a,
15478                                       (vector unsigned short)__b);
15479 }
15480
15481 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool short __a,
15482                                               vector unsigned short __b) {
15483   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__a,
15484                                       __b);
15485 }
15486
15487 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool short __a,
15488                                               vector bool short __b) {
15489   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__a,
15490                                       (vector unsigned short)__b);
15491 }
15492
15493 static __inline__ int __ATTRS_o_ai vec_any_le(vector int __a, vector int __b) {
15494   return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, __a, __b);
15495 }
15496
15497 static __inline__ int __ATTRS_o_ai vec_any_le(vector int __a,
15498                                               vector bool int __b) {
15499   return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, __a, (vector int)__b);
15500 }
15501
15502 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned int __a,
15503                                               vector unsigned int __b) {
15504   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __a, __b);
15505 }
15506
15507 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned int __a,
15508                                               vector bool int __b) {
15509   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __a,
15510                                       (vector unsigned int)__b);
15511 }
15512
15513 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool int __a,
15514                                               vector int __b) {
15515   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__a,
15516                                       (vector unsigned int)__b);
15517 }
15518
15519 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool int __a,
15520                                               vector unsigned int __b) {
15521   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__a,
15522                                       __b);
15523 }
15524
15525 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool int __a,
15526                                               vector bool int __b) {
15527   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__a,
15528                                       (vector unsigned int)__b);
15529 }
15530
15531 #ifdef __POWER8_VECTOR__
15532 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed long long __a,
15533                                               vector signed long long __b) {
15534   return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV, __a, __b);
15535 }
15536
15537 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned long long __a,
15538                                               vector unsigned long long __b) {
15539   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __a, __b);
15540 }
15541
15542 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed long long __a,
15543                                               vector bool long long __b) {
15544   return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV, __a,
15545                                       (vector signed long long)__b);
15546 }
15547
15548 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned long long __a,
15549                                               vector bool long long __b) {
15550   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __a,
15551                                       (vector unsigned long long)__b);
15552 }
15553
15554 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool long long __a,
15555                                               vector signed long long __b) {
15556   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
15557                                       (vector unsigned long long)__a,
15558                                       (vector unsigned long long)__b);
15559 }
15560
15561 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool long long __a,
15562                                               vector unsigned long long __b) {
15563   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
15564                                       (vector unsigned long long)__a, __b);
15565 }
15566
15567 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool long long __a,
15568                                               vector bool long long __b) {
15569   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
15570                                       (vector unsigned long long)__a,
15571                                       (vector unsigned long long)__b);
15572 }
15573 #endif
15574
15575 static __inline__ int __ATTRS_o_ai vec_any_le(vector float __a,
15576                                               vector float __b) {
15577 #ifdef __VSX__
15578   return __builtin_vsx_xvcmpgesp_p(__CR6_EQ_REV, __b, __a);
15579 #else
15580   return __builtin_altivec_vcmpgefp_p(__CR6_EQ_REV, __b, __a);
15581 #endif
15582 }
15583
15584 #ifdef __VSX__
15585 static __inline__ int __ATTRS_o_ai vec_any_le(vector double __a,
15586                                               vector double __b) {
15587   return __builtin_vsx_xvcmpgedp_p(__CR6_EQ_REV, __b, __a);
15588 }
15589 #endif
15590
15591 /* vec_any_lt */
15592
15593 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed char __a,
15594                                               vector signed char __b) {
15595   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, __b, __a);
15596 }
15597
15598 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed char __a,
15599                                               vector bool char __b) {
15600   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, (vector signed char)__b,
15601                                       __a);
15602 }
15603
15604 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned char __a,
15605                                               vector unsigned char __b) {
15606   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __b, __a);
15607 }
15608
15609 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned char __a,
15610                                               vector bool char __b) {
15611   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__b,
15612                                       __a);
15613 }
15614
15615 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool char __a,
15616                                               vector signed char __b) {
15617   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__b,
15618                                       (vector unsigned char)__a);
15619 }
15620
15621 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool char __a,
15622                                               vector unsigned char __b) {
15623   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __b,
15624                                       (vector unsigned char)__a);
15625 }
15626
15627 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool char __a,
15628                                               vector bool char __b) {
15629   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__b,
15630                                       (vector unsigned char)__a);
15631 }
15632
15633 static __inline__ int __ATTRS_o_ai vec_any_lt(vector short __a,
15634                                               vector short __b) {
15635   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, __b, __a);
15636 }
15637
15638 static __inline__ int __ATTRS_o_ai vec_any_lt(vector short __a,
15639                                               vector bool short __b) {
15640   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, (vector short)__b, __a);
15641 }
15642
15643 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned short __a,
15644                                               vector unsigned short __b) {
15645   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __b, __a);
15646 }
15647
15648 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned short __a,
15649                                               vector bool short __b) {
15650   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__b,
15651                                       __a);
15652 }
15653
15654 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool short __a,
15655                                               vector short __b) {
15656   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__b,
15657                                       (vector unsigned short)__a);
15658 }
15659
15660 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool short __a,
15661                                               vector unsigned short __b) {
15662   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __b,
15663                                       (vector unsigned short)__a);
15664 }
15665
15666 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool short __a,
15667                                               vector bool short __b) {
15668   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__b,
15669                                       (vector unsigned short)__a);
15670 }
15671
15672 static __inline__ int __ATTRS_o_ai vec_any_lt(vector int __a, vector int __b) {
15673   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, __b, __a);
15674 }
15675
15676 static __inline__ int __ATTRS_o_ai vec_any_lt(vector int __a,
15677                                               vector bool int __b) {
15678   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, (vector int)__b, __a);
15679 }
15680
15681 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned int __a,
15682                                               vector unsigned int __b) {
15683   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __b, __a);
15684 }
15685
15686 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned int __a,
15687                                               vector bool int __b) {
15688   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__b,
15689                                       __a);
15690 }
15691
15692 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool int __a,
15693                                               vector int __b) {
15694   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__b,
15695                                       (vector unsigned int)__a);
15696 }
15697
15698 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool int __a,
15699                                               vector unsigned int __b) {
15700   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __b,
15701                                       (vector unsigned int)__a);
15702 }
15703
15704 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool int __a,
15705                                               vector bool int __b) {
15706   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__b,
15707                                       (vector unsigned int)__a);
15708 }
15709
15710 #ifdef __POWER8_VECTOR__
15711 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed long long __a,
15712                                               vector signed long long __b) {
15713   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV, __b, __a);
15714 }
15715
15716 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned long long __a,
15717                                               vector unsigned long long __b) {
15718   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __b, __a);
15719 }
15720
15721 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed long long __a,
15722                                               vector bool long long __b) {
15723   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV,
15724                                       (vector signed long long)__b, __a);
15725 }
15726
15727 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned long long __a,
15728                                               vector bool long long __b) {
15729   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
15730                                       (vector unsigned long long)__b, __a);
15731 }
15732
15733 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool long long __a,
15734                                               vector signed long long __b) {
15735   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
15736                                       (vector unsigned long long)__b,
15737                                       (vector unsigned long long)__a);
15738 }
15739
15740 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool long long __a,
15741                                               vector unsigned long long __b) {
15742   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __b,
15743                                       (vector unsigned long long)__a);
15744 }
15745
15746 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool long long __a,
15747                                               vector bool long long __b) {
15748   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
15749                                       (vector unsigned long long)__b,
15750                                       (vector unsigned long long)__a);
15751 }
15752 #endif
15753
15754 static __inline__ int __ATTRS_o_ai vec_any_lt(vector float __a,
15755                                               vector float __b) {
15756 #ifdef __VSX__
15757   return __builtin_vsx_xvcmpgtsp_p(__CR6_EQ_REV, __b, __a);
15758 #else
15759   return __builtin_altivec_vcmpgtfp_p(__CR6_EQ_REV, __b, __a);
15760 #endif
15761 }
15762
15763 #ifdef __VSX__
15764 static __inline__ int __ATTRS_o_ai vec_any_lt(vector double __a,
15765                                               vector double __b) {
15766   return __builtin_vsx_xvcmpgtdp_p(__CR6_EQ_REV, __b, __a);
15767 }
15768 #endif
15769
15770 /* vec_any_nan */
15771
15772 static __inline__ int __attribute__((__always_inline__))
15773 vec_any_nan(vector float __a) {
15774   return __builtin_altivec_vcmpeqfp_p(__CR6_LT_REV, __a, __a);
15775 }
15776
15777 /* vec_any_ne */
15778
15779 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed char __a,
15780                                               vector signed char __b) {
15781   return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
15782                                       (vector char)__b);
15783 }
15784
15785 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed char __a,
15786                                               vector bool char __b) {
15787   return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
15788                                       (vector char)__b);
15789 }
15790
15791 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned char __a,
15792                                               vector unsigned char __b) {
15793   return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
15794                                       (vector char)__b);
15795 }
15796
15797 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned char __a,
15798                                               vector bool char __b) {
15799   return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
15800                                       (vector char)__b);
15801 }
15802
15803 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool char __a,
15804                                               vector signed char __b) {
15805   return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
15806                                       (vector char)__b);
15807 }
15808
15809 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool char __a,
15810                                               vector unsigned char __b) {
15811   return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
15812                                       (vector char)__b);
15813 }
15814
15815 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool char __a,
15816                                               vector bool char __b) {
15817   return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
15818                                       (vector char)__b);
15819 }
15820
15821 static __inline__ int __ATTRS_o_ai vec_any_ne(vector short __a,
15822                                               vector short __b) {
15823   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, __a, __b);
15824 }
15825
15826 static __inline__ int __ATTRS_o_ai vec_any_ne(vector short __a,
15827                                               vector bool short __b) {
15828   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, __a, (vector short)__b);
15829 }
15830
15831 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned short __a,
15832                                               vector unsigned short __b) {
15833   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
15834                                       (vector short)__b);
15835 }
15836
15837 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned short __a,
15838                                               vector bool short __b) {
15839   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
15840                                       (vector short)__b);
15841 }
15842
15843 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool short __a,
15844                                               vector short __b) {
15845   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
15846                                       (vector short)__b);
15847 }
15848
15849 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool short __a,
15850                                               vector unsigned short __b) {
15851   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
15852                                       (vector short)__b);
15853 }
15854
15855 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool short __a,
15856                                               vector bool short __b) {
15857   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
15858                                       (vector short)__b);
15859 }
15860
15861 static __inline__ int __ATTRS_o_ai vec_any_ne(vector pixel __a,
15862                                               vector pixel __b) {
15863   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
15864                                       (vector short)__b);
15865 }
15866
15867 static __inline__ int __ATTRS_o_ai vec_any_ne(vector int __a, vector int __b) {
15868   return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, __a, __b);
15869 }
15870
15871 static __inline__ int __ATTRS_o_ai vec_any_ne(vector int __a,
15872                                               vector bool int __b) {
15873   return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, __a, (vector int)__b);
15874 }
15875
15876 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned int __a,
15877                                               vector unsigned int __b) {
15878   return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
15879                                       (vector int)__b);
15880 }
15881
15882 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned int __a,
15883                                               vector bool int __b) {
15884   return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
15885                                       (vector int)__b);
15886 }
15887
15888 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool int __a,
15889                                               vector int __b) {
15890   return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
15891                                       (vector int)__b);
15892 }
15893
15894 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool int __a,
15895                                               vector unsigned int __b) {
15896   return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
15897                                       (vector int)__b);
15898 }
15899
15900 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool int __a,
15901                                               vector bool int __b) {
15902   return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
15903                                       (vector int)__b);
15904 }
15905
15906 #ifdef __POWER8_VECTOR__
15907 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed long long __a,
15908                                               vector signed long long __b) {
15909   return __builtin_altivec_vcmpequd_p(__CR6_LT_REV, __a, __b);
15910 }
15911
15912 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned long long __a,
15913                                               vector unsigned long long __b) {
15914   return __builtin_altivec_vcmpequd_p(__CR6_LT_REV, (vector long long)__a,
15915                                       (vector long long)__b);
15916 }
15917
15918 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed long long __a,
15919                                               vector bool long long __b) {
15920   return __builtin_altivec_vcmpequd_p(__CR6_LT_REV, __a,
15921                                       (vector signed long long)__b);
15922 }
15923
15924 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned long long __a,
15925                                               vector bool long long __b) {
15926   return __builtin_altivec_vcmpequd_p(
15927       __CR6_LT_REV, (vector signed long long)__a, (vector signed long long)__b);
15928 }
15929
15930 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool long long __a,
15931                                               vector signed long long __b) {
15932   return __builtin_altivec_vcmpequd_p(
15933       __CR6_LT_REV, (vector signed long long)__a, (vector signed long long)__b);
15934 }
15935
15936 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool long long __a,
15937                                               vector unsigned long long __b) {
15938   return __builtin_altivec_vcmpequd_p(
15939       __CR6_LT_REV, (vector signed long long)__a, (vector signed long long)__b);
15940 }
15941
15942 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool long long __a,
15943                                               vector bool long long __b) {
15944   return __builtin_altivec_vcmpequd_p(
15945       __CR6_LT_REV, (vector signed long long)__a, (vector signed long long)__b);
15946 }
15947 #endif
15948
15949 static __inline__ int __ATTRS_o_ai vec_any_ne(vector float __a,
15950                                               vector float __b) {
15951 #ifdef __VSX__
15952   return __builtin_vsx_xvcmpeqsp_p(__CR6_LT_REV, __a, __b);
15953 #else
15954   return __builtin_altivec_vcmpeqfp_p(__CR6_LT_REV, __a, __b);
15955 #endif
15956 }
15957
15958 #ifdef __VSX__
15959 static __inline__ int __ATTRS_o_ai vec_any_ne(vector double __a,
15960                                               vector double __b) {
15961   return __builtin_vsx_xvcmpeqdp_p(__CR6_LT_REV, __a, __b);
15962 }
15963 #endif
15964
15965 /* vec_any_nge */
15966
15967 static __inline__ int __attribute__((__always_inline__))
15968 vec_any_nge(vector float __a, vector float __b) {
15969   return __builtin_altivec_vcmpgefp_p(__CR6_LT_REV, __a, __b);
15970 }
15971
15972 /* vec_any_ngt */
15973
15974 static __inline__ int __attribute__((__always_inline__))
15975 vec_any_ngt(vector float __a, vector float __b) {
15976   return __builtin_altivec_vcmpgtfp_p(__CR6_LT_REV, __a, __b);
15977 }
15978
15979 /* vec_any_nle */
15980
15981 static __inline__ int __attribute__((__always_inline__))
15982 vec_any_nle(vector float __a, vector float __b) {
15983   return __builtin_altivec_vcmpgefp_p(__CR6_LT_REV, __b, __a);
15984 }
15985
15986 /* vec_any_nlt */
15987
15988 static __inline__ int __attribute__((__always_inline__))
15989 vec_any_nlt(vector float __a, vector float __b) {
15990   return __builtin_altivec_vcmpgtfp_p(__CR6_LT_REV, __b, __a);
15991 }
15992
15993 /* vec_any_numeric */
15994
15995 static __inline__ int __attribute__((__always_inline__))
15996 vec_any_numeric(vector float __a) {
15997   return __builtin_altivec_vcmpeqfp_p(__CR6_EQ_REV, __a, __a);
15998 }
15999
16000 /* vec_any_out */
16001
16002 static __inline__ int __attribute__((__always_inline__))
16003 vec_any_out(vector float __a, vector float __b) {
16004   return __builtin_altivec_vcmpbfp_p(__CR6_EQ_REV, __a, __b);
16005 }
16006
16007 /* Power 8 Crypto functions
16008 Note: We diverge from the current GCC implementation with regard
16009 to cryptography and related functions as follows:
16010 - Only the SHA and AES instructions and builtins are disabled by -mno-crypto
16011 - The remaining ones are only available on Power8 and up so
16012   require -mpower8-vector
16013 The justification for this is that export requirements require that
16014 Category:Vector.Crypto is optional (i.e. compliant hardware may not provide
16015 support). As a result, we need to be able to turn off support for those.
16016 The remaining ones (currently controlled by -mcrypto for GCC) still
16017 need to be provided on compliant hardware even if Vector.Crypto is not
16018 provided.
16019 */
16020 #ifdef __CRYPTO__
16021 #define vec_sbox_be __builtin_altivec_crypto_vsbox
16022 #define vec_cipher_be __builtin_altivec_crypto_vcipher
16023 #define vec_cipherlast_be __builtin_altivec_crypto_vcipherlast
16024 #define vec_ncipher_be __builtin_altivec_crypto_vncipher
16025 #define vec_ncipherlast_be __builtin_altivec_crypto_vncipherlast
16026
16027 static __inline__ vector unsigned long long __attribute__((__always_inline__))
16028 __builtin_crypto_vsbox(vector unsigned long long __a) {
16029   return __builtin_altivec_crypto_vsbox(__a);
16030 }
16031
16032 static __inline__ vector unsigned long long __attribute__((__always_inline__))
16033 __builtin_crypto_vcipher(vector unsigned long long __a,
16034                          vector unsigned long long __b) {
16035   return __builtin_altivec_crypto_vcipher(__a, __b);
16036 }
16037
16038 static __inline__ vector unsigned long long __attribute__((__always_inline__))
16039 __builtin_crypto_vcipherlast(vector unsigned long long __a,
16040                              vector unsigned long long __b) {
16041   return __builtin_altivec_crypto_vcipherlast(__a, __b);
16042 }
16043
16044 static __inline__ vector unsigned long long __attribute__((__always_inline__))
16045 __builtin_crypto_vncipher(vector unsigned long long __a,
16046                           vector unsigned long long __b) {
16047   return __builtin_altivec_crypto_vncipher(__a, __b);
16048 }
16049
16050 static __inline__ vector unsigned long long __attribute__((__always_inline__))
16051 __builtin_crypto_vncipherlast(vector unsigned long long __a,
16052                               vector unsigned long long __b) {
16053   return __builtin_altivec_crypto_vncipherlast(__a, __b);
16054 }
16055
16056 #define __builtin_crypto_vshasigmad __builtin_altivec_crypto_vshasigmad
16057 #define __builtin_crypto_vshasigmaw __builtin_altivec_crypto_vshasigmaw
16058
16059 #define vec_shasigma_be(X, Y, Z)                                               \
16060   _Generic((X), vector unsigned int                                            \
16061            : __builtin_crypto_vshasigmaw, vector unsigned long long            \
16062            : __builtin_crypto_vshasigmad)((X), (Y), (Z))
16063 #endif
16064
16065 #ifdef __POWER8_VECTOR__
16066 static __inline__ vector bool char __ATTRS_o_ai
16067 vec_permxor(vector bool char __a, vector bool char __b,
16068             vector bool char __c) {
16069   return __builtin_altivec_crypto_vpermxor(__a, __b, __c);
16070 }
16071
16072 static __inline__ vector signed char __ATTRS_o_ai
16073 vec_permxor(vector signed char __a, vector signed char __b,
16074             vector signed char __c) {
16075   return __builtin_altivec_crypto_vpermxor(__a, __b, __c);
16076 }
16077
16078 static __inline__ vector unsigned char __ATTRS_o_ai
16079 vec_permxor(vector unsigned char __a, vector unsigned char __b,
16080             vector unsigned char __c) {
16081   return __builtin_altivec_crypto_vpermxor(__a, __b, __c);
16082 }
16083
16084 static __inline__ vector unsigned char __ATTRS_o_ai
16085 __builtin_crypto_vpermxor(vector unsigned char __a, vector unsigned char __b,
16086                           vector unsigned char __c) {
16087   return __builtin_altivec_crypto_vpermxor(__a, __b, __c);
16088 }
16089
16090 static __inline__ vector unsigned short __ATTRS_o_ai
16091 __builtin_crypto_vpermxor(vector unsigned short __a, vector unsigned short __b,
16092                           vector unsigned short __c) {
16093   return (vector unsigned short)__builtin_altivec_crypto_vpermxor(
16094       (vector unsigned char)__a, (vector unsigned char)__b,
16095       (vector unsigned char)__c);
16096 }
16097
16098 static __inline__ vector unsigned int __ATTRS_o_ai __builtin_crypto_vpermxor(
16099     vector unsigned int __a, vector unsigned int __b, vector unsigned int __c) {
16100   return (vector unsigned int)__builtin_altivec_crypto_vpermxor(
16101       (vector unsigned char)__a, (vector unsigned char)__b,
16102       (vector unsigned char)__c);
16103 }
16104
16105 static __inline__ vector unsigned long long __ATTRS_o_ai
16106 __builtin_crypto_vpermxor(vector unsigned long long __a,
16107                           vector unsigned long long __b,
16108                           vector unsigned long long __c) {
16109   return (vector unsigned long long)__builtin_altivec_crypto_vpermxor(
16110       (vector unsigned char)__a, (vector unsigned char)__b,
16111       (vector unsigned char)__c);
16112 }
16113
16114 static __inline__ vector unsigned char __ATTRS_o_ai
16115 __builtin_crypto_vpmsumb(vector unsigned char __a, vector unsigned char __b) {
16116   return __builtin_altivec_crypto_vpmsumb(__a, __b);
16117 }
16118
16119 static __inline__ vector unsigned short __ATTRS_o_ai
16120 __builtin_crypto_vpmsumb(vector unsigned short __a, vector unsigned short __b) {
16121   return __builtin_altivec_crypto_vpmsumh(__a, __b);
16122 }
16123
16124 static __inline__ vector unsigned int __ATTRS_o_ai
16125 __builtin_crypto_vpmsumb(vector unsigned int __a, vector unsigned int __b) {
16126   return __builtin_altivec_crypto_vpmsumw(__a, __b);
16127 }
16128
16129 static __inline__ vector unsigned long long __ATTRS_o_ai
16130 __builtin_crypto_vpmsumb(vector unsigned long long __a,
16131                          vector unsigned long long __b) {
16132   return __builtin_altivec_crypto_vpmsumd(__a, __b);
16133 }
16134
16135 static __inline__ vector signed char __ATTRS_o_ai
16136 vec_vgbbd(vector signed char __a) {
16137   return __builtin_altivec_vgbbd((vector unsigned char)__a);
16138 }
16139
16140 #define vec_pmsum_be __builtin_crypto_vpmsumb
16141 #define vec_gb __builtin_altivec_vgbbd
16142
16143 static __inline__ vector unsigned char __ATTRS_o_ai
16144 vec_vgbbd(vector unsigned char __a) {
16145   return __builtin_altivec_vgbbd(__a);
16146 }
16147
16148 static __inline__ vector long long __ATTRS_o_ai
16149 vec_vbpermq(vector signed char __a, vector signed char __b) {
16150   return __builtin_altivec_vbpermq((vector unsigned char)__a,
16151                                    (vector unsigned char)__b);
16152 }
16153
16154 static __inline__ vector long long __ATTRS_o_ai
16155 vec_vbpermq(vector unsigned char __a, vector unsigned char __b) {
16156   return __builtin_altivec_vbpermq(__a, __b);
16157 }
16158
16159 #ifdef __powerpc64__
16160 static __inline__ vector unsigned long long __attribute__((__always_inline__))
16161 vec_bperm(vector unsigned __int128 __a, vector unsigned char __b) {
16162   return __builtin_altivec_vbpermq((vector unsigned char)__a,
16163                                    (vector unsigned char)__b);
16164 }
16165 #endif
16166 #endif
16167
16168
16169 /* vec_reve */
16170
16171 static inline __ATTRS_o_ai vector bool char vec_reve(vector bool char __a) {
16172   return __builtin_shufflevector(__a, __a, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6,
16173                                  5, 4, 3, 2, 1, 0);
16174 }
16175
16176 static inline __ATTRS_o_ai vector signed char vec_reve(vector signed char __a) {
16177   return __builtin_shufflevector(__a, __a, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6,
16178                                  5, 4, 3, 2, 1, 0);
16179 }
16180
16181 static inline __ATTRS_o_ai vector unsigned char
16182 vec_reve(vector unsigned char __a) {
16183   return __builtin_shufflevector(__a, __a, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6,
16184                                  5, 4, 3, 2, 1, 0);
16185 }
16186
16187 static inline __ATTRS_o_ai vector bool int vec_reve(vector bool int __a) {
16188   return __builtin_shufflevector(__a, __a, 3, 2, 1, 0);
16189 }
16190
16191 static inline __ATTRS_o_ai vector signed int vec_reve(vector signed int __a) {
16192   return __builtin_shufflevector(__a, __a, 3, 2, 1, 0);
16193 }
16194
16195 static inline __ATTRS_o_ai vector unsigned int
16196 vec_reve(vector unsigned int __a) {
16197   return __builtin_shufflevector(__a, __a, 3, 2, 1, 0);
16198 }
16199
16200 static inline __ATTRS_o_ai vector bool short vec_reve(vector bool short __a) {
16201   return __builtin_shufflevector(__a, __a, 7, 6, 5, 4, 3, 2, 1, 0);
16202 }
16203
16204 static inline __ATTRS_o_ai vector signed short
16205 vec_reve(vector signed short __a) {
16206   return __builtin_shufflevector(__a, __a, 7, 6, 5, 4, 3, 2, 1, 0);
16207 }
16208
16209 static inline __ATTRS_o_ai vector unsigned short
16210 vec_reve(vector unsigned short __a) {
16211   return __builtin_shufflevector(__a, __a, 7, 6, 5, 4, 3, 2, 1, 0);
16212 }
16213
16214 static inline __ATTRS_o_ai vector float vec_reve(vector float __a) {
16215   return __builtin_shufflevector(__a, __a, 3, 2, 1, 0);
16216 }
16217
16218 #ifdef __VSX__
16219 static inline __ATTRS_o_ai vector bool long long
16220 vec_reve(vector bool long long __a) {
16221   return __builtin_shufflevector(__a, __a, 1, 0);
16222 }
16223
16224 static inline __ATTRS_o_ai vector signed long long
16225 vec_reve(vector signed long long __a) {
16226   return __builtin_shufflevector(__a, __a, 1, 0);
16227 }
16228
16229 static inline __ATTRS_o_ai vector unsigned long long
16230 vec_reve(vector unsigned long long __a) {
16231   return __builtin_shufflevector(__a, __a, 1, 0);
16232 }
16233
16234 static inline __ATTRS_o_ai vector double vec_reve(vector double __a) {
16235   return __builtin_shufflevector(__a, __a, 1, 0);
16236 }
16237 #endif
16238
16239 /* vec_revb */
16240 static __inline__ vector bool char __ATTRS_o_ai
16241 vec_revb(vector bool char __a) {
16242   return __a;
16243 }
16244
16245 static __inline__ vector signed char __ATTRS_o_ai
16246 vec_revb(vector signed char __a) {
16247   return __a;
16248 }
16249
16250 static __inline__ vector unsigned char __ATTRS_o_ai
16251 vec_revb(vector unsigned char __a) {
16252   return __a;
16253 }
16254
16255 static __inline__ vector bool short __ATTRS_o_ai
16256 vec_revb(vector bool short __a) {
16257   vector unsigned char __indices =
16258       { 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14 };
16259   return vec_perm(__a, __a, __indices);
16260 }
16261
16262 static __inline__ vector signed short __ATTRS_o_ai
16263 vec_revb(vector signed short __a) {
16264   vector unsigned char __indices =
16265       { 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14 };
16266   return vec_perm(__a, __a, __indices);
16267 }
16268
16269 static __inline__ vector unsigned short __ATTRS_o_ai
16270 vec_revb(vector unsigned short __a) {
16271   vector unsigned char __indices =
16272      { 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14 };
16273   return vec_perm(__a, __a, __indices);
16274 }
16275
16276 static __inline__ vector bool int __ATTRS_o_ai
16277 vec_revb(vector bool int __a) {
16278   vector unsigned char __indices =
16279       { 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12 };
16280   return vec_perm(__a, __a, __indices);
16281 }
16282
16283 static __inline__ vector signed int __ATTRS_o_ai
16284 vec_revb(vector signed int __a) {
16285   vector unsigned char __indices =
16286       { 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12 };
16287   return vec_perm(__a, __a, __indices);
16288 }
16289
16290 static __inline__ vector unsigned int __ATTRS_o_ai
16291 vec_revb(vector unsigned int __a) {
16292   vector unsigned char __indices =
16293       { 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12 };
16294   return vec_perm(__a, __a, __indices);
16295 }
16296
16297 static __inline__ vector float __ATTRS_o_ai
16298 vec_revb(vector float __a) {
16299  vector unsigned char __indices =
16300       { 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12 };
16301  return vec_perm(__a, __a, __indices);
16302 }
16303
16304 #ifdef __VSX__
16305 static __inline__ vector bool long long __ATTRS_o_ai
16306 vec_revb(vector bool long long __a) {
16307   vector unsigned char __indices =
16308       { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8 };
16309   return vec_perm(__a, __a, __indices);
16310 }
16311
16312 static __inline__ vector signed long long __ATTRS_o_ai
16313 vec_revb(vector signed long long __a) {
16314   vector unsigned char __indices =
16315       { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8 };
16316   return vec_perm(__a, __a, __indices);
16317 }
16318
16319 static __inline__ vector unsigned long long __ATTRS_o_ai
16320 vec_revb(vector unsigned long long __a) {
16321   vector unsigned char __indices =
16322       { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8 };
16323   return vec_perm(__a, __a, __indices);
16324 }
16325
16326 static __inline__ vector double __ATTRS_o_ai
16327 vec_revb(vector double __a) {
16328   vector unsigned char __indices =
16329       { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8 };
16330   return vec_perm(__a, __a, __indices);
16331 }
16332 #endif /* End __VSX__ */
16333
16334 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
16335 static __inline__ vector signed __int128 __ATTRS_o_ai
16336 vec_revb(vector signed __int128 __a) {
16337   vector unsigned char __indices =
16338       { 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
16339   return (vector signed __int128)vec_perm((vector signed int)__a,
16340                                           (vector signed int)__a,
16341                                            __indices);
16342 }
16343
16344 static __inline__ vector unsigned __int128 __ATTRS_o_ai
16345 vec_revb(vector unsigned __int128 __a) {
16346   vector unsigned char __indices =
16347       { 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
16348   return (vector unsigned __int128)vec_perm((vector signed int)__a,
16349                                             (vector signed int)__a,
16350                                              __indices);
16351 }
16352 #endif /* END __POWER8_VECTOR__ && __powerpc64__ */
16353
16354 /* vec_xl */
16355
16356 static inline __ATTRS_o_ai vector signed char vec_xl(signed long long __offset,
16357                                                      signed char *__ptr) {
16358   return *(vector signed char *)(__ptr + __offset);
16359 }
16360
16361 static inline __ATTRS_o_ai vector unsigned char
16362 vec_xl(signed long long __offset, unsigned char *__ptr) {
16363   return *(vector unsigned char *)(__ptr + __offset);
16364 }
16365
16366 static inline __ATTRS_o_ai vector signed short vec_xl(signed long long __offset,
16367                                                       signed short *__ptr) {
16368   return *(vector signed short *)(__ptr + __offset);
16369 }
16370
16371 static inline __ATTRS_o_ai vector unsigned short
16372 vec_xl(signed long long __offset, unsigned short *__ptr) {
16373   return *(vector unsigned short *)(__ptr + __offset);
16374 }
16375
16376 static inline __ATTRS_o_ai vector signed int vec_xl(signed long long __offset,
16377                                                     signed int *__ptr) {
16378   return *(vector signed int *)(__ptr + __offset);
16379 }
16380
16381 static inline __ATTRS_o_ai vector unsigned int vec_xl(signed long long __offset,
16382                                                       unsigned int *__ptr) {
16383   return *(vector unsigned int *)(__ptr + __offset);
16384 }
16385
16386 static inline __ATTRS_o_ai vector float vec_xl(signed long long __offset,
16387                                                float *__ptr) {
16388   return *(vector float *)(__ptr + __offset);
16389 }
16390
16391 #ifdef __VSX__
16392 static inline __ATTRS_o_ai vector signed long long
16393 vec_xl(signed long long __offset, signed long long *__ptr) {
16394   return *(vector signed long long *)(__ptr + __offset);
16395 }
16396
16397 static inline __ATTRS_o_ai vector unsigned long long
16398 vec_xl(signed long long __offset, unsigned long long *__ptr) {
16399   return *(vector unsigned long long *)(__ptr + __offset);
16400 }
16401
16402 static inline __ATTRS_o_ai vector double vec_xl(signed long long __offset,
16403                                                 double *__ptr) {
16404   return *(vector double *)(__ptr + __offset);
16405 }
16406 #endif
16407
16408 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
16409 static inline __ATTRS_o_ai vector signed __int128
16410 vec_xl(signed long long __offset, signed __int128 *__ptr) {
16411   return *(vector signed __int128 *)(__ptr + __offset);
16412 }
16413
16414 static inline __ATTRS_o_ai vector unsigned __int128
16415 vec_xl(signed long long __offset, unsigned __int128 *__ptr) {
16416   return *(vector unsigned __int128 *)(__ptr + __offset);
16417 }
16418 #endif
16419
16420 /* vec_xl_be */
16421
16422 #ifdef __LITTLE_ENDIAN__
16423 static __inline__ vector signed char __ATTRS_o_ai
16424 vec_xl_be(signed long long __offset, signed char *__ptr) {
16425   vector signed char __vec = __builtin_vsx_lxvd2x_be(__offset, __ptr);
16426   return __builtin_shufflevector(__vec, __vec, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14,
16427                                  13, 12, 11, 10, 9, 8);
16428 }
16429
16430 static __inline__ vector unsigned char __ATTRS_o_ai
16431 vec_xl_be(signed long long __offset, unsigned char *__ptr) {
16432   vector unsigned char __vec = __builtin_vsx_lxvd2x_be(__offset, __ptr);
16433   return __builtin_shufflevector(__vec, __vec, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14,
16434                                  13, 12, 11, 10, 9, 8);
16435 }
16436
16437 static __inline__ vector signed short  __ATTRS_o_ai
16438 vec_xl_be(signed long long __offset, signed short *__ptr) {
16439   vector signed short __vec = __builtin_vsx_lxvd2x_be(__offset, __ptr);
16440   return __builtin_shufflevector(__vec, __vec, 3, 2, 1, 0, 7, 6, 5, 4);
16441 }
16442
16443 static __inline__ vector unsigned short __ATTRS_o_ai
16444 vec_xl_be(signed long long __offset, unsigned short *__ptr) {
16445   vector unsigned short __vec = __builtin_vsx_lxvd2x_be(__offset, __ptr);
16446   return __builtin_shufflevector(__vec, __vec, 3, 2, 1, 0, 7, 6, 5, 4);
16447 }
16448
16449 static __inline__ vector signed int __ATTRS_o_ai
16450 vec_xl_be(signed long long  __offset, signed int *__ptr) {
16451   return (vector signed int)__builtin_vsx_lxvw4x_be(__offset, __ptr);
16452 }
16453
16454 static __inline__ vector unsigned int __ATTRS_o_ai
16455 vec_xl_be(signed long long  __offset, unsigned int *__ptr) {
16456   return (vector unsigned int)__builtin_vsx_lxvw4x_be(__offset, __ptr);
16457 }
16458
16459 static __inline__ vector float __ATTRS_o_ai
16460 vec_xl_be(signed long long  __offset, float *__ptr) {
16461   return (vector float)__builtin_vsx_lxvw4x_be(__offset, __ptr);
16462 }
16463
16464 #ifdef __VSX__
16465 static __inline__ vector signed long long __ATTRS_o_ai
16466 vec_xl_be(signed long long  __offset, signed long long *__ptr) {
16467   return (vector signed long long)__builtin_vsx_lxvd2x_be(__offset, __ptr);
16468 }
16469
16470 static __inline__ vector unsigned long long __ATTRS_o_ai
16471 vec_xl_be(signed long long  __offset, unsigned long long *__ptr) {
16472   return (vector unsigned long long)__builtin_vsx_lxvd2x_be(__offset, __ptr);
16473 }
16474
16475 static __inline__ vector double __ATTRS_o_ai
16476 vec_xl_be(signed long long  __offset, double *__ptr) {
16477   return (vector double)__builtin_vsx_lxvd2x_be(__offset, __ptr);
16478 }
16479 #endif
16480
16481 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
16482 static __inline__ vector signed __int128 __ATTRS_o_ai
16483 vec_xl_be(signed long long  __offset, signed __int128 *__ptr) {
16484   return vec_xl(__offset, __ptr);
16485 }
16486
16487 static __inline__ vector unsigned __int128 __ATTRS_o_ai
16488 vec_xl_be(signed long long  __offset, unsigned __int128 *__ptr) {
16489   return vec_xl(__offset, __ptr);
16490 }
16491 #endif
16492 #else
16493   #define vec_xl_be vec_xl
16494 #endif
16495
16496 /* vec_xst */
16497
16498 static inline __ATTRS_o_ai void vec_xst(vector signed char __vec,
16499                                         signed long long __offset,
16500                                         signed char *__ptr) {
16501   *(vector signed char *)(__ptr + __offset) = __vec;
16502 }
16503
16504 static inline __ATTRS_o_ai void vec_xst(vector unsigned char __vec,
16505                                         signed long long __offset,
16506                                         unsigned char *__ptr) {
16507   *(vector unsigned char *)(__ptr + __offset) = __vec;
16508 }
16509
16510 static inline __ATTRS_o_ai void vec_xst(vector signed short __vec,
16511                                         signed long long __offset,
16512                                         signed short *__ptr) {
16513   *(vector signed short *)(__ptr + __offset) = __vec;
16514 }
16515
16516 static inline __ATTRS_o_ai void vec_xst(vector unsigned short __vec,
16517                                         signed long long __offset,
16518                                         unsigned short *__ptr) {
16519   *(vector unsigned short *)(__ptr + __offset) = __vec;
16520 }
16521
16522 static inline __ATTRS_o_ai void vec_xst(vector signed int __vec,
16523                                         signed long long __offset,
16524                                         signed int *__ptr) {
16525   *(vector signed int *)(__ptr + __offset) = __vec;
16526 }
16527
16528 static inline __ATTRS_o_ai void vec_xst(vector unsigned int __vec,
16529                                         signed long long __offset,
16530                                         unsigned int *__ptr) {
16531   *(vector unsigned int *)(__ptr + __offset) = __vec;
16532 }
16533
16534 static inline __ATTRS_o_ai void vec_xst(vector float __vec,
16535                                         signed long long __offset,
16536                                         float *__ptr) {
16537   *(vector float *)(__ptr + __offset) = __vec;
16538 }
16539
16540 #ifdef __VSX__
16541 static inline __ATTRS_o_ai void vec_xst(vector signed long long __vec,
16542                                         signed long long __offset,
16543                                         signed long long *__ptr) {
16544   *(vector signed long long *)(__ptr + __offset) = __vec;
16545 }
16546
16547 static inline __ATTRS_o_ai void vec_xst(vector unsigned long long __vec,
16548                                         signed long long __offset,
16549                                         unsigned long long *__ptr) {
16550   *(vector unsigned long long *)(__ptr + __offset) = __vec;
16551 }
16552
16553 static inline __ATTRS_o_ai void vec_xst(vector double __vec,
16554                                         signed long long __offset,
16555                                         double *__ptr) {
16556   *(vector double *)(__ptr + __offset) = __vec;
16557 }
16558 #endif
16559
16560 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
16561 static inline __ATTRS_o_ai void vec_xst(vector signed __int128 __vec,
16562                                         signed long long __offset,
16563                                         signed __int128 *__ptr) {
16564   *(vector signed __int128 *)(__ptr + __offset) = __vec;
16565 }
16566
16567 static inline __ATTRS_o_ai void vec_xst(vector unsigned __int128 __vec,
16568                                         signed long long __offset,
16569                                         unsigned __int128 *__ptr) {
16570   *(vector unsigned __int128 *)(__ptr + __offset) = __vec;
16571 }
16572 #endif
16573
16574 /* vec_xst_be */
16575
16576 #ifdef __LITTLE_ENDIAN__
16577 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed char __vec,
16578                                                signed long long  __offset,
16579                                                signed char *__ptr) {
16580   vector signed char __tmp =
16581      __builtin_shufflevector(__vec, __vec, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14,
16582                              13, 12, 11, 10, 9, 8);
16583   __builtin_vsx_stxvd2x_be(__tmp, __offset, __ptr);
16584 }
16585
16586 static __inline__ void __ATTRS_o_ai vec_xst_be(vector unsigned char __vec,
16587                                                signed long long  __offset,
16588                                                unsigned char *__ptr) {
16589   vector unsigned char __tmp =
16590      __builtin_shufflevector(__vec, __vec, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14,
16591                              13, 12, 11, 10, 9, 8);
16592   __builtin_vsx_stxvd2x_be(__tmp, __offset, __ptr);
16593 }
16594
16595 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed short __vec,
16596                                                signed long long  __offset,
16597                                                signed short *__ptr) {
16598   vector signed short __tmp =
16599      __builtin_shufflevector(__vec, __vec, 3, 2, 1, 0, 7, 6, 5, 4);
16600   __builtin_vsx_stxvd2x_be(__tmp, __offset, __ptr);
16601 }
16602
16603 static __inline__ void __ATTRS_o_ai vec_xst_be(vector unsigned short __vec,
16604                                                signed long long  __offset,
16605                                                unsigned short *__ptr) {
16606   vector unsigned short __tmp =
16607      __builtin_shufflevector(__vec, __vec, 3, 2, 1, 0, 7, 6, 5, 4);
16608   __builtin_vsx_stxvd2x_be(__tmp, __offset, __ptr);
16609 }
16610
16611 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed int __vec,
16612                                                signed long long  __offset,
16613                                                signed int *__ptr) {
16614   __builtin_vsx_stxvw4x_be(__vec, __offset, __ptr);
16615 }
16616
16617 static __inline__ void __ATTRS_o_ai vec_xst_be(vector unsigned int __vec,
16618                                                signed long long  __offset,
16619                                                unsigned int *__ptr) {
16620   __builtin_vsx_stxvw4x_be(__vec, __offset, __ptr);
16621 }
16622
16623 static __inline__ void __ATTRS_o_ai vec_xst_be(vector float __vec,
16624                                                signed long long  __offset,
16625                                                float *__ptr) {
16626   __builtin_vsx_stxvw4x_be(__vec, __offset, __ptr);
16627 }
16628
16629 #ifdef __VSX__
16630 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed long long __vec,
16631                                                signed long long  __offset,
16632                                                signed long long *__ptr) {
16633   __builtin_vsx_stxvd2x_be(__vec, __offset, __ptr);
16634 }
16635
16636 static __inline__ void __ATTRS_o_ai vec_xst_be(vector unsigned long long __vec,
16637                                                signed long long  __offset,
16638                                                unsigned long long *__ptr) {
16639   __builtin_vsx_stxvd2x_be(__vec, __offset, __ptr);
16640 }
16641
16642 static __inline__ void __ATTRS_o_ai vec_xst_be(vector double __vec,
16643                                                signed long long  __offset,
16644                                                double *__ptr) {
16645   __builtin_vsx_stxvd2x_be(__vec, __offset, __ptr);
16646 }
16647 #endif
16648
16649 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
16650 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed __int128 __vec,
16651                                                signed long long  __offset,
16652                                                signed __int128 *__ptr) {
16653   vec_xst(__vec, __offset, __ptr);
16654 }
16655
16656 static __inline__ void __ATTRS_o_ai vec_xst_be(vector unsigned __int128 __vec,
16657                                                signed long long  __offset,
16658                                                unsigned __int128 *__ptr) {
16659   vec_xst(__vec, __offset, __ptr);
16660 }
16661 #endif
16662 #else
16663   #define vec_xst_be vec_xst
16664 #endif
16665
16666 #ifdef __POWER9_VECTOR__
16667 #define vec_test_data_class(__a, __b)                                      \
16668         _Generic((__a),                                                    \
16669            vector float:                                                   \
16670              (vector bool int)__builtin_vsx_xvtstdcsp((__a), (__b)),       \
16671            vector double:                                                  \
16672              (vector bool long long)__builtin_vsx_xvtstdcdp((__a), (__b))  \
16673         )
16674
16675 #endif /* #ifdef __POWER9_VECTOR__ */
16676
16677 static vector float __ATTRS_o_ai vec_neg(vector float __a) {
16678   return -__a;
16679 }
16680
16681 #ifdef __VSX__
16682 static vector double __ATTRS_o_ai vec_neg(vector double __a) {
16683   return -__a;
16684 }
16685
16686 #endif
16687
16688 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
16689 static vector long long __ATTRS_o_ai vec_neg(vector long long __a) {
16690   return -__a;
16691 }
16692 #endif
16693
16694 static vector signed int __ATTRS_o_ai vec_neg(vector signed int __a) {
16695   return -__a;
16696 }
16697
16698 static vector signed short __ATTRS_o_ai vec_neg(vector signed short __a) {
16699   return -__a;
16700 }
16701
16702 static vector signed char __ATTRS_o_ai vec_neg(vector signed char __a) {
16703   return -__a;
16704 }
16705
16706 static vector float __ATTRS_o_ai vec_nabs(vector float __a) {
16707   return - vec_abs(__a);
16708 }
16709
16710 #ifdef __VSX__
16711 static vector double __ATTRS_o_ai vec_nabs(vector double __a) {
16712   return - vec_abs(__a);
16713 }
16714
16715 #endif
16716
16717 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
16718 static vector long long __ATTRS_o_ai vec_nabs(vector long long __a) {
16719   return __builtin_altivec_vminsd(__a, -__a);
16720 }
16721 #endif
16722
16723 static vector signed int __ATTRS_o_ai vec_nabs(vector signed int __a) {
16724   return __builtin_altivec_vminsw(__a, -__a);
16725 }
16726
16727 static vector signed short __ATTRS_o_ai vec_nabs(vector signed short __a) {
16728   return __builtin_altivec_vminsh(__a, -__a);
16729 }
16730
16731 static vector signed char __ATTRS_o_ai vec_nabs(vector signed char __a) {
16732   return __builtin_altivec_vminsb(__a, -__a);
16733 }
16734 #undef __ATTRS_o_ai
16735
16736 #endif /* __ALTIVEC_H */