Home | History | Annotate | Download | only in include 
      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 */
   16737