Home | History | Annotate | Download | only in Headers 
      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 #define __ATTRS_o_ai __attribute__((__overloadable__, __always_inline__))
     38 
     39 static __inline__ vector signed char __ATTRS_o_ai vec_perm(
     40     vector signed char __a, vector signed char __b, vector unsigned char __c);
     41 
     42 static __inline__ vector unsigned char __ATTRS_o_ai
     43 vec_perm(vector unsigned char __a, vector unsigned char __b,
     44          vector unsigned char __c);
     45 
     46 static __inline__ vector bool char __ATTRS_o_ai
     47 vec_perm(vector bool char __a, vector bool char __b, vector unsigned char __c);
     48 
     49 static __inline__ vector short __ATTRS_o_ai vec_perm(vector signed short __a,
     50                                                      vector signed short __b,
     51                                                      vector unsigned char __c);
     52 
     53 static __inline__ vector unsigned short __ATTRS_o_ai
     54 vec_perm(vector unsigned short __a, vector unsigned short __b,
     55          vector unsigned char __c);
     56 
     57 static __inline__ vector bool short __ATTRS_o_ai vec_perm(
     58     vector bool short __a, vector bool short __b, vector unsigned char __c);
     59 
     60 static __inline__ vector pixel __ATTRS_o_ai vec_perm(vector pixel __a,
     61                                                      vector pixel __b,
     62                                                      vector unsigned char __c);
     63 
     64 static __inline__ vector int __ATTRS_o_ai vec_perm(vector signed int __a,
     65                                                    vector signed int __b,
     66                                                    vector unsigned char __c);
     67 
     68 static __inline__ vector unsigned int __ATTRS_o_ai vec_perm(
     69     vector unsigned int __a, vector unsigned int __b, vector unsigned char __c);
     70 
     71 static __inline__ vector bool int __ATTRS_o_ai
     72 vec_perm(vector bool int __a, vector bool int __b, vector unsigned char __c);
     73 
     74 static __inline__ vector float __ATTRS_o_ai vec_perm(vector float __a,
     75                                                      vector float __b,
     76                                                      vector unsigned char __c);
     77 
     78 #ifdef __VSX__
     79 static __inline__ vector long long __ATTRS_o_ai
     80 vec_perm(vector signed long long __a, vector signed long long __b,
     81          vector unsigned char __c);
     82 
     83 static __inline__ vector unsigned long long __ATTRS_o_ai
     84 vec_perm(vector unsigned long long __a, vector unsigned long long __b,
     85          vector unsigned char __c);
     86 
     87 static __inline__ vector bool long long __ATTRS_o_ai
     88 vec_perm(vector bool long long __a, vector bool long long __b,
     89          vector unsigned char __c);
     90 
     91 static __inline__ vector double __ATTRS_o_ai vec_perm(vector double __a,
     92                                                       vector double __b,
     93                                                       vector unsigned char __c);
     94 #endif
     95 
     96 static __inline__ vector unsigned char __ATTRS_o_ai
     97 vec_xor(vector unsigned char __a, vector unsigned char __b);
     98 
     99 /* vec_abs */
    100 
    101 #define __builtin_altivec_abs_v16qi vec_abs
    102 #define __builtin_altivec_abs_v8hi vec_abs
    103 #define __builtin_altivec_abs_v4si vec_abs
    104 
    105 static __inline__ vector signed char __ATTRS_o_ai
    106 vec_abs(vector signed char __a) {
    107   return __builtin_altivec_vmaxsb(__a, -__a);
    108 }
    109 
    110 static __inline__ vector signed short __ATTRS_o_ai
    111 vec_abs(vector signed short __a) {
    112   return __builtin_altivec_vmaxsh(__a, -__a);
    113 }
    114 
    115 static __inline__ vector signed int __ATTRS_o_ai
    116 vec_abs(vector signed int __a) {
    117   return __builtin_altivec_vmaxsw(__a, -__a);
    118 }
    119 
    120 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
    121 static __inline__ vector signed long long __ATTRS_o_ai
    122 vec_abs(vector signed long long __a) {
    123   return __builtin_altivec_vmaxsd(__a, -__a);
    124 }
    125 #endif
    126 
    127 static __inline__ vector float __ATTRS_o_ai vec_abs(vector float __a) {
    128 #ifdef __VSX__
    129   return __builtin_vsx_xvabssp(__a);
    130 #else
    131   vector unsigned int __res =
    132       (vector unsigned int)__a & (vector unsigned int)(0x7FFFFFFF);
    133   return (vector float)__res;
    134 #endif
    135 }
    136 
    137 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
    138 static __inline__ vector double __ATTRS_o_ai vec_abs(vector double __a) {
    139   return __builtin_vsx_xvabsdp(__a);
    140 }
    141 #endif
    142 
    143 /* vec_abss */
    144 #define __builtin_altivec_abss_v16qi vec_abss
    145 #define __builtin_altivec_abss_v8hi vec_abss
    146 #define __builtin_altivec_abss_v4si vec_abss
    147 
    148 static __inline__ vector signed char __ATTRS_o_ai
    149 vec_abss(vector signed char __a) {
    150   return __builtin_altivec_vmaxsb(
    151       __a, __builtin_altivec_vsubsbs((vector signed char)(0), __a));
    152 }
    153 
    154 static __inline__ vector signed short __ATTRS_o_ai
    155 vec_abss(vector signed short __a) {
    156   return __builtin_altivec_vmaxsh(
    157       __a, __builtin_altivec_vsubshs((vector signed short)(0), __a));
    158 }
    159 
    160 static __inline__ vector signed int __ATTRS_o_ai
    161 vec_abss(vector signed int __a) {
    162   return __builtin_altivec_vmaxsw(
    163       __a, __builtin_altivec_vsubsws((vector signed int)(0), __a));
    164 }
    165 
    166 /* vec_add */
    167 
    168 static __inline__ vector signed char __ATTRS_o_ai
    169 vec_add(vector signed char __a, vector signed char __b) {
    170   return __a + __b;
    171 }
    172 
    173 static __inline__ vector signed char __ATTRS_o_ai
    174 vec_add(vector bool char __a, vector signed char __b) {
    175   return (vector signed char)__a + __b;
    176 }
    177 
    178 static __inline__ vector signed char __ATTRS_o_ai
    179 vec_add(vector signed char __a, vector bool char __b) {
    180   return __a + (vector signed char)__b;
    181 }
    182 
    183 static __inline__ vector unsigned char __ATTRS_o_ai
    184 vec_add(vector unsigned char __a, vector unsigned char __b) {
    185   return __a + __b;
    186 }
    187 
    188 static __inline__ vector unsigned char __ATTRS_o_ai
    189 vec_add(vector bool char __a, vector unsigned char __b) {
    190   return (vector unsigned char)__a + __b;
    191 }
    192 
    193 static __inline__ vector unsigned char __ATTRS_o_ai
    194 vec_add(vector unsigned char __a, vector bool char __b) {
    195   return __a + (vector unsigned char)__b;
    196 }
    197 
    198 static __inline__ vector short __ATTRS_o_ai vec_add(vector short __a,
    199                                                     vector short __b) {
    200   return __a + __b;
    201 }
    202 
    203 static __inline__ vector short __ATTRS_o_ai vec_add(vector bool short __a,
    204                                                     vector short __b) {
    205   return (vector short)__a + __b;
    206 }
    207 
    208 static __inline__ vector short __ATTRS_o_ai vec_add(vector short __a,
    209                                                     vector bool short __b) {
    210   return __a + (vector short)__b;
    211 }
    212 
    213 static __inline__ vector unsigned short __ATTRS_o_ai
    214 vec_add(vector unsigned short __a, vector unsigned short __b) {
    215   return __a + __b;
    216 }
    217 
    218 static __inline__ vector unsigned short __ATTRS_o_ai
    219 vec_add(vector bool short __a, vector unsigned short __b) {
    220   return (vector unsigned short)__a + __b;
    221 }
    222 
    223 static __inline__ vector unsigned short __ATTRS_o_ai
    224 vec_add(vector unsigned short __a, vector bool short __b) {
    225   return __a + (vector unsigned short)__b;
    226 }
    227 
    228 static __inline__ vector int __ATTRS_o_ai vec_add(vector int __a,
    229                                                   vector int __b) {
    230   return __a + __b;
    231 }
    232 
    233 static __inline__ vector int __ATTRS_o_ai vec_add(vector bool int __a,
    234                                                   vector int __b) {
    235   return (vector int)__a + __b;
    236 }
    237 
    238 static __inline__ vector int __ATTRS_o_ai vec_add(vector int __a,
    239                                                   vector bool int __b) {
    240   return __a + (vector int)__b;
    241 }
    242 
    243 static __inline__ vector unsigned int __ATTRS_o_ai
    244 vec_add(vector unsigned int __a, vector unsigned int __b) {
    245   return __a + __b;
    246 }
    247 
    248 static __inline__ vector unsigned int __ATTRS_o_ai
    249 vec_add(vector bool int __a, vector unsigned int __b) {
    250   return (vector unsigned int)__a + __b;
    251 }
    252 
    253 static __inline__ vector unsigned int __ATTRS_o_ai
    254 vec_add(vector unsigned int __a, vector bool int __b) {
    255   return __a + (vector unsigned int)__b;
    256 }
    257 
    258 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
    259 static __inline__ vector signed long long __ATTRS_o_ai
    260 vec_add(vector signed long long __a, vector signed long long __b) {
    261   return __a + __b;
    262 }
    263 
    264 static __inline__ vector unsigned long long __ATTRS_o_ai
    265 vec_add(vector unsigned long long __a, vector unsigned long long __b) {
    266   return __a + __b;
    267 }
    268 
    269 static __inline__ vector signed __int128 __ATTRS_o_ai
    270 vec_add(vector signed __int128 __a, vector signed __int128 __b) {
    271   return __a + __b;
    272 }
    273 
    274 static __inline__ vector unsigned __int128 __ATTRS_o_ai
    275 vec_add(vector unsigned __int128 __a, vector unsigned __int128 __b) {
    276   return __a + __b;
    277 }
    278 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
    279 
    280 static __inline__ vector float __ATTRS_o_ai vec_add(vector float __a,
    281                                                     vector float __b) {
    282   return __a + __b;
    283 }
    284 
    285 #ifdef __VSX__
    286 static __inline__ vector double __ATTRS_o_ai vec_add(vector double __a,
    287                                                      vector double __b) {
    288   return __a + __b;
    289 }
    290 #endif // __VSX__
    291 
    292 /* vec_adde */
    293 
    294 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
    295 static __inline__ vector signed __int128 __ATTRS_o_ai
    296 vec_adde(vector signed __int128 __a, vector signed __int128 __b,
    297          vector signed __int128 __c) {
    298   return __builtin_altivec_vaddeuqm(__a, __b, __c);
    299 }
    300 
    301 static __inline__ vector unsigned __int128 __ATTRS_o_ai
    302 vec_adde(vector unsigned __int128 __a, vector unsigned __int128 __b,
    303          vector unsigned __int128 __c) {
    304   return __builtin_altivec_vaddeuqm(__a, __b, __c);
    305 }
    306 #endif
    307 
    308 /* vec_addec */
    309 
    310 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
    311 static __inline__ vector signed __int128 __ATTRS_o_ai
    312 vec_addec(vector signed __int128 __a, vector signed __int128 __b,
    313           vector signed __int128 __c) {
    314   return __builtin_altivec_vaddecuq(__a, __b, __c);
    315 }
    316 
    317 static __inline__ vector unsigned __int128 __ATTRS_o_ai
    318 vec_addec(vector unsigned __int128 __a, vector unsigned __int128 __b,
    319           vector unsigned __int128 __c) {
    320   return __builtin_altivec_vaddecuq(__a, __b, __c);
    321 }
    322 #endif
    323 
    324 /* vec_vaddubm */
    325 
    326 #define __builtin_altivec_vaddubm vec_vaddubm
    327 
    328 static __inline__ vector signed char __ATTRS_o_ai
    329 vec_vaddubm(vector signed char __a, vector signed char __b) {
    330   return __a + __b;
    331 }
    332 
    333 static __inline__ vector signed char __ATTRS_o_ai
    334 vec_vaddubm(vector bool char __a, vector signed char __b) {
    335   return (vector signed char)__a + __b;
    336 }
    337 
    338 static __inline__ vector signed char __ATTRS_o_ai
    339 vec_vaddubm(vector signed char __a, vector bool char __b) {
    340   return __a + (vector signed char)__b;
    341 }
    342 
    343 static __inline__ vector unsigned char __ATTRS_o_ai
    344 vec_vaddubm(vector unsigned char __a, vector unsigned char __b) {
    345   return __a + __b;
    346 }
    347 
    348 static __inline__ vector unsigned char __ATTRS_o_ai
    349 vec_vaddubm(vector bool char __a, vector unsigned char __b) {
    350   return (vector unsigned char)__a + __b;
    351 }
    352 
    353 static __inline__ vector unsigned char __ATTRS_o_ai
    354 vec_vaddubm(vector unsigned char __a, vector bool char __b) {
    355   return __a + (vector unsigned char)__b;
    356 }
    357 
    358 /* vec_vadduhm */
    359 
    360 #define __builtin_altivec_vadduhm vec_vadduhm
    361 
    362 static __inline__ vector short __ATTRS_o_ai vec_vadduhm(vector short __a,
    363                                                         vector short __b) {
    364   return __a + __b;
    365 }
    366 
    367 static __inline__ vector short __ATTRS_o_ai vec_vadduhm(vector bool short __a,
    368                                                         vector short __b) {
    369   return (vector short)__a + __b;
    370 }
    371 
    372 static __inline__ vector short __ATTRS_o_ai vec_vadduhm(vector short __a,
    373                                                         vector bool short __b) {
    374   return __a + (vector short)__b;
    375 }
    376 
    377 static __inline__ vector unsigned short __ATTRS_o_ai
    378 vec_vadduhm(vector unsigned short __a, vector unsigned short __b) {
    379   return __a + __b;
    380 }
    381 
    382 static __inline__ vector unsigned short __ATTRS_o_ai
    383 vec_vadduhm(vector bool short __a, vector unsigned short __b) {
    384   return (vector unsigned short)__a + __b;
    385 }
    386 
    387 static __inline__ vector unsigned short __ATTRS_o_ai
    388 vec_vadduhm(vector unsigned short __a, vector bool short __b) {
    389   return __a + (vector unsigned short)__b;
    390 }
    391 
    392 /* vec_vadduwm */
    393 
    394 #define __builtin_altivec_vadduwm vec_vadduwm
    395 
    396 static __inline__ vector int __ATTRS_o_ai vec_vadduwm(vector int __a,
    397                                                       vector int __b) {
    398   return __a + __b;
    399 }
    400 
    401 static __inline__ vector int __ATTRS_o_ai vec_vadduwm(vector bool int __a,
    402                                                       vector int __b) {
    403   return (vector int)__a + __b;
    404 }
    405 
    406 static __inline__ vector int __ATTRS_o_ai vec_vadduwm(vector int __a,
    407                                                       vector bool int __b) {
    408   return __a + (vector int)__b;
    409 }
    410 
    411 static __inline__ vector unsigned int __ATTRS_o_ai
    412 vec_vadduwm(vector unsigned int __a, vector unsigned int __b) {
    413   return __a + __b;
    414 }
    415 
    416 static __inline__ vector unsigned int __ATTRS_o_ai
    417 vec_vadduwm(vector bool int __a, vector unsigned int __b) {
    418   return (vector unsigned int)__a + __b;
    419 }
    420 
    421 static __inline__ vector unsigned int __ATTRS_o_ai
    422 vec_vadduwm(vector unsigned int __a, vector bool int __b) {
    423   return __a + (vector unsigned int)__b;
    424 }
    425 
    426 /* vec_vaddfp */
    427 
    428 #define __builtin_altivec_vaddfp vec_vaddfp
    429 
    430 static __inline__ vector float __attribute__((__always_inline__))
    431 vec_vaddfp(vector float __a, vector float __b) {
    432   return __a + __b;
    433 }
    434 
    435 /* vec_addc */
    436 
    437 static __inline__ vector signed int __ATTRS_o_ai
    438 vec_addc(vector signed int __a, vector signed int __b) {
    439   return (vector signed int)__builtin_altivec_vaddcuw((vector unsigned int)__a,
    440                                                       (vector unsigned int)__b);
    441 }
    442 
    443 static __inline__ vector unsigned int __ATTRS_o_ai
    444 vec_addc(vector unsigned int __a, vector unsigned int __b) {
    445   return __builtin_altivec_vaddcuw(__a, __b);
    446 }
    447 
    448 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
    449 static __inline__ vector signed __int128 __ATTRS_o_ai
    450 vec_addc(vector signed __int128 __a, vector signed __int128 __b) {
    451   return (vector signed __int128)__builtin_altivec_vaddcuq(
    452       (vector unsigned __int128)__a, (vector unsigned __int128)__b);
    453 }
    454 
    455 static __inline__ vector unsigned __int128 __ATTRS_o_ai
    456 vec_addc(vector unsigned __int128 __a, vector unsigned __int128 __b) {
    457   return __builtin_altivec_vaddcuq(__a, __b);
    458 }
    459 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
    460 
    461 /* vec_vaddcuw */
    462 
    463 static __inline__ vector unsigned int __attribute__((__always_inline__))
    464 vec_vaddcuw(vector unsigned int __a, vector unsigned int __b) {
    465   return __builtin_altivec_vaddcuw(__a, __b);
    466 }
    467 
    468 /* vec_adds */
    469 
    470 static __inline__ vector signed char __ATTRS_o_ai
    471 vec_adds(vector signed char __a, vector signed char __b) {
    472   return __builtin_altivec_vaddsbs(__a, __b);
    473 }
    474 
    475 static __inline__ vector signed char __ATTRS_o_ai
    476 vec_adds(vector bool char __a, vector signed char __b) {
    477   return __builtin_altivec_vaddsbs((vector signed char)__a, __b);
    478 }
    479 
    480 static __inline__ vector signed char __ATTRS_o_ai
    481 vec_adds(vector signed char __a, vector bool char __b) {
    482   return __builtin_altivec_vaddsbs(__a, (vector signed char)__b);
    483 }
    484 
    485 static __inline__ vector unsigned char __ATTRS_o_ai
    486 vec_adds(vector unsigned char __a, vector unsigned char __b) {
    487   return __builtin_altivec_vaddubs(__a, __b);
    488 }
    489 
    490 static __inline__ vector unsigned char __ATTRS_o_ai
    491 vec_adds(vector bool char __a, vector unsigned char __b) {
    492   return __builtin_altivec_vaddubs((vector unsigned char)__a, __b);
    493 }
    494 
    495 static __inline__ vector unsigned char __ATTRS_o_ai
    496 vec_adds(vector unsigned char __a, vector bool char __b) {
    497   return __builtin_altivec_vaddubs(__a, (vector unsigned char)__b);
    498 }
    499 
    500 static __inline__ vector short __ATTRS_o_ai vec_adds(vector short __a,
    501                                                      vector short __b) {
    502   return __builtin_altivec_vaddshs(__a, __b);
    503 }
    504 
    505 static __inline__ vector short __ATTRS_o_ai vec_adds(vector bool short __a,
    506                                                      vector short __b) {
    507   return __builtin_altivec_vaddshs((vector short)__a, __b);
    508 }
    509 
    510 static __inline__ vector short __ATTRS_o_ai vec_adds(vector short __a,
    511                                                      vector bool short __b) {
    512   return __builtin_altivec_vaddshs(__a, (vector short)__b);
    513 }
    514 
    515 static __inline__ vector unsigned short __ATTRS_o_ai
    516 vec_adds(vector unsigned short __a, vector unsigned short __b) {
    517   return __builtin_altivec_vadduhs(__a, __b);
    518 }
    519 
    520 static __inline__ vector unsigned short __ATTRS_o_ai
    521 vec_adds(vector bool short __a, vector unsigned short __b) {
    522   return __builtin_altivec_vadduhs((vector unsigned short)__a, __b);
    523 }
    524 
    525 static __inline__ vector unsigned short __ATTRS_o_ai
    526 vec_adds(vector unsigned short __a, vector bool short __b) {
    527   return __builtin_altivec_vadduhs(__a, (vector unsigned short)__b);
    528 }
    529 
    530 static __inline__ vector int __ATTRS_o_ai vec_adds(vector int __a,
    531                                                    vector int __b) {
    532   return __builtin_altivec_vaddsws(__a, __b);
    533 }
    534 
    535 static __inline__ vector int __ATTRS_o_ai vec_adds(vector bool int __a,
    536                                                    vector int __b) {
    537   return __builtin_altivec_vaddsws((vector int)__a, __b);
    538 }
    539 
    540 static __inline__ vector int __ATTRS_o_ai vec_adds(vector int __a,
    541                                                    vector bool int __b) {
    542   return __builtin_altivec_vaddsws(__a, (vector int)__b);
    543 }
    544 
    545 static __inline__ vector unsigned int __ATTRS_o_ai
    546 vec_adds(vector unsigned int __a, vector unsigned int __b) {
    547   return __builtin_altivec_vadduws(__a, __b);
    548 }
    549 
    550 static __inline__ vector unsigned int __ATTRS_o_ai
    551 vec_adds(vector bool int __a, vector unsigned int __b) {
    552   return __builtin_altivec_vadduws((vector unsigned int)__a, __b);
    553 }
    554 
    555 static __inline__ vector unsigned int __ATTRS_o_ai
    556 vec_adds(vector unsigned int __a, vector bool int __b) {
    557   return __builtin_altivec_vadduws(__a, (vector unsigned int)__b);
    558 }
    559 
    560 /* vec_vaddsbs */
    561 
    562 static __inline__ vector signed char __ATTRS_o_ai
    563 vec_vaddsbs(vector signed char __a, vector signed char __b) {
    564   return __builtin_altivec_vaddsbs(__a, __b);
    565 }
    566 
    567 static __inline__ vector signed char __ATTRS_o_ai
    568 vec_vaddsbs(vector bool char __a, vector signed char __b) {
    569   return __builtin_altivec_vaddsbs((vector signed char)__a, __b);
    570 }
    571 
    572 static __inline__ vector signed char __ATTRS_o_ai
    573 vec_vaddsbs(vector signed char __a, vector bool char __b) {
    574   return __builtin_altivec_vaddsbs(__a, (vector signed char)__b);
    575 }
    576 
    577 /* vec_vaddubs */
    578 
    579 static __inline__ vector unsigned char __ATTRS_o_ai
    580 vec_vaddubs(vector unsigned char __a, vector unsigned char __b) {
    581   return __builtin_altivec_vaddubs(__a, __b);
    582 }
    583 
    584 static __inline__ vector unsigned char __ATTRS_o_ai
    585 vec_vaddubs(vector bool char __a, vector unsigned char __b) {
    586   return __builtin_altivec_vaddubs((vector unsigned char)__a, __b);
    587 }
    588 
    589 static __inline__ vector unsigned char __ATTRS_o_ai
    590 vec_vaddubs(vector unsigned char __a, vector bool char __b) {
    591   return __builtin_altivec_vaddubs(__a, (vector unsigned char)__b);
    592 }
    593 
    594 /* vec_vaddshs */
    595 
    596 static __inline__ vector short __ATTRS_o_ai vec_vaddshs(vector short __a,
    597                                                         vector short __b) {
    598   return __builtin_altivec_vaddshs(__a, __b);
    599 }
    600 
    601 static __inline__ vector short __ATTRS_o_ai vec_vaddshs(vector bool short __a,
    602                                                         vector short __b) {
    603   return __builtin_altivec_vaddshs((vector short)__a, __b);
    604 }
    605 
    606 static __inline__ vector short __ATTRS_o_ai vec_vaddshs(vector short __a,
    607                                                         vector bool short __b) {
    608   return __builtin_altivec_vaddshs(__a, (vector short)__b);
    609 }
    610 
    611 /* vec_vadduhs */
    612 
    613 static __inline__ vector unsigned short __ATTRS_o_ai
    614 vec_vadduhs(vector unsigned short __a, vector unsigned short __b) {
    615   return __builtin_altivec_vadduhs(__a, __b);
    616 }
    617 
    618 static __inline__ vector unsigned short __ATTRS_o_ai
    619 vec_vadduhs(vector bool short __a, vector unsigned short __b) {
    620   return __builtin_altivec_vadduhs((vector unsigned short)__a, __b);
    621 }
    622 
    623 static __inline__ vector unsigned short __ATTRS_o_ai
    624 vec_vadduhs(vector unsigned short __a, vector bool short __b) {
    625   return __builtin_altivec_vadduhs(__a, (vector unsigned short)__b);
    626 }
    627 
    628 /* vec_vaddsws */
    629 
    630 static __inline__ vector int __ATTRS_o_ai vec_vaddsws(vector int __a,
    631                                                       vector int __b) {
    632   return __builtin_altivec_vaddsws(__a, __b);
    633 }
    634 
    635 static __inline__ vector int __ATTRS_o_ai vec_vaddsws(vector bool int __a,
    636                                                       vector int __b) {
    637   return __builtin_altivec_vaddsws((vector int)__a, __b);
    638 }
    639 
    640 static __inline__ vector int __ATTRS_o_ai vec_vaddsws(vector int __a,
    641                                                       vector bool int __b) {
    642   return __builtin_altivec_vaddsws(__a, (vector int)__b);
    643 }
    644 
    645 /* vec_vadduws */
    646 
    647 static __inline__ vector unsigned int __ATTRS_o_ai
    648 vec_vadduws(vector unsigned int __a, vector unsigned int __b) {
    649   return __builtin_altivec_vadduws(__a, __b);
    650 }
    651 
    652 static __inline__ vector unsigned int __ATTRS_o_ai
    653 vec_vadduws(vector bool int __a, vector unsigned int __b) {
    654   return __builtin_altivec_vadduws((vector unsigned int)__a, __b);
    655 }
    656 
    657 static __inline__ vector unsigned int __ATTRS_o_ai
    658 vec_vadduws(vector unsigned int __a, vector bool int __b) {
    659   return __builtin_altivec_vadduws(__a, (vector unsigned int)__b);
    660 }
    661 
    662 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
    663 /* vec_vadduqm */
    664 
    665 static __inline__ vector signed __int128 __ATTRS_o_ai
    666 vec_vadduqm(vector signed __int128 __a, vector signed __int128 __b) {
    667   return __a + __b;
    668 }
    669 
    670 static __inline__ vector unsigned __int128 __ATTRS_o_ai
    671 vec_vadduqm(vector unsigned __int128 __a, vector unsigned __int128 __b) {
    672   return __a + __b;
    673 }
    674 
    675 /* vec_vaddeuqm */
    676 
    677 static __inline__ vector signed __int128 __ATTRS_o_ai
    678 vec_vaddeuqm(vector signed __int128 __a, vector signed __int128 __b,
    679              vector signed __int128 __c) {
    680   return __builtin_altivec_vaddeuqm(__a, __b, __c);
    681 }
    682 
    683 static __inline__ vector unsigned __int128 __ATTRS_o_ai
    684 vec_vaddeuqm(vector unsigned __int128 __a, vector unsigned __int128 __b,
    685              vector unsigned __int128 __c) {
    686   return __builtin_altivec_vaddeuqm(__a, __b, __c);
    687 }
    688 
    689 /* vec_vaddcuq */
    690 
    691 static __inline__ vector signed __int128 __ATTRS_o_ai
    692 vec_vaddcuq(vector signed __int128 __a, vector signed __int128 __b) {
    693   return __builtin_altivec_vaddcuq(__a, __b);
    694 }
    695 
    696 static __inline__ vector unsigned __int128 __ATTRS_o_ai
    697 vec_vaddcuq(vector unsigned __int128 __a, vector unsigned __int128 __b) {
    698   return __builtin_altivec_vaddcuq(__a, __b);
    699 }
    700 
    701 /* vec_vaddecuq */
    702 
    703 static __inline__ vector signed __int128 __ATTRS_o_ai
    704 vec_vaddecuq(vector signed __int128 __a, vector signed __int128 __b,
    705              vector signed __int128 __c) {
    706   return __builtin_altivec_vaddecuq(__a, __b, __c);
    707 }
    708 
    709 static __inline__ vector unsigned __int128 __ATTRS_o_ai
    710 vec_vaddecuq(vector unsigned __int128 __a, vector unsigned __int128 __b,
    711              vector unsigned __int128 __c) {
    712   return __builtin_altivec_vaddecuq(__a, __b, __c);
    713 }
    714 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
    715 
    716 /* vec_and */
    717 
    718 #define __builtin_altivec_vand vec_and
    719 
    720 static __inline__ vector signed char __ATTRS_o_ai
    721 vec_and(vector signed char __a, vector signed char __b) {
    722   return __a & __b;
    723 }
    724 
    725 static __inline__ vector signed char __ATTRS_o_ai
    726 vec_and(vector bool char __a, vector signed char __b) {
    727   return (vector signed char)__a & __b;
    728 }
    729 
    730 static __inline__ vector signed char __ATTRS_o_ai
    731 vec_and(vector signed char __a, vector bool char __b) {
    732   return __a & (vector signed char)__b;
    733 }
    734 
    735 static __inline__ vector unsigned char __ATTRS_o_ai
    736 vec_and(vector unsigned char __a, vector unsigned char __b) {
    737   return __a & __b;
    738 }
    739 
    740 static __inline__ vector unsigned char __ATTRS_o_ai
    741 vec_and(vector bool char __a, vector unsigned char __b) {
    742   return (vector unsigned char)__a & __b;
    743 }
    744 
    745 static __inline__ vector unsigned char __ATTRS_o_ai
    746 vec_and(vector unsigned char __a, vector bool char __b) {
    747   return __a & (vector unsigned char)__b;
    748 }
    749 
    750 static __inline__ vector bool char __ATTRS_o_ai vec_and(vector bool char __a,
    751                                                         vector bool char __b) {
    752   return __a & __b;
    753 }
    754 
    755 static __inline__ vector short __ATTRS_o_ai vec_and(vector short __a,
    756                                                     vector short __b) {
    757   return __a & __b;
    758 }
    759 
    760 static __inline__ vector short __ATTRS_o_ai vec_and(vector bool short __a,
    761                                                     vector short __b) {
    762   return (vector short)__a & __b;
    763 }
    764 
    765 static __inline__ vector short __ATTRS_o_ai vec_and(vector short __a,
    766                                                     vector bool short __b) {
    767   return __a & (vector short)__b;
    768 }
    769 
    770 static __inline__ vector unsigned short __ATTRS_o_ai
    771 vec_and(vector unsigned short __a, vector unsigned short __b) {
    772   return __a & __b;
    773 }
    774 
    775 static __inline__ vector unsigned short __ATTRS_o_ai
    776 vec_and(vector bool short __a, vector unsigned short __b) {
    777   return (vector unsigned short)__a & __b;
    778 }
    779 
    780 static __inline__ vector unsigned short __ATTRS_o_ai
    781 vec_and(vector unsigned short __a, vector bool short __b) {
    782   return __a & (vector unsigned short)__b;
    783 }
    784 
    785 static __inline__ vector bool short __ATTRS_o_ai
    786 vec_and(vector bool short __a, vector bool short __b) {
    787   return __a & __b;
    788 }
    789 
    790 static __inline__ vector int __ATTRS_o_ai vec_and(vector int __a,
    791                                                   vector int __b) {
    792   return __a & __b;
    793 }
    794 
    795 static __inline__ vector int __ATTRS_o_ai vec_and(vector bool int __a,
    796                                                   vector int __b) {
    797   return (vector int)__a & __b;
    798 }
    799 
    800 static __inline__ vector int __ATTRS_o_ai vec_and(vector int __a,
    801                                                   vector bool int __b) {
    802   return __a & (vector int)__b;
    803 }
    804 
    805 static __inline__ vector unsigned int __ATTRS_o_ai
    806 vec_and(vector unsigned int __a, vector unsigned int __b) {
    807   return __a & __b;
    808 }
    809 
    810 static __inline__ vector unsigned int __ATTRS_o_ai
    811 vec_and(vector bool int __a, vector unsigned int __b) {
    812   return (vector unsigned int)__a & __b;
    813 }
    814 
    815 static __inline__ vector unsigned int __ATTRS_o_ai
    816 vec_and(vector unsigned int __a, vector bool int __b) {
    817   return __a & (vector unsigned int)__b;
    818 }
    819 
    820 static __inline__ vector bool int __ATTRS_o_ai vec_and(vector bool int __a,
    821                                                        vector bool int __b) {
    822   return __a & __b;
    823 }
    824 
    825 static __inline__ vector float __ATTRS_o_ai vec_and(vector float __a,
    826                                                     vector float __b) {
    827   vector unsigned int __res =
    828       (vector unsigned int)__a & (vector unsigned int)__b;
    829   return (vector float)__res;
    830 }
    831 
    832 static __inline__ vector float __ATTRS_o_ai vec_and(vector bool int __a,
    833                                                     vector float __b) {
    834   vector unsigned int __res =
    835       (vector unsigned int)__a & (vector unsigned int)__b;
    836   return (vector float)__res;
    837 }
    838 
    839 static __inline__ vector float __ATTRS_o_ai vec_and(vector float __a,
    840                                                     vector bool int __b) {
    841   vector unsigned int __res =
    842       (vector unsigned int)__a & (vector unsigned int)__b;
    843   return (vector float)__res;
    844 }
    845 
    846 #ifdef __VSX__
    847 static __inline__ vector double __ATTRS_o_ai vec_and(vector bool long long __a,
    848                                                      vector double __b) {
    849   vector unsigned long long __res =
    850       (vector unsigned long long)__a & (vector unsigned long long)__b;
    851   return (vector double)__res;
    852 }
    853 
    854 static __inline__ vector double __ATTRS_o_ai
    855 vec_and(vector double __a, vector bool long long __b) {
    856   vector unsigned long long __res =
    857       (vector unsigned long long)__a & (vector unsigned long long)__b;
    858   return (vector double)__res;
    859 }
    860 
    861 static __inline__ vector double __ATTRS_o_ai vec_and(vector double __a,
    862                                                      vector double __b) {
    863   vector unsigned long long __res =
    864       (vector unsigned long long)__a & (vector unsigned long long)__b;
    865   return (vector double)__res;
    866 }
    867 
    868 static __inline__ vector signed long long __ATTRS_o_ai
    869 vec_and(vector signed long long __a, vector signed long long __b) {
    870   return __a & __b;
    871 }
    872 
    873 static __inline__ vector signed long long __ATTRS_o_ai
    874 vec_and(vector bool long long __a, vector signed long long __b) {
    875   return (vector signed long long)__a & __b;
    876 }
    877 
    878 static __inline__ vector signed long long __ATTRS_o_ai
    879 vec_and(vector signed long long __a, vector bool long long __b) {
    880   return __a & (vector signed long long)__b;
    881 }
    882 
    883 static __inline__ vector unsigned long long __ATTRS_o_ai
    884 vec_and(vector unsigned long long __a, vector unsigned long long __b) {
    885   return __a & __b;
    886 }
    887 
    888 static __inline__ vector unsigned long long __ATTRS_o_ai
    889 vec_and(vector bool long long __a, vector unsigned long long __b) {
    890   return (vector unsigned long long)__a & __b;
    891 }
    892 
    893 static __inline__ vector unsigned long long __ATTRS_o_ai
    894 vec_and(vector unsigned long long __a, vector bool long long __b) {
    895   return __a & (vector unsigned long long)__b;
    896 }
    897 
    898 static __inline__ vector bool long long __ATTRS_o_ai
    899 vec_and(vector bool long long __a, vector bool long long __b) {
    900   return __a & __b;
    901 }
    902 #endif
    903 
    904 /* vec_vand */
    905 
    906 static __inline__ vector signed char __ATTRS_o_ai
    907 vec_vand(vector signed char __a, vector signed char __b) {
    908   return __a & __b;
    909 }
    910 
    911 static __inline__ vector signed char __ATTRS_o_ai
    912 vec_vand(vector bool char __a, vector signed char __b) {
    913   return (vector signed char)__a & __b;
    914 }
    915 
    916 static __inline__ vector signed char __ATTRS_o_ai
    917 vec_vand(vector signed char __a, vector bool char __b) {
    918   return __a & (vector signed char)__b;
    919 }
    920 
    921 static __inline__ vector unsigned char __ATTRS_o_ai
    922 vec_vand(vector unsigned char __a, vector unsigned char __b) {
    923   return __a & __b;
    924 }
    925 
    926 static __inline__ vector unsigned char __ATTRS_o_ai
    927 vec_vand(vector bool char __a, vector unsigned char __b) {
    928   return (vector unsigned char)__a & __b;
    929 }
    930 
    931 static __inline__ vector unsigned char __ATTRS_o_ai
    932 vec_vand(vector unsigned char __a, vector bool char __b) {
    933   return __a & (vector unsigned char)__b;
    934 }
    935 
    936 static __inline__ vector bool char __ATTRS_o_ai vec_vand(vector bool char __a,
    937                                                          vector bool char __b) {
    938   return __a & __b;
    939 }
    940 
    941 static __inline__ vector short __ATTRS_o_ai vec_vand(vector short __a,
    942                                                      vector short __b) {
    943   return __a & __b;
    944 }
    945 
    946 static __inline__ vector short __ATTRS_o_ai vec_vand(vector bool short __a,
    947                                                      vector short __b) {
    948   return (vector short)__a & __b;
    949 }
    950 
    951 static __inline__ vector short __ATTRS_o_ai vec_vand(vector short __a,
    952                                                      vector bool short __b) {
    953   return __a & (vector short)__b;
    954 }
    955 
    956 static __inline__ vector unsigned short __ATTRS_o_ai
    957 vec_vand(vector unsigned short __a, vector unsigned short __b) {
    958   return __a & __b;
    959 }
    960 
    961 static __inline__ vector unsigned short __ATTRS_o_ai
    962 vec_vand(vector bool short __a, vector unsigned short __b) {
    963   return (vector unsigned short)__a & __b;
    964 }
    965 
    966 static __inline__ vector unsigned short __ATTRS_o_ai
    967 vec_vand(vector unsigned short __a, vector bool short __b) {
    968   return __a & (vector unsigned short)__b;
    969 }
    970 
    971 static __inline__ vector bool short __ATTRS_o_ai
    972 vec_vand(vector bool short __a, vector bool short __b) {
    973   return __a & __b;
    974 }
    975 
    976 static __inline__ vector int __ATTRS_o_ai vec_vand(vector int __a,
    977                                                    vector int __b) {
    978   return __a & __b;
    979 }
    980 
    981 static __inline__ vector int __ATTRS_o_ai vec_vand(vector bool int __a,
    982                                                    vector int __b) {
    983   return (vector int)__a & __b;
    984 }
    985 
    986 static __inline__ vector int __ATTRS_o_ai vec_vand(vector int __a,
    987                                                    vector bool int __b) {
    988   return __a & (vector int)__b;
    989 }
    990 
    991 static __inline__ vector unsigned int __ATTRS_o_ai
    992 vec_vand(vector unsigned int __a, vector unsigned int __b) {
    993   return __a & __b;
    994 }
    995 
    996 static __inline__ vector unsigned int __ATTRS_o_ai
    997 vec_vand(vector bool int __a, vector unsigned int __b) {
    998   return (vector unsigned int)__a & __b;
    999 }
   1000 
   1001 static __inline__ vector unsigned int __ATTRS_o_ai
   1002 vec_vand(vector unsigned int __a, vector bool int __b) {
   1003   return __a & (vector unsigned int)__b;
   1004 }
   1005 
   1006 static __inline__ vector bool int __ATTRS_o_ai vec_vand(vector bool int __a,
   1007                                                         vector bool int __b) {
   1008   return __a & __b;
   1009 }
   1010 
   1011 static __inline__ vector float __ATTRS_o_ai vec_vand(vector float __a,
   1012                                                      vector float __b) {
   1013   vector unsigned int __res =
   1014       (vector unsigned int)__a & (vector unsigned int)__b;
   1015   return (vector float)__res;
   1016 }
   1017 
   1018 static __inline__ vector float __ATTRS_o_ai vec_vand(vector bool int __a,
   1019                                                      vector float __b) {
   1020   vector unsigned int __res =
   1021       (vector unsigned int)__a & (vector unsigned int)__b;
   1022   return (vector float)__res;
   1023 }
   1024 
   1025 static __inline__ vector float __ATTRS_o_ai vec_vand(vector float __a,
   1026                                                      vector bool int __b) {
   1027   vector unsigned int __res =
   1028       (vector unsigned int)__a & (vector unsigned int)__b;
   1029   return (vector float)__res;
   1030 }
   1031 
   1032 #ifdef __VSX__
   1033 static __inline__ vector signed long long __ATTRS_o_ai
   1034 vec_vand(vector signed long long __a, vector signed long long __b) {
   1035   return __a & __b;
   1036 }
   1037 
   1038 static __inline__ vector signed long long __ATTRS_o_ai
   1039 vec_vand(vector bool long long __a, vector signed long long __b) {
   1040   return (vector signed long long)__a & __b;
   1041 }
   1042 
   1043 static __inline__ vector signed long long __ATTRS_o_ai
   1044 vec_vand(vector signed long long __a, vector bool long long __b) {
   1045   return __a & (vector signed long long)__b;
   1046 }
   1047 
   1048 static __inline__ vector unsigned long long __ATTRS_o_ai
   1049 vec_vand(vector unsigned long long __a, vector unsigned long long __b) {
   1050   return __a & __b;
   1051 }
   1052 
   1053 static __inline__ vector unsigned long long __ATTRS_o_ai
   1054 vec_vand(vector bool long long __a, vector unsigned long long __b) {
   1055   return (vector unsigned long long)__a & __b;
   1056 }
   1057 
   1058 static __inline__ vector unsigned long long __ATTRS_o_ai
   1059 vec_vand(vector unsigned long long __a, vector bool long long __b) {
   1060   return __a & (vector unsigned long long)__b;
   1061 }
   1062 
   1063 static __inline__ vector bool long long __ATTRS_o_ai
   1064 vec_vand(vector bool long long __a, vector bool long long __b) {
   1065   return __a & __b;
   1066 }
   1067 #endif
   1068 
   1069 /* vec_andc */
   1070 
   1071 #define __builtin_altivec_vandc vec_andc
   1072 
   1073 static __inline__ vector signed char __ATTRS_o_ai
   1074 vec_andc(vector signed char __a, vector signed char __b) {
   1075   return __a & ~__b;
   1076 }
   1077 
   1078 static __inline__ vector signed char __ATTRS_o_ai
   1079 vec_andc(vector bool char __a, vector signed char __b) {
   1080   return (vector signed char)__a & ~__b;
   1081 }
   1082 
   1083 static __inline__ vector signed char __ATTRS_o_ai
   1084 vec_andc(vector signed char __a, vector bool char __b) {
   1085   return __a & ~(vector signed char)__b;
   1086 }
   1087 
   1088 static __inline__ vector unsigned char __ATTRS_o_ai
   1089 vec_andc(vector unsigned char __a, vector unsigned char __b) {
   1090   return __a & ~__b;
   1091 }
   1092 
   1093 static __inline__ vector unsigned char __ATTRS_o_ai
   1094 vec_andc(vector bool char __a, vector unsigned char __b) {
   1095   return (vector unsigned char)__a & ~__b;
   1096 }
   1097 
   1098 static __inline__ vector unsigned char __ATTRS_o_ai
   1099 vec_andc(vector unsigned char __a, vector bool char __b) {
   1100   return __a & ~(vector unsigned char)__b;
   1101 }
   1102 
   1103 static __inline__ vector bool char __ATTRS_o_ai vec_andc(vector bool char __a,
   1104                                                          vector bool char __b) {
   1105   return __a & ~__b;
   1106 }
   1107 
   1108 static __inline__ vector short __ATTRS_o_ai vec_andc(vector short __a,
   1109                                                      vector short __b) {
   1110   return __a & ~__b;
   1111 }
   1112 
   1113 static __inline__ vector short __ATTRS_o_ai vec_andc(vector bool short __a,
   1114                                                      vector short __b) {
   1115   return (vector short)__a & ~__b;
   1116 }
   1117 
   1118 static __inline__ vector short __ATTRS_o_ai vec_andc(vector short __a,
   1119                                                      vector bool short __b) {
   1120   return __a & ~(vector short)__b;
   1121 }
   1122 
   1123 static __inline__ vector unsigned short __ATTRS_o_ai
   1124 vec_andc(vector unsigned short __a, vector unsigned short __b) {
   1125   return __a & ~__b;
   1126 }
   1127 
   1128 static __inline__ vector unsigned short __ATTRS_o_ai
   1129 vec_andc(vector bool short __a, vector unsigned short __b) {
   1130   return (vector unsigned short)__a & ~__b;
   1131 }
   1132 
   1133 static __inline__ vector unsigned short __ATTRS_o_ai
   1134 vec_andc(vector unsigned short __a, vector bool short __b) {
   1135   return __a & ~(vector unsigned short)__b;
   1136 }
   1137 
   1138 static __inline__ vector bool short __ATTRS_o_ai
   1139 vec_andc(vector bool short __a, vector bool short __b) {
   1140   return __a & ~__b;
   1141 }
   1142 
   1143 static __inline__ vector int __ATTRS_o_ai vec_andc(vector int __a,
   1144                                                    vector int __b) {
   1145   return __a & ~__b;
   1146 }
   1147 
   1148 static __inline__ vector int __ATTRS_o_ai vec_andc(vector bool int __a,
   1149                                                    vector int __b) {
   1150   return (vector int)__a & ~__b;
   1151 }
   1152 
   1153 static __inline__ vector int __ATTRS_o_ai vec_andc(vector int __a,
   1154                                                    vector bool int __b) {
   1155   return __a & ~(vector int)__b;
   1156 }
   1157 
   1158 static __inline__ vector unsigned int __ATTRS_o_ai
   1159 vec_andc(vector unsigned int __a, vector unsigned int __b) {
   1160   return __a & ~__b;
   1161 }
   1162 
   1163 static __inline__ vector unsigned int __ATTRS_o_ai
   1164 vec_andc(vector bool int __a, vector unsigned int __b) {
   1165   return (vector unsigned int)__a & ~__b;
   1166 }
   1167 
   1168 static __inline__ vector unsigned int __ATTRS_o_ai
   1169 vec_andc(vector unsigned int __a, vector bool int __b) {
   1170   return __a & ~(vector unsigned int)__b;
   1171 }
   1172 
   1173 static __inline__ vector bool int __ATTRS_o_ai vec_andc(vector bool int __a,
   1174                                                         vector bool int __b) {
   1175   return __a & ~__b;
   1176 }
   1177 
   1178 static __inline__ vector float __ATTRS_o_ai vec_andc(vector float __a,
   1179                                                      vector float __b) {
   1180   vector unsigned int __res =
   1181       (vector unsigned int)__a & ~(vector unsigned int)__b;
   1182   return (vector float)__res;
   1183 }
   1184 
   1185 static __inline__ vector float __ATTRS_o_ai vec_andc(vector bool int __a,
   1186                                                      vector float __b) {
   1187   vector unsigned int __res =
   1188       (vector unsigned int)__a & ~(vector unsigned int)__b;
   1189   return (vector float)__res;
   1190 }
   1191 
   1192 static __inline__ vector float __ATTRS_o_ai vec_andc(vector float __a,
   1193                                                      vector bool int __b) {
   1194   vector unsigned int __res =
   1195       (vector unsigned int)__a & ~(vector unsigned int)__b;
   1196   return (vector float)__res;
   1197 }
   1198 
   1199 #ifdef __VSX__
   1200 static __inline__ vector double __ATTRS_o_ai vec_andc(vector bool long long __a,
   1201                                                       vector double __b) {
   1202   vector unsigned long long __res =
   1203       (vector unsigned long long)__a & ~(vector unsigned long long)__b;
   1204   return (vector double)__res;
   1205 }
   1206 
   1207 static __inline__ vector double __ATTRS_o_ai
   1208 vec_andc(vector double __a, vector bool long long __b) {
   1209   vector unsigned long long __res =
   1210       (vector unsigned long long)__a & ~(vector unsigned long long)__b;
   1211   return (vector double)__res;
   1212 }
   1213 
   1214 static __inline__ vector double __ATTRS_o_ai vec_andc(vector double __a,
   1215                                                       vector double __b) {
   1216   vector unsigned long long __res =
   1217       (vector unsigned long long)__a & ~(vector unsigned long long)__b;
   1218   return (vector double)__res;
   1219 }
   1220 
   1221 static __inline__ vector signed long long __ATTRS_o_ai
   1222 vec_andc(vector signed long long __a, vector signed long long __b) {
   1223   return __a & ~__b;
   1224 }
   1225 
   1226 static __inline__ vector signed long long __ATTRS_o_ai
   1227 vec_andc(vector bool long long __a, vector signed long long __b) {
   1228   return (vector signed long long)__a & ~__b;
   1229 }
   1230 
   1231 static __inline__ vector signed long long __ATTRS_o_ai
   1232 vec_andc(vector signed long long __a, vector bool long long __b) {
   1233   return __a & ~(vector signed long long)__b;
   1234 }
   1235 
   1236 static __inline__ vector unsigned long long __ATTRS_o_ai
   1237 vec_andc(vector unsigned long long __a, vector unsigned long long __b) {
   1238   return __a & ~__b;
   1239 }
   1240 
   1241 static __inline__ vector unsigned long long __ATTRS_o_ai
   1242 vec_andc(vector bool long long __a, vector unsigned long long __b) {
   1243   return (vector unsigned long long)__a & ~__b;
   1244 }
   1245 
   1246 static __inline__ vector unsigned long long __ATTRS_o_ai
   1247 vec_andc(vector unsigned long long __a, vector bool long long __b) {
   1248   return __a & ~(vector unsigned long long)__b;
   1249 }
   1250 
   1251 static __inline__ vector bool long long __ATTRS_o_ai
   1252 vec_andc(vector bool long long __a, vector bool long long __b) {
   1253   return __a & ~__b;
   1254 }
   1255 #endif
   1256 
   1257 /* vec_vandc */
   1258 
   1259 static __inline__ vector signed char __ATTRS_o_ai
   1260 vec_vandc(vector signed char __a, vector signed char __b) {
   1261   return __a & ~__b;
   1262 }
   1263 
   1264 static __inline__ vector signed char __ATTRS_o_ai
   1265 vec_vandc(vector bool char __a, vector signed char __b) {
   1266   return (vector signed char)__a & ~__b;
   1267 }
   1268 
   1269 static __inline__ vector signed char __ATTRS_o_ai
   1270 vec_vandc(vector signed char __a, vector bool char __b) {
   1271   return __a & ~(vector signed char)__b;
   1272 }
   1273 
   1274 static __inline__ vector unsigned char __ATTRS_o_ai
   1275 vec_vandc(vector unsigned char __a, vector unsigned char __b) {
   1276   return __a & ~__b;
   1277 }
   1278 
   1279 static __inline__ vector unsigned char __ATTRS_o_ai
   1280 vec_vandc(vector bool char __a, vector unsigned char __b) {
   1281   return (vector unsigned char)__a & ~__b;
   1282 }
   1283 
   1284 static __inline__ vector unsigned char __ATTRS_o_ai
   1285 vec_vandc(vector unsigned char __a, vector bool char __b) {
   1286   return __a & ~(vector unsigned char)__b;
   1287 }
   1288 
   1289 static __inline__ vector bool char __ATTRS_o_ai
   1290 vec_vandc(vector bool char __a, vector bool char __b) {
   1291   return __a & ~__b;
   1292 }
   1293 
   1294 static __inline__ vector short __ATTRS_o_ai vec_vandc(vector short __a,
   1295                                                       vector short __b) {
   1296   return __a & ~__b;
   1297 }
   1298 
   1299 static __inline__ vector short __ATTRS_o_ai vec_vandc(vector bool short __a,
   1300                                                       vector short __b) {
   1301   return (vector short)__a & ~__b;
   1302 }
   1303 
   1304 static __inline__ vector short __ATTRS_o_ai vec_vandc(vector short __a,
   1305                                                       vector bool short __b) {
   1306   return __a & ~(vector short)__b;
   1307 }
   1308 
   1309 static __inline__ vector unsigned short __ATTRS_o_ai
   1310 vec_vandc(vector unsigned short __a, vector unsigned short __b) {
   1311   return __a & ~__b;
   1312 }
   1313 
   1314 static __inline__ vector unsigned short __ATTRS_o_ai
   1315 vec_vandc(vector bool short __a, vector unsigned short __b) {
   1316   return (vector unsigned short)__a & ~__b;
   1317 }
   1318 
   1319 static __inline__ vector unsigned short __ATTRS_o_ai
   1320 vec_vandc(vector unsigned short __a, vector bool short __b) {
   1321   return __a & ~(vector unsigned short)__b;
   1322 }
   1323 
   1324 static __inline__ vector bool short __ATTRS_o_ai
   1325 vec_vandc(vector bool short __a, vector bool short __b) {
   1326   return __a & ~__b;
   1327 }
   1328 
   1329 static __inline__ vector int __ATTRS_o_ai vec_vandc(vector int __a,
   1330                                                     vector int __b) {
   1331   return __a & ~__b;
   1332 }
   1333 
   1334 static __inline__ vector int __ATTRS_o_ai vec_vandc(vector bool int __a,
   1335                                                     vector int __b) {
   1336   return (vector int)__a & ~__b;
   1337 }
   1338 
   1339 static __inline__ vector int __ATTRS_o_ai vec_vandc(vector int __a,
   1340                                                     vector bool int __b) {
   1341   return __a & ~(vector int)__b;
   1342 }
   1343 
   1344 static __inline__ vector unsigned int __ATTRS_o_ai
   1345 vec_vandc(vector unsigned int __a, vector unsigned int __b) {
   1346   return __a & ~__b;
   1347 }
   1348 
   1349 static __inline__ vector unsigned int __ATTRS_o_ai
   1350 vec_vandc(vector bool int __a, vector unsigned int __b) {
   1351   return (vector unsigned int)__a & ~__b;
   1352 }
   1353 
   1354 static __inline__ vector unsigned int __ATTRS_o_ai
   1355 vec_vandc(vector unsigned int __a, vector bool int __b) {
   1356   return __a & ~(vector unsigned int)__b;
   1357 }
   1358 
   1359 static __inline__ vector bool int __ATTRS_o_ai vec_vandc(vector bool int __a,
   1360                                                          vector bool int __b) {
   1361   return __a & ~__b;
   1362 }
   1363 
   1364 static __inline__ vector float __ATTRS_o_ai vec_vandc(vector float __a,
   1365                                                       vector float __b) {
   1366   vector unsigned int __res =
   1367       (vector unsigned int)__a & ~(vector unsigned int)__b;
   1368   return (vector float)__res;
   1369 }
   1370 
   1371 static __inline__ vector float __ATTRS_o_ai vec_vandc(vector bool int __a,
   1372                                                       vector float __b) {
   1373   vector unsigned int __res =
   1374       (vector unsigned int)__a & ~(vector unsigned int)__b;
   1375   return (vector float)__res;
   1376 }
   1377 
   1378 static __inline__ vector float __ATTRS_o_ai vec_vandc(vector float __a,
   1379                                                       vector bool int __b) {
   1380   vector unsigned int __res =
   1381       (vector unsigned int)__a & ~(vector unsigned int)__b;
   1382   return (vector float)__res;
   1383 }
   1384 
   1385 #ifdef __VSX__
   1386 static __inline__ vector signed long long __ATTRS_o_ai
   1387 vec_vandc(vector signed long long __a, vector signed long long __b) {
   1388   return __a & ~__b;
   1389 }
   1390 
   1391 static __inline__ vector signed long long __ATTRS_o_ai
   1392 vec_vandc(vector bool long long __a, vector signed long long __b) {
   1393   return (vector signed long long)__a & ~__b;
   1394 }
   1395 
   1396 static __inline__ vector signed long long __ATTRS_o_ai
   1397 vec_vandc(vector signed long long __a, vector bool long long __b) {
   1398   return __a & ~(vector signed long long)__b;
   1399 }
   1400 
   1401 static __inline__ vector unsigned long long __ATTRS_o_ai
   1402 vec_vandc(vector unsigned long long __a, vector unsigned long long __b) {
   1403   return __a & ~__b;
   1404 }
   1405 
   1406 static __inline__ vector unsigned long long __ATTRS_o_ai
   1407 vec_vandc(vector bool long long __a, vector unsigned long long __b) {
   1408   return (vector unsigned long long)__a & ~__b;
   1409 }
   1410 
   1411 static __inline__ vector unsigned long long __ATTRS_o_ai
   1412 vec_vandc(vector unsigned long long __a, vector bool long long __b) {
   1413   return __a & ~(vector unsigned long long)__b;
   1414 }
   1415 
   1416 static __inline__ vector bool long long __ATTRS_o_ai
   1417 vec_vandc(vector bool long long __a, vector bool long long __b) {
   1418   return __a & ~__b;
   1419 }
   1420 #endif
   1421 
   1422 /* vec_avg */
   1423 
   1424 static __inline__ vector signed char __ATTRS_o_ai
   1425 vec_avg(vector signed char __a, vector signed char __b) {
   1426   return __builtin_altivec_vavgsb(__a, __b);
   1427 }
   1428 
   1429 static __inline__ vector unsigned char __ATTRS_o_ai
   1430 vec_avg(vector unsigned char __a, vector unsigned char __b) {
   1431   return __builtin_altivec_vavgub(__a, __b);
   1432 }
   1433 
   1434 static __inline__ vector short __ATTRS_o_ai vec_avg(vector short __a,
   1435                                                     vector short __b) {
   1436   return __builtin_altivec_vavgsh(__a, __b);
   1437 }
   1438 
   1439 static __inline__ vector unsigned short __ATTRS_o_ai
   1440 vec_avg(vector unsigned short __a, vector unsigned short __b) {
   1441   return __builtin_altivec_vavguh(__a, __b);
   1442 }
   1443 
   1444 static __inline__ vector int __ATTRS_o_ai vec_avg(vector int __a,
   1445                                                   vector int __b) {
   1446   return __builtin_altivec_vavgsw(__a, __b);
   1447 }
   1448 
   1449 static __inline__ vector unsigned int __ATTRS_o_ai
   1450 vec_avg(vector unsigned int __a, vector unsigned int __b) {
   1451   return __builtin_altivec_vavguw(__a, __b);
   1452 }
   1453 
   1454 /* vec_vavgsb */
   1455 
   1456 static __inline__ vector signed char __attribute__((__always_inline__))
   1457 vec_vavgsb(vector signed char __a, vector signed char __b) {
   1458   return __builtin_altivec_vavgsb(__a, __b);
   1459 }
   1460 
   1461 /* vec_vavgub */
   1462 
   1463 static __inline__ vector unsigned char __attribute__((__always_inline__))
   1464 vec_vavgub(vector unsigned char __a, vector unsigned char __b) {
   1465   return __builtin_altivec_vavgub(__a, __b);
   1466 }
   1467 
   1468 /* vec_vavgsh */
   1469 
   1470 static __inline__ vector short __attribute__((__always_inline__))
   1471 vec_vavgsh(vector short __a, vector short __b) {
   1472   return __builtin_altivec_vavgsh(__a, __b);
   1473 }
   1474 
   1475 /* vec_vavguh */
   1476 
   1477 static __inline__ vector unsigned short __attribute__((__always_inline__))
   1478 vec_vavguh(vector unsigned short __a, vector unsigned short __b) {
   1479   return __builtin_altivec_vavguh(__a, __b);
   1480 }
   1481 
   1482 /* vec_vavgsw */
   1483 
   1484 static __inline__ vector int __attribute__((__always_inline__))
   1485 vec_vavgsw(vector int __a, vector int __b) {
   1486   return __builtin_altivec_vavgsw(__a, __b);
   1487 }
   1488 
   1489 /* vec_vavguw */
   1490 
   1491 static __inline__ vector unsigned int __attribute__((__always_inline__))
   1492 vec_vavguw(vector unsigned int __a, vector unsigned int __b) {
   1493   return __builtin_altivec_vavguw(__a, __b);
   1494 }
   1495 
   1496 /* vec_ceil */
   1497 
   1498 static __inline__ vector float __ATTRS_o_ai vec_ceil(vector float __a) {
   1499 #ifdef __VSX__
   1500   return __builtin_vsx_xvrspip(__a);
   1501 #else
   1502   return __builtin_altivec_vrfip(__a);
   1503 #endif
   1504 }
   1505 
   1506 #ifdef __VSX__
   1507 static __inline__ vector double __ATTRS_o_ai vec_ceil(vector double __a) {
   1508   return __builtin_vsx_xvrdpip(__a);
   1509 }
   1510 #endif
   1511 
   1512 /* vec_vrfip */
   1513 
   1514 static __inline__ vector float __attribute__((__always_inline__))
   1515 vec_vrfip(vector float __a) {
   1516   return __builtin_altivec_vrfip(__a);
   1517 }
   1518 
   1519 /* vec_cmpb */
   1520 
   1521 static __inline__ vector int __attribute__((__always_inline__))
   1522 vec_cmpb(vector float __a, vector float __b) {
   1523   return __builtin_altivec_vcmpbfp(__a, __b);
   1524 }
   1525 
   1526 /* vec_vcmpbfp */
   1527 
   1528 static __inline__ vector int __attribute__((__always_inline__))
   1529 vec_vcmpbfp(vector float __a, vector float __b) {
   1530   return __builtin_altivec_vcmpbfp(__a, __b);
   1531 }
   1532 
   1533 /* vec_cmpeq */
   1534 
   1535 static __inline__ vector bool char __ATTRS_o_ai
   1536 vec_cmpeq(vector signed char __a, vector signed char __b) {
   1537   return (vector bool char)__builtin_altivec_vcmpequb((vector char)__a,
   1538                                                       (vector char)__b);
   1539 }
   1540 
   1541 static __inline__ vector bool char __ATTRS_o_ai
   1542 vec_cmpeq(vector unsigned char __a, vector unsigned char __b) {
   1543   return (vector bool char)__builtin_altivec_vcmpequb((vector char)__a,
   1544                                                       (vector char)__b);
   1545 }
   1546 
   1547 static __inline__ vector bool short __ATTRS_o_ai vec_cmpeq(vector short __a,
   1548                                                            vector short __b) {
   1549   return (vector bool short)__builtin_altivec_vcmpequh(__a, __b);
   1550 }
   1551 
   1552 static __inline__ vector bool short __ATTRS_o_ai
   1553 vec_cmpeq(vector unsigned short __a, vector unsigned short __b) {
   1554   return (vector bool short)__builtin_altivec_vcmpequh((vector short)__a,
   1555                                                        (vector short)__b);
   1556 }
   1557 
   1558 static __inline__ vector bool int __ATTRS_o_ai vec_cmpeq(vector int __a,
   1559                                                          vector int __b) {
   1560   return (vector bool int)__builtin_altivec_vcmpequw(__a, __b);
   1561 }
   1562 
   1563 static __inline__ vector bool int __ATTRS_o_ai
   1564 vec_cmpeq(vector unsigned int __a, vector unsigned int __b) {
   1565   return (vector bool int)__builtin_altivec_vcmpequw((vector int)__a,
   1566                                                      (vector int)__b);
   1567 }
   1568 
   1569 #ifdef __POWER8_VECTOR__
   1570 static __inline__ vector bool long long __ATTRS_o_ai
   1571 vec_cmpeq(vector signed long long __a, vector signed long long __b) {
   1572   return (vector bool long long)__builtin_altivec_vcmpequd(__a, __b);
   1573 }
   1574 
   1575 static __inline__ vector bool long long __ATTRS_o_ai
   1576 vec_cmpeq(vector unsigned long long __a, vector unsigned long long __b) {
   1577   return (vector bool long long)__builtin_altivec_vcmpequd(
   1578       (vector long long)__a, (vector long long)__b);
   1579 }
   1580 #endif
   1581 
   1582 static __inline__ vector bool int __ATTRS_o_ai vec_cmpeq(vector float __a,
   1583                                                          vector float __b) {
   1584 #ifdef __VSX__
   1585   return (vector bool int)__builtin_vsx_xvcmpeqsp(__a, __b);
   1586 #else
   1587   return (vector bool int)__builtin_altivec_vcmpeqfp(__a, __b);
   1588 #endif
   1589 }
   1590 
   1591 #ifdef __VSX__
   1592 static __inline__ vector bool long long __ATTRS_o_ai
   1593 vec_cmpeq(vector double __a, vector double __b) {
   1594   return (vector bool long long)__builtin_vsx_xvcmpeqdp(__a, __b);
   1595 }
   1596 #endif
   1597 
   1598 /* vec_cmpgt */
   1599 
   1600 static __inline__ vector bool char __ATTRS_o_ai
   1601 vec_cmpgt(vector signed char __a, vector signed char __b) {
   1602   return (vector bool char)__builtin_altivec_vcmpgtsb(__a, __b);
   1603 }
   1604 
   1605 static __inline__ vector bool char __ATTRS_o_ai
   1606 vec_cmpgt(vector unsigned char __a, vector unsigned char __b) {
   1607   return (vector bool char)__builtin_altivec_vcmpgtub(__a, __b);
   1608 }
   1609 
   1610 static __inline__ vector bool short __ATTRS_o_ai vec_cmpgt(vector short __a,
   1611                                                            vector short __b) {
   1612   return (vector bool short)__builtin_altivec_vcmpgtsh(__a, __b);
   1613 }
   1614 
   1615 static __inline__ vector bool short __ATTRS_o_ai
   1616 vec_cmpgt(vector unsigned short __a, vector unsigned short __b) {
   1617   return (vector bool short)__builtin_altivec_vcmpgtuh(__a, __b);
   1618 }
   1619 
   1620 static __inline__ vector bool int __ATTRS_o_ai vec_cmpgt(vector int __a,
   1621                                                          vector int __b) {
   1622   return (vector bool int)__builtin_altivec_vcmpgtsw(__a, __b);
   1623 }
   1624 
   1625 static __inline__ vector bool int __ATTRS_o_ai
   1626 vec_cmpgt(vector unsigned int __a, vector unsigned int __b) {
   1627   return (vector bool int)__builtin_altivec_vcmpgtuw(__a, __b);
   1628 }
   1629 
   1630 #ifdef __POWER8_VECTOR__
   1631 static __inline__ vector bool long long __ATTRS_o_ai
   1632 vec_cmpgt(vector signed long long __a, vector signed long long __b) {
   1633   return (vector bool long long)__builtin_altivec_vcmpgtsd(__a, __b);
   1634 }
   1635 
   1636 static __inline__ vector bool long long __ATTRS_o_ai
   1637 vec_cmpgt(vector unsigned long long __a, vector unsigned long long __b) {
   1638   return (vector bool long long)__builtin_altivec_vcmpgtud(__a, __b);
   1639 }
   1640 #endif
   1641 
   1642 static __inline__ vector bool int __ATTRS_o_ai vec_cmpgt(vector float __a,
   1643                                                          vector float __b) {
   1644 #ifdef __VSX__
   1645   return (vector bool int)__builtin_vsx_xvcmpgtsp(__a, __b);
   1646 #else
   1647   return (vector bool int)__builtin_altivec_vcmpgtfp(__a, __b);
   1648 #endif
   1649 }
   1650 
   1651 #ifdef __VSX__
   1652 static __inline__ vector bool long long __ATTRS_o_ai
   1653 vec_cmpgt(vector double __a, vector double __b) {
   1654   return (vector bool long long)__builtin_vsx_xvcmpgtdp(__a, __b);
   1655 }
   1656 #endif
   1657 
   1658 /* vec_cmpge */
   1659 
   1660 static __inline__ vector bool char __ATTRS_o_ai
   1661 vec_cmpge(vector signed char __a, vector signed char __b) {
   1662   return ~(vec_cmpgt(__b, __a));
   1663 }
   1664 
   1665 static __inline__ vector bool char __ATTRS_o_ai
   1666 vec_cmpge(vector unsigned char __a, vector unsigned char __b) {
   1667   return ~(vec_cmpgt(__b, __a));
   1668 }
   1669 
   1670 static __inline__ vector bool short __ATTRS_o_ai
   1671 vec_cmpge(vector signed short __a, vector signed short __b) {
   1672   return ~(vec_cmpgt(__b, __a));
   1673 }
   1674 
   1675 static __inline__ vector bool short __ATTRS_o_ai
   1676 vec_cmpge(vector unsigned short __a, vector unsigned short __b) {
   1677   return ~(vec_cmpgt(__b, __a));
   1678 }
   1679 
   1680 static __inline__ vector bool int __ATTRS_o_ai
   1681 vec_cmpge(vector signed int __a, vector signed int __b) {
   1682   return ~(vec_cmpgt(__b, __a));
   1683 }
   1684 
   1685 static __inline__ vector bool int __ATTRS_o_ai
   1686 vec_cmpge(vector unsigned int __a, vector unsigned int __b) {
   1687   return ~(vec_cmpgt(__b, __a));
   1688 }
   1689 
   1690 static __inline__ vector bool int __ATTRS_o_ai vec_cmpge(vector float __a,
   1691                                                          vector float __b) {
   1692 #ifdef __VSX__
   1693   return (vector bool int)__builtin_vsx_xvcmpgesp(__a, __b);
   1694 #else
   1695   return (vector bool int)__builtin_altivec_vcmpgefp(__a, __b);
   1696 #endif
   1697 }
   1698 
   1699 #ifdef __VSX__
   1700 static __inline__ vector bool long long __ATTRS_o_ai
   1701 vec_cmpge(vector double __a, vector double __b) {
   1702   return (vector bool long long)__builtin_vsx_xvcmpgedp(__a, __b);
   1703 }
   1704 #endif
   1705 
   1706 #ifdef __POWER8_VECTOR__
   1707 static __inline__ vector bool long long __ATTRS_o_ai
   1708 vec_cmpge(vector signed long long __a, vector signed long long __b) {
   1709   return ~(vec_cmpgt(__b, __a));
   1710 }
   1711 
   1712 static __inline__ vector bool long long __ATTRS_o_ai
   1713 vec_cmpge(vector unsigned long long __a, vector unsigned long long __b) {
   1714   return ~(vec_cmpgt(__b, __a));
   1715 }
   1716 #endif
   1717 
   1718 /* vec_vcmpgefp */
   1719 
   1720 static __inline__ vector bool int __attribute__((__always_inline__))
   1721 vec_vcmpgefp(vector float __a, vector float __b) {
   1722   return (vector bool int)__builtin_altivec_vcmpgefp(__a, __b);
   1723 }
   1724 
   1725 /* vec_vcmpgtsb */
   1726 
   1727 static __inline__ vector bool char __attribute__((__always_inline__))
   1728 vec_vcmpgtsb(vector signed char __a, vector signed char __b) {
   1729   return (vector bool char)__builtin_altivec_vcmpgtsb(__a, __b);
   1730 }
   1731 
   1732 /* vec_vcmpgtub */
   1733 
   1734 static __inline__ vector bool char __attribute__((__always_inline__))
   1735 vec_vcmpgtub(vector unsigned char __a, vector unsigned char __b) {
   1736   return (vector bool char)__builtin_altivec_vcmpgtub(__a, __b);
   1737 }
   1738 
   1739 /* vec_vcmpgtsh */
   1740 
   1741 static __inline__ vector bool short __attribute__((__always_inline__))
   1742 vec_vcmpgtsh(vector short __a, vector short __b) {
   1743   return (vector bool short)__builtin_altivec_vcmpgtsh(__a, __b);
   1744 }
   1745 
   1746 /* vec_vcmpgtuh */
   1747 
   1748 static __inline__ vector bool short __attribute__((__always_inline__))
   1749 vec_vcmpgtuh(vector unsigned short __a, vector unsigned short __b) {
   1750   return (vector bool short)__builtin_altivec_vcmpgtuh(__a, __b);
   1751 }
   1752 
   1753 /* vec_vcmpgtsw */
   1754 
   1755 static __inline__ vector bool int __attribute__((__always_inline__))
   1756 vec_vcmpgtsw(vector int __a, vector int __b) {
   1757   return (vector bool int)__builtin_altivec_vcmpgtsw(__a, __b);
   1758 }
   1759 
   1760 /* vec_vcmpgtuw */
   1761 
   1762 static __inline__ vector bool int __attribute__((__always_inline__))
   1763 vec_vcmpgtuw(vector unsigned int __a, vector unsigned int __b) {
   1764   return (vector bool int)__builtin_altivec_vcmpgtuw(__a, __b);
   1765 }
   1766 
   1767 /* vec_vcmpgtfp */
   1768 
   1769 static __inline__ vector bool int __attribute__((__always_inline__))
   1770 vec_vcmpgtfp(vector float __a, vector float __b) {
   1771   return (vector bool int)__builtin_altivec_vcmpgtfp(__a, __b);
   1772 }
   1773 
   1774 /* vec_cmple */
   1775 
   1776 static __inline__ vector bool char __ATTRS_o_ai
   1777 vec_cmple(vector signed char __a, vector signed char __b) {
   1778   return vec_cmpge(__b, __a);
   1779 }
   1780 
   1781 static __inline__ vector bool char __ATTRS_o_ai
   1782 vec_cmple(vector unsigned char __a, vector unsigned char __b) {
   1783   return vec_cmpge(__b, __a);
   1784 }
   1785 
   1786 static __inline__ vector bool short __ATTRS_o_ai
   1787 vec_cmple(vector signed short __a, vector signed short __b) {
   1788   return vec_cmpge(__b, __a);
   1789 }
   1790 
   1791 static __inline__ vector bool short __ATTRS_o_ai
   1792 vec_cmple(vector unsigned short __a, vector unsigned short __b) {
   1793   return vec_cmpge(__b, __a);
   1794 }
   1795 
   1796 static __inline__ vector bool int __ATTRS_o_ai
   1797 vec_cmple(vector signed int __a, vector signed int __b) {
   1798   return vec_cmpge(__b, __a);
   1799 }
   1800 
   1801 static __inline__ vector bool int __ATTRS_o_ai
   1802 vec_cmple(vector unsigned int __a, vector unsigned int __b) {
   1803   return vec_cmpge(__b, __a);
   1804 }
   1805 
   1806 static __inline__ vector bool int __ATTRS_o_ai vec_cmple(vector float __a,
   1807                                                          vector float __b) {
   1808   return vec_cmpge(__b, __a);
   1809 }
   1810 
   1811 #ifdef __VSX__
   1812 static __inline__ vector bool long long __ATTRS_o_ai
   1813 vec_cmple(vector double __a, vector double __b) {
   1814   return vec_cmpge(__b, __a);
   1815 }
   1816 #endif
   1817 
   1818 #ifdef __POWER8_VECTOR__
   1819 static __inline__ vector bool long long __ATTRS_o_ai
   1820 vec_cmple(vector signed long long __a, vector signed long long __b) {
   1821   return vec_cmpge(__b, __a);
   1822 }
   1823 
   1824 static __inline__ vector bool long long __ATTRS_o_ai
   1825 vec_cmple(vector unsigned long long __a, vector unsigned long long __b) {
   1826   return vec_cmpge(__b, __a);
   1827 }
   1828 #endif
   1829 
   1830 /* vec_cmplt */
   1831 
   1832 static __inline__ vector bool char __ATTRS_o_ai
   1833 vec_cmplt(vector signed char __a, vector signed char __b) {
   1834   return vec_cmpgt(__b, __a);
   1835 }
   1836 
   1837 static __inline__ vector bool char __ATTRS_o_ai
   1838 vec_cmplt(vector unsigned char __a, vector unsigned char __b) {
   1839   return vec_cmpgt(__b, __a);
   1840 }
   1841 
   1842 static __inline__ vector bool short __ATTRS_o_ai vec_cmplt(vector short __a,
   1843                                                            vector short __b) {
   1844   return vec_cmpgt(__b, __a);
   1845 }
   1846 
   1847 static __inline__ vector bool short __ATTRS_o_ai
   1848 vec_cmplt(vector unsigned short __a, vector unsigned short __b) {
   1849   return vec_cmpgt(__b, __a);
   1850 }
   1851 
   1852 static __inline__ vector bool int __ATTRS_o_ai vec_cmplt(vector int __a,
   1853                                                          vector int __b) {
   1854   return vec_cmpgt(__b, __a);
   1855 }
   1856 
   1857 static __inline__ vector bool int __ATTRS_o_ai
   1858 vec_cmplt(vector unsigned int __a, vector unsigned int __b) {
   1859   return vec_cmpgt(__b, __a);
   1860 }
   1861 
   1862 static __inline__ vector bool int __ATTRS_o_ai vec_cmplt(vector float __a,
   1863                                                          vector float __b) {
   1864   return vec_cmpgt(__b, __a);
   1865 }
   1866 
   1867 #ifdef __VSX__
   1868 static __inline__ vector bool long long __ATTRS_o_ai
   1869 vec_cmplt(vector double __a, vector double __b) {
   1870   return vec_cmpgt(__b, __a);
   1871 }
   1872 #endif
   1873 
   1874 #ifdef __POWER8_VECTOR__
   1875 static __inline__ vector bool long long __ATTRS_o_ai
   1876 vec_cmplt(vector signed long long __a, vector signed long long __b) {
   1877   return vec_cmpgt(__b, __a);
   1878 }
   1879 
   1880 static __inline__ vector bool long long __ATTRS_o_ai
   1881 vec_cmplt(vector unsigned long long __a, vector unsigned long long __b) {
   1882   return vec_cmpgt(__b, __a);
   1883 }
   1884 
   1885 /* vec_cntlz */
   1886 
   1887 static __inline__ vector signed char __ATTRS_o_ai
   1888 vec_cntlz(vector signed char __a) {
   1889   return __builtin_altivec_vclzb(__a);
   1890 }
   1891 static __inline__ vector unsigned char __ATTRS_o_ai
   1892 vec_cntlz(vector unsigned char __a) {
   1893   return __builtin_altivec_vclzb(__a);
   1894 }
   1895 static __inline__ vector signed short __ATTRS_o_ai
   1896 vec_cntlz(vector signed short __a) {
   1897   return __builtin_altivec_vclzh(__a);
   1898 }
   1899 static __inline__ vector unsigned short __ATTRS_o_ai
   1900 vec_cntlz(vector unsigned short __a) {
   1901   return __builtin_altivec_vclzh(__a);
   1902 }
   1903 static __inline__ vector signed int __ATTRS_o_ai
   1904 vec_cntlz(vector signed int __a) {
   1905   return __builtin_altivec_vclzw(__a);
   1906 }
   1907 static __inline__ vector unsigned int __ATTRS_o_ai
   1908 vec_cntlz(vector unsigned int __a) {
   1909   return __builtin_altivec_vclzw(__a);
   1910 }
   1911 static __inline__ vector signed long long __ATTRS_o_ai
   1912 vec_cntlz(vector signed long long __a) {
   1913   return __builtin_altivec_vclzd(__a);
   1914 }
   1915 static __inline__ vector unsigned long long __ATTRS_o_ai
   1916 vec_cntlz(vector unsigned long long __a) {
   1917   return __builtin_altivec_vclzd(__a);
   1918 }
   1919 #endif
   1920 
   1921 /* vec_cpsgn */
   1922 
   1923 #ifdef __VSX__
   1924 static __inline__ vector float __ATTRS_o_ai vec_cpsgn(vector float __a,
   1925                                                       vector float __b) {
   1926   return __builtin_vsx_xvcpsgnsp(__a, __b);
   1927 }
   1928 
   1929 static __inline__ vector double __ATTRS_o_ai vec_cpsgn(vector double __a,
   1930                                                        vector double __b) {
   1931   return __builtin_vsx_xvcpsgndp(__a, __b);
   1932 }
   1933 #endif
   1934 
   1935 /* vec_ctf */
   1936 
   1937 static __inline__ vector float __ATTRS_o_ai vec_ctf(vector int __a, int __b) {
   1938   return __builtin_altivec_vcfsx(__a, __b);
   1939 }
   1940 
   1941 static __inline__ vector float __ATTRS_o_ai vec_ctf(vector unsigned int __a,
   1942                                                     int __b) {
   1943   return __builtin_altivec_vcfux((vector int)__a, __b);
   1944 }
   1945 
   1946 #ifdef __VSX__
   1947 static __inline__ vector double __ATTRS_o_ai
   1948 vec_ctf(vector unsigned long long __a, int __b) {
   1949   vector double __ret = __builtin_convertvector(__a, vector double);
   1950   __ret *= (vector double)(vector unsigned long long)((0x3ffULL - __b) << 52);
   1951   return __ret;
   1952 }
   1953 
   1954 static __inline__ vector double __ATTRS_o_ai
   1955 vec_ctf(vector signed long long __a, int __b) {
   1956   vector double __ret = __builtin_convertvector(__a, vector double);
   1957   __ret *= (vector double)(vector unsigned long long)((0x3ffULL - __b) << 52);
   1958   return __ret;
   1959 }
   1960 #endif
   1961 
   1962 /* vec_vcfsx */
   1963 
   1964 static __inline__ vector float __attribute__((__always_inline__))
   1965 vec_vcfsx(vector int __a, int __b) {
   1966   return __builtin_altivec_vcfsx(__a, __b);
   1967 }
   1968 
   1969 /* vec_vcfux */
   1970 
   1971 static __inline__ vector float __attribute__((__always_inline__))
   1972 vec_vcfux(vector unsigned int __a, int __b) {
   1973   return __builtin_altivec_vcfux((vector int)__a, __b);
   1974 }
   1975 
   1976 /* vec_cts */
   1977 
   1978 static __inline__ vector int __ATTRS_o_ai vec_cts(vector float __a, int __b) {
   1979   return __builtin_altivec_vctsxs(__a, __b);
   1980 }
   1981 
   1982 #ifdef __VSX__
   1983 static __inline__ vector signed long long __ATTRS_o_ai
   1984 vec_cts(vector double __a, int __b) {
   1985   __a *= (vector double)(vector unsigned long long)((0x3ffULL + __b) << 52);
   1986   return __builtin_convertvector(__a, vector signed long long);
   1987 }
   1988 #endif
   1989 
   1990 /* vec_vctsxs */
   1991 
   1992 static __inline__ vector int __attribute__((__always_inline__))
   1993 vec_vctsxs(vector float __a, int __b) {
   1994   return __builtin_altivec_vctsxs(__a, __b);
   1995 }
   1996 
   1997 /* vec_ctu */
   1998 
   1999 static __inline__ vector unsigned int __ATTRS_o_ai vec_ctu(vector float __a,
   2000                                                            int __b) {
   2001   return __builtin_altivec_vctuxs(__a, __b);
   2002 }
   2003 
   2004 #ifdef __VSX__
   2005 static __inline__ vector unsigned long long __ATTRS_o_ai
   2006 vec_ctu(vector double __a, int __b) {
   2007   __a *= (vector double)(vector unsigned long long)((0x3ffULL + __b) << 52);
   2008   return __builtin_convertvector(__a, vector unsigned long long);
   2009 }
   2010 #endif
   2011 
   2012 /* vec_vctuxs */
   2013 
   2014 static __inline__ vector unsigned int __attribute__((__always_inline__))
   2015 vec_vctuxs(vector float __a, int __b) {
   2016   return __builtin_altivec_vctuxs(__a, __b);
   2017 }
   2018 
   2019 /* vec_double */
   2020 
   2021 #ifdef __VSX__
   2022 static __inline__ vector double __ATTRS_o_ai
   2023 vec_double(vector signed long long __a) {
   2024   vector double __ret = {__a[0], __a[1]};
   2025   return __ret;
   2026 }
   2027 
   2028 static __inline__ vector double __ATTRS_o_ai
   2029 vec_double(vector unsigned long long __a) {
   2030   vector double __ret = {__a[0], __a[1]};
   2031   return __ret;
   2032 }
   2033 #endif
   2034 
   2035 /* vec_div */
   2036 
   2037 /* Integer vector divides (vectors are scalarized, elements divided
   2038    and the vectors reassembled).
   2039 */
   2040 static __inline__ vector signed char __ATTRS_o_ai
   2041 vec_div(vector signed char __a, vector signed char __b) {
   2042   return __a / __b;
   2043 }
   2044 
   2045 static __inline__ vector unsigned char __ATTRS_o_ai
   2046 vec_div(vector unsigned char __a, vector unsigned char __b) {
   2047   return __a / __b;
   2048 }
   2049 
   2050 static __inline__ vector signed short __ATTRS_o_ai
   2051 vec_div(vector signed short __a, vector signed short __b) {
   2052   return __a / __b;
   2053 }
   2054 
   2055 static __inline__ vector unsigned short __ATTRS_o_ai
   2056 vec_div(vector unsigned short __a, vector unsigned short __b) {
   2057   return __a / __b;
   2058 }
   2059 
   2060 static __inline__ vector signed int __ATTRS_o_ai
   2061 vec_div(vector signed int __a, vector signed int __b) {
   2062   return __a / __b;
   2063 }
   2064 
   2065 static __inline__ vector unsigned int __ATTRS_o_ai
   2066 vec_div(vector unsigned int __a, vector unsigned int __b) {
   2067   return __a / __b;
   2068 }
   2069 
   2070 #ifdef __VSX__
   2071 static __inline__ vector signed long long __ATTRS_o_ai
   2072 vec_div(vector signed long long __a, vector signed long long __b) {
   2073   return __a / __b;
   2074 }
   2075 
   2076 static __inline__ vector unsigned long long __ATTRS_o_ai
   2077 vec_div(vector unsigned long long __a, vector unsigned long long __b) {
   2078   return __a / __b;
   2079 }
   2080 
   2081 static __inline__ vector float __ATTRS_o_ai vec_div(vector float __a,
   2082                                                     vector float __b) {
   2083   return __a / __b;
   2084 }
   2085 
   2086 static __inline__ vector double __ATTRS_o_ai vec_div(vector double __a,
   2087                                                      vector double __b) {
   2088   return __a / __b;
   2089 }
   2090 #endif
   2091 
   2092 /* vec_dss */
   2093 
   2094 static __inline__ void __attribute__((__always_inline__)) vec_dss(int __a) {
   2095   __builtin_altivec_dss(__a);
   2096 }
   2097 
   2098 /* vec_dssall */
   2099 
   2100 static __inline__ void __attribute__((__always_inline__)) vec_dssall(void) {
   2101   __builtin_altivec_dssall();
   2102 }
   2103 
   2104 /* vec_dst */
   2105 #define vec_dst(__PTR, __CW, __STR) \
   2106   __extension__(                    \
   2107       { __builtin_altivec_dst((const void *)(__PTR), (__CW), (__STR)); })
   2108 
   2109 /* vec_dstst */
   2110 #define vec_dstst(__PTR, __CW, __STR) \
   2111   __extension__(                      \
   2112       { __builtin_altivec_dstst((const void *)(__PTR), (__CW), (__STR)); })
   2113 
   2114 /* vec_dststt */
   2115 #define vec_dststt(__PTR, __CW, __STR) \
   2116   __extension__(                       \
   2117       { __builtin_altivec_dststt((const void *)(__PTR), (__CW), (__STR)); })
   2118 
   2119 /* vec_dstt */
   2120 #define vec_dstt(__PTR, __CW, __STR) \
   2121   __extension__(                     \
   2122       { __builtin_altivec_dstt((const void *)(__PTR), (__CW), (__STR)); })
   2123 
   2124 /* vec_eqv */
   2125 
   2126 #ifdef __POWER8_VECTOR__
   2127 static __inline__ vector signed char __ATTRS_o_ai
   2128 vec_eqv(vector signed char __a, vector signed char __b) {
   2129   return (vector signed char)__builtin_vsx_xxleqv((vector unsigned int)__a,
   2130                                                   (vector unsigned int)__b);
   2131 }
   2132 
   2133 static __inline__ vector unsigned char __ATTRS_o_ai
   2134 vec_eqv(vector unsigned char __a, vector unsigned char __b) {
   2135   return (vector unsigned char)__builtin_vsx_xxleqv((vector unsigned int)__a,
   2136                                                     (vector unsigned int)__b);
   2137 }
   2138 
   2139 static __inline__ vector bool char __ATTRS_o_ai vec_eqv(vector bool char __a,
   2140                                                         vector bool char __b) {
   2141   return (vector bool char)__builtin_vsx_xxleqv((vector unsigned int)__a,
   2142                                                 (vector unsigned int)__b);
   2143 }
   2144 
   2145 static __inline__ vector signed short __ATTRS_o_ai
   2146 vec_eqv(vector signed short __a, vector signed short __b) {
   2147   return (vector signed short)__builtin_vsx_xxleqv((vector unsigned int)__a,
   2148                                                    (vector unsigned int)__b);
   2149 }
   2150 
   2151 static __inline__ vector unsigned short __ATTRS_o_ai
   2152 vec_eqv(vector unsigned short __a, vector unsigned short __b) {
   2153   return (vector unsigned short)__builtin_vsx_xxleqv((vector unsigned int)__a,
   2154                                                      (vector unsigned int)__b);
   2155 }
   2156 
   2157 static __inline__ vector bool short __ATTRS_o_ai
   2158 vec_eqv(vector bool short __a, vector bool short __b) {
   2159   return (vector bool short)__builtin_vsx_xxleqv((vector unsigned int)__a,
   2160                                                  (vector unsigned int)__b);
   2161 }
   2162 
   2163 static __inline__ vector signed int __ATTRS_o_ai
   2164 vec_eqv(vector signed int __a, vector signed int __b) {
   2165   return (vector signed int)__builtin_vsx_xxleqv((vector unsigned int)__a,
   2166                                                  (vector unsigned int)__b);
   2167 }
   2168 
   2169 static __inline__ vector unsigned int __ATTRS_o_ai
   2170 vec_eqv(vector unsigned int __a, vector unsigned int __b) {
   2171   return __builtin_vsx_xxleqv(__a, __b);
   2172 }
   2173 
   2174 static __inline__ vector bool int __ATTRS_o_ai vec_eqv(vector bool int __a,
   2175                                                        vector bool int __b) {
   2176   return (vector bool int)__builtin_vsx_xxleqv((vector unsigned int)__a,
   2177                                                (vector unsigned int)__b);
   2178 }
   2179 
   2180 static __inline__ vector signed long long __ATTRS_o_ai
   2181 vec_eqv(vector signed long long __a, vector signed long long __b) {
   2182   return (vector signed long long)__builtin_vsx_xxleqv(
   2183       (vector unsigned int)__a, (vector unsigned int)__b);
   2184 }
   2185 
   2186 static __inline__ vector unsigned long long __ATTRS_o_ai
   2187 vec_eqv(vector unsigned long long __a, vector unsigned long long __b) {
   2188   return (vector unsigned long long)__builtin_vsx_xxleqv(
   2189       (vector unsigned int)__a, (vector unsigned int)__b);
   2190 }
   2191 
   2192 static __inline__ vector bool long long __ATTRS_o_ai
   2193 vec_eqv(vector bool long long __a, vector bool long long __b) {
   2194   return (vector bool long long)__builtin_vsx_xxleqv((vector unsigned int)__a,
   2195                                                      (vector unsigned int)__b);
   2196 }
   2197 
   2198 static __inline__ vector float __ATTRS_o_ai vec_eqv(vector float __a,
   2199                                                     vector float __b) {
   2200   return (vector float)__builtin_vsx_xxleqv((vector unsigned int)__a,
   2201                                             (vector unsigned int)__b);
   2202 }
   2203 
   2204 static __inline__ vector double __ATTRS_o_ai vec_eqv(vector double __a,
   2205                                                      vector double __b) {
   2206   return (vector double)__builtin_vsx_xxleqv((vector unsigned int)__a,
   2207                                              (vector unsigned int)__b);
   2208 }
   2209 #endif
   2210 
   2211 /* vec_expte */
   2212 
   2213 static __inline__ vector float __attribute__((__always_inline__))
   2214 vec_expte(vector float __a) {
   2215   return __builtin_altivec_vexptefp(__a);
   2216 }
   2217 
   2218 /* vec_vexptefp */
   2219 
   2220 static __inline__ vector float __attribute__((__always_inline__))
   2221 vec_vexptefp(vector float __a) {
   2222   return __builtin_altivec_vexptefp(__a);
   2223 }
   2224 
   2225 /* vec_floor */
   2226 
   2227 static __inline__ vector float __ATTRS_o_ai vec_floor(vector float __a) {
   2228 #ifdef __VSX__
   2229   return __builtin_vsx_xvrspim(__a);
   2230 #else
   2231   return __builtin_altivec_vrfim(__a);
   2232 #endif
   2233 }
   2234 
   2235 #ifdef __VSX__
   2236 static __inline__ vector double __ATTRS_o_ai vec_floor(vector double __a) {
   2237   return __builtin_vsx_xvrdpim(__a);
   2238 }
   2239 #endif
   2240 
   2241 /* vec_vrfim */
   2242 
   2243 static __inline__ vector float __attribute__((__always_inline__))
   2244 vec_vrfim(vector float __a) {
   2245   return __builtin_altivec_vrfim(__a);
   2246 }
   2247 
   2248 /* vec_ld */
   2249 
   2250 static __inline__ vector signed char __ATTRS_o_ai
   2251 vec_ld(int __a, const vector signed char *__b) {
   2252   return (vector signed char)__builtin_altivec_lvx(__a, __b);
   2253 }
   2254 
   2255 static __inline__ vector signed char __ATTRS_o_ai
   2256 vec_ld(int __a, const signed char *__b) {
   2257   return (vector signed char)__builtin_altivec_lvx(__a, __b);
   2258 }
   2259 
   2260 static __inline__ vector unsigned char __ATTRS_o_ai
   2261 vec_ld(int __a, const vector unsigned char *__b) {
   2262   return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
   2263 }
   2264 
   2265 static __inline__ vector unsigned char __ATTRS_o_ai
   2266 vec_ld(int __a, const unsigned char *__b) {
   2267   return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
   2268 }
   2269 
   2270 static __inline__ vector bool char __ATTRS_o_ai
   2271 vec_ld(int __a, const vector bool char *__b) {
   2272   return (vector bool char)__builtin_altivec_lvx(__a, __b);
   2273 }
   2274 
   2275 static __inline__ vector short __ATTRS_o_ai vec_ld(int __a,
   2276                                                    const vector short *__b) {
   2277   return (vector short)__builtin_altivec_lvx(__a, __b);
   2278 }
   2279 
   2280 static __inline__ vector short __ATTRS_o_ai vec_ld(int __a, const short *__b) {
   2281   return (vector short)__builtin_altivec_lvx(__a, __b);
   2282 }
   2283 
   2284 static __inline__ vector unsigned short __ATTRS_o_ai
   2285 vec_ld(int __a, const vector unsigned short *__b) {
   2286   return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
   2287 }
   2288 
   2289 static __inline__ vector unsigned short __ATTRS_o_ai
   2290 vec_ld(int __a, const unsigned short *__b) {
   2291   return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
   2292 }
   2293 
   2294 static __inline__ vector bool short __ATTRS_o_ai
   2295 vec_ld(int __a, const vector bool short *__b) {
   2296   return (vector bool short)__builtin_altivec_lvx(__a, __b);
   2297 }
   2298 
   2299 static __inline__ vector pixel __ATTRS_o_ai vec_ld(int __a,
   2300                                                    const vector pixel *__b) {
   2301   return (vector pixel)__builtin_altivec_lvx(__a, __b);
   2302 }
   2303 
   2304 static __inline__ vector int __ATTRS_o_ai vec_ld(int __a,
   2305                                                  const vector int *__b) {
   2306   return (vector int)__builtin_altivec_lvx(__a, __b);
   2307 }
   2308 
   2309 static __inline__ vector int __ATTRS_o_ai vec_ld(int __a, const int *__b) {
   2310   return (vector int)__builtin_altivec_lvx(__a, __b);
   2311 }
   2312 
   2313 static __inline__ vector unsigned int __ATTRS_o_ai
   2314 vec_ld(int __a, const vector unsigned int *__b) {
   2315   return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
   2316 }
   2317 
   2318 static __inline__ vector unsigned int __ATTRS_o_ai
   2319 vec_ld(int __a, const unsigned int *__b) {
   2320   return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
   2321 }
   2322 
   2323 static __inline__ vector bool int __ATTRS_o_ai
   2324 vec_ld(int __a, const vector bool int *__b) {
   2325   return (vector bool int)__builtin_altivec_lvx(__a, __b);
   2326 }
   2327 
   2328 static __inline__ vector float __ATTRS_o_ai vec_ld(int __a,
   2329                                                    const vector float *__b) {
   2330   return (vector float)__builtin_altivec_lvx(__a, __b);
   2331 }
   2332 
   2333 static __inline__ vector float __ATTRS_o_ai vec_ld(int __a, const float *__b) {
   2334   return (vector float)__builtin_altivec_lvx(__a, __b);
   2335 }
   2336 
   2337 /* vec_lvx */
   2338 
   2339 static __inline__ vector signed char __ATTRS_o_ai
   2340 vec_lvx(int __a, const vector signed char *__b) {
   2341   return (vector signed char)__builtin_altivec_lvx(__a, __b);
   2342 }
   2343 
   2344 static __inline__ vector signed char __ATTRS_o_ai
   2345 vec_lvx(int __a, const signed char *__b) {
   2346   return (vector signed char)__builtin_altivec_lvx(__a, __b);
   2347 }
   2348 
   2349 static __inline__ vector unsigned char __ATTRS_o_ai
   2350 vec_lvx(int __a, const vector unsigned char *__b) {
   2351   return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
   2352 }
   2353 
   2354 static __inline__ vector unsigned char __ATTRS_o_ai
   2355 vec_lvx(int __a, const unsigned char *__b) {
   2356   return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
   2357 }
   2358 
   2359 static __inline__ vector bool char __ATTRS_o_ai
   2360 vec_lvx(int __a, const vector bool char *__b) {
   2361   return (vector bool char)__builtin_altivec_lvx(__a, __b);
   2362 }
   2363 
   2364 static __inline__ vector short __ATTRS_o_ai vec_lvx(int __a,
   2365                                                     const vector short *__b) {
   2366   return (vector short)__builtin_altivec_lvx(__a, __b);
   2367 }
   2368 
   2369 static __inline__ vector short __ATTRS_o_ai vec_lvx(int __a, const short *__b) {
   2370   return (vector short)__builtin_altivec_lvx(__a, __b);
   2371 }
   2372 
   2373 static __inline__ vector unsigned short __ATTRS_o_ai
   2374 vec_lvx(int __a, const vector unsigned short *__b) {
   2375   return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
   2376 }
   2377 
   2378 static __inline__ vector unsigned short __ATTRS_o_ai
   2379 vec_lvx(int __a, const unsigned short *__b) {
   2380   return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
   2381 }
   2382 
   2383 static __inline__ vector bool short __ATTRS_o_ai
   2384 vec_lvx(int __a, const vector bool short *__b) {
   2385   return (vector bool short)__builtin_altivec_lvx(__a, __b);
   2386 }
   2387 
   2388 static __inline__ vector pixel __ATTRS_o_ai vec_lvx(int __a,
   2389                                                     const vector pixel *__b) {
   2390   return (vector pixel)__builtin_altivec_lvx(__a, __b);
   2391 }
   2392 
   2393 static __inline__ vector int __ATTRS_o_ai vec_lvx(int __a,
   2394                                                   const vector int *__b) {
   2395   return (vector int)__builtin_altivec_lvx(__a, __b);
   2396 }
   2397 
   2398 static __inline__ vector int __ATTRS_o_ai vec_lvx(int __a, const int *__b) {
   2399   return (vector int)__builtin_altivec_lvx(__a, __b);
   2400 }
   2401 
   2402 static __inline__ vector unsigned int __ATTRS_o_ai
   2403 vec_lvx(int __a, const vector unsigned int *__b) {
   2404   return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
   2405 }
   2406 
   2407 static __inline__ vector unsigned int __ATTRS_o_ai
   2408 vec_lvx(int __a, const unsigned int *__b) {
   2409   return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
   2410 }
   2411 
   2412 static __inline__ vector bool int __ATTRS_o_ai
   2413 vec_lvx(int __a, const vector bool int *__b) {
   2414   return (vector bool int)__builtin_altivec_lvx(__a, __b);
   2415 }
   2416 
   2417 static __inline__ vector float __ATTRS_o_ai vec_lvx(int __a,
   2418                                                     const vector float *__b) {
   2419   return (vector float)__builtin_altivec_lvx(__a, __b);
   2420 }
   2421 
   2422 static __inline__ vector float __ATTRS_o_ai vec_lvx(int __a, const float *__b) {
   2423   return (vector float)__builtin_altivec_lvx(__a, __b);
   2424 }
   2425 
   2426 /* vec_lde */
   2427 
   2428 static __inline__ vector signed char __ATTRS_o_ai
   2429 vec_lde(int __a, const signed char *__b) {
   2430   return (vector signed char)__builtin_altivec_lvebx(__a, __b);
   2431 }
   2432 
   2433 static __inline__ vector unsigned char __ATTRS_o_ai
   2434 vec_lde(int __a, const unsigned char *__b) {
   2435   return (vector unsigned char)__builtin_altivec_lvebx(__a, __b);
   2436 }
   2437 
   2438 static __inline__ vector short __ATTRS_o_ai vec_lde(int __a, const short *__b) {
   2439   return (vector short)__builtin_altivec_lvehx(__a, __b);
   2440 }
   2441 
   2442 static __inline__ vector unsigned short __ATTRS_o_ai
   2443 vec_lde(int __a, const unsigned short *__b) {
   2444   return (vector unsigned short)__builtin_altivec_lvehx(__a, __b);
   2445 }
   2446 
   2447 static __inline__ vector int __ATTRS_o_ai vec_lde(int __a, const int *__b) {
   2448   return (vector int)__builtin_altivec_lvewx(__a, __b);
   2449 }
   2450 
   2451 static __inline__ vector unsigned int __ATTRS_o_ai
   2452 vec_lde(int __a, const unsigned int *__b) {
   2453   return (vector unsigned int)__builtin_altivec_lvewx(__a, __b);
   2454 }
   2455 
   2456 static __inline__ vector float __ATTRS_o_ai vec_lde(int __a, const float *__b) {
   2457   return (vector float)__builtin_altivec_lvewx(__a, __b);
   2458 }
   2459 
   2460 /* vec_lvebx */
   2461 
   2462 static __inline__ vector signed char __ATTRS_o_ai
   2463 vec_lvebx(int __a, const signed char *__b) {
   2464   return (vector signed char)__builtin_altivec_lvebx(__a, __b);
   2465 }
   2466 
   2467 static __inline__ vector unsigned char __ATTRS_o_ai
   2468 vec_lvebx(int __a, const unsigned char *__b) {
   2469   return (vector unsigned char)__builtin_altivec_lvebx(__a, __b);
   2470 }
   2471 
   2472 /* vec_lvehx */
   2473 
   2474 static __inline__ vector short __ATTRS_o_ai vec_lvehx(int __a,
   2475                                                       const short *__b) {
   2476   return (vector short)__builtin_altivec_lvehx(__a, __b);
   2477 }
   2478 
   2479 static __inline__ vector unsigned short __ATTRS_o_ai
   2480 vec_lvehx(int __a, const unsigned short *__b) {
   2481   return (vector unsigned short)__builtin_altivec_lvehx(__a, __b);
   2482 }
   2483 
   2484 /* vec_lvewx */
   2485 
   2486 static __inline__ vector int __ATTRS_o_ai vec_lvewx(int __a, const int *__b) {
   2487   return (vector int)__builtin_altivec_lvewx(__a, __b);
   2488 }
   2489 
   2490 static __inline__ vector unsigned int __ATTRS_o_ai
   2491 vec_lvewx(int __a, const unsigned int *__b) {
   2492   return (vector unsigned int)__builtin_altivec_lvewx(__a, __b);
   2493 }
   2494 
   2495 static __inline__ vector float __ATTRS_o_ai vec_lvewx(int __a,
   2496                                                       const float *__b) {
   2497   return (vector float)__builtin_altivec_lvewx(__a, __b);
   2498 }
   2499 
   2500 /* vec_ldl */
   2501 
   2502 static __inline__ vector signed char __ATTRS_o_ai
   2503 vec_ldl(int __a, const vector signed char *__b) {
   2504   return (vector signed char)__builtin_altivec_lvxl(__a, __b);
   2505 }
   2506 
   2507 static __inline__ vector signed char __ATTRS_o_ai
   2508 vec_ldl(int __a, const signed char *__b) {
   2509   return (vector signed char)__builtin_altivec_lvxl(__a, __b);
   2510 }
   2511 
   2512 static __inline__ vector unsigned char __ATTRS_o_ai
   2513 vec_ldl(int __a, const vector unsigned char *__b) {
   2514   return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
   2515 }
   2516 
   2517 static __inline__ vector unsigned char __ATTRS_o_ai
   2518 vec_ldl(int __a, const unsigned char *__b) {
   2519   return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
   2520 }
   2521 
   2522 static __inline__ vector bool char __ATTRS_o_ai
   2523 vec_ldl(int __a, const vector bool char *__b) {
   2524   return (vector bool char)__builtin_altivec_lvxl(__a, __b);
   2525 }
   2526 
   2527 static __inline__ vector short __ATTRS_o_ai vec_ldl(int __a,
   2528                                                     const vector short *__b) {
   2529   return (vector short)__builtin_altivec_lvxl(__a, __b);
   2530 }
   2531 
   2532 static __inline__ vector short __ATTRS_o_ai vec_ldl(int __a, const short *__b) {
   2533   return (vector short)__builtin_altivec_lvxl(__a, __b);
   2534 }
   2535 
   2536 static __inline__ vector unsigned short __ATTRS_o_ai
   2537 vec_ldl(int __a, const vector unsigned short *__b) {
   2538   return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
   2539 }
   2540 
   2541 static __inline__ vector unsigned short __ATTRS_o_ai
   2542 vec_ldl(int __a, const unsigned short *__b) {
   2543   return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
   2544 }
   2545 
   2546 static __inline__ vector bool short __ATTRS_o_ai
   2547 vec_ldl(int __a, const vector bool short *__b) {
   2548   return (vector bool short)__builtin_altivec_lvxl(__a, __b);
   2549 }
   2550 
   2551 static __inline__ vector pixel __ATTRS_o_ai vec_ldl(int __a,
   2552                                                     const vector pixel *__b) {
   2553   return (vector pixel short)__builtin_altivec_lvxl(__a, __b);
   2554 }
   2555 
   2556 static __inline__ vector int __ATTRS_o_ai vec_ldl(int __a,
   2557                                                   const vector int *__b) {
   2558   return (vector int)__builtin_altivec_lvxl(__a, __b);
   2559 }
   2560 
   2561 static __inline__ vector int __ATTRS_o_ai vec_ldl(int __a, const int *__b) {
   2562   return (vector int)__builtin_altivec_lvxl(__a, __b);
   2563 }
   2564 
   2565 static __inline__ vector unsigned int __ATTRS_o_ai
   2566 vec_ldl(int __a, const vector unsigned int *__b) {
   2567   return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
   2568 }
   2569 
   2570 static __inline__ vector unsigned int __ATTRS_o_ai
   2571 vec_ldl(int __a, const unsigned int *__b) {
   2572   return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
   2573 }
   2574 
   2575 static __inline__ vector bool int __ATTRS_o_ai
   2576 vec_ldl(int __a, const vector bool int *__b) {
   2577   return (vector bool int)__builtin_altivec_lvxl(__a, __b);
   2578 }
   2579 
   2580 static __inline__ vector float __ATTRS_o_ai vec_ldl(int __a,
   2581                                                     const vector float *__b) {
   2582   return (vector float)__builtin_altivec_lvxl(__a, __b);
   2583 }
   2584 
   2585 static __inline__ vector float __ATTRS_o_ai vec_ldl(int __a, const float *__b) {
   2586   return (vector float)__builtin_altivec_lvxl(__a, __b);
   2587 }
   2588 
   2589 /* vec_lvxl */
   2590 
   2591 static __inline__ vector signed char __ATTRS_o_ai
   2592 vec_lvxl(int __a, const vector signed char *__b) {
   2593   return (vector signed char)__builtin_altivec_lvxl(__a, __b);
   2594 }
   2595 
   2596 static __inline__ vector signed char __ATTRS_o_ai
   2597 vec_lvxl(int __a, const signed char *__b) {
   2598   return (vector signed char)__builtin_altivec_lvxl(__a, __b);
   2599 }
   2600 
   2601 static __inline__ vector unsigned char __ATTRS_o_ai
   2602 vec_lvxl(int __a, const vector unsigned char *__b) {
   2603   return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
   2604 }
   2605 
   2606 static __inline__ vector unsigned char __ATTRS_o_ai
   2607 vec_lvxl(int __a, const unsigned char *__b) {
   2608   return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
   2609 }
   2610 
   2611 static __inline__ vector bool char __ATTRS_o_ai
   2612 vec_lvxl(int __a, const vector bool char *__b) {
   2613   return (vector bool char)__builtin_altivec_lvxl(__a, __b);
   2614 }
   2615 
   2616 static __inline__ vector short __ATTRS_o_ai vec_lvxl(int __a,
   2617                                                      const vector short *__b) {
   2618   return (vector short)__builtin_altivec_lvxl(__a, __b);
   2619 }
   2620 
   2621 static __inline__ vector short __ATTRS_o_ai vec_lvxl(int __a,
   2622                                                      const short *__b) {
   2623   return (vector short)__builtin_altivec_lvxl(__a, __b);
   2624 }
   2625 
   2626 static __inline__ vector unsigned short __ATTRS_o_ai
   2627 vec_lvxl(int __a, const vector unsigned short *__b) {
   2628   return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
   2629 }
   2630 
   2631 static __inline__ vector unsigned short __ATTRS_o_ai
   2632 vec_lvxl(int __a, const unsigned short *__b) {
   2633   return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
   2634 }
   2635 
   2636 static __inline__ vector bool short __ATTRS_o_ai
   2637 vec_lvxl(int __a, const vector bool short *__b) {
   2638   return (vector bool short)__builtin_altivec_lvxl(__a, __b);
   2639 }
   2640 
   2641 static __inline__ vector pixel __ATTRS_o_ai vec_lvxl(int __a,
   2642                                                      const vector pixel *__b) {
   2643   return (vector pixel)__builtin_altivec_lvxl(__a, __b);
   2644 }
   2645 
   2646 static __inline__ vector int __ATTRS_o_ai vec_lvxl(int __a,
   2647                                                    const vector int *__b) {
   2648   return (vector int)__builtin_altivec_lvxl(__a, __b);
   2649 }
   2650 
   2651 static __inline__ vector int __ATTRS_o_ai vec_lvxl(int __a, const int *__b) {
   2652   return (vector int)__builtin_altivec_lvxl(__a, __b);
   2653 }
   2654 
   2655 static __inline__ vector unsigned int __ATTRS_o_ai
   2656 vec_lvxl(int __a, const vector unsigned int *__b) {
   2657   return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
   2658 }
   2659 
   2660 static __inline__ vector unsigned int __ATTRS_o_ai
   2661 vec_lvxl(int __a, const unsigned int *__b) {
   2662   return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
   2663 }
   2664 
   2665 static __inline__ vector bool int __ATTRS_o_ai
   2666 vec_lvxl(int __a, const vector bool int *__b) {
   2667   return (vector bool int)__builtin_altivec_lvxl(__a, __b);
   2668 }
   2669 
   2670 static __inline__ vector float __ATTRS_o_ai vec_lvxl(int __a,
   2671                                                      const vector float *__b) {
   2672   return (vector float)__builtin_altivec_lvxl(__a, __b);
   2673 }
   2674 
   2675 static __inline__ vector float __ATTRS_o_ai vec_lvxl(int __a,
   2676                                                      const float *__b) {
   2677   return (vector float)__builtin_altivec_lvxl(__a, __b);
   2678 }
   2679 
   2680 /* vec_loge */
   2681 
   2682 static __inline__ vector float __attribute__((__always_inline__))
   2683 vec_loge(vector float __a) {
   2684   return __builtin_altivec_vlogefp(__a);
   2685 }
   2686 
   2687 /* vec_vlogefp */
   2688 
   2689 static __inline__ vector float __attribute__((__always_inline__))
   2690 vec_vlogefp(vector float __a) {
   2691   return __builtin_altivec_vlogefp(__a);
   2692 }
   2693 
   2694 /* vec_lvsl */
   2695 
   2696 #ifdef __LITTLE_ENDIAN__
   2697 static __inline__ vector unsigned char __ATTRS_o_ai
   2698     __attribute__((__deprecated__("use assignment for unaligned little endian \
   2699 loads/stores"))) vec_lvsl(int __a, const signed char *__b) {
   2700   vector unsigned char mask =
   2701       (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
   2702   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
   2703                                   7,  6,  5,  4,  3,  2,  1, 0};
   2704   return vec_perm(mask, mask, reverse);
   2705 }
   2706 #else
   2707 static __inline__ vector unsigned char __ATTRS_o_ai
   2708 vec_lvsl(int __a, const signed char *__b) {
   2709   return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
   2710 }
   2711 #endif
   2712 
   2713 #ifdef __LITTLE_ENDIAN__
   2714 static __inline__ vector unsigned char __ATTRS_o_ai
   2715     __attribute__((__deprecated__("use assignment for unaligned little endian \
   2716 loads/stores"))) vec_lvsl(int __a, const unsigned char *__b) {
   2717   vector unsigned char mask =
   2718       (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
   2719   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
   2720                                   7,  6,  5,  4,  3,  2,  1, 0};
   2721   return vec_perm(mask, mask, reverse);
   2722 }
   2723 #else
   2724 static __inline__ vector unsigned char __ATTRS_o_ai
   2725 vec_lvsl(int __a, const unsigned char *__b) {
   2726   return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
   2727 }
   2728 #endif
   2729 
   2730 #ifdef __LITTLE_ENDIAN__
   2731 static __inline__ vector unsigned char __ATTRS_o_ai
   2732     __attribute__((__deprecated__("use assignment for unaligned little endian \
   2733 loads/stores"))) vec_lvsl(int __a, const short *__b) {
   2734   vector unsigned char mask =
   2735       (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
   2736   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
   2737                                   7,  6,  5,  4,  3,  2,  1, 0};
   2738   return vec_perm(mask, mask, reverse);
   2739 }
   2740 #else
   2741 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsl(int __a,
   2742                                                              const short *__b) {
   2743   return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
   2744 }
   2745 #endif
   2746 
   2747 #ifdef __LITTLE_ENDIAN__
   2748 static __inline__ vector unsigned char __ATTRS_o_ai
   2749     __attribute__((__deprecated__("use assignment for unaligned little endian \
   2750 loads/stores"))) vec_lvsl(int __a, const unsigned short *__b) {
   2751   vector unsigned char mask =
   2752       (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
   2753   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
   2754                                   7,  6,  5,  4,  3,  2,  1, 0};
   2755   return vec_perm(mask, mask, reverse);
   2756 }
   2757 #else
   2758 static __inline__ vector unsigned char __ATTRS_o_ai
   2759 vec_lvsl(int __a, const unsigned short *__b) {
   2760   return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
   2761 }
   2762 #endif
   2763 
   2764 #ifdef __LITTLE_ENDIAN__
   2765 static __inline__ vector unsigned char __ATTRS_o_ai
   2766     __attribute__((__deprecated__("use assignment for unaligned little endian \
   2767 loads/stores"))) vec_lvsl(int __a, const int *__b) {
   2768   vector unsigned char mask =
   2769       (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
   2770   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
   2771                                   7,  6,  5,  4,  3,  2,  1, 0};
   2772   return vec_perm(mask, mask, reverse);
   2773 }
   2774 #else
   2775 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsl(int __a,
   2776                                                              const int *__b) {
   2777   return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
   2778 }
   2779 #endif
   2780 
   2781 #ifdef __LITTLE_ENDIAN__
   2782 static __inline__ vector unsigned char __ATTRS_o_ai
   2783     __attribute__((__deprecated__("use assignment for unaligned little endian \
   2784 loads/stores"))) vec_lvsl(int __a, const unsigned int *__b) {
   2785   vector unsigned char mask =
   2786       (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
   2787   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
   2788                                   7,  6,  5,  4,  3,  2,  1, 0};
   2789   return vec_perm(mask, mask, reverse);
   2790 }
   2791 #else
   2792 static __inline__ vector unsigned char __ATTRS_o_ai
   2793 vec_lvsl(int __a, const unsigned int *__b) {
   2794   return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
   2795 }
   2796 #endif
   2797 
   2798 #ifdef __LITTLE_ENDIAN__
   2799 static __inline__ vector unsigned char __ATTRS_o_ai
   2800     __attribute__((__deprecated__("use assignment for unaligned little endian \
   2801 loads/stores"))) vec_lvsl(int __a, const float *__b) {
   2802   vector unsigned char mask =
   2803       (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
   2804   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
   2805                                   7,  6,  5,  4,  3,  2,  1, 0};
   2806   return vec_perm(mask, mask, reverse);
   2807 }
   2808 #else
   2809 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsl(int __a,
   2810                                                              const float *__b) {
   2811   return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
   2812 }
   2813 #endif
   2814 
   2815 /* vec_lvsr */
   2816 
   2817 #ifdef __LITTLE_ENDIAN__
   2818 static __inline__ vector unsigned char __ATTRS_o_ai
   2819     __attribute__((__deprecated__("use assignment for unaligned little endian \
   2820 loads/stores"))) vec_lvsr(int __a, const signed char *__b) {
   2821   vector unsigned char mask =
   2822       (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
   2823   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
   2824                                   7,  6,  5,  4,  3,  2,  1, 0};
   2825   return vec_perm(mask, mask, reverse);
   2826 }
   2827 #else
   2828 static __inline__ vector unsigned char __ATTRS_o_ai
   2829 vec_lvsr(int __a, const signed char *__b) {
   2830   return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
   2831 }
   2832 #endif
   2833 
   2834 #ifdef __LITTLE_ENDIAN__
   2835 static __inline__ vector unsigned char __ATTRS_o_ai
   2836     __attribute__((__deprecated__("use assignment for unaligned little endian \
   2837 loads/stores"))) vec_lvsr(int __a, const unsigned char *__b) {
   2838   vector unsigned char mask =
   2839       (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
   2840   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
   2841                                   7,  6,  5,  4,  3,  2,  1, 0};
   2842   return vec_perm(mask, mask, reverse);
   2843 }
   2844 #else
   2845 static __inline__ vector unsigned char __ATTRS_o_ai
   2846 vec_lvsr(int __a, const unsigned char *__b) {
   2847   return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
   2848 }
   2849 #endif
   2850 
   2851 #ifdef __LITTLE_ENDIAN__
   2852 static __inline__ vector unsigned char __ATTRS_o_ai
   2853     __attribute__((__deprecated__("use assignment for unaligned little endian \
   2854 loads/stores"))) vec_lvsr(int __a, const short *__b) {
   2855   vector unsigned char mask =
   2856       (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
   2857   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
   2858                                   7,  6,  5,  4,  3,  2,  1, 0};
   2859   return vec_perm(mask, mask, reverse);
   2860 }
   2861 #else
   2862 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsr(int __a,
   2863                                                              const short *__b) {
   2864   return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
   2865 }
   2866 #endif
   2867 
   2868 #ifdef __LITTLE_ENDIAN__
   2869 static __inline__ vector unsigned char __ATTRS_o_ai
   2870     __attribute__((__deprecated__("use assignment for unaligned little endian \
   2871 loads/stores"))) vec_lvsr(int __a, const unsigned short *__b) {
   2872   vector unsigned char mask =
   2873       (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
   2874   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
   2875                                   7,  6,  5,  4,  3,  2,  1, 0};
   2876   return vec_perm(mask, mask, reverse);
   2877 }
   2878 #else
   2879 static __inline__ vector unsigned char __ATTRS_o_ai
   2880 vec_lvsr(int __a, const unsigned short *__b) {
   2881   return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
   2882 }
   2883 #endif
   2884 
   2885 #ifdef __LITTLE_ENDIAN__
   2886 static __inline__ vector unsigned char __ATTRS_o_ai
   2887     __attribute__((__deprecated__("use assignment for unaligned little endian \
   2888 loads/stores"))) vec_lvsr(int __a, const int *__b) {
   2889   vector unsigned char mask =
   2890       (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
   2891   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
   2892                                   7,  6,  5,  4,  3,  2,  1, 0};
   2893   return vec_perm(mask, mask, reverse);
   2894 }
   2895 #else
   2896 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsr(int __a,
   2897                                                              const int *__b) {
   2898   return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
   2899 }
   2900 #endif
   2901 
   2902 #ifdef __LITTLE_ENDIAN__
   2903 static __inline__ vector unsigned char __ATTRS_o_ai
   2904     __attribute__((__deprecated__("use assignment for unaligned little endian \
   2905 loads/stores"))) vec_lvsr(int __a, const unsigned int *__b) {
   2906   vector unsigned char mask =
   2907       (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
   2908   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
   2909                                   7,  6,  5,  4,  3,  2,  1, 0};
   2910   return vec_perm(mask, mask, reverse);
   2911 }
   2912 #else
   2913 static __inline__ vector unsigned char __ATTRS_o_ai
   2914 vec_lvsr(int __a, const unsigned int *__b) {
   2915   return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
   2916 }
   2917 #endif
   2918 
   2919 #ifdef __LITTLE_ENDIAN__
   2920 static __inline__ vector unsigned char __ATTRS_o_ai
   2921     __attribute__((__deprecated__("use assignment for unaligned little endian \
   2922 loads/stores"))) vec_lvsr(int __a, const float *__b) {
   2923   vector unsigned char mask =
   2924       (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
   2925   vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
   2926                                   7,  6,  5,  4,  3,  2,  1, 0};
   2927   return vec_perm(mask, mask, reverse);
   2928 }
   2929 #else
   2930 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsr(int __a,
   2931                                                              const float *__b) {
   2932   return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
   2933 }
   2934 #endif
   2935 
   2936 /* vec_madd */
   2937 static __inline__ vector signed short __ATTRS_o_ai
   2938 vec_mladd(vector signed short, vector signed short, vector signed short);
   2939 static __inline__ vector signed short __ATTRS_o_ai
   2940 vec_mladd(vector signed short, vector unsigned short, vector unsigned short);
   2941 static __inline__ vector signed short __ATTRS_o_ai
   2942 vec_mladd(vector unsigned short, vector signed short, vector signed short);
   2943 static __inline__ vector unsigned short __ATTRS_o_ai
   2944 vec_mladd(vector unsigned short, vector unsigned short, vector unsigned short);
   2945 
   2946 static __inline__ vector signed short __ATTRS_o_ai vec_madd(
   2947     vector signed short __a, vector signed short __b, vector signed short __c) {
   2948   return vec_mladd(__a, __b, __c);
   2949 }
   2950 
   2951 static __inline__ vector signed short __ATTRS_o_ai
   2952 vec_madd(vector signed short __a, vector unsigned short __b,
   2953          vector unsigned short __c) {
   2954   return vec_mladd(__a, __b, __c);
   2955 }
   2956 
   2957 static __inline__ vector signed short __ATTRS_o_ai
   2958 vec_madd(vector unsigned short __a, vector signed short __b,
   2959          vector signed short __c) {
   2960   return vec_mladd(__a, __b, __c);
   2961 }
   2962 
   2963 static __inline__ vector unsigned short __ATTRS_o_ai
   2964 vec_madd(vector unsigned short __a, vector unsigned short __b,
   2965          vector unsigned short __c) {
   2966   return vec_mladd(__a, __b, __c);
   2967 }
   2968 
   2969 static __inline__ vector float __ATTRS_o_ai vec_madd(vector float __a,
   2970                                                      vector float __b,
   2971                                                      vector float __c) {
   2972 #ifdef __VSX__
   2973   return __builtin_vsx_xvmaddasp(__a, __b, __c);
   2974 #else
   2975   return __builtin_altivec_vmaddfp(__a, __b, __c);
   2976 #endif
   2977 }
   2978 
   2979 #ifdef __VSX__
   2980 static __inline__ vector double __ATTRS_o_ai vec_madd(vector double __a,
   2981                                                       vector double __b,
   2982                                                       vector double __c) {
   2983   return __builtin_vsx_xvmaddadp(__a, __b, __c);
   2984 }
   2985 #endif
   2986 
   2987 /* vec_vmaddfp */
   2988 
   2989 static __inline__ vector float __attribute__((__always_inline__))
   2990 vec_vmaddfp(vector float __a, vector float __b, vector float __c) {
   2991   return __builtin_altivec_vmaddfp(__a, __b, __c);
   2992 }
   2993 
   2994 /* vec_madds */
   2995 
   2996 static __inline__ vector signed short __attribute__((__always_inline__))
   2997 vec_madds(vector signed short __a, vector signed short __b,
   2998           vector signed short __c) {
   2999   return __builtin_altivec_vmhaddshs(__a, __b, __c);
   3000 }
   3001 
   3002 /* vec_vmhaddshs */
   3003 static __inline__ vector signed short __attribute__((__always_inline__))
   3004 vec_vmhaddshs(vector signed short __a, vector signed short __b,
   3005               vector signed short __c) {
   3006   return __builtin_altivec_vmhaddshs(__a, __b, __c);
   3007 }
   3008 
   3009 /* vec_msub */
   3010 
   3011 #ifdef __VSX__
   3012 static __inline__ vector float __ATTRS_o_ai vec_msub(vector float __a,
   3013                                                      vector float __b,
   3014                                                      vector float __c) {
   3015   return __builtin_vsx_xvmsubasp(__a, __b, __c);
   3016 }
   3017 
   3018 static __inline__ vector double __ATTRS_o_ai vec_msub(vector double __a,
   3019                                                       vector double __b,
   3020                                                       vector double __c) {
   3021   return __builtin_vsx_xvmsubadp(__a, __b, __c);
   3022 }
   3023 #endif
   3024 
   3025 /* vec_max */
   3026 
   3027 static __inline__ vector signed char __ATTRS_o_ai
   3028 vec_max(vector signed char __a, vector signed char __b) {
   3029   return __builtin_altivec_vmaxsb(__a, __b);
   3030 }
   3031 
   3032 static __inline__ vector signed char __ATTRS_o_ai
   3033 vec_max(vector bool char __a, vector signed char __b) {
   3034   return __builtin_altivec_vmaxsb((vector signed char)__a, __b);
   3035 }
   3036 
   3037 static __inline__ vector signed char __ATTRS_o_ai
   3038 vec_max(vector signed char __a, vector bool char __b) {
   3039   return __builtin_altivec_vmaxsb(__a, (vector signed char)__b);
   3040 }
   3041 
   3042 static __inline__ vector unsigned char __ATTRS_o_ai
   3043 vec_max(vector unsigned char __a, vector unsigned char __b) {
   3044   return __builtin_altivec_vmaxub(__a, __b);
   3045 }
   3046 
   3047 static __inline__ vector unsigned char __ATTRS_o_ai
   3048 vec_max(vector bool char __a, vector unsigned char __b) {
   3049   return __builtin_altivec_vmaxub((vector unsigned char)__a, __b);
   3050 }
   3051 
   3052 static __inline__ vector unsigned char __ATTRS_o_ai
   3053 vec_max(vector unsigned char __a, vector bool char __b) {
   3054   return __builtin_altivec_vmaxub(__a, (vector unsigned char)__b);
   3055 }
   3056 
   3057 static __inline__ vector short __ATTRS_o_ai vec_max(vector short __a,
   3058                                                     vector short __b) {
   3059   return __builtin_altivec_vmaxsh(__a, __b);
   3060 }
   3061 
   3062 static __inline__ vector short __ATTRS_o_ai vec_max(vector bool short __a,
   3063                                                     vector short __b) {
   3064   return __builtin_altivec_vmaxsh((vector short)__a, __b);
   3065 }
   3066 
   3067 static __inline__ vector short __ATTRS_o_ai vec_max(vector short __a,
   3068                                                     vector bool short __b) {
   3069   return __builtin_altivec_vmaxsh(__a, (vector short)__b);
   3070 }
   3071 
   3072 static __inline__ vector unsigned short __ATTRS_o_ai
   3073 vec_max(vector unsigned short __a, vector unsigned short __b) {
   3074   return __builtin_altivec_vmaxuh(__a, __b);
   3075 }
   3076 
   3077 static __inline__ vector unsigned short __ATTRS_o_ai
   3078 vec_max(vector bool short __a, vector unsigned short __b) {
   3079   return __builtin_altivec_vmaxuh((vector unsigned short)__a, __b);
   3080 }
   3081 
   3082 static __inline__ vector unsigned short __ATTRS_o_ai
   3083 vec_max(vector unsigned short __a, vector bool short __b) {
   3084   return __builtin_altivec_vmaxuh(__a, (vector unsigned short)__b);
   3085 }
   3086 
   3087 static __inline__ vector int __ATTRS_o_ai vec_max(vector int __a,
   3088                                                   vector int __b) {
   3089   return __builtin_altivec_vmaxsw(__a, __b);
   3090 }
   3091 
   3092 static __inline__ vector int __ATTRS_o_ai vec_max(vector bool int __a,
   3093                                                   vector int __b) {
   3094   return __builtin_altivec_vmaxsw((vector int)__a, __b);
   3095 }
   3096 
   3097 static __inline__ vector int __ATTRS_o_ai vec_max(vector int __a,
   3098                                                   vector bool int __b) {
   3099   return __builtin_altivec_vmaxsw(__a, (vector int)__b);
   3100 }
   3101 
   3102 static __inline__ vector unsigned int __ATTRS_o_ai
   3103 vec_max(vector unsigned int __a, vector unsigned int __b) {
   3104   return __builtin_altivec_vmaxuw(__a, __b);
   3105 }
   3106 
   3107 static __inline__ vector unsigned int __ATTRS_o_ai
   3108 vec_max(vector bool int __a, vector unsigned int __b) {
   3109   return __builtin_altivec_vmaxuw((vector unsigned int)__a, __b);
   3110 }
   3111 
   3112 static __inline__ vector unsigned int __ATTRS_o_ai
   3113 vec_max(vector unsigned int __a, vector bool int __b) {
   3114   return __builtin_altivec_vmaxuw(__a, (vector unsigned int)__b);
   3115 }
   3116 
   3117 #ifdef __POWER8_VECTOR__
   3118 static __inline__ vector signed long long __ATTRS_o_ai
   3119 vec_max(vector signed long long __a, vector signed long long __b) {
   3120   return __builtin_altivec_vmaxsd(__a, __b);
   3121 }
   3122 
   3123 static __inline__ vector signed long long __ATTRS_o_ai
   3124 vec_max(vector bool long long __a, vector signed long long __b) {
   3125   return __builtin_altivec_vmaxsd((vector signed long long)__a, __b);
   3126 }
   3127 
   3128 static __inline__ vector signed long long __ATTRS_o_ai
   3129 vec_max(vector signed long long __a, vector bool long long __b) {
   3130   return __builtin_altivec_vmaxsd(__a, (vector signed long long)__b);
   3131 }
   3132 
   3133 static __inline__ vector unsigned long long __ATTRS_o_ai
   3134 vec_max(vector unsigned long long __a, vector unsigned long long __b) {
   3135   return __builtin_altivec_vmaxud(__a, __b);
   3136 }
   3137 
   3138 static __inline__ vector unsigned long long __ATTRS_o_ai
   3139 vec_max(vector bool long long __a, vector unsigned long long __b) {
   3140   return __builtin_altivec_vmaxud((vector unsigned long long)__a, __b);
   3141 }
   3142 
   3143 static __inline__ vector unsigned long long __ATTRS_o_ai
   3144 vec_max(vector unsigned long long __a, vector bool long long __b) {
   3145   return __builtin_altivec_vmaxud(__a, (vector unsigned long long)__b);
   3146 }
   3147 #endif
   3148 
   3149 static __inline__ vector float __ATTRS_o_ai vec_max(vector float __a,
   3150                                                     vector float __b) {
   3151 #ifdef __VSX__
   3152   return __builtin_vsx_xvmaxsp(__a, __b);
   3153 #else
   3154   return __builtin_altivec_vmaxfp(__a, __b);
   3155 #endif
   3156 }
   3157 
   3158 #ifdef __VSX__
   3159 static __inline__ vector double __ATTRS_o_ai vec_max(vector double __a,
   3160                                                      vector double __b) {
   3161   return __builtin_vsx_xvmaxdp(__a, __b);
   3162 }
   3163 #endif
   3164 
   3165 /* vec_vmaxsb */
   3166 
   3167 static __inline__ vector signed char __ATTRS_o_ai
   3168 vec_vmaxsb(vector signed char __a, vector signed char __b) {
   3169   return __builtin_altivec_vmaxsb(__a, __b);
   3170 }
   3171 
   3172 static __inline__ vector signed char __ATTRS_o_ai
   3173 vec_vmaxsb(vector bool char __a, vector signed char __b) {
   3174   return __builtin_altivec_vmaxsb((vector signed char)__a, __b);
   3175 }
   3176 
   3177 static __inline__ vector signed char __ATTRS_o_ai
   3178 vec_vmaxsb(vector signed char __a, vector bool char __b) {
   3179   return __builtin_altivec_vmaxsb(__a, (vector signed char)__b);
   3180 }
   3181 
   3182 /* vec_vmaxub */
   3183 
   3184 static __inline__ vector unsigned char __ATTRS_o_ai
   3185 vec_vmaxub(vector unsigned char __a, vector unsigned char __b) {
   3186   return __builtin_altivec_vmaxub(__a, __b);
   3187 }
   3188 
   3189 static __inline__ vector unsigned char __ATTRS_o_ai
   3190 vec_vmaxub(vector bool char __a, vector unsigned char __b) {
   3191   return __builtin_altivec_vmaxub((vector unsigned char)__a, __b);
   3192 }
   3193 
   3194 static __inline__ vector unsigned char __ATTRS_o_ai
   3195 vec_vmaxub(vector unsigned char __a, vector bool char __b) {
   3196   return __builtin_altivec_vmaxub(__a, (vector unsigned char)__b);
   3197 }
   3198 
   3199 /* vec_vmaxsh */
   3200 
   3201 static __inline__ vector short __ATTRS_o_ai vec_vmaxsh(vector short __a,
   3202                                                        vector short __b) {
   3203   return __builtin_altivec_vmaxsh(__a, __b);
   3204 }
   3205 
   3206 static __inline__ vector short __ATTRS_o_ai vec_vmaxsh(vector bool short __a,
   3207                                                        vector short __b) {
   3208   return __builtin_altivec_vmaxsh((vector short)__a, __b);
   3209 }
   3210 
   3211 static __inline__ vector short __ATTRS_o_ai vec_vmaxsh(vector short __a,
   3212                                                        vector bool short __b) {
   3213   return __builtin_altivec_vmaxsh(__a, (vector short)__b);
   3214 }
   3215 
   3216 /* vec_vmaxuh */
   3217 
   3218 static __inline__ vector unsigned short __ATTRS_o_ai
   3219 vec_vmaxuh(vector unsigned short __a, vector unsigned short __b) {
   3220   return __builtin_altivec_vmaxuh(__a, __b);
   3221 }
   3222 
   3223 static __inline__ vector unsigned short __ATTRS_o_ai
   3224 vec_vmaxuh(vector bool short __a, vector unsigned short __b) {
   3225   return __builtin_altivec_vmaxuh((vector unsigned short)__a, __b);
   3226 }
   3227 
   3228 static __inline__ vector unsigned short __ATTRS_o_ai
   3229 vec_vmaxuh(vector unsigned short __a, vector bool short __b) {
   3230   return __builtin_altivec_vmaxuh(__a, (vector unsigned short)__b);
   3231 }
   3232 
   3233 /* vec_vmaxsw */
   3234 
   3235 static __inline__ vector int __ATTRS_o_ai vec_vmaxsw(vector int __a,
   3236                                                      vector int __b) {
   3237   return __builtin_altivec_vmaxsw(__a, __b);
   3238 }
   3239 
   3240 static __inline__ vector int __ATTRS_o_ai vec_vmaxsw(vector bool int __a,
   3241                                                      vector int __b) {
   3242   return __builtin_altivec_vmaxsw((vector int)__a, __b);
   3243 }
   3244 
   3245 static __inline__ vector int __ATTRS_o_ai vec_vmaxsw(vector int __a,
   3246                                                      vector bool int __b) {
   3247   return __builtin_altivec_vmaxsw(__a, (vector int)__b);
   3248 }
   3249 
   3250 /* vec_vmaxuw */
   3251 
   3252 static __inline__ vector unsigned int __ATTRS_o_ai
   3253 vec_vmaxuw(vector unsigned int __a, vector unsigned int __b) {
   3254   return __builtin_altivec_vmaxuw(__a, __b);
   3255 }
   3256 
   3257 static __inline__ vector unsigned int __ATTRS_o_ai
   3258 vec_vmaxuw(vector bool int __a, vector unsigned int __b) {
   3259   return __builtin_altivec_vmaxuw((vector unsigned int)__a, __b);
   3260 }
   3261 
   3262 static __inline__ vector unsigned int __ATTRS_o_ai
   3263 vec_vmaxuw(vector unsigned int __a, vector bool int __b) {
   3264   return __builtin_altivec_vmaxuw(__a, (vector unsigned int)__b);
   3265 }
   3266 
   3267 /* vec_vmaxfp */
   3268 
   3269 static __inline__ vector float __attribute__((__always_inline__))
   3270 vec_vmaxfp(vector float __a, vector float __b) {
   3271 #ifdef __VSX__
   3272   return __builtin_vsx_xvmaxsp(__a, __b);
   3273 #else
   3274   return __builtin_altivec_vmaxfp(__a, __b);
   3275 #endif
   3276 }
   3277 
   3278 /* vec_mergeh */
   3279 
   3280 static __inline__ vector signed char __ATTRS_o_ai
   3281 vec_mergeh(vector signed char __a, vector signed char __b) {
   3282   return vec_perm(__a, __b,
   3283                   (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
   3284                                          0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
   3285                                          0x06, 0x16, 0x07, 0x17));
   3286 }
   3287 
   3288 static __inline__ vector unsigned char __ATTRS_o_ai
   3289 vec_mergeh(vector unsigned char __a, vector unsigned char __b) {
   3290   return vec_perm(__a, __b,
   3291                   (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
   3292                                          0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
   3293                                          0x06, 0x16, 0x07, 0x17));
   3294 }
   3295 
   3296 static __inline__ vector bool char __ATTRS_o_ai
   3297 vec_mergeh(vector bool char __a, vector bool char __b) {
   3298   return vec_perm(__a, __b,
   3299                   (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
   3300                                          0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
   3301                                          0x06, 0x16, 0x07, 0x17));
   3302 }
   3303 
   3304 static __inline__ vector short __ATTRS_o_ai vec_mergeh(vector short __a,
   3305                                                        vector short __b) {
   3306   return vec_perm(__a, __b,
   3307                   (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
   3308                                          0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
   3309                                          0x06, 0x07, 0x16, 0x17));
   3310 }
   3311 
   3312 static __inline__ vector unsigned short __ATTRS_o_ai
   3313 vec_mergeh(vector unsigned short __a, vector unsigned short __b) {
   3314   return vec_perm(__a, __b,
   3315                   (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
   3316                                          0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
   3317                                          0x06, 0x07, 0x16, 0x17));
   3318 }
   3319 
   3320 static __inline__ vector bool short __ATTRS_o_ai
   3321 vec_mergeh(vector bool short __a, vector bool short __b) {
   3322   return vec_perm(__a, __b,
   3323                   (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
   3324                                          0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
   3325                                          0x06, 0x07, 0x16, 0x17));
   3326 }
   3327 
   3328 static __inline__ vector pixel __ATTRS_o_ai vec_mergeh(vector pixel __a,
   3329                                                        vector pixel __b) {
   3330   return vec_perm(__a, __b,
   3331                   (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
   3332                                          0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
   3333                                          0x06, 0x07, 0x16, 0x17));
   3334 }
   3335 
   3336 static __inline__ vector int __ATTRS_o_ai vec_mergeh(vector int __a,
   3337                                                      vector int __b) {
   3338   return vec_perm(__a, __b,
   3339                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
   3340                                          0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
   3341                                          0x14, 0x15, 0x16, 0x17));
   3342 }
   3343 
   3344 static __inline__ vector unsigned int __ATTRS_o_ai
   3345 vec_mergeh(vector unsigned int __a, vector unsigned int __b) {
   3346   return vec_perm(__a, __b,
   3347                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
   3348                                          0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
   3349                                          0x14, 0x15, 0x16, 0x17));
   3350 }
   3351 
   3352 static __inline__ vector bool int __ATTRS_o_ai vec_mergeh(vector bool int __a,
   3353                                                           vector bool int __b) {
   3354   return vec_perm(__a, __b,
   3355                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
   3356                                          0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
   3357                                          0x14, 0x15, 0x16, 0x17));
   3358 }
   3359 
   3360 static __inline__ vector float __ATTRS_o_ai vec_mergeh(vector float __a,
   3361                                                        vector float __b) {
   3362   return vec_perm(__a, __b,
   3363                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
   3364                                          0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
   3365                                          0x14, 0x15, 0x16, 0x17));
   3366 }
   3367 
   3368 #ifdef __VSX__
   3369 static __inline__ vector signed long long __ATTRS_o_ai
   3370 vec_mergeh(vector signed long long __a, vector signed long long __b) {
   3371   return vec_perm(__a, __b,
   3372                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
   3373                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
   3374                                          0x14, 0x15, 0x16, 0x17));
   3375 }
   3376 
   3377 static __inline__ vector signed long long __ATTRS_o_ai
   3378 vec_mergeh(vector signed long long __a, vector bool long long __b) {
   3379   return vec_perm(__a, (vector signed long long)__b,
   3380                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
   3381                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
   3382                                          0x14, 0x15, 0x16, 0x17));
   3383 }
   3384 
   3385 static __inline__ vector signed long long __ATTRS_o_ai
   3386 vec_mergeh(vector bool long long __a, vector signed long long __b) {
   3387   return vec_perm((vector signed long long)__a, __b,
   3388                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
   3389                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
   3390                                          0x14, 0x15, 0x16, 0x17));
   3391 }
   3392 
   3393 static __inline__ vector unsigned long long __ATTRS_o_ai
   3394 vec_mergeh(vector unsigned long long __a, vector unsigned long long __b) {
   3395   return vec_perm(__a, __b,
   3396                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
   3397                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
   3398                                          0x14, 0x15, 0x16, 0x17));
   3399 }
   3400 
   3401 static __inline__ vector unsigned long long __ATTRS_o_ai
   3402 vec_mergeh(vector unsigned long long __a, vector bool long long __b) {
   3403   return vec_perm(__a, (vector unsigned long long)__b,
   3404                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
   3405                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
   3406                                          0x14, 0x15, 0x16, 0x17));
   3407 }
   3408 
   3409 static __inline__ vector unsigned long long __ATTRS_o_ai
   3410 vec_mergeh(vector bool long long __a, vector unsigned long long __b) {
   3411   return vec_perm((vector unsigned long long)__a, __b,
   3412                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
   3413                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
   3414                                          0x14, 0x15, 0x16, 0x17));
   3415 }
   3416 
   3417 static __inline__ vector bool long long __ATTRS_o_ai
   3418 vec_mergeh(vector bool long long __a, vector bool long long __b) {
   3419   return vec_perm(__a, __b,
   3420                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
   3421                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
   3422                                          0x14, 0x15, 0x16, 0x17));
   3423 }
   3424 
   3425 static __inline__ vector double __ATTRS_o_ai vec_mergeh(vector double __a,
   3426                                                         vector double __b) {
   3427   return vec_perm(__a, __b,
   3428                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
   3429                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
   3430                                          0x14, 0x15, 0x16, 0x17));
   3431 }
   3432 static __inline__ vector double __ATTRS_o_ai
   3433 vec_mergeh(vector double __a, vector bool long long __b) {
   3434   return vec_perm(__a, (vector double)__b,
   3435                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
   3436                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
   3437                                          0x14, 0x15, 0x16, 0x17));
   3438 }
   3439 static __inline__ vector double __ATTRS_o_ai
   3440 vec_mergeh(vector bool long long __a, vector double __b) {
   3441   return vec_perm((vector double)__a, __b,
   3442                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
   3443                                          0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
   3444                                          0x14, 0x15, 0x16, 0x17));
   3445 }
   3446 #endif
   3447 
   3448 /* vec_vmrghb */
   3449 
   3450 #define __builtin_altivec_vmrghb vec_vmrghb
   3451 
   3452 static __inline__ vector signed char __ATTRS_o_ai
   3453 vec_vmrghb(vector signed char __a, vector signed char __b) {
   3454   return vec_perm(__a, __b,
   3455                   (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
   3456                                          0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
   3457                                          0x06, 0x16, 0x07, 0x17));
   3458 }
   3459 
   3460 static __inline__ vector unsigned char __ATTRS_o_ai
   3461 vec_vmrghb(vector unsigned char __a, vector unsigned char __b) {
   3462   return vec_perm(__a, __b,
   3463                   (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
   3464                                          0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
   3465                                          0x06, 0x16, 0x07, 0x17));
   3466 }
   3467 
   3468 static __inline__ vector bool char __ATTRS_o_ai
   3469 vec_vmrghb(vector bool char __a, vector bool char __b) {
   3470   return vec_perm(__a, __b,
   3471                   (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
   3472                                          0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
   3473                                          0x06, 0x16, 0x07, 0x17));
   3474 }
   3475 
   3476 /* vec_vmrghh */
   3477 
   3478 #define __builtin_altivec_vmrghh vec_vmrghh
   3479 
   3480 static __inline__ vector short __ATTRS_o_ai vec_vmrghh(vector short __a,
   3481                                                        vector short __b) {
   3482   return vec_perm(__a, __b,
   3483                   (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
   3484                                          0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
   3485                                          0x06, 0x07, 0x16, 0x17));
   3486 }
   3487 
   3488 static __inline__ vector unsigned short __ATTRS_o_ai
   3489 vec_vmrghh(vector unsigned short __a, vector unsigned short __b) {
   3490   return vec_perm(__a, __b,
   3491                   (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
   3492                                          0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
   3493                                          0x06, 0x07, 0x16, 0x17));
   3494 }
   3495 
   3496 static __inline__ vector bool short __ATTRS_o_ai
   3497 vec_vmrghh(vector bool short __a, vector bool short __b) {
   3498   return vec_perm(__a, __b,
   3499                   (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
   3500                                          0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
   3501                                          0x06, 0x07, 0x16, 0x17));
   3502 }
   3503 
   3504 static __inline__ vector pixel __ATTRS_o_ai vec_vmrghh(vector pixel __a,
   3505                                                        vector pixel __b) {
   3506   return vec_perm(__a, __b,
   3507                   (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
   3508                                          0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
   3509                                          0x06, 0x07, 0x16, 0x17));
   3510 }
   3511 
   3512 /* vec_vmrghw */
   3513 
   3514 #define __builtin_altivec_vmrghw vec_vmrghw
   3515 
   3516 static __inline__ vector int __ATTRS_o_ai vec_vmrghw(vector int __a,
   3517                                                      vector int __b) {
   3518   return vec_perm(__a, __b,
   3519                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
   3520                                          0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
   3521                                          0x14, 0x15, 0x16, 0x17));
   3522 }
   3523 
   3524 static __inline__ vector unsigned int __ATTRS_o_ai
   3525 vec_vmrghw(vector unsigned int __a, vector unsigned int __b) {
   3526   return vec_perm(__a, __b,
   3527                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
   3528                                          0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
   3529                                          0x14, 0x15, 0x16, 0x17));
   3530 }
   3531 
   3532 static __inline__ vector bool int __ATTRS_o_ai vec_vmrghw(vector bool int __a,
   3533                                                           vector bool int __b) {
   3534   return vec_perm(__a, __b,
   3535                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
   3536                                          0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
   3537                                          0x14, 0x15, 0x16, 0x17));
   3538 }
   3539 
   3540 static __inline__ vector float __ATTRS_o_ai vec_vmrghw(vector float __a,
   3541                                                        vector float __b) {
   3542   return vec_perm(__a, __b,
   3543                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
   3544                                          0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
   3545                                          0x14, 0x15, 0x16, 0x17));
   3546 }
   3547 
   3548 /* vec_mergel */
   3549 
   3550 static __inline__ vector signed char __ATTRS_o_ai
   3551 vec_mergel(vector signed char __a, vector signed char __b) {
   3552   return vec_perm(__a, __b,
   3553                   (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
   3554                                          0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
   3555                                          0x0E, 0x1E, 0x0F, 0x1F));
   3556 }
   3557 
   3558 static __inline__ vector unsigned char __ATTRS_o_ai
   3559 vec_mergel(vector unsigned char __a, vector unsigned char __b) {
   3560   return vec_perm(__a, __b,
   3561                   (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
   3562                                          0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
   3563                                          0x0E, 0x1E, 0x0F, 0x1F));
   3564 }
   3565 
   3566 static __inline__ vector bool char __ATTRS_o_ai
   3567 vec_mergel(vector bool char __a, vector bool char __b) {
   3568   return vec_perm(__a, __b,
   3569                   (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
   3570                                          0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
   3571                                          0x0E, 0x1E, 0x0F, 0x1F));
   3572 }
   3573 
   3574 static __inline__ vector short __ATTRS_o_ai vec_mergel(vector short __a,
   3575                                                        vector short __b) {
   3576   return vec_perm(__a, __b,
   3577                   (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
   3578                                          0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
   3579                                          0x0E, 0x0F, 0x1E, 0x1F));
   3580 }
   3581 
   3582 static __inline__ vector unsigned short __ATTRS_o_ai
   3583 vec_mergel(vector unsigned short __a, vector unsigned short __b) {
   3584   return vec_perm(__a, __b,
   3585                   (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
   3586                                          0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
   3587                                          0x0E, 0x0F, 0x1E, 0x1F));
   3588 }
   3589 
   3590 static __inline__ vector bool short __ATTRS_o_ai
   3591 vec_mergel(vector bool short __a, vector bool short __b) {
   3592   return vec_perm(__a, __b,
   3593                   (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
   3594                                          0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
   3595                                          0x0E, 0x0F, 0x1E, 0x1F));
   3596 }
   3597 
   3598 static __inline__ vector pixel __ATTRS_o_ai vec_mergel(vector pixel __a,
   3599                                                        vector pixel __b) {
   3600   return vec_perm(__a, __b,
   3601                   (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
   3602                                          0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
   3603                                          0x0E, 0x0F, 0x1E, 0x1F));
   3604 }
   3605 
   3606 static __inline__ vector int __ATTRS_o_ai vec_mergel(vector int __a,
   3607                                                      vector int __b) {
   3608   return vec_perm(__a, __b,
   3609                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
   3610                                          0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
   3611                                          0x1C, 0x1D, 0x1E, 0x1F));
   3612 }
   3613 
   3614 static __inline__ vector unsigned int __ATTRS_o_ai
   3615 vec_mergel(vector unsigned int __a, vector unsigned int __b) {
   3616   return vec_perm(__a, __b,
   3617                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
   3618                                          0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
   3619                                          0x1C, 0x1D, 0x1E, 0x1F));
   3620 }
   3621 
   3622 static __inline__ vector bool int __ATTRS_o_ai vec_mergel(vector bool int __a,
   3623                                                           vector bool int __b) {
   3624   return vec_perm(__a, __b,
   3625                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
   3626                                          0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
   3627                                          0x1C, 0x1D, 0x1E, 0x1F));
   3628 }
   3629 
   3630 static __inline__ vector float __ATTRS_o_ai vec_mergel(vector float __a,
   3631                                                        vector float __b) {
   3632   return vec_perm(__a, __b,
   3633                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
   3634                                          0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
   3635                                          0x1C, 0x1D, 0x1E, 0x1F));
   3636 }
   3637 
   3638 #ifdef __VSX__
   3639 static __inline__ vector signed long long __ATTRS_o_ai
   3640 vec_mergel(vector signed long long __a, vector signed long long __b) {
   3641   return vec_perm(__a, __b,
   3642                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
   3643                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
   3644                                          0x1C, 0x1D, 0x1E, 0x1F));
   3645 }
   3646 static __inline__ vector signed long long __ATTRS_o_ai
   3647 vec_mergel(vector signed long long __a, vector bool long long __b) {
   3648   return vec_perm(__a, (vector signed long long)__b,
   3649                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
   3650                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
   3651                                          0x1C, 0x1D, 0x1E, 0x1F));
   3652 }
   3653 static __inline__ vector signed long long __ATTRS_o_ai
   3654 vec_mergel(vector bool long long __a, vector signed long long __b) {
   3655   return vec_perm((vector signed long long)__a, __b,
   3656                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
   3657                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
   3658                                          0x1C, 0x1D, 0x1E, 0x1F));
   3659 }
   3660 static __inline__ vector unsigned long long __ATTRS_o_ai
   3661 vec_mergel(vector unsigned long long __a, vector unsigned long long __b) {
   3662   return vec_perm(__a, __b,
   3663                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
   3664                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
   3665                                          0x1C, 0x1D, 0x1E, 0x1F));
   3666 }
   3667 static __inline__ vector unsigned long long __ATTRS_o_ai
   3668 vec_mergel(vector unsigned long long __a, vector bool long long __b) {
   3669   return vec_perm(__a, (vector unsigned long long)__b,
   3670                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
   3671                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
   3672                                          0x1C, 0x1D, 0x1E, 0x1F));
   3673 }
   3674 static __inline__ vector unsigned long long __ATTRS_o_ai
   3675 vec_mergel(vector bool long long __a, vector unsigned long long __b) {
   3676   return vec_perm((vector unsigned long long)__a, __b,
   3677                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
   3678                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
   3679                                          0x1C, 0x1D, 0x1E, 0x1F));
   3680 }
   3681 static __inline__ vector bool long long __ATTRS_o_ai
   3682 vec_mergel(vector bool long long __a, vector bool long long __b) {
   3683   return vec_perm(__a, __b,
   3684                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
   3685                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
   3686                                          0x1C, 0x1D, 0x1E, 0x1F));
   3687 }
   3688 static __inline__ vector double __ATTRS_o_ai vec_mergel(vector double __a,
   3689                                                         vector double __b) {
   3690   return vec_perm(__a, __b,
   3691                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
   3692                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
   3693                                          0x1C, 0x1D, 0x1E, 0x1F));
   3694 }
   3695 static __inline__ vector double __ATTRS_o_ai
   3696 vec_mergel(vector double __a, vector bool long long __b) {
   3697   return vec_perm(__a, (vector double)__b,
   3698                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
   3699                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
   3700                                          0x1C, 0x1D, 0x1E, 0x1F));
   3701 }
   3702 static __inline__ vector double __ATTRS_o_ai
   3703 vec_mergel(vector bool long long __a, vector double __b) {
   3704   return vec_perm((vector double)__a, __b,
   3705                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
   3706                                          0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
   3707                                          0x1C, 0x1D, 0x1E, 0x1F));
   3708 }
   3709 #endif
   3710 
   3711 /* vec_vmrglb */
   3712 
   3713 #define __builtin_altivec_vmrglb vec_vmrglb
   3714 
   3715 static __inline__ vector signed char __ATTRS_o_ai
   3716 vec_vmrglb(vector signed char __a, vector signed char __b) {
   3717   return vec_perm(__a, __b,
   3718                   (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
   3719                                          0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
   3720                                          0x0E, 0x1E, 0x0F, 0x1F));
   3721 }
   3722 
   3723 static __inline__ vector unsigned char __ATTRS_o_ai
   3724 vec_vmrglb(vector unsigned char __a, vector unsigned char __b) {
   3725   return vec_perm(__a, __b,
   3726                   (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
   3727                                          0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
   3728                                          0x0E, 0x1E, 0x0F, 0x1F));
   3729 }
   3730 
   3731 static __inline__ vector bool char __ATTRS_o_ai
   3732 vec_vmrglb(vector bool char __a, vector bool char __b) {
   3733   return vec_perm(__a, __b,
   3734                   (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
   3735                                          0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
   3736                                          0x0E, 0x1E, 0x0F, 0x1F));
   3737 }
   3738 
   3739 /* vec_vmrglh */
   3740 
   3741 #define __builtin_altivec_vmrglh vec_vmrglh
   3742 
   3743 static __inline__ vector short __ATTRS_o_ai vec_vmrglh(vector short __a,
   3744                                                        vector short __b) {
   3745   return vec_perm(__a, __b,
   3746                   (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
   3747                                          0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
   3748                                          0x0E, 0x0F, 0x1E, 0x1F));
   3749 }
   3750 
   3751 static __inline__ vector unsigned short __ATTRS_o_ai
   3752 vec_vmrglh(vector unsigned short __a, vector unsigned short __b) {
   3753   return vec_perm(__a, __b,
   3754                   (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
   3755                                          0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
   3756                                          0x0E, 0x0F, 0x1E, 0x1F));
   3757 }
   3758 
   3759 static __inline__ vector bool short __ATTRS_o_ai
   3760 vec_vmrglh(vector bool short __a, vector bool short __b) {
   3761   return vec_perm(__a, __b,
   3762                   (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
   3763                                          0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
   3764                                          0x0E, 0x0F, 0x1E, 0x1F));
   3765 }
   3766 
   3767 static __inline__ vector pixel __ATTRS_o_ai vec_vmrglh(vector pixel __a,
   3768                                                        vector pixel __b) {
   3769   return vec_perm(__a, __b,
   3770                   (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
   3771                                          0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
   3772                                          0x0E, 0x0F, 0x1E, 0x1F));
   3773 }
   3774 
   3775 /* vec_vmrglw */
   3776 
   3777 #define __builtin_altivec_vmrglw vec_vmrglw
   3778 
   3779 static __inline__ vector int __ATTRS_o_ai vec_vmrglw(vector int __a,
   3780                                                      vector int __b) {
   3781   return vec_perm(__a, __b,
   3782                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
   3783                                          0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
   3784                                          0x1C, 0x1D, 0x1E, 0x1F));
   3785 }
   3786 
   3787 static __inline__ vector unsigned int __ATTRS_o_ai
   3788 vec_vmrglw(vector unsigned int __a, vector unsigned int __b) {
   3789   return vec_perm(__a, __b,
   3790                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
   3791                                          0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
   3792                                          0x1C, 0x1D, 0x1E, 0x1F));
   3793 }
   3794 
   3795 static __inline__ vector bool int __ATTRS_o_ai vec_vmrglw(vector bool int __a,
   3796                                                           vector bool int __b) {
   3797   return vec_perm(__a, __b,
   3798                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
   3799                                          0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
   3800                                          0x1C, 0x1D, 0x1E, 0x1F));
   3801 }
   3802 
   3803 static __inline__ vector float __ATTRS_o_ai vec_vmrglw(vector float __a,
   3804                                                        vector float __b) {
   3805   return vec_perm(__a, __b,
   3806                   (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
   3807                                          0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
   3808                                          0x1C, 0x1D, 0x1E, 0x1F));
   3809 }
   3810 
   3811 #ifdef __POWER8_VECTOR__
   3812 /* vec_mergee */
   3813 
   3814 static __inline__ vector bool int __ATTRS_o_ai vec_mergee(vector bool int __a,
   3815                                                           vector bool int __b) {
   3816   return vec_perm(__a, __b,
   3817                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
   3818                                          0x12, 0x13, 0x08, 0x09, 0x0A, 0x0B,
   3819                                          0x18, 0x19, 0x1A, 0x1B));
   3820 }
   3821 
   3822 static __inline__ vector signed int __ATTRS_o_ai
   3823 vec_mergee(vector signed int __a, vector signed int __b) {
   3824   return vec_perm(__a, __b,
   3825                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
   3826                                          0x12, 0x13, 0x08, 0x09, 0x0A, 0x0B,
   3827                                          0x18, 0x19, 0x1A, 0x1B));
   3828 }
   3829 
   3830 static __inline__ vector unsigned int __ATTRS_o_ai
   3831 vec_mergee(vector unsigned int __a, vector unsigned int __b) {
   3832   return vec_perm(__a, __b,
   3833                   (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
   3834                                          0x12, 0x13, 0x08, 0x09, 0x0A, 0x0B,
   3835                                          0x18, 0x19, 0x1A, 0x1B));
   3836 }
   3837 
   3838 /* vec_mergeo */
   3839 
   3840 static __inline__ vector bool int __ATTRS_o_ai vec_mergeo(vector bool int __a,
   3841                                                           vector bool int __b) {
   3842   return vec_perm(__a, __b,
   3843                   (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x14, 0x15,
   3844                                          0x16, 0x17, 0x0C, 0x0D, 0x0E, 0x0F,
   3845                                          0x1C, 0x1D, 0x1E, 0x1F));
   3846 }
   3847 
   3848 static __inline__ vector signed int __ATTRS_o_ai
   3849 vec_mergeo(vector signed int __a, vector signed int __b) {
   3850   return vec_perm(__a, __b,
   3851                   (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x14, 0x15,
   3852                                          0x16, 0x17, 0x0C, 0x0D, 0x0E, 0x0F,
   3853                                          0x1C, 0x1D, 0x1E, 0x1F));
   3854 }
   3855 
   3856 static __inline__ vector unsigned int __ATTRS_o_ai
   3857 vec_mergeo(vector unsigned int __a, vector unsigned int __b) {
   3858   return vec_perm(__a, __b,
   3859                   (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x14, 0x15,
   3860                                          0x16, 0x17, 0x0C, 0x0D, 0x0E, 0x0F,
   3861                                          0x1C, 0x1D, 0x1E, 0x1F));
   3862 }
   3863 
   3864 #endif
   3865 
   3866 /* vec_mfvscr */
   3867 
   3868 static __inline__ vector unsigned short __attribute__((__always_inline__))
   3869 vec_mfvscr(void) {
   3870   return __builtin_altivec_mfvscr();
   3871 }
   3872 
   3873 /* vec_min */
   3874 
   3875 static __inline__ vector signed char __ATTRS_o_ai
   3876 vec_min(vector signed char __a, vector signed char __b) {
   3877   return __builtin_altivec_vminsb(__a, __b);
   3878 }
   3879 
   3880 static __inline__ vector signed char __ATTRS_o_ai
   3881 vec_min(vector bool char __a, vector signed char __b) {
   3882   return __builtin_altivec_vminsb((vector signed char)__a, __b);
   3883 }
   3884 
   3885 static __inline__ vector signed char __ATTRS_o_ai
   3886 vec_min(vector signed char __a, vector bool char __b) {
   3887   return __builtin_altivec_vminsb(__a, (vector signed char)__b);
   3888 }
   3889 
   3890 static __inline__ vector unsigned char __ATTRS_o_ai
   3891 vec_min(vector unsigned char __a, vector unsigned char __b) {
   3892   return __builtin_altivec_vminub(__a, __b);
   3893 }
   3894 
   3895 static __inline__ vector unsigned char __ATTRS_o_ai
   3896 vec_min(vector bool char __a, vector unsigned char __b) {
   3897   return __builtin_altivec_vminub((vector unsigned char)__a, __b);
   3898 }
   3899 
   3900 static __inline__ vector unsigned char __ATTRS_o_ai
   3901 vec_min(vector unsigned char __a, vector bool char __b) {
   3902   return __builtin_altivec_vminub(__a, (vector unsigned char)__b);
   3903 }
   3904 
   3905 static __inline__ vector short __ATTRS_o_ai vec_min(vector short __a,
   3906                                                     vector short __b) {
   3907   return __builtin_altivec_vminsh(__a, __b);
   3908 }
   3909 
   3910 static __inline__ vector short __ATTRS_o_ai vec_min(vector bool short __a,
   3911                                                     vector short __b) {
   3912   return __builtin_altivec_vminsh((vector short)__a, __b);
   3913 }
   3914 
   3915 static __inline__ vector short __ATTRS_o_ai vec_min(vector short __a,
   3916                                                     vector bool short __b) {
   3917   return __builtin_altivec_vminsh(__a, (vector short)__b);
   3918 }
   3919 
   3920 static __inline__ vector unsigned short __ATTRS_o_ai
   3921 vec_min(vector unsigned short __a, vector unsigned short __b) {
   3922   return __builtin_altivec_vminuh(__a, __b);
   3923 }
   3924 
   3925 static __inline__ vector unsigned short __ATTRS_o_ai
   3926 vec_min(vector bool short __a, vector unsigned short __b) {
   3927   return __builtin_altivec_vminuh((vector unsigned short)__a, __b);
   3928 }
   3929 
   3930 static __inline__ vector unsigned short __ATTRS_o_ai
   3931 vec_min(vector unsigned short __a, vector bool short __b) {
   3932   return __builtin_altivec_vminuh(__a, (vector unsigned short)__b);
   3933 }
   3934 
   3935 static __inline__ vector int __ATTRS_o_ai vec_min(vector int __a,
   3936                                                   vector int __b) {
   3937   return __builtin_altivec_vminsw(__a, __b);
   3938 }
   3939 
   3940 static __inline__ vector int __ATTRS_o_ai vec_min(vector bool int __a,
   3941                                                   vector int __b) {
   3942   return __builtin_altivec_vminsw((vector int)__a, __b);
   3943 }
   3944 
   3945 static __inline__ vector int __ATTRS_o_ai vec_min(vector int __a,
   3946                                                   vector bool int __b) {
   3947   return __builtin_altivec_vminsw(__a, (vector int)__b);
   3948 }
   3949 
   3950 static __inline__ vector unsigned int __ATTRS_o_ai
   3951 vec_min(vector unsigned int __a, vector unsigned int __b) {
   3952   return __builtin_altivec_vminuw(__a, __b);
   3953 }
   3954 
   3955 static __inline__ vector unsigned int __ATTRS_o_ai
   3956 vec_min(vector bool int __a, vector unsigned int __b) {
   3957   return __builtin_altivec_vminuw((vector unsigned int)__a, __b);
   3958 }
   3959 
   3960 static __inline__ vector unsigned int __ATTRS_o_ai
   3961 vec_min(vector unsigned int __a, vector bool int __b) {
   3962   return __builtin_altivec_vminuw(__a, (vector unsigned int)__b);
   3963 }
   3964 
   3965 #ifdef __POWER8_VECTOR__
   3966 static __inline__ vector signed long long __ATTRS_o_ai
   3967 vec_min(vector signed long long __a, vector signed long long __b) {
   3968   return __builtin_altivec_vminsd(__a, __b);
   3969 }
   3970 
   3971 static __inline__ vector signed long long __ATTRS_o_ai
   3972 vec_min(vector bool long long __a, vector signed long long __b) {
   3973   return __builtin_altivec_vminsd((vector signed long long)__a, __b);
   3974 }
   3975 
   3976 static __inline__ vector signed long long __ATTRS_o_ai
   3977 vec_min(vector signed long long __a, vector bool long long __b) {
   3978   return __builtin_altivec_vminsd(__a, (vector signed long long)__b);
   3979 }
   3980 
   3981 static __inline__ vector unsigned long long __ATTRS_o_ai
   3982 vec_min(vector unsigned long long __a, vector unsigned long long __b) {
   3983   return __builtin_altivec_vminud(__a, __b);
   3984 }
   3985 
   3986 static __inline__ vector unsigned long long __ATTRS_o_ai
   3987 vec_min(vector bool long long __a, vector unsigned long long __b) {
   3988   return __builtin_altivec_vminud((vector unsigned long long)__a, __b);
   3989 }
   3990 
   3991 static __inline__ vector unsigned long long __ATTRS_o_ai
   3992 vec_min(vector unsigned long long __a, vector bool long long __b) {
   3993   return __builtin_altivec_vminud(__a, (vector unsigned long long)__b);
   3994 }
   3995 #endif
   3996 
   3997 static __inline__ vector float __ATTRS_o_ai vec_min(vector float __a,
   3998                                                     vector float __b) {
   3999 #ifdef __VSX__
   4000   return __builtin_vsx_xvminsp(__a, __b);
   4001 #else
   4002   return __builtin_altivec_vminfp(__a, __b);
   4003 #endif
   4004 }
   4005 
   4006 #ifdef __VSX__
   4007 static __inline__ vector double __ATTRS_o_ai vec_min(vector double __a,
   4008                                                      vector double __b) {
   4009   return __builtin_vsx_xvmindp(__a, __b);
   4010 }
   4011 #endif
   4012 
   4013 /* vec_vminsb */
   4014 
   4015 static __inline__ vector signed char __ATTRS_o_ai
   4016 vec_vminsb(vector signed char __a, vector signed char __b) {
   4017   return __builtin_altivec_vminsb(__a, __b);
   4018 }
   4019 
   4020 static __inline__ vector signed char __ATTRS_o_ai
   4021 vec_vminsb(vector bool char __a, vector signed char __b) {
   4022   return __builtin_altivec_vminsb((vector signed char)__a, __b);
   4023 }
   4024 
   4025 static __inline__ vector signed char __ATTRS_o_ai
   4026 vec_vminsb(vector signed char __a, vector bool char __b) {
   4027   return __builtin_altivec_vminsb(__a, (vector signed char)__b);
   4028 }
   4029 
   4030 /* vec_vminub */
   4031 
   4032 static __inline__ vector unsigned char __ATTRS_o_ai
   4033 vec_vminub(vector unsigned char __a, vector unsigned char __b) {
   4034   return __builtin_altivec_vminub(__a, __b);
   4035 }
   4036 
   4037 static __inline__ vector unsigned char __ATTRS_o_ai
   4038 vec_vminub(vector bool char __a, vector unsigned char __b) {
   4039   return __builtin_altivec_vminub((vector unsigned char)__a, __b);
   4040 }
   4041 
   4042 static __inline__ vector unsigned char __ATTRS_o_ai
   4043 vec_vminub(vector unsigned char __a, vector bool char __b) {
   4044   return __builtin_altivec_vminub(__a, (vector unsigned char)__b);
   4045 }
   4046 
   4047 /* vec_vminsh */
   4048 
   4049 static __inline__ vector short __ATTRS_o_ai vec_vminsh(vector short __a,
   4050                                                        vector short __b) {
   4051   return __builtin_altivec_vminsh(__a, __b);
   4052 }
   4053 
   4054 static __inline__ vector short __ATTRS_o_ai vec_vminsh(vector bool short __a,
   4055                                                        vector short __b) {
   4056   return __builtin_altivec_vminsh((vector short)__a, __b);
   4057 }
   4058 
   4059 static __inline__ vector short __ATTRS_o_ai vec_vminsh(vector short __a,
   4060                                                        vector bool short __b) {
   4061   return __builtin_altivec_vminsh(__a, (vector short)__b);
   4062 }
   4063 
   4064 /* vec_vminuh */
   4065 
   4066 static __inline__ vector unsigned short __ATTRS_o_ai
   4067 vec_vminuh(vector unsigned short __a, vector unsigned short __b) {
   4068   return __builtin_altivec_vminuh(__a, __b);
   4069 }
   4070 
   4071 static __inline__ vector unsigned short __ATTRS_o_ai
   4072 vec_vminuh(vector bool short __a, vector unsigned short __b) {
   4073   return __builtin_altivec_vminuh((vector unsigned short)__a, __b);
   4074 }
   4075 
   4076 static __inline__ vector unsigned short __ATTRS_o_ai
   4077 vec_vminuh(vector unsigned short __a, vector bool short __b) {
   4078   return __builtin_altivec_vminuh(__a, (vector unsigned short)__b);
   4079 }
   4080 
   4081 /* vec_vminsw */
   4082 
   4083 static __inline__ vector int __ATTRS_o_ai vec_vminsw(vector int __a,
   4084                                                      vector int __b) {
   4085   return __builtin_altivec_vminsw(__a, __b);
   4086 }
   4087 
   4088 static __inline__ vector int __ATTRS_o_ai vec_vminsw(vector bool int __a,
   4089                                                      vector int __b) {
   4090   return __builtin_altivec_vminsw((vector int)__a, __b);
   4091 }
   4092 
   4093 static __inline__ vector int __ATTRS_o_ai vec_vminsw(vector int __a,
   4094                                                      vector bool int __b) {
   4095   return __builtin_altivec_vminsw(__a, (vector int)__b);
   4096 }
   4097 
   4098 /* vec_vminuw */
   4099 
   4100 static __inline__ vector unsigned int __ATTRS_o_ai
   4101 vec_vminuw(vector unsigned int __a, vector unsigned int __b) {
   4102   return __builtin_altivec_vminuw(__a, __b);
   4103 }
   4104 
   4105 static __inline__ vector unsigned int __ATTRS_o_ai
   4106 vec_vminuw(vector bool int __a, vector unsigned int __b) {
   4107   return __builtin_altivec_vminuw((vector unsigned int)__a, __b);
   4108 }
   4109 
   4110 static __inline__ vector unsigned int __ATTRS_o_ai
   4111 vec_vminuw(vector unsigned int __a, vector bool int __b) {
   4112   return __builtin_altivec_vminuw(__a, (vector unsigned int)__b);
   4113 }
   4114 
   4115 /* vec_vminfp */
   4116 
   4117 static __inline__ vector float __attribute__((__always_inline__))
   4118 vec_vminfp(vector float __a, vector float __b) {
   4119 #ifdef __VSX__
   4120   return __builtin_vsx_xvminsp(__a, __b);
   4121 #else
   4122   return __builtin_altivec_vminfp(__a, __b);
   4123 #endif
   4124 }
   4125 
   4126 /* vec_mladd */
   4127 
   4128 #define __builtin_altivec_vmladduhm vec_mladd
   4129 
   4130 static __inline__ vector short __ATTRS_o_ai vec_mladd(vector short __a,
   4131                                                       vector short __b,
   4132                                                       vector short __c) {
   4133   return __a * __b + __c;
   4134 }
   4135 
   4136 static __inline__ vector short __ATTRS_o_ai vec_mladd(
   4137     vector short __a, vector unsigned short __b, vector unsigned short __c) {
   4138   return __a * (vector short)__b + (vector short)__c;
   4139 }
   4140 
   4141 static __inline__ vector short __ATTRS_o_ai vec_mladd(vector unsigned short __a,
   4142                                                       vector short __b,
   4143                                                       vector short __c) {
   4144   return (vector short)__a * __b + __c;
   4145 }
   4146 
   4147 static __inline__ vector unsigned short __ATTRS_o_ai
   4148 vec_mladd(vector unsigned short __a, vector unsigned short __b,
   4149           vector unsigned short __c) {
   4150   return __a * __b + __c;
   4151 }
   4152 
   4153 /* vec_vmladduhm */
   4154 
   4155 static __inline__ vector short __ATTRS_o_ai vec_vmladduhm(vector short __a,
   4156                                                           vector short __b,
   4157                                                           vector short __c) {
   4158   return __a * __b + __c;
   4159 }
   4160 
   4161 static __inline__ vector short __ATTRS_o_ai vec_vmladduhm(
   4162     vector short __a, vector unsigned short __b, vector unsigned short __c) {
   4163   return __a * (vector short)__b + (vector short)__c;
   4164 }
   4165 
   4166 static __inline__ vector short __ATTRS_o_ai
   4167 vec_vmladduhm(vector unsigned short __a, vector short __b, vector short __c) {
   4168   return (vector short)__a * __b + __c;
   4169 }
   4170 
   4171 static __inline__ vector unsigned short __ATTRS_o_ai
   4172 vec_vmladduhm(vector unsigned short __a, vector unsigned short __b,
   4173               vector unsigned short __c) {
   4174   return __a * __b + __c;
   4175 }
   4176 
   4177 /* vec_mradds */
   4178 
   4179 static __inline__ vector short __attribute__((__always_inline__))
   4180 vec_mradds(vector short __a, vector short __b, vector short __c) {
   4181   return __builtin_altivec_vmhraddshs(__a, __b, __c);
   4182 }
   4183 
   4184 /* vec_vmhraddshs */
   4185 
   4186 static __inline__ vector short __attribute__((__always_inline__))
   4187 vec_vmhraddshs(vector short __a, vector short __b, vector short __c) {
   4188   return __builtin_altivec_vmhraddshs(__a, __b, __c);
   4189 }
   4190 
   4191 /* vec_msum */
   4192 
   4193 static __inline__ vector int __ATTRS_o_ai vec_msum(vector signed char __a,
   4194                                                    vector unsigned char __b,
   4195                                                    vector int __c) {
   4196   return __builtin_altivec_vmsummbm(__a, __b, __c);
   4197 }
   4198 
   4199 static __inline__ vector unsigned int __ATTRS_o_ai
   4200 vec_msum(vector unsigned char __a, vector unsigned char __b,
   4201          vector unsigned int __c) {
   4202   return __builtin_altivec_vmsumubm(__a, __b, __c);
   4203 }
   4204 
   4205 static __inline__ vector int __ATTRS_o_ai vec_msum(vector short __a,
   4206                                                    vector short __b,
   4207                                                    vector int __c) {
   4208   return __builtin_altivec_vmsumshm(__a, __b, __c);
   4209 }
   4210 
   4211 static __inline__ vector unsigned int __ATTRS_o_ai
   4212 vec_msum(vector unsigned short __a, vector unsigned short __b,
   4213          vector unsigned int __c) {
   4214   return __builtin_altivec_vmsumuhm(__a, __b, __c);
   4215 }
   4216 
   4217 /* vec_vmsummbm */
   4218 
   4219 static __inline__ vector int __attribute__((__always_inline__))
   4220 vec_vmsummbm(vector signed char __a, vector unsigned char __b, vector int __c) {
   4221   return __builtin_altivec_vmsummbm(__a, __b, __c);
   4222 }
   4223 
   4224 /* vec_vmsumubm */
   4225 
   4226 static __inline__ vector unsigned int __attribute__((__always_inline__))
   4227 vec_vmsumubm(vector unsigned char __a, vector unsigned char __b,
   4228              vector unsigned int __c) {
   4229   return __builtin_altivec_vmsumubm(__a, __b, __c);
   4230 }
   4231 
   4232 /* vec_vmsumshm */
   4233 
   4234 static __inline__ vector int __attribute__((__always_inline__))
   4235 vec_vmsumshm(vector short __a, vector short __b, vector int __c) {
   4236   return __builtin_altivec_vmsumshm(__a, __b, __c);
   4237 }
   4238 
   4239 /* vec_vmsumuhm */
   4240 
   4241 static __inline__ vector unsigned int __attribute__((__always_inline__))
   4242 vec_vmsumuhm(vector unsigned short __a, vector unsigned short __b,
   4243              vector unsigned int __c) {
   4244   return __builtin_altivec_vmsumuhm(__a, __b, __c);
   4245 }
   4246 
   4247 /* vec_msums */
   4248 
   4249 static __inline__ vector int __ATTRS_o_ai vec_msums(vector short __a,
   4250                                                     vector short __b,
   4251                                                     vector int __c) {
   4252   return __builtin_altivec_vmsumshs(__a, __b, __c);
   4253 }
   4254 
   4255 static __inline__ vector unsigned int __ATTRS_o_ai
   4256 vec_msums(vector unsigned short __a, vector unsigned short __b,
   4257           vector unsigned int __c) {
   4258   return __builtin_altivec_vmsumuhs(__a, __b, __c);
   4259 }
   4260 
   4261 /* vec_vmsumshs */
   4262 
   4263 static __inline__ vector int __attribute__((__always_inline__))
   4264 vec_vmsumshs(vector short __a, vector short __b, vector int __c) {
   4265   return __builtin_altivec_vmsumshs(__a, __b, __c);
   4266 }
   4267 
   4268 /* vec_vmsumuhs */
   4269 
   4270 static __inline__ vector unsigned int __attribute__((__always_inline__))
   4271 vec_vmsumuhs(vector unsigned short __a, vector unsigned short __b,
   4272              vector unsigned int __c) {
   4273   return __builtin_altivec_vmsumuhs(__a, __b, __c);
   4274 }
   4275 
   4276 /* vec_mtvscr */
   4277 
   4278 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector signed char __a) {
   4279   __builtin_altivec_mtvscr((vector int)__a);
   4280 }
   4281 
   4282 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector unsigned char __a) {
   4283   __builtin_altivec_mtvscr((vector int)__a);
   4284 }
   4285 
   4286 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector bool char __a) {
   4287   __builtin_altivec_mtvscr((vector int)__a);
   4288 }
   4289 
   4290 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector short __a) {
   4291   __builtin_altivec_mtvscr((vector int)__a);
   4292 }
   4293 
   4294 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector unsigned short __a) {
   4295   __builtin_altivec_mtvscr((vector int)__a);
   4296 }
   4297 
   4298 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector bool short __a) {
   4299   __builtin_altivec_mtvscr((vector int)__a);
   4300 }
   4301 
   4302 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector pixel __a) {
   4303   __builtin_altivec_mtvscr((vector int)__a);
   4304 }
   4305 
   4306 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector int __a) {
   4307   __builtin_altivec_mtvscr((vector int)__a);
   4308 }
   4309 
   4310 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector unsigned int __a) {
   4311   __builtin_altivec_mtvscr((vector int)__a);
   4312 }
   4313 
   4314 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector bool int __a) {
   4315   __builtin_altivec_mtvscr((vector int)__a);
   4316 }
   4317 
   4318 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector float __a) {
   4319   __builtin_altivec_mtvscr((vector int)__a);
   4320 }
   4321 
   4322 /* vec_mul */
   4323 
   4324 /* Integer vector multiplication will involve multiplication of the odd/even
   4325    elements separately, then truncating the results and moving to the
   4326    result vector.
   4327 */
   4328 static __inline__ vector signed char __ATTRS_o_ai
   4329 vec_mul(vector signed char __a, vector signed char __b) {
   4330   return __a * __b;
   4331 }
   4332 
   4333 static __inline__ vector unsigned char __ATTRS_o_ai
   4334 vec_mul(vector unsigned char __a, vector unsigned char __b) {
   4335   return __a * __b;
   4336 }
   4337 
   4338 static __inline__ vector signed short __ATTRS_o_ai
   4339 vec_mul(vector signed short __a, vector signed short __b) {
   4340   return __a * __b;
   4341 }
   4342 
   4343 static __inline__ vector unsigned short __ATTRS_o_ai
   4344 vec_mul(vector unsigned short __a, vector unsigned short __b) {
   4345   return __a * __b;
   4346 }
   4347 
   4348 static __inline__ vector signed int __ATTRS_o_ai
   4349 vec_mul(vector signed int __a, vector signed int __b) {
   4350   return __a * __b;
   4351 }
   4352 
   4353 static __inline__ vector unsigned int __ATTRS_o_ai
   4354 vec_mul(vector unsigned int __a, vector unsigned int __b) {
   4355   return __a * __b;
   4356 }
   4357 
   4358 #ifdef __VSX__
   4359 static __inline__ vector signed long long __ATTRS_o_ai
   4360 vec_mul(vector signed long long __a, vector signed long long __b) {
   4361   return __a * __b;
   4362 }
   4363 
   4364 static __inline__ vector unsigned long long __ATTRS_o_ai
   4365 vec_mul(vector unsigned long long __a, vector unsigned long long __b) {
   4366   return __a * __b;
   4367 }
   4368 #endif
   4369 
   4370 static __inline__ vector float __ATTRS_o_ai vec_mul(vector float __a,
   4371                                                     vector float __b) {
   4372   return __a * __b;
   4373 }
   4374 
   4375 #ifdef __VSX__
   4376 static __inline__ vector double __ATTRS_o_ai vec_mul(vector double __a,
   4377                                                      vector double __b) {
   4378   return __a * __b;
   4379 }
   4380 #endif
   4381 
   4382 /* The vmulos* and vmules* instructions have a big endian bias, so
   4383    we must reverse the meaning of "even" and "odd" for little endian.  */
   4384 
   4385 /* vec_mule */
   4386 
   4387 static __inline__ vector short __ATTRS_o_ai vec_mule(vector signed char __a,
   4388                                                      vector signed char __b) {
   4389 #ifdef __LITTLE_ENDIAN__
   4390   return __builtin_altivec_vmulosb(__a, __b);
   4391 #else
   4392   return __builtin_altivec_vmulesb(__a, __b);
   4393 #endif
   4394 }
   4395 
   4396 static __inline__ vector unsigned short __ATTRS_o_ai
   4397 vec_mule(vector unsigned char __a, vector unsigned char __b) {
   4398 #ifdef __LITTLE_ENDIAN__
   4399   return __builtin_altivec_vmuloub(__a, __b);
   4400 #else
   4401   return __builtin_altivec_vmuleub(__a, __b);
   4402 #endif
   4403 }
   4404 
   4405 static __inline__ vector int __ATTRS_o_ai vec_mule(vector short __a,
   4406                                                    vector short __b) {
   4407 #ifdef __LITTLE_ENDIAN__
   4408   return __builtin_altivec_vmulosh(__a, __b);
   4409 #else
   4410   return __builtin_altivec_vmulesh(__a, __b);
   4411 #endif
   4412 }
   4413 
   4414 static __inline__ vector unsigned int __ATTRS_o_ai
   4415 vec_mule(vector unsigned short __a, vector unsigned short __b) {
   4416 #ifdef __LITTLE_ENDIAN__
   4417   return __builtin_altivec_vmulouh(__a, __b);
   4418 #else
   4419   return __builtin_altivec_vmuleuh(__a, __b);
   4420 #endif
   4421 }
   4422 
   4423 #ifdef __POWER8_VECTOR__
   4424 static __inline__ vector signed long long __ATTRS_o_ai
   4425 vec_mule(vector signed int __a, vector signed int __b) {
   4426 #ifdef __LITTLE_ENDIAN__
   4427   return __builtin_altivec_vmulosw(__a, __b);
   4428 #else
   4429   return __builtin_altivec_vmulesw(__a, __b);
   4430 #endif
   4431 }
   4432 
   4433 static __inline__ vector unsigned long long __ATTRS_o_ai
   4434 vec_mule(vector unsigned int __a, vector unsigned int __b) {
   4435 #ifdef __LITTLE_ENDIAN__
   4436   return __builtin_altivec_vmulouw(__a, __b);
   4437 #else
   4438   return __builtin_altivec_vmuleuw(__a, __b);
   4439 #endif
   4440 }
   4441 #endif
   4442 
   4443 /* vec_vmulesb */
   4444 
   4445 static __inline__ vector short __attribute__((__always_inline__))
   4446 vec_vmulesb(vector signed char __a, vector signed char __b) {
   4447 #ifdef __LITTLE_ENDIAN__
   4448   return __builtin_altivec_vmulosb(__a, __b);
   4449 #else
   4450   return __builtin_altivec_vmulesb(__a, __b);
   4451 #endif
   4452 }
   4453 
   4454 /* vec_vmuleub */
   4455 
   4456 static __inline__ vector unsigned short __attribute__((__always_inline__))
   4457 vec_vmuleub(vector unsigned char __a, vector unsigned char __b) {
   4458 #ifdef __LITTLE_ENDIAN__
   4459   return __builtin_altivec_vmuloub(__a, __b);
   4460 #else
   4461   return __builtin_altivec_vmuleub(__a, __b);
   4462 #endif
   4463 }
   4464 
   4465 /* vec_vmulesh */
   4466 
   4467 static __inline__ vector int __attribute__((__always_inline__))
   4468 vec_vmulesh(vector short __a, vector short __b) {
   4469 #ifdef __LITTLE_ENDIAN__
   4470   return __builtin_altivec_vmulosh(__a, __b);
   4471 #else
   4472   return __builtin_altivec_vmulesh(__a, __b);
   4473 #endif
   4474 }
   4475 
   4476 /* vec_vmuleuh */
   4477 
   4478 static __inline__ vector unsigned int __attribute__((__always_inline__))
   4479 vec_vmuleuh(vector unsigned short __a, vector unsigned short __b) {
   4480 #ifdef __LITTLE_ENDIAN__
   4481   return __builtin_altivec_vmulouh(__a, __b);
   4482 #else
   4483   return __builtin_altivec_vmuleuh(__a, __b);
   4484 #endif
   4485 }
   4486 
   4487 /* vec_mulo */
   4488 
   4489 static __inline__ vector short __ATTRS_o_ai vec_mulo(vector signed char __a,
   4490                                                      vector signed char __b) {
   4491 #ifdef __LITTLE_ENDIAN__
   4492   return __builtin_altivec_vmulesb(__a, __b);
   4493 #else
   4494   return __builtin_altivec_vmulosb(__a, __b);
   4495 #endif
   4496 }
   4497 
   4498 static __inline__ vector unsigned short __ATTRS_o_ai
   4499 vec_mulo(vector unsigned char __a, vector unsigned char __b) {
   4500 #ifdef __LITTLE_ENDIAN__
   4501   return __builtin_altivec_vmuleub(__a, __b);
   4502 #else
   4503   return __builtin_altivec_vmuloub(__a, __b);
   4504 #endif
   4505 }
   4506 
   4507 static __inline__ vector int __ATTRS_o_ai vec_mulo(vector short __a,
   4508                                                    vector short __b) {
   4509 #ifdef __LITTLE_ENDIAN__
   4510   return __builtin_altivec_vmulesh(__a, __b);
   4511 #else
   4512   return __builtin_altivec_vmulosh(__a, __b);
   4513 #endif
   4514 }
   4515 
   4516 static __inline__ vector unsigned int __ATTRS_o_ai
   4517 vec_mulo(vector unsigned short __a, vector unsigned short __b) {
   4518 #ifdef __LITTLE_ENDIAN__
   4519   return __builtin_altivec_vmuleuh(__a, __b);
   4520 #else
   4521   return __builtin_altivec_vmulouh(__a, __b);
   4522 #endif
   4523 }
   4524 
   4525 #ifdef __POWER8_VECTOR__
   4526 static __inline__ vector signed long long __ATTRS_o_ai
   4527 vec_mulo(vector signed int __a, vector signed int __b) {
   4528 #ifdef __LITTLE_ENDIAN__
   4529   return __builtin_altivec_vmulesw(__a, __b);
   4530 #else
   4531   return __builtin_altivec_vmulosw(__a, __b);
   4532 #endif
   4533 }
   4534 
   4535 static __inline__ vector unsigned long long __ATTRS_o_ai
   4536 vec_mulo(vector unsigned int __a, vector unsigned int __b) {
   4537 #ifdef __LITTLE_ENDIAN__
   4538   return __builtin_altivec_vmuleuw(__a, __b);
   4539 #else
   4540   return __builtin_altivec_vmulouw(__a, __b);
   4541 #endif
   4542 }
   4543 #endif
   4544 
   4545 /* vec_vmulosb */
   4546 
   4547 static __inline__ vector short __attribute__((__always_inline__))
   4548 vec_vmulosb(vector signed char __a, vector signed char __b) {
   4549 #ifdef __LITTLE_ENDIAN__
   4550   return __builtin_altivec_vmulesb(__a, __b);
   4551 #else
   4552   return __builtin_altivec_vmulosb(__a, __b);
   4553 #endif
   4554 }
   4555 
   4556 /* vec_vmuloub */
   4557 
   4558 static __inline__ vector unsigned short __attribute__((__always_inline__))
   4559 vec_vmuloub(vector unsigned char __a, vector unsigned char __b) {
   4560 #ifdef __LITTLE_ENDIAN__
   4561   return __builtin_altivec_vmuleub(__a, __b);
   4562 #else
   4563   return __builtin_altivec_vmuloub(__a, __b);
   4564 #endif
   4565 }
   4566 
   4567 /* vec_vmulosh */
   4568 
   4569 static __inline__ vector int __attribute__((__always_inline__))
   4570 vec_vmulosh(vector short __a, vector short __b) {
   4571 #ifdef __LITTLE_ENDIAN__
   4572   return __builtin_altivec_vmulesh(__a, __b);
   4573 #else
   4574   return __builtin_altivec_vmulosh(__a, __b);
   4575 #endif
   4576 }
   4577 
   4578 /* vec_vmulouh */
   4579 
   4580 static __inline__ vector unsigned int __attribute__((__always_inline__))
   4581 vec_vmulouh(vector unsigned short __a, vector unsigned short __b) {
   4582 #ifdef __LITTLE_ENDIAN__
   4583   return __builtin_altivec_vmuleuh(__a, __b);
   4584 #else
   4585   return __builtin_altivec_vmulouh(__a, __b);
   4586 #endif
   4587 }
   4588 
   4589 /*  vec_nand */
   4590 
   4591 #ifdef __POWER8_VECTOR__
   4592 static __inline__ vector signed char __ATTRS_o_ai
   4593 vec_nand(vector signed char __a, vector signed char __b) {
   4594   return ~(__a & __b);
   4595 }
   4596 
   4597 static __inline__ vector signed char __ATTRS_o_ai
   4598 vec_nand(vector signed char __a, vector bool char __b) {
   4599   return ~(__a & __b);
   4600 }
   4601 
   4602 static __inline__ vector signed char __ATTRS_o_ai
   4603 vec_nand(vector bool char __a, vector signed char __b) {
   4604   return ~(__a & __b);
   4605 }
   4606 
   4607 static __inline__ vector unsigned char __ATTRS_o_ai
   4608 vec_nand(vector unsigned char __a, vector unsigned char __b) {
   4609   return ~(__a & __b);
   4610 }
   4611 
   4612 static __inline__ vector unsigned char __ATTRS_o_ai
   4613 vec_nand(vector unsigned char __a, vector bool char __b) {
   4614   return ~(__a & __b);
   4615 }
   4616 
   4617 static __inline__ vector unsigned char __ATTRS_o_ai
   4618 vec_nand(vector bool char __a, vector unsigned char __b) {
   4619   return ~(__a & __b);
   4620 }
   4621 
   4622 static __inline__ vector bool char __ATTRS_o_ai vec_nand(vector bool char __a,
   4623                                                          vector bool char __b) {
   4624   return ~(__a & __b);
   4625 }
   4626 
   4627 static __inline__ vector signed short __ATTRS_o_ai
   4628 vec_nand(vector signed short __a, vector signed short __b) {
   4629   return ~(__a & __b);
   4630 }
   4631 
   4632 static __inline__ vector signed short __ATTRS_o_ai
   4633 vec_nand(vector signed short __a, vector bool short __b) {
   4634   return ~(__a & __b);
   4635 }
   4636 
   4637 static __inline__ vector signed short __ATTRS_o_ai
   4638 vec_nand(vector bool short __a, vector signed short __b) {
   4639   return ~(__a & __b);
   4640 }
   4641 
   4642 static __inline__ vector unsigned short __ATTRS_o_ai
   4643 vec_nand(vector unsigned short __a, vector unsigned short __b) {
   4644   return ~(__a & __b);
   4645 }
   4646 
   4647 static __inline__ vector unsigned short __ATTRS_o_ai
   4648 vec_nand(vector unsigned short __a, vector bool short __b) {
   4649   return ~(__a & __b);
   4650 }
   4651 
   4652 static __inline__ vector bool short __ATTRS_o_ai
   4653 vec_nand(vector bool short __a, vector bool short __b) {
   4654   return ~(__a & __b);
   4655 }
   4656 
   4657 static __inline__ vector signed int __ATTRS_o_ai
   4658 vec_nand(vector signed int __a, vector signed int __b) {
   4659   return ~(__a & __b);
   4660 }
   4661 
   4662 static __inline__ vector signed int __ATTRS_o_ai vec_nand(vector signed int __a,
   4663                                                           vector bool int __b) {
   4664   return ~(__a & __b);
   4665 }
   4666 
   4667 static __inline__ vector signed int __ATTRS_o_ai
   4668 vec_nand(vector bool int __a, vector signed int __b) {
   4669   return ~(__a & __b);
   4670 }
   4671 
   4672 static __inline__ vector unsigned int __ATTRS_o_ai
   4673 vec_nand(vector unsigned int __a, vector unsigned int __b) {
   4674   return ~(__a & __b);
   4675 }
   4676 
   4677 static __inline__ vector unsigned int __ATTRS_o_ai
   4678 vec_nand(vector unsigned int __a, vector bool int __b) {
   4679   return ~(__a & __b);
   4680 }
   4681 
   4682 static __inline__ vector unsigned int __ATTRS_o_ai
   4683 vec_nand(vector bool int __a, vector unsigned int __b) {
   4684   return ~(__a & __b);
   4685 }
   4686 
   4687 static __inline__ vector bool int __ATTRS_o_ai vec_nand(vector bool int __a,
   4688                                                         vector bool int __b) {
   4689   return ~(__a & __b);
   4690 }
   4691 
   4692 static __inline__ vector signed long long __ATTRS_o_ai
   4693 vec_nand(vector signed long long __a, vector signed long long __b) {
   4694   return ~(__a & __b);
   4695 }
   4696 
   4697 static __inline__ vector signed long long __ATTRS_o_ai
   4698 vec_nand(vector signed long long __a, vector bool long long __b) {
   4699   return ~(__a & __b);
   4700 }
   4701 
   4702 static __inline__ vector signed long long __ATTRS_o_ai
   4703 vec_nand(vector bool long long __a, vector signed long long __b) {
   4704   return ~(__a & __b);
   4705 }
   4706 
   4707 static __inline__ vector unsigned long long __ATTRS_o_ai
   4708 vec_nand(vector unsigned long long __a, vector unsigned long long __b) {
   4709   return ~(__a & __b);
   4710 }
   4711 
   4712 static __inline__ vector unsigned long long __ATTRS_o_ai
   4713 vec_nand(vector unsigned long long __a, vector bool long long __b) {
   4714   return ~(__a & __b);
   4715 }
   4716 
   4717 static __inline__ vector unsigned long long __ATTRS_o_ai
   4718 vec_nand(vector bool long long __a, vector unsigned long long __b) {
   4719   return ~(__a & __b);
   4720 }
   4721 
   4722 static __inline__ vector bool long long __ATTRS_o_ai
   4723 vec_nand(vector bool long long __a, vector bool long long __b) {
   4724   return ~(__a & __b);
   4725 }
   4726 
   4727 #endif
   4728 
   4729 /* vec_nmadd */
   4730 
   4731 #ifdef __VSX__
   4732 static __inline__ vector float __ATTRS_o_ai vec_nmadd(vector float __a,
   4733                                                       vector float __b,
   4734                                                       vector float __c) {
   4735   return __builtin_vsx_xvnmaddasp(__a, __b, __c);
   4736 }
   4737 
   4738 static __inline__ vector double __ATTRS_o_ai vec_nmadd(vector double __a,
   4739                                                        vector double __b,
   4740                                                        vector double __c) {
   4741   return __builtin_vsx_xvnmaddadp(__a, __b, __c);
   4742 }
   4743 #endif
   4744 
   4745 /* vec_nmsub */
   4746 
   4747 static __inline__ vector float __ATTRS_o_ai vec_nmsub(vector float __a,
   4748                                                       vector float __b,
   4749                                                       vector float __c) {
   4750 #ifdef __VSX__
   4751   return __builtin_vsx_xvnmsubasp(__a, __b, __c);
   4752 #else
   4753   return __builtin_altivec_vnmsubfp(__a, __b, __c);
   4754 #endif
   4755 }
   4756 
   4757 #ifdef __VSX__
   4758 static __inline__ vector double __ATTRS_o_ai vec_nmsub(vector double __a,
   4759                                                        vector double __b,
   4760                                                        vector double __c) {
   4761   return __builtin_vsx_xvnmsubadp(__a, __b, __c);
   4762 }
   4763 #endif
   4764 
   4765 /* vec_vnmsubfp */
   4766 
   4767 static __inline__ vector float __attribute__((__always_inline__))
   4768 vec_vnmsubfp(vector float __a, vector float __b, vector float __c) {
   4769   return __builtin_altivec_vnmsubfp(__a, __b, __c);
   4770 }
   4771 
   4772 /* vec_nor */
   4773 
   4774 #define __builtin_altivec_vnor vec_nor
   4775 
   4776 static __inline__ vector signed char __ATTRS_o_ai
   4777 vec_nor(vector signed char __a, vector signed char __b) {
   4778   return ~(__a | __b);
   4779 }
   4780 
   4781 static __inline__ vector unsigned char __ATTRS_o_ai
   4782 vec_nor(vector unsigned char __a, vector unsigned char __b) {
   4783   return ~(__a | __b);
   4784 }
   4785 
   4786 static __inline__ vector bool char __ATTRS_o_ai vec_nor(vector bool char __a,
   4787                                                         vector bool char __b) {
   4788   return ~(__a | __b);
   4789 }
   4790 
   4791 static __inline__ vector short __ATTRS_o_ai vec_nor(vector short __a,
   4792                                                     vector short __b) {
   4793   return ~(__a | __b);
   4794 }
   4795 
   4796 static __inline__ vector unsigned short __ATTRS_o_ai
   4797 vec_nor(vector unsigned short __a, vector unsigned short __b) {
   4798   return ~(__a | __b);
   4799 }
   4800 
   4801 static __inline__ vector bool short __ATTRS_o_ai
   4802 vec_nor(vector bool short __a, vector bool short __b) {
   4803   return ~(__a | __b);
   4804 }
   4805 
   4806 static __inline__ vector int __ATTRS_o_ai vec_nor(vector int __a,
   4807                                                   vector int __b) {
   4808   return ~(__a | __b);
   4809 }
   4810 
   4811 static __inline__ vector unsigned int __ATTRS_o_ai
   4812 vec_nor(vector unsigned int __a, vector unsigned int __b) {
   4813   return ~(__a | __b);
   4814 }
   4815 
   4816 static __inline__ vector bool int __ATTRS_o_ai vec_nor(vector bool int __a,
   4817                                                        vector bool int __b) {
   4818   return ~(__a | __b);
   4819 }
   4820 
   4821 static __inline__ vector float __ATTRS_o_ai vec_nor(vector float __a,
   4822                                                     vector float __b) {
   4823   vector unsigned int __res =
   4824       ~((vector unsigned int)__a | (vector unsigned int)__b);
   4825   return (vector float)__res;
   4826 }
   4827 
   4828 #ifdef __VSX__
   4829 static __inline__ vector double __ATTRS_o_ai vec_nor(vector double __a,
   4830                                                      vector double __b) {
   4831   vector unsigned long long __res =
   4832       ~((vector unsigned long long)__a | (vector unsigned long long)__b);
   4833   return (vector double)__res;
   4834 }
   4835 #endif
   4836 
   4837 /* vec_vnor */
   4838 
   4839 static __inline__ vector signed char __ATTRS_o_ai
   4840 vec_vnor(vector signed char __a, vector signed char __b) {
   4841   return ~(__a | __b);
   4842 }
   4843 
   4844 static __inline__ vector unsigned char __ATTRS_o_ai
   4845 vec_vnor(vector unsigned char __a, vector unsigned char __b) {
   4846   return ~(__a | __b);
   4847 }
   4848 
   4849 static __inline__ vector bool char __ATTRS_o_ai vec_vnor(vector bool char __a,
   4850                                                          vector bool char __b) {
   4851   return ~(__a | __b);
   4852 }
   4853 
   4854 static __inline__ vector short __ATTRS_o_ai vec_vnor(vector short __a,
   4855                                                      vector short __b) {
   4856   return ~(__a | __b);
   4857 }
   4858 
   4859 static __inline__ vector unsigned short __ATTRS_o_ai
   4860 vec_vnor(vector unsigned short __a, vector unsigned short __b) {
   4861   return ~(__a | __b);
   4862 }
   4863 
   4864 static __inline__ vector bool short __ATTRS_o_ai
   4865 vec_vnor(vector bool short __a, vector bool short __b) {
   4866   return ~(__a | __b);
   4867 }
   4868 
   4869 static __inline__ vector int __ATTRS_o_ai vec_vnor(vector int __a,
   4870                                                    vector int __b) {
   4871   return ~(__a | __b);
   4872 }
   4873 
   4874 static __inline__ vector unsigned int __ATTRS_o_ai
   4875 vec_vnor(vector unsigned int __a, vector unsigned int __b) {
   4876   return ~(__a | __b);
   4877 }
   4878 
   4879 static __inline__ vector bool int __ATTRS_o_ai vec_vnor(vector bool int __a,
   4880                                                         vector bool int __b) {
   4881   return ~(__a | __b);
   4882 }
   4883 
   4884 static __inline__ vector float __ATTRS_o_ai vec_vnor(vector float __a,
   4885                                                      vector float __b) {
   4886   vector unsigned int __res =
   4887       ~((vector unsigned int)__a | (vector unsigned int)__b);
   4888   return (vector float)__res;
   4889 }
   4890 
   4891 #ifdef __VSX__
   4892 static __inline__ vector signed long long __ATTRS_o_ai
   4893 vec_nor(vector signed long long __a, vector signed long long __b) {
   4894   return ~(__a | __b);
   4895 }
   4896 
   4897 static __inline__ vector unsigned long long __ATTRS_o_ai
   4898 vec_nor(vector unsigned long long __a, vector unsigned long long __b) {
   4899   return ~(__a | __b);
   4900 }
   4901 
   4902 static __inline__ vector bool long long __ATTRS_o_ai
   4903 vec_nor(vector bool long long __a, vector bool long long __b) {
   4904   return ~(__a | __b);
   4905 }
   4906 #endif
   4907 
   4908 /* vec_or */
   4909 
   4910 #define __builtin_altivec_vor vec_or
   4911 
   4912 static __inline__ vector signed char __ATTRS_o_ai
   4913 vec_or(vector signed char __a, vector signed char __b) {
   4914   return __a | __b;
   4915 }
   4916 
   4917 static __inline__ vector signed char __ATTRS_o_ai
   4918 vec_or(vector bool char __a, vector signed char __b) {
   4919   return (vector signed char)__a | __b;
   4920 }
   4921 
   4922 static __inline__ vector signed char __ATTRS_o_ai vec_or(vector signed char __a,
   4923                                                          vector bool char __b) {
   4924   return __a | (vector signed char)__b;
   4925 }
   4926 
   4927 static __inline__ vector unsigned char __ATTRS_o_ai
   4928 vec_or(vector unsigned char __a, vector unsigned char __b) {
   4929   return __a | __b;
   4930 }
   4931 
   4932 static __inline__ vector unsigned char __ATTRS_o_ai
   4933 vec_or(vector bool char __a, vector unsigned char __b) {
   4934   return (vector unsigned char)__a | __b;
   4935 }
   4936 
   4937 static __inline__ vector unsigned char __ATTRS_o_ai
   4938 vec_or(vector unsigned char __a, vector bool char __b) {
   4939   return __a | (vector unsigned char)__b;
   4940 }
   4941 
   4942 static __inline__ vector bool char __ATTRS_o_ai vec_or(vector bool char __a,
   4943                                                        vector bool char __b) {
   4944   return __a | __b;
   4945 }
   4946 
   4947 static __inline__ vector short __ATTRS_o_ai vec_or(vector short __a,
   4948                                                    vector short __b) {
   4949   return __a | __b;
   4950 }
   4951 
   4952 static __inline__ vector short __ATTRS_o_ai vec_or(vector bool short __a,
   4953                                                    vector short __b) {
   4954   return (vector short)__a | __b;
   4955 }
   4956 
   4957 static __inline__ vector short __ATTRS_o_ai vec_or(vector short __a,
   4958                                                    vector bool short __b) {
   4959   return __a | (vector short)__b;
   4960 }
   4961 
   4962 static __inline__ vector unsigned short __ATTRS_o_ai
   4963 vec_or(vector unsigned short __a, vector unsigned short __b) {
   4964   return __a | __b;
   4965 }
   4966 
   4967 static __inline__ vector unsigned short __ATTRS_o_ai
   4968 vec_or(vector bool short __a, vector unsigned short __b) {
   4969   return (vector unsigned short)__a | __b;
   4970 }
   4971 
   4972 static __inline__ vector unsigned short __ATTRS_o_ai
   4973 vec_or(vector unsigned short __a, vector bool short __b) {
   4974   return __a | (vector unsigned short)__b;
   4975 }
   4976 
   4977 static __inline__ vector bool short __ATTRS_o_ai vec_or(vector bool short __a,
   4978                                                         vector bool short __b) {
   4979   return __a | __b;
   4980 }
   4981 
   4982 static __inline__ vector int __ATTRS_o_ai vec_or(vector int __a,
   4983                                                  vector int __b) {
   4984   return __a | __b;
   4985 }
   4986 
   4987 static __inline__ vector int __ATTRS_o_ai vec_or(vector bool int __a,
   4988                                                  vector int __b) {
   4989   return (vector int)__a | __b;
   4990 }
   4991 
   4992 static __inline__ vector int __ATTRS_o_ai vec_or(vector int __a,
   4993                                                  vector bool int __b) {
   4994   return __a | (vector int)__b;
   4995 }
   4996 
   4997 static __inline__ vector unsigned int __ATTRS_o_ai
   4998 vec_or(vector unsigned int __a, vector unsigned int __b) {
   4999   return __a | __b;
   5000 }
   5001 
   5002 static __inline__ vector unsigned int __ATTRS_o_ai
   5003 vec_or(vector bool int __a, vector unsigned int __b) {
   5004   return (vector unsigned int)__a | __b;
   5005 }
   5006 
   5007 static __inline__ vector unsigned int __ATTRS_o_ai
   5008 vec_or(vector unsigned int __a, vector bool int __b) {
   5009   return __a | (vector unsigned int)__b;
   5010 }
   5011 
   5012 static __inline__ vector bool int __ATTRS_o_ai vec_or(vector bool int __a,
   5013                                                       vector bool int __b) {
   5014   return __a | __b;
   5015 }
   5016 
   5017 static __inline__ vector float __ATTRS_o_ai vec_or(vector float __a,
   5018                                                    vector float __b) {
   5019   vector unsigned int __res =
   5020       (vector unsigned int)__a | (vector unsigned int)__b;
   5021   return (vector float)__res;
   5022 }
   5023 
   5024 static __inline__ vector float __ATTRS_o_ai vec_or(vector bool int __a,
   5025                                                    vector float __b) {
   5026   vector unsigned int __res =
   5027       (vector unsigned int)__a | (vector unsigned int)__b;
   5028   return (vector float)__res;
   5029 }
   5030 
   5031 static __inline__ vector float __ATTRS_o_ai vec_or(vector float __a,
   5032                                                    vector bool int __b) {
   5033   vector unsigned int __res =
   5034       (vector unsigned int)__a | (vector unsigned int)__b;
   5035   return (vector float)__res;
   5036 }
   5037 
   5038 #ifdef __VSX__
   5039 static __inline__ vector double __ATTRS_o_ai vec_or(vector bool long long __a,
   5040                                                     vector double __b) {
   5041   return (vector unsigned long long)__a | (vector unsigned long long)__b;
   5042 }
   5043 
   5044 static __inline__ vector double __ATTRS_o_ai vec_or(vector double __a,
   5045                                                     vector bool long long __b) {
   5046   return (vector unsigned long long)__a | (vector unsigned long long)__b;
   5047 }
   5048 
   5049 static __inline__ vector double __ATTRS_o_ai vec_or(vector double __a,
   5050                                                     vector double __b) {
   5051   vector unsigned long long __res =
   5052       (vector unsigned long long)__a | (vector unsigned long long)__b;
   5053   return (vector double)__res;
   5054 }
   5055 
   5056 static __inline__ vector signed long long __ATTRS_o_ai
   5057 vec_or(vector signed long long __a, vector signed long long __b) {
   5058   return __a | __b;
   5059 }
   5060 
   5061 static __inline__ vector signed long long __ATTRS_o_ai
   5062 vec_or(vector bool long long __a, vector signed long long __b) {
   5063   return (vector signed long long)__a | __b;
   5064 }
   5065 
   5066 static __inline__ vector signed long long __ATTRS_o_ai
   5067 vec_or(vector signed long long __a, vector bool long long __b) {
   5068   return __a | (vector signed long long)__b;
   5069 }
   5070 
   5071 static __inline__ vector unsigned long long __ATTRS_o_ai
   5072 vec_or(vector unsigned long long __a, vector unsigned long long __b) {
   5073   return __a | __b;
   5074 }
   5075 
   5076 static __inline__ vector unsigned long long __ATTRS_o_ai
   5077 vec_or(vector bool long long __a, vector unsigned long long __b) {
   5078   return (vector unsigned long long)__a | __b;
   5079 }
   5080 
   5081 static __inline__ vector unsigned long long __ATTRS_o_ai
   5082 vec_or(vector unsigned long long __a, vector bool long long __b) {
   5083   return __a | (vector unsigned long long)__b;
   5084 }
   5085 
   5086 static __inline__ vector bool long long __ATTRS_o_ai
   5087 vec_or(vector bool long long __a, vector bool long long __b) {
   5088   return __a | __b;
   5089 }
   5090 #endif
   5091 
   5092 #ifdef __POWER8_VECTOR__
   5093 static __inline__ vector signed char __ATTRS_o_ai
   5094 vec_orc(vector signed char __a, vector signed char __b) {
   5095   return __a | ~__b;
   5096 }
   5097 
   5098 static __inline__ vector signed char __ATTRS_o_ai
   5099 vec_orc(vector signed char __a, vector bool char __b) {
   5100   return __a | ~__b;
   5101 }
   5102 
   5103 static __inline__ vector signed char __ATTRS_o_ai
   5104 vec_orc(vector bool char __a, vector signed char __b) {
   5105   return __a | ~__b;
   5106 }
   5107 
   5108 static __inline__ vector unsigned char __ATTRS_o_ai
   5109 vec_orc(vector unsigned char __a, vector unsigned char __b) {
   5110   return __a | ~__b;
   5111 }
   5112 
   5113 static __inline__ vector unsigned char __ATTRS_o_ai
   5114 vec_orc(vector unsigned char __a, vector bool char __b) {
   5115   return __a | ~__b;
   5116 }
   5117 
   5118 static __inline__ vector unsigned char __ATTRS_o_ai
   5119 vec_orc(vector bool char __a, vector unsigned char __b) {
   5120   return __a | ~__b;
   5121 }
   5122 
   5123 static __inline__ vector bool char __ATTRS_o_ai vec_orc(vector bool char __a,
   5124                                                         vector bool char __b) {
   5125   return __a | ~__b;
   5126 }
   5127 
   5128 static __inline__ vector signed short __ATTRS_o_ai
   5129 vec_orc(vector signed short __a, vector signed short __b) {
   5130   return __a | ~__b;
   5131 }
   5132 
   5133 static __inline__ vector signed short __ATTRS_o_ai
   5134 vec_orc(vector signed short __a, vector bool short __b) {
   5135   return __a | ~__b;
   5136 }
   5137 
   5138 static __inline__ vector signed short __ATTRS_o_ai
   5139 vec_orc(vector bool short __a, vector signed short __b) {
   5140   return __a | ~__b;
   5141 }
   5142 
   5143 static __inline__ vector unsigned short __ATTRS_o_ai
   5144 vec_orc(vector unsigned short __a, vector unsigned short __b) {
   5145   return __a | ~__b;
   5146 }
   5147 
   5148 static __inline__ vector unsigned short __ATTRS_o_ai
   5149 vec_orc(vector unsigned short __a, vector bool short __b) {
   5150   return __a | ~__b;
   5151 }
   5152 
   5153 static __inline__ vector unsigned short __ATTRS_o_ai
   5154 vec_orc(vector bool short __a, vector unsigned short __b) {
   5155   return __a | ~__b;
   5156 }
   5157 
   5158 static __inline__ vector bool short __ATTRS_o_ai
   5159 vec_orc(vector bool short __a, vector bool short __b) {
   5160   return __a | ~__b;
   5161 }
   5162 
   5163 static __inline__ vector signed int __ATTRS_o_ai
   5164 vec_orc(vector signed int __a, vector signed int __b) {
   5165   return __a | ~__b;
   5166 }
   5167 
   5168 static __inline__ vector signed int __ATTRS_o_ai vec_orc(vector signed int __a,
   5169                                                          vector bool int __b) {
   5170   return __a | ~__b;
   5171 }
   5172 
   5173 static __inline__ vector signed int __ATTRS_o_ai
   5174 vec_orc(vector bool int __a, vector signed int __b) {
   5175   return __a | ~__b;
   5176 }
   5177 
   5178 static __inline__ vector unsigned int __ATTRS_o_ai
   5179 vec_orc(vector unsigned int __a, vector unsigned int __b) {
   5180   return __a | ~__b;
   5181 }
   5182 
   5183 static __inline__ vector unsigned int __ATTRS_o_ai
   5184 vec_orc(vector unsigned int __a, vector bool int __b) {
   5185   return __a | ~__b;
   5186 }
   5187 
   5188 static __inline__ vector unsigned int __ATTRS_o_ai
   5189 vec_orc(vector bool int __a, vector unsigned int __b) {
   5190   return __a | ~__b;
   5191 }
   5192 
   5193 static __inline__ vector bool int __ATTRS_o_ai vec_orc(vector bool int __a,
   5194                                                        vector bool int __b) {
   5195   return __a | ~__b;
   5196 }
   5197 
   5198 static __inline__ vector signed long long __ATTRS_o_ai
   5199 vec_orc(vector signed long long __a, vector signed long long __b) {
   5200   return __a | ~__b;
   5201 }
   5202 
   5203 static __inline__ vector signed long long __ATTRS_o_ai
   5204 vec_orc(vector signed long long __a, vector bool long long __b) {
   5205   return __a | ~__b;
   5206 }
   5207 
   5208 static __inline__ vector signed long long __ATTRS_o_ai
   5209 vec_orc(vector bool long long __a, vector signed long long __b) {
   5210   return __a | ~__b;
   5211 }
   5212 
   5213 static __inline__ vector unsigned long long __ATTRS_o_ai
   5214 vec_orc(vector unsigned long long __a, vector unsigned long long __b) {
   5215   return __a | ~__b;
   5216 }
   5217 
   5218 static __inline__ vector unsigned long long __ATTRS_o_ai
   5219 vec_orc(vector unsigned long long __a, vector bool long long __b) {
   5220   return __a | ~__b;
   5221 }
   5222 
   5223 static __inline__ vector unsigned long long __ATTRS_o_ai
   5224 vec_orc(vector bool long long __a, vector unsigned long long __b) {
   5225   return __a | ~__b;
   5226 }
   5227 
   5228 static __inline__ vector bool long long __ATTRS_o_ai
   5229 vec_orc(vector bool long long __a, vector bool long long __b) {
   5230   return __a | ~__b;
   5231 }
   5232 #endif
   5233 
   5234 /* vec_vor */
   5235 
   5236 static __inline__ vector signed char __ATTRS_o_ai
   5237 vec_vor(vector signed char __a, vector signed char __b) {
   5238   return __a | __b;
   5239 }
   5240 
   5241 static __inline__ vector signed char __ATTRS_o_ai
   5242 vec_vor(vector bool char __a, vector signed char __b) {
   5243   return (vector signed char)__a | __b;
   5244 }
   5245 
   5246 static __inline__ vector signed char __ATTRS_o_ai
   5247 vec_vor(vector signed char __a, vector bool char __b) {
   5248   return __a | (vector signed char)__b;
   5249 }
   5250 
   5251 static __inline__ vector unsigned char __ATTRS_o_ai
   5252 vec_vor(vector unsigned char __a, vector unsigned char __b) {
   5253   return __a | __b;
   5254 }
   5255 
   5256 static __inline__ vector unsigned char __ATTRS_o_ai
   5257 vec_vor(vector bool char __a, vector unsigned char __b) {
   5258   return (vector unsigned char)__a | __b;
   5259 }
   5260 
   5261 static __inline__ vector unsigned char __ATTRS_o_ai
   5262 vec_vor(vector unsigned char __a, vector bool char __b) {
   5263   return __a | (vector unsigned char)__b;
   5264 }
   5265 
   5266 static __inline__ vector bool char __ATTRS_o_ai vec_vor(vector bool char __a,
   5267                                                         vector bool char __b) {
   5268   return __a | __b;
   5269 }
   5270 
   5271 static __inline__ vector short __ATTRS_o_ai vec_vor(vector short __a,
   5272                                                     vector short __b) {
   5273   return __a | __b;
   5274 }
   5275 
   5276 static __inline__ vector short __ATTRS_o_ai vec_vor(vector bool short __a,
   5277                                                     vector short __b) {
   5278   return (vector short)__a | __b;
   5279 }
   5280 
   5281 static __inline__ vector short __ATTRS_o_ai vec_vor(vector short __a,
   5282                                                     vector bool short __b) {
   5283   return __a | (vector short)__b;
   5284 }
   5285 
   5286 static __inline__ vector unsigned short __ATTRS_o_ai
   5287 vec_vor(vector unsigned short __a, vector unsigned short __b) {
   5288   return __a | __b;
   5289 }
   5290 
   5291 static __inline__ vector unsigned short __ATTRS_o_ai
   5292 vec_vor(vector bool short __a, vector unsigned short __b) {
   5293   return (vector unsigned short)__a | __b;
   5294 }
   5295 
   5296 static __inline__ vector unsigned short __ATTRS_o_ai
   5297 vec_vor(vector unsigned short __a, vector bool short __b) {
   5298   return __a | (vector unsigned short)__b;
   5299 }
   5300 
   5301 static __inline__ vector bool short __ATTRS_o_ai
   5302 vec_vor(vector bool short __a, vector bool short __b) {
   5303   return __a | __b;
   5304 }
   5305 
   5306 static __inline__ vector int __ATTRS_o_ai vec_vor(vector int __a,
   5307                                                   vector int __b) {
   5308   return __a | __b;
   5309 }
   5310 
   5311 static __inline__ vector int __ATTRS_o_ai vec_vor(vector bool int __a,
   5312                                                   vector int __b) {
   5313   return (vector int)__a | __b;
   5314 }
   5315 
   5316 static __inline__ vector int __ATTRS_o_ai vec_vor(vector int __a,
   5317                                                   vector bool int __b) {
   5318   return __a | (vector int)__b;
   5319 }
   5320 
   5321 static __inline__ vector unsigned int __ATTRS_o_ai
   5322 vec_vor(vector unsigned int __a, vector unsigned int __b) {
   5323   return __a | __b;
   5324 }
   5325 
   5326 static __inline__ vector unsigned int __ATTRS_o_ai
   5327 vec_vor(vector bool int __a, vector unsigned int __b) {
   5328   return (vector unsigned int)__a | __b;
   5329 }
   5330 
   5331 static __inline__ vector unsigned int __ATTRS_o_ai
   5332 vec_vor(vector unsigned int __a, vector bool int __b) {
   5333   return __a | (vector unsigned int)__b;
   5334 }
   5335 
   5336 static __inline__ vector bool int __ATTRS_o_ai vec_vor(vector bool int __a,
   5337                                                        vector bool int __b) {
   5338   return __a | __b;
   5339 }
   5340 
   5341 static __inline__ vector float __ATTRS_o_ai vec_vor(vector float __a,
   5342                                                     vector float __b) {
   5343   vector unsigned int __res =
   5344       (vector unsigned int)__a | (vector unsigned int)__b;
   5345   return (vector float)__res;
   5346 }
   5347 
   5348 static __inline__ vector float __ATTRS_o_ai vec_vor(vector bool int __a,
   5349                                                     vector float __b) {
   5350   vector unsigned int __res =
   5351       (vector unsigned int)__a | (vector unsigned int)__b;
   5352   return (vector float)__res;
   5353 }
   5354 
   5355 static __inline__ vector float __ATTRS_o_ai vec_vor(vector float __a,
   5356                                                     vector bool int __b) {
   5357   vector unsigned int __res =
   5358       (vector unsigned int)__a | (vector unsigned int)__b;
   5359   return (vector float)__res;
   5360 }
   5361 
   5362 #ifdef __VSX__
   5363 static __inline__ vector signed long long __ATTRS_o_ai
   5364 vec_vor(vector signed long long __a, vector signed long long __b) {
   5365   return __a | __b;
   5366 }
   5367 
   5368 static __inline__ vector signed long long __ATTRS_o_ai
   5369 vec_vor(vector bool long long __a, vector signed long long __b) {
   5370   return (vector signed long long)__a | __b;
   5371 }
   5372 
   5373 static __inline__ vector signed long long __ATTRS_o_ai
   5374 vec_vor(vector signed long long __a, vector bool long long __b) {
   5375   return __a | (vector signed long long)__b;
   5376 }
   5377 
   5378 static __inline__ vector unsigned long long __ATTRS_o_ai
   5379 vec_vor(vector unsigned long long __a, vector unsigned long long __b) {
   5380   return __a | __b;
   5381 }
   5382 
   5383 static __inline__ vector unsigned long long __ATTRS_o_ai
   5384 vec_vor(vector bool long long __a, vector unsigned long long __b) {
   5385   return (vector unsigned long long)__a | __b;
   5386 }
   5387 
   5388 static __inline__ vector unsigned long long __ATTRS_o_ai
   5389 vec_vor(vector unsigned long long __a, vector bool long long __b) {
   5390   return __a | (vector unsigned long long)__b;
   5391 }
   5392 
   5393 static __inline__ vector bool long long __ATTRS_o_ai
   5394 vec_vor(vector bool long long __a, vector bool long long __b) {
   5395   return __a | __b;
   5396 }
   5397 #endif
   5398 
   5399 /* vec_pack */
   5400 
   5401 /* The various vector pack instructions have a big-endian bias, so for
   5402    little endian we must handle reversed element numbering.  */
   5403 
   5404 static __inline__ vector signed char __ATTRS_o_ai
   5405 vec_pack(vector signed short __a, vector signed short __b) {
   5406 #ifdef __LITTLE_ENDIAN__
   5407   return (vector signed char)vec_perm(
   5408       __a, __b,
   5409       (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
   5410                              0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
   5411 #else
   5412   return (vector signed char)vec_perm(
   5413       __a, __b,
   5414       (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
   5415                              0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
   5416 #endif
   5417 }
   5418 
   5419 static __inline__ vector unsigned char __ATTRS_o_ai
   5420 vec_pack(vector unsigned short __a, vector unsigned short __b) {
   5421 #ifdef __LITTLE_ENDIAN__
   5422   return (vector unsigned char)vec_perm(
   5423       __a, __b,
   5424       (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
   5425                              0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
   5426 #else
   5427   return (vector unsigned char)vec_perm(
   5428       __a, __b,
   5429       (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
   5430                              0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
   5431 #endif
   5432 }
   5433 
   5434 static __inline__ vector bool char __ATTRS_o_ai
   5435 vec_pack(vector bool short __a, vector bool short __b) {
   5436 #ifdef __LITTLE_ENDIAN__
   5437   return (vector bool char)vec_perm(
   5438       __a, __b,
   5439       (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
   5440                              0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
   5441 #else
   5442   return (vector bool char)vec_perm(
   5443       __a, __b,
   5444       (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
   5445                              0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
   5446 #endif
   5447 }
   5448 
   5449 static __inline__ vector short __ATTRS_o_ai vec_pack(vector int __a,
   5450                                                      vector int __b) {
   5451 #ifdef __LITTLE_ENDIAN__
   5452   return (vector short)vec_perm(
   5453       __a, __b,
   5454       (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
   5455                              0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
   5456 #else
   5457   return (vector short)vec_perm(
   5458       __a, __b,
   5459       (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
   5460                              0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
   5461 #endif
   5462 }
   5463 
   5464 static __inline__ vector unsigned short __ATTRS_o_ai
   5465 vec_pack(vector unsigned int __a, vector unsigned int __b) {
   5466 #ifdef __LITTLE_ENDIAN__
   5467   return (vector unsigned short)vec_perm(
   5468       __a, __b,
   5469       (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
   5470                              0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
   5471 #else
   5472   return (vector unsigned short)vec_perm(
   5473       __a, __b,
   5474       (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
   5475                              0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
   5476 #endif
   5477 }
   5478 
   5479 static __inline__ vector bool short __ATTRS_o_ai vec_pack(vector bool int __a,
   5480                                                           vector bool int __b) {
   5481 #ifdef __LITTLE_ENDIAN__
   5482   return (vector bool short)vec_perm(
   5483       __a, __b,
   5484       (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
   5485                              0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
   5486 #else
   5487   return (vector bool short)vec_perm(
   5488       __a, __b,
   5489       (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
   5490                              0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
   5491 #endif
   5492 }
   5493 
   5494 #ifdef __VSX__
   5495 static __inline__ vector signed int __ATTRS_o_ai
   5496 vec_pack(vector signed long long __a, vector signed long long __b) {
   5497 #ifdef __LITTLE_ENDIAN__
   5498   return (vector signed int)vec_perm(
   5499       __a, __b,
   5500       (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
   5501                              0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
   5502 #else
   5503   return (vector signed int)vec_perm(
   5504       __a, __b,
   5505       (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
   5506                              0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
   5507 #endif
   5508 }
   5509 static __inline__ vector unsigned int __ATTRS_o_ai
   5510 vec_pack(vector unsigned long long __a, vector unsigned long long __b) {
   5511 #ifdef __LITTLE_ENDIAN__
   5512   return (vector unsigned int)vec_perm(
   5513       __a, __b,
   5514       (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
   5515                              0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
   5516 #else
   5517   return (vector unsigned int)vec_perm(
   5518       __a, __b,
   5519       (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
   5520                              0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
   5521 #endif
   5522 }
   5523 
   5524 static __inline__ vector bool int __ATTRS_o_ai
   5525 vec_pack(vector bool long long __a, vector bool long long __b) {
   5526 #ifdef __LITTLE_ENDIAN__
   5527   return (vector bool int)vec_perm(
   5528       __a, __b,
   5529       (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
   5530                              0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
   5531 #else
   5532   return (vector bool int)vec_perm(
   5533       __a, __b,
   5534       (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
   5535                              0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
   5536 #endif
   5537 }
   5538 
   5539 #endif
   5540 
   5541 /* vec_vpkuhum */
   5542 
   5543 #define __builtin_altivec_vpkuhum vec_vpkuhum
   5544 
   5545 static __inline__ vector signed char __ATTRS_o_ai
   5546 vec_vpkuhum(vector signed short __a, vector signed short __b) {
   5547 #ifdef __LITTLE_ENDIAN__
   5548   return (vector signed char)vec_perm(
   5549       __a, __b,
   5550       (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
   5551                              0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
   5552 #else
   5553   return (vector signed char)vec_perm(
   5554       __a, __b,
   5555       (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
   5556                              0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
   5557 #endif
   5558 }
   5559 
   5560 static __inline__ vector unsigned char __ATTRS_o_ai
   5561 vec_vpkuhum(vector unsigned short __a, vector unsigned short __b) {
   5562 #ifdef __LITTLE_ENDIAN__
   5563   return (vector unsigned char)vec_perm(
   5564       __a, __b,
   5565       (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
   5566                              0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
   5567 #else
   5568   return (vector unsigned char)vec_perm(
   5569       __a, __b,
   5570       (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
   5571                              0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
   5572 #endif
   5573 }
   5574 
   5575 static __inline__ vector bool char __ATTRS_o_ai
   5576 vec_vpkuhum(vector bool short __a, vector bool short __b) {
   5577 #ifdef __LITTLE_ENDIAN__
   5578   return (vector bool char)vec_perm(
   5579       __a, __b,
   5580       (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
   5581                              0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
   5582 #else
   5583   return (vector bool char)vec_perm(
   5584       __a, __b,
   5585       (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
   5586                              0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
   5587 #endif
   5588 }
   5589 
   5590 /* vec_vpkuwum */
   5591 
   5592 #define __builtin_altivec_vpkuwum vec_vpkuwum
   5593 
   5594 static __inline__ vector short __ATTRS_o_ai vec_vpkuwum(vector int __a,
   5595                                                         vector int __b) {
   5596 #ifdef __LITTLE_ENDIAN__
   5597   return (vector short)vec_perm(
   5598       __a, __b,
   5599       (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
   5600                              0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
   5601 #else
   5602   return (vector short)vec_perm(
   5603       __a, __b,
   5604       (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
   5605                              0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
   5606 #endif
   5607 }
   5608 
   5609 static __inline__ vector unsigned short __ATTRS_o_ai
   5610 vec_vpkuwum(vector unsigned int __a, vector unsigned int __b) {
   5611 #ifdef __LITTLE_ENDIAN__
   5612   return (vector unsigned short)vec_perm(
   5613       __a, __b,
   5614       (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
   5615                              0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
   5616 #else
   5617   return (vector unsigned short)vec_perm(
   5618       __a, __b,
   5619       (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
   5620                              0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
   5621 #endif
   5622 }
   5623 
   5624 static __inline__ vector bool short __ATTRS_o_ai
   5625 vec_vpkuwum(vector bool int __a, vector bool int __b) {
   5626 #ifdef __LITTLE_ENDIAN__
   5627   return (vector bool short)vec_perm(
   5628       __a, __b,
   5629       (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
   5630                              0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
   5631 #else
   5632   return (vector bool short)vec_perm(
   5633       __a, __b,
   5634       (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
   5635                              0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
   5636 #endif
   5637 }
   5638 
   5639 /* vec_vpkudum */
   5640 
   5641 #ifdef __POWER8_VECTOR__
   5642 #define __builtin_altivec_vpkudum vec_vpkudum
   5643 
   5644 static __inline__ vector int __ATTRS_o_ai vec_vpkudum(vector long long __a,
   5645                                                       vector long long __b) {
   5646 #ifdef __LITTLE_ENDIAN__
   5647   return (vector int)vec_perm(
   5648       __a, __b,
   5649       (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
   5650                              0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
   5651 #else
   5652   return (vector int)vec_perm(
   5653       __a, __b,
   5654       (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
   5655                              0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
   5656 #endif
   5657 }
   5658 
   5659 static __inline__ vector unsigned int __ATTRS_o_ai
   5660 vec_vpkudum(vector unsigned long long __a, vector unsigned long long __b) {
   5661 #ifdef __LITTLE_ENDIAN__
   5662   return (vector unsigned int)vec_perm(
   5663       __a, __b,
   5664       (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
   5665                              0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
   5666 #else
   5667   return (vector unsigned int)vec_perm(
   5668       __a, __b,
   5669       (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
   5670                              0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
   5671 #endif
   5672 }
   5673 
   5674 static __inline__ vector bool int __ATTRS_o_ai
   5675 vec_vpkudum(vector bool long long __a, vector bool long long __b) {
   5676 #ifdef __LITTLE_ENDIAN__
   5677   return (vector bool int)vec_perm(
   5678       (vector long long)__a, (vector long long)__b,
   5679       (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
   5680                              0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
   5681 #else
   5682   return (vector bool int)vec_perm(
   5683       (vector long long)__a, (vector long long)__b,
   5684       (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
   5685                              0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
   5686 #endif
   5687 }
   5688 #endif
   5689 
   5690 /* vec_packpx */
   5691 
   5692 static __inline__ vector pixel __attribute__((__always_inline__))
   5693 vec_packpx(vector unsigned int __a, vector unsigned int __b) {
   5694 #ifdef __LITTLE_ENDIAN__
   5695   return (vector pixel)__builtin_altivec_vpkpx(__b, __a);
   5696 #else
   5697   return (vector pixel)__builtin_altivec_vpkpx(__a, __b);
   5698 #endif
   5699 }
   5700 
   5701 /* vec_vpkpx */
   5702 
   5703 static __inline__ vector pixel __attribute__((__always_inline__))
   5704 vec_vpkpx(vector unsigned int __a, vector unsigned int __b) {
   5705 #ifdef __LITTLE_ENDIAN__
   5706   return (vector pixel)__builtin_altivec_vpkpx(__b, __a);
   5707 #else
   5708   return (vector pixel)__builtin_altivec_vpkpx(__a, __b);
   5709 #endif
   5710 }
   5711 
   5712 /* vec_packs */
   5713 
   5714 static __inline__ vector signed char __ATTRS_o_ai vec_packs(vector short __a,
   5715                                                             vector short __b) {
   5716 #ifdef __LITTLE_ENDIAN__
   5717   return __builtin_altivec_vpkshss(__b, __a);
   5718 #else
   5719   return __builtin_altivec_vpkshss(__a, __b);
   5720 #endif
   5721 }
   5722 
   5723 static __inline__ vector unsigned char __ATTRS_o_ai
   5724 vec_packs(vector unsigned short __a, vector unsigned short __b) {
   5725 #ifdef __LITTLE_ENDIAN__
   5726   return __builtin_altivec_vpkuhus(__b, __a);
   5727 #else
   5728   return __builtin_altivec_vpkuhus(__a, __b);
   5729 #endif
   5730 }
   5731 
   5732 static __inline__ vector signed short __ATTRS_o_ai vec_packs(vector int __a,
   5733                                                              vector int __b) {
   5734 #ifdef __LITTLE_ENDIAN__
   5735   return __builtin_altivec_vpkswss(__b, __a);
   5736 #else
   5737   return __builtin_altivec_vpkswss(__a, __b);
   5738 #endif
   5739 }
   5740 
   5741 static __inline__ vector unsigned short __ATTRS_o_ai
   5742 vec_packs(vector unsigned int __a, vector unsigned int __b) {
   5743 #ifdef __LITTLE_ENDIAN__
   5744   return __builtin_altivec_vpkuwus(__b, __a);
   5745 #else
   5746   return __builtin_altivec_vpkuwus(__a, __b);
   5747 #endif
   5748 }
   5749 
   5750 #ifdef __POWER8_VECTOR__
   5751 static __inline__ vector int __ATTRS_o_ai vec_packs(vector long long __a,
   5752                                                     vector long long __b) {
   5753 #ifdef __LITTLE_ENDIAN__
   5754   return __builtin_altivec_vpksdss(__b, __a);
   5755 #else
   5756   return __builtin_altivec_vpksdss(__a, __b);
   5757 #endif
   5758 }
   5759 
   5760 static __inline__ vector unsigned int __ATTRS_o_ai
   5761 vec_packs(vector unsigned long long __a, vector unsigned long long __b) {
   5762 #ifdef __LITTLE_ENDIAN__
   5763   return __builtin_altivec_vpkudus(__b, __a);
   5764 #else
   5765   return __builtin_altivec_vpkudus(__a, __b);
   5766 #endif
   5767 }
   5768 #endif
   5769 
   5770 /* vec_vpkshss */
   5771 
   5772 static __inline__ vector signed char __attribute__((__always_inline__))
   5773 vec_vpkshss(vector short __a, vector short __b) {
   5774 #ifdef __LITTLE_ENDIAN__
   5775   return __builtin_altivec_vpkshss(__b, __a);
   5776 #else
   5777   return __builtin_altivec_vpkshss(__a, __b);
   5778 #endif
   5779 }
   5780 
   5781 /* vec_vpksdss */
   5782 
   5783 #ifdef __POWER8_VECTOR__
   5784 static __inline__ vector int __ATTRS_o_ai vec_vpksdss(vector long long __a,
   5785                                                       vector long long __b) {
   5786 #ifdef __LITTLE_ENDIAN__
   5787   return __builtin_altivec_vpksdss(__b, __a);
   5788 #else
   5789   return __builtin_altivec_vpksdss(__a, __b);
   5790 #endif
   5791 }
   5792 #endif
   5793 
   5794 /* vec_vpkuhus */
   5795 
   5796 static __inline__ vector unsigned char __attribute__((__always_inline__))
   5797 vec_vpkuhus(vector unsigned short __a, vector unsigned short __b) {
   5798 #ifdef __LITTLE_ENDIAN__
   5799   return __builtin_altivec_vpkuhus(__b, __a);
   5800 #else
   5801   return __builtin_altivec_vpkuhus(__a, __b);
   5802 #endif
   5803 }
   5804 
   5805 /* vec_vpkudus */
   5806 
   5807 #ifdef __POWER8_VECTOR__
   5808 static __inline__ vector unsigned int __attribute__((__always_inline__))
   5809 vec_vpkudus(vector unsigned long long __a, vector unsigned long long __b) {
   5810 #ifdef __LITTLE_ENDIAN__
   5811   return __builtin_altivec_vpkudus(__b, __a);
   5812 #else
   5813   return __builtin_altivec_vpkudus(__a, __b);
   5814 #endif
   5815 }
   5816 #endif
   5817 
   5818 /* vec_vpkswss */
   5819 
   5820 static __inline__ vector signed short __attribute__((__always_inline__))
   5821 vec_vpkswss(vector int __a, vector int __b) {
   5822 #ifdef __LITTLE_ENDIAN__
   5823   return __builtin_altivec_vpkswss(__b, __a);
   5824 #else
   5825   return __builtin_altivec_vpkswss(__a, __b);
   5826 #endif
   5827 }
   5828 
   5829 /* vec_vpkuwus */
   5830 
   5831 static __inline__ vector unsigned short __attribute__((__always_inline__))
   5832 vec_vpkuwus(vector unsigned int __a, vector unsigned int __b) {
   5833 #ifdef __LITTLE_ENDIAN__
   5834   return __builtin_altivec_vpkuwus(__b, __a);
   5835 #else
   5836   return __builtin_altivec_vpkuwus(__a, __b);
   5837 #endif
   5838 }
   5839 
   5840 /* vec_packsu */
   5841 
   5842 static __inline__ vector unsigned char __ATTRS_o_ai
   5843 vec_packsu(vector short __a, vector short __b) {
   5844 #ifdef __LITTLE_ENDIAN__
   5845   return __builtin_altivec_vpkshus(__b, __a);
   5846 #else
   5847   return __builtin_altivec_vpkshus(__a, __b);
   5848 #endif
   5849 }
   5850 
   5851 static __inline__ vector unsigned char __ATTRS_o_ai
   5852 vec_packsu(vector unsigned short __a, vector unsigned short __b) {
   5853 #ifdef __LITTLE_ENDIAN__
   5854   return __builtin_altivec_vpkuhus(__b, __a);
   5855 #else
   5856   return __builtin_altivec_vpkuhus(__a, __b);
   5857 #endif
   5858 }
   5859 
   5860 static __inline__ vector unsigned short __ATTRS_o_ai
   5861 vec_packsu(vector int __a, vector int __b) {
   5862 #ifdef __LITTLE_ENDIAN__
   5863   return __builtin_altivec_vpkswus(__b, __a);
   5864 #else
   5865   return __builtin_altivec_vpkswus(__a, __b);
   5866 #endif
   5867 }
   5868 
   5869 static __inline__ vector unsigned short __ATTRS_o_ai
   5870 vec_packsu(vector unsigned int __a, vector unsigned int __b) {
   5871 #ifdef __LITTLE_ENDIAN__
   5872   return __builtin_altivec_vpkuwus(__b, __a);
   5873 #else
   5874   return __builtin_altivec_vpkuwus(__a, __b);
   5875 #endif
   5876 }
   5877 
   5878 #ifdef __POWER8_VECTOR__
   5879 static __inline__ vector unsigned int __ATTRS_o_ai
   5880 vec_packsu(vector long long __a, vector long long __b) {
   5881 #ifdef __LITTLE_ENDIAN__
   5882   return __builtin_altivec_vpksdus(__b, __a);
   5883 #else
   5884   return __builtin_altivec_vpksdus(__a, __b);
   5885 #endif
   5886 }
   5887 
   5888 static __inline__ vector unsigned int __ATTRS_o_ai
   5889 vec_packsu(vector unsigned long long __a, vector unsigned long long __b) {
   5890 #ifdef __LITTLE_ENDIAN__
   5891   return __builtin_altivec_vpkudus(__b, __a);
   5892 #else
   5893   return __builtin_altivec_vpkudus(__a, __b);
   5894 #endif
   5895 }
   5896 #endif
   5897 
   5898 /* vec_vpkshus */
   5899 
   5900 static __inline__ vector unsigned char __ATTRS_o_ai
   5901 vec_vpkshus(vector short __a, vector short __b) {
   5902 #ifdef __LITTLE_ENDIAN__
   5903   return __builtin_altivec_vpkshus(__b, __a);
   5904 #else
   5905   return __builtin_altivec_vpkshus(__a, __b);
   5906 #endif
   5907 }
   5908 
   5909 static __inline__ vector unsigned char __ATTRS_o_ai
   5910 vec_vpkshus(vector unsigned short __a, vector unsigned short __b) {
   5911 #ifdef __LITTLE_ENDIAN__
   5912   return __builtin_altivec_vpkuhus(__b, __a);
   5913 #else
   5914   return __builtin_altivec_vpkuhus(__a, __b);
   5915 #endif
   5916 }
   5917 
   5918 /* vec_vpkswus */
   5919 
   5920 static __inline__ vector unsigned short __ATTRS_o_ai
   5921 vec_vpkswus(vector int __a, vector int __b) {
   5922 #ifdef __LITTLE_ENDIAN__
   5923   return __builtin_altivec_vpkswus(__b, __a);
   5924 #else
   5925   return __builtin_altivec_vpkswus(__a, __b);
   5926 #endif
   5927 }
   5928 
   5929 static __inline__ vector unsigned short __ATTRS_o_ai
   5930 vec_vpkswus(vector unsigned int __a, vector unsigned int __b) {
   5931 #ifdef __LITTLE_ENDIAN__
   5932   return __builtin_altivec_vpkuwus(__b, __a);
   5933 #else
   5934   return __builtin_altivec_vpkuwus(__a, __b);
   5935 #endif
   5936 }
   5937 
   5938 /* vec_vpksdus */
   5939 
   5940 #ifdef __POWER8_VECTOR__
   5941 static __inline__ vector unsigned int __ATTRS_o_ai
   5942 vec_vpksdus(vector long long __a, vector long long __b) {
   5943 #ifdef __LITTLE_ENDIAN__
   5944   return __builtin_altivec_vpksdus(__b, __a);
   5945 #else
   5946   return __builtin_altivec_vpksdus(__a, __b);
   5947 #endif
   5948 }
   5949 #endif
   5950 
   5951 /* vec_perm */
   5952 
   5953 // The vperm instruction is defined architecturally with a big-endian bias.
   5954 // For little endian, we swap the input operands and invert the permute
   5955 // control vector.  Only the rightmost 5 bits matter, so we could use
   5956 // a vector of all 31s instead of all 255s to perform the inversion.
   5957 // However, when the PCV is not a constant, using 255 has an advantage
   5958 // in that the vec_xor can be recognized as a vec_nor (and for P8 and
   5959 // later, possibly a vec_nand).
   5960 
   5961 static __inline__ vector signed char __ATTRS_o_ai vec_perm(
   5962     vector signed char __a, vector signed char __b, vector unsigned char __c) {
   5963 #ifdef __LITTLE_ENDIAN__
   5964   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
   5965                               255, 255, 255, 255, 255, 255, 255, 255};
   5966   __d = vec_xor(__c, __d);
   5967   return (vector signed char)__builtin_altivec_vperm_4si((vector int)__b,
   5968                                                          (vector int)__a, __d);
   5969 #else
   5970   return (vector signed char)__builtin_altivec_vperm_4si((vector int)__a,
   5971                                                          (vector int)__b, __c);
   5972 #endif
   5973 }
   5974 
   5975 static __inline__ vector unsigned char __ATTRS_o_ai
   5976 vec_perm(vector unsigned char __a, vector unsigned char __b,
   5977          vector unsigned char __c) {
   5978 #ifdef __LITTLE_ENDIAN__
   5979   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
   5980                               255, 255, 255, 255, 255, 255, 255, 255};
   5981   __d = vec_xor(__c, __d);
   5982   return (vector unsigned char)__builtin_altivec_vperm_4si(
   5983       (vector int)__b, (vector int)__a, __d);
   5984 #else
   5985   return (vector unsigned char)__builtin_altivec_vperm_4si(
   5986       (vector int)__a, (vector int)__b, __c);
   5987 #endif
   5988 }
   5989 
   5990 static __inline__ vector bool char __ATTRS_o_ai
   5991 vec_perm(vector bool char __a, vector bool char __b, vector unsigned char __c) {
   5992 #ifdef __LITTLE_ENDIAN__
   5993   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
   5994                               255, 255, 255, 255, 255, 255, 255, 255};
   5995   __d = vec_xor(__c, __d);
   5996   return (vector bool char)__builtin_altivec_vperm_4si((vector int)__b,
   5997                                                        (vector int)__a, __d);
   5998 #else
   5999   return (vector bool char)__builtin_altivec_vperm_4si((vector int)__a,
   6000                                                        (vector int)__b, __c);
   6001 #endif
   6002 }
   6003 
   6004 static __inline__ vector short __ATTRS_o_ai vec_perm(vector signed short __a,
   6005                                                      vector signed short __b,
   6006                                                      vector unsigned char __c) {
   6007 #ifdef __LITTLE_ENDIAN__
   6008   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
   6009                               255, 255, 255, 255, 255, 255, 255, 255};
   6010   __d = vec_xor(__c, __d);
   6011   return (vector signed short)__builtin_altivec_vperm_4si((vector int)__b,
   6012                                                           (vector int)__a, __d);
   6013 #else
   6014   return (vector signed short)__builtin_altivec_vperm_4si((vector int)__a,
   6015                                                           (vector int)__b, __c);
   6016 #endif
   6017 }
   6018 
   6019 static __inline__ vector unsigned short __ATTRS_o_ai
   6020 vec_perm(vector unsigned short __a, vector unsigned short __b,
   6021          vector unsigned char __c) {
   6022 #ifdef __LITTLE_ENDIAN__
   6023   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
   6024                               255, 255, 255, 255, 255, 255, 255, 255};
   6025   __d = vec_xor(__c, __d);
   6026   return (vector unsigned short)__builtin_altivec_vperm_4si(
   6027       (vector int)__b, (vector int)__a, __d);
   6028 #else
   6029   return (vector unsigned short)__builtin_altivec_vperm_4si(
   6030       (vector int)__a, (vector int)__b, __c);
   6031 #endif
   6032 }
   6033 
   6034 static __inline__ vector bool short __ATTRS_o_ai vec_perm(
   6035     vector bool short __a, vector bool short __b, vector unsigned char __c) {
   6036 #ifdef __LITTLE_ENDIAN__
   6037   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
   6038                               255, 255, 255, 255, 255, 255, 255, 255};
   6039   __d = vec_xor(__c, __d);
   6040   return (vector bool short)__builtin_altivec_vperm_4si((vector int)__b,
   6041                                                         (vector int)__a, __d);
   6042 #else
   6043   return (vector bool short)__builtin_altivec_vperm_4si((vector int)__a,
   6044                                                         (vector int)__b, __c);
   6045 #endif
   6046 }
   6047 
   6048 static __inline__ vector pixel __ATTRS_o_ai vec_perm(vector pixel __a,
   6049                                                      vector pixel __b,
   6050                                                      vector unsigned char __c) {
   6051 #ifdef __LITTLE_ENDIAN__
   6052   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
   6053                               255, 255, 255, 255, 255, 255, 255, 255};
   6054   __d = vec_xor(__c, __d);
   6055   return (vector pixel)__builtin_altivec_vperm_4si((vector int)__b,
   6056                                                    (vector int)__a, __d);
   6057 #else
   6058   return (vector pixel)__builtin_altivec_vperm_4si((vector int)__a,
   6059                                                    (vector int)__b, __c);
   6060 #endif
   6061 }
   6062 
   6063 static __inline__ vector int __ATTRS_o_ai vec_perm(vector signed int __a,
   6064                                                    vector signed int __b,
   6065                                                    vector unsigned char __c) {
   6066 #ifdef __LITTLE_ENDIAN__
   6067   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
   6068                               255, 255, 255, 255, 255, 255, 255, 255};
   6069   __d = vec_xor(__c, __d);
   6070   return (vector signed int)__builtin_altivec_vperm_4si(__b, __a, __d);
   6071 #else
   6072   return (vector signed int)__builtin_altivec_vperm_4si(__a, __b, __c);
   6073 #endif
   6074 }
   6075 
   6076 static __inline__ vector unsigned int __ATTRS_o_ai
   6077 vec_perm(vector unsigned int __a, vector unsigned int __b,
   6078          vector unsigned char __c) {
   6079 #ifdef __LITTLE_ENDIAN__
   6080   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
   6081                               255, 255, 255, 255, 255, 255, 255, 255};
   6082   __d = vec_xor(__c, __d);
   6083   return (vector unsigned int)__builtin_altivec_vperm_4si((vector int)__b,
   6084                                                           (vector int)__a, __d);
   6085 #else
   6086   return (vector unsigned int)__builtin_altivec_vperm_4si((vector int)__a,
   6087                                                           (vector int)__b, __c);
   6088 #endif
   6089 }
   6090 
   6091 static __inline__ vector bool int __ATTRS_o_ai
   6092 vec_perm(vector bool int __a, vector bool int __b, vector unsigned char __c) {
   6093 #ifdef __LITTLE_ENDIAN__
   6094   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
   6095                               255, 255, 255, 255, 255, 255, 255, 255};
   6096   __d = vec_xor(__c, __d);
   6097   return (vector bool int)__builtin_altivec_vperm_4si((vector int)__b,
   6098                                                       (vector int)__a, __d);
   6099 #else
   6100   return (vector bool int)__builtin_altivec_vperm_4si((vector int)__a,
   6101                                                       (vector int)__b, __c);
   6102 #endif
   6103 }
   6104 
   6105 static __inline__ vector float __ATTRS_o_ai vec_perm(vector float __a,
   6106                                                      vector float __b,
   6107                                                      vector unsigned char __c) {
   6108 #ifdef __LITTLE_ENDIAN__
   6109   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
   6110                               255, 255, 255, 255, 255, 255, 255, 255};
   6111   __d = vec_xor(__c, __d);
   6112   return (vector float)__builtin_altivec_vperm_4si((vector int)__b,
   6113                                                    (vector int)__a, __d);
   6114 #else
   6115   return (vector float)__builtin_altivec_vperm_4si((vector int)__a,
   6116                                                    (vector int)__b, __c);
   6117 #endif
   6118 }
   6119 
   6120 #ifdef __VSX__
   6121 static __inline__ vector long long __ATTRS_o_ai
   6122 vec_perm(vector signed long long __a, vector signed long long __b,
   6123          vector unsigned char __c) {
   6124 #ifdef __LITTLE_ENDIAN__
   6125   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
   6126                               255, 255, 255, 255, 255, 255, 255, 255};
   6127   __d = vec_xor(__c, __d);
   6128   return (vector signed long long)__builtin_altivec_vperm_4si(
   6129       (vector int)__b, (vector int)__a, __d);
   6130 #else
   6131   return (vector signed long long)__builtin_altivec_vperm_4si(
   6132       (vector int)__a, (vector int)__b, __c);
   6133 #endif
   6134 }
   6135 
   6136 static __inline__ vector unsigned long long __ATTRS_o_ai
   6137 vec_perm(vector unsigned long long __a, vector unsigned long long __b,
   6138          vector unsigned char __c) {
   6139 #ifdef __LITTLE_ENDIAN__
   6140   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
   6141                               255, 255, 255, 255, 255, 255, 255, 255};
   6142   __d = vec_xor(__c, __d);
   6143   return (vector unsigned long long)__builtin_altivec_vperm_4si(
   6144       (vector int)__b, (vector int)__a, __d);
   6145 #else
   6146   return (vector unsigned long long)__builtin_altivec_vperm_4si(
   6147       (vector int)__a, (vector int)__b, __c);
   6148 #endif
   6149 }
   6150 
   6151 static __inline__ vector bool long long __ATTRS_o_ai
   6152 vec_perm(vector bool long long __a, vector bool long long __b,
   6153          vector unsigned char __c) {
   6154 #ifdef __LITTLE_ENDIAN__
   6155   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
   6156                               255, 255, 255, 255, 255, 255, 255, 255};
   6157   __d = vec_xor(__c, __d);
   6158   return (vector bool long long)__builtin_altivec_vperm_4si(
   6159       (vector int)__b, (vector int)__a, __d);
   6160 #else
   6161   return (vector bool long long)__builtin_altivec_vperm_4si(
   6162       (vector int)__a, (vector int)__b, __c);
   6163 #endif
   6164 }
   6165 
   6166 static __inline__ vector double __ATTRS_o_ai
   6167 vec_perm(vector double __a, vector double __b, vector unsigned char __c) {
   6168 #ifdef __LITTLE_ENDIAN__
   6169   vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
   6170                               255, 255, 255, 255, 255, 255, 255, 255};
   6171   __d = vec_xor(__c, __d);
   6172   return (vector double)__builtin_altivec_vperm_4si((vector int)__b,
   6173                                                     (vector int)__a, __d);
   6174 #else
   6175   return (vector double)__builtin_altivec_vperm_4si((vector int)__a,
   6176                                                     (vector int)__b, __c);
   6177 #endif
   6178 }
   6179 #endif
   6180 
   6181 /* vec_vperm */
   6182 
   6183 static __inline__ vector signed char __ATTRS_o_ai vec_vperm(
   6184     vector signed char __a, vector signed char __b, vector unsigned char __c) {
   6185   return vec_perm(__a, __b, __c);
   6186 }
   6187 
   6188 static __inline__ vector unsigned char __ATTRS_o_ai
   6189 vec_vperm(vector unsigned char __a, vector unsigned char __b,
   6190           vector unsigned char __c) {
   6191   return vec_perm(__a, __b, __c);
   6192 }
   6193 
   6194 static __inline__ vector bool char __ATTRS_o_ai vec_vperm(
   6195     vector bool char __a, vector bool char __b, vector unsigned char __c) {
   6196   return vec_perm(__a, __b, __c);
   6197 }
   6198 
   6199 static __inline__ vector short __ATTRS_o_ai
   6200 vec_vperm(vector short __a, vector short __b, vector unsigned char __c) {
   6201   return vec_perm(__a, __b, __c);
   6202 }
   6203 
   6204 static __inline__ vector unsigned short __ATTRS_o_ai
   6205 vec_vperm(vector unsigned short __a, vector unsigned short __b,
   6206           vector unsigned char __c) {
   6207   return vec_perm(__a, __b, __c);
   6208 }
   6209 
   6210 static __inline__ vector bool short __ATTRS_o_ai vec_vperm(
   6211     vector bool short __a, vector bool short __b, vector unsigned char __c) {
   6212   return vec_perm(__a, __b, __c);
   6213 }
   6214 
   6215 static __inline__ vector pixel __ATTRS_o_ai
   6216 vec_vperm(vector pixel __a, vector pixel __b, vector unsigned char __c) {
   6217   return vec_perm(__a, __b, __c);
   6218 }
   6219 
   6220 static __inline__ vector int __ATTRS_o_ai vec_vperm(vector int __a,
   6221                                                     vector int __b,
   6222                                                     vector unsigned char __c) {
   6223   return vec_perm(__a, __b, __c);
   6224 }
   6225 
   6226 static __inline__ vector unsigned int __ATTRS_o_ai
   6227 vec_vperm(vector unsigned int __a, vector unsigned int __b,
   6228           vector unsigned char __c) {
   6229   return vec_perm(__a, __b, __c);
   6230 }
   6231 
   6232 static __inline__ vector bool int __ATTRS_o_ai
   6233 vec_vperm(vector bool int __a, vector bool int __b, vector unsigned char __c) {
   6234   return vec_perm(__a, __b, __c);
   6235 }
   6236 
   6237 static __inline__ vector float __ATTRS_o_ai
   6238 vec_vperm(vector float __a, vector float __b, vector unsigned char __c) {
   6239   return vec_perm(__a, __b, __c);
   6240 }
   6241 
   6242 #ifdef __VSX__
   6243 static __inline__ vector long long __ATTRS_o_ai vec_vperm(
   6244     vector long long __a, vector long long __b, vector unsigned char __c) {
   6245   return vec_perm(__a, __b, __c);
   6246 }
   6247 
   6248 static __inline__ vector unsigned long long __ATTRS_o_ai
   6249 vec_vperm(vector unsigned long long __a, vector unsigned long long __b,
   6250           vector unsigned char __c) {
   6251   return vec_perm(__a, __b, __c);
   6252 }
   6253 
   6254 static __inline__ vector double __ATTRS_o_ai
   6255 vec_vperm(vector double __a, vector double __b, vector unsigned char __c) {
   6256   return vec_perm(__a, __b, __c);
   6257 }
   6258 #endif
   6259 
   6260 /* vec_re */
   6261 
   6262 static __inline__ vector float __ATTRS_o_ai vec_re(vector float __a) {
   6263 #ifdef __VSX__
   6264   return __builtin_vsx_xvresp(__a);
   6265 #else
   6266   return __builtin_altivec_vrefp(__a);
   6267 #endif
   6268 }
   6269 
   6270 #ifdef __VSX__
   6271 static __inline__ vector double __ATTRS_o_ai vec_re(vector double __a) {
   6272   return __builtin_vsx_xvredp(__a);
   6273 }
   6274 #endif
   6275 
   6276 /* vec_vrefp */
   6277 
   6278 static __inline__ vector float __attribute__((__always_inline__))
   6279 vec_vrefp(vector float __a) {
   6280   return __builtin_altivec_vrefp(__a);
   6281 }
   6282 
   6283 /* vec_rl */
   6284 
   6285 static __inline__ vector signed char __ATTRS_o_ai
   6286 vec_rl(vector signed char __a, vector unsigned char __b) {
   6287   return (vector signed char)__builtin_altivec_vrlb((vector char)__a, __b);
   6288 }
   6289 
   6290 static __inline__ vector unsigned char __ATTRS_o_ai
   6291 vec_rl(vector unsigned char __a, vector unsigned char __b) {
   6292   return (vector unsigned char)__builtin_altivec_vrlb((vector char)__a, __b);
   6293 }
   6294 
   6295 static __inline__ vector short __ATTRS_o_ai vec_rl(vector short __a,
   6296                                                    vector unsigned short __b) {
   6297   return __builtin_altivec_vrlh(__a, __b);
   6298 }
   6299 
   6300 static __inline__ vector unsigned short __ATTRS_o_ai
   6301 vec_rl(vector unsigned short __a, vector unsigned short __b) {
   6302   return (vector unsigned short)__builtin_altivec_vrlh((vector short)__a, __b);
   6303 }
   6304 
   6305 static __inline__ vector int __ATTRS_o_ai vec_rl(vector int __a,
   6306                                                  vector unsigned int __b) {
   6307   return __builtin_altivec_vrlw(__a, __b);
   6308 }
   6309 
   6310 static __inline__ vector unsigned int __ATTRS_o_ai
   6311 vec_rl(vector unsigned int __a, vector unsigned int __b) {
   6312   return (vector unsigned int)__builtin_altivec_vrlw((vector int)__a, __b);
   6313 }
   6314 
   6315 #ifdef __POWER8_VECTOR__
   6316 static __inline__ vector signed long long __ATTRS_o_ai
   6317 vec_rl(vector signed long long __a, vector unsigned long long __b) {
   6318   return __builtin_altivec_vrld(__a, __b);
   6319 }
   6320 
   6321 static __inline__ vector unsigned long long __ATTRS_o_ai
   6322 vec_rl(vector unsigned long long __a, vector unsigned long long __b) {
   6323   return __builtin_altivec_vrld(__a, __b);
   6324 }
   6325 #endif
   6326 
   6327 /* vec_vrlb */
   6328 
   6329 static __inline__ vector signed char __ATTRS_o_ai
   6330 vec_vrlb(vector signed char __a, vector unsigned char __b) {
   6331   return (vector signed char)__builtin_altivec_vrlb((vector char)__a, __b);
   6332 }
   6333 
   6334 static __inline__ vector unsigned char __ATTRS_o_ai
   6335 vec_vrlb(vector unsigned char __a, vector unsigned char __b) {
   6336   return (vector unsigned char)__builtin_altivec_vrlb((vector char)__a, __b);
   6337 }
   6338 
   6339 /* vec_vrlh */
   6340 
   6341 static __inline__ vector short __ATTRS_o_ai
   6342 vec_vrlh(vector short __a, vector unsigned short __b) {
   6343   return __builtin_altivec_vrlh(__a, __b);
   6344 }
   6345 
   6346 static __inline__ vector unsigned short __ATTRS_o_ai
   6347 vec_vrlh(vector unsigned short __a, vector unsigned short __b) {
   6348   return (vector unsigned short)__builtin_altivec_vrlh((vector short)__a, __b);
   6349 }
   6350 
   6351 /* vec_vrlw */
   6352 
   6353 static __inline__ vector int __ATTRS_o_ai vec_vrlw(vector int __a,
   6354                                                    vector unsigned int __b) {
   6355   return __builtin_altivec_vrlw(__a, __b);
   6356 }
   6357 
   6358 static __inline__ vector unsigned int __ATTRS_o_ai
   6359 vec_vrlw(vector unsigned int __a, vector unsigned int __b) {
   6360   return (vector unsigned int)__builtin_altivec_vrlw((vector int)__a, __b);
   6361 }
   6362 
   6363 /* vec_round */
   6364 
   6365 static __inline__ vector float __ATTRS_o_ai vec_round(vector float __a) {
   6366 #ifdef __VSX__
   6367   return __builtin_vsx_xvrspi(__a);
   6368 #else
   6369   return __builtin_altivec_vrfin(__a);
   6370 #endif
   6371 }
   6372 
   6373 #ifdef __VSX__
   6374 static __inline__ vector double __ATTRS_o_ai vec_round(vector double __a) {
   6375   return __builtin_vsx_xvrdpi(__a);
   6376 }
   6377 
   6378 /* vec_rint */
   6379 
   6380 static __inline__ vector float __ATTRS_o_ai vec_rint(vector float __a) {
   6381   return __builtin_vsx_xvrspic(__a);
   6382 }
   6383 
   6384 static __inline__ vector double __ATTRS_o_ai vec_rint(vector double __a) {
   6385   return __builtin_vsx_xvrdpic(__a);
   6386 }
   6387 
   6388 /* vec_nearbyint */
   6389 
   6390 static __inline__ vector float __ATTRS_o_ai vec_nearbyint(vector float __a) {
   6391   return __builtin_vsx_xvrspi(__a);
   6392 }
   6393 
   6394 static __inline__ vector double __ATTRS_o_ai vec_nearbyint(vector double __a) {
   6395   return __builtin_vsx_xvrdpi(__a);
   6396 }
   6397 #endif
   6398 
   6399 /* vec_vrfin */
   6400 
   6401 static __inline__ vector float __attribute__((__always_inline__))
   6402 vec_vrfin(vector float __a) {
   6403   return __builtin_altivec_vrfin(__a);
   6404 }
   6405 
   6406 /* vec_sqrt */
   6407 
   6408 #ifdef __VSX__
   6409 static __inline__ vector float __ATTRS_o_ai vec_sqrt(vector float __a) {
   6410   return __builtin_vsx_xvsqrtsp(__a);
   6411 }
   6412 
   6413 static __inline__ vector double __ATTRS_o_ai vec_sqrt(vector double __a) {
   6414   return __builtin_vsx_xvsqrtdp(__a);
   6415 }
   6416 #endif
   6417 
   6418 /* vec_rsqrte */
   6419 
   6420 static __inline__ vector float __ATTRS_o_ai vec_rsqrte(vector float __a) {
   6421 #ifdef __VSX__
   6422   return __builtin_vsx_xvrsqrtesp(__a);
   6423 #else
   6424   return __builtin_altivec_vrsqrtefp(__a);
   6425 #endif
   6426 }
   6427 
   6428 #ifdef __VSX__
   6429 static __inline__ vector double __ATTRS_o_ai vec_rsqrte(vector double __a) {
   6430   return __builtin_vsx_xvrsqrtedp(__a);
   6431 }
   6432 #endif
   6433 
   6434 /* vec_vrsqrtefp */
   6435 
   6436 static __inline__ __vector float __attribute__((__always_inline__))
   6437 vec_vrsqrtefp(vector float __a) {
   6438   return __builtin_altivec_vrsqrtefp(__a);
   6439 }
   6440 
   6441 /* vec_sel */
   6442 
   6443 #define __builtin_altivec_vsel_4si vec_sel
   6444 
   6445 static __inline__ vector signed char __ATTRS_o_ai vec_sel(
   6446     vector signed char __a, vector signed char __b, vector unsigned char __c) {
   6447   return (__a & ~(vector signed char)__c) | (__b & (vector signed char)__c);
   6448 }
   6449 
   6450 static __inline__ vector signed char __ATTRS_o_ai
   6451 vec_sel(vector signed char __a, vector signed char __b, vector bool char __c) {
   6452   return (__a & ~(vector signed char)__c) | (__b & (vector signed char)__c);
   6453 }
   6454 
   6455 static __inline__ vector unsigned char __ATTRS_o_ai
   6456 vec_sel(vector unsigned char __a, vector unsigned char __b,
   6457         vector unsigned char __c) {
   6458   return (__a & ~__c) | (__b & __c);
   6459 }
   6460 
   6461 static __inline__ vector unsigned char __ATTRS_o_ai vec_sel(
   6462     vector unsigned char __a, vector unsigned char __b, vector bool char __c) {
   6463   return (__a & ~(vector unsigned char)__c) | (__b & (vector unsigned char)__c);
   6464 }
   6465 
   6466 static __inline__ vector bool char __ATTRS_o_ai
   6467 vec_sel(vector bool char __a, vector bool char __b, vector unsigned char __c) {
   6468   return (__a & ~(vector bool char)__c) | (__b & (vector bool char)__c);
   6469 }
   6470 
   6471 static __inline__ vector bool char __ATTRS_o_ai vec_sel(vector bool char __a,
   6472                                                         vector bool char __b,
   6473                                                         vector bool char __c) {
   6474   return (__a & ~__c) | (__b & __c);
   6475 }
   6476 
   6477 static __inline__ vector short __ATTRS_o_ai vec_sel(vector short __a,
   6478                                                     vector short __b,
   6479                                                     vector unsigned short __c) {
   6480   return (__a & ~(vector short)__c) | (__b & (vector short)__c);
   6481 }
   6482 
   6483 static __inline__ vector short __ATTRS_o_ai vec_sel(vector short __a,
   6484                                                     vector short __b,
   6485                                                     vector bool short __c) {
   6486   return (__a & ~(vector short)__c) | (__b & (vector short)__c);
   6487 }
   6488 
   6489 static __inline__ vector unsigned short __ATTRS_o_ai
   6490 vec_sel(vector unsigned short __a, vector unsigned short __b,
   6491         vector unsigned short __c) {
   6492   return (__a & ~__c) | (__b & __c);
   6493 }
   6494 
   6495 static __inline__ vector unsigned short __ATTRS_o_ai
   6496 vec_sel(vector unsigned short __a, vector unsigned short __b,
   6497         vector bool short __c) {
   6498   return (__a & ~(vector unsigned short)__c) |
   6499          (__b & (vector unsigned short)__c);
   6500 }
   6501 
   6502 static __inline__ vector bool short __ATTRS_o_ai vec_sel(
   6503     vector bool short __a, vector bool short __b, vector unsigned short __c) {
   6504   return (__a & ~(vector bool short)__c) | (__b & (vector bool short)__c);
   6505 }
   6506 
   6507 static __inline__ vector bool short __ATTRS_o_ai
   6508 vec_sel(vector bool short __a, vector bool short __b, vector bool short __c) {
   6509   return (__a & ~__c) | (__b & __c);
   6510 }
   6511 
   6512 static __inline__ vector int __ATTRS_o_ai vec_sel(vector int __a,
   6513                                                   vector int __b,
   6514                                                   vector unsigned int __c) {
   6515   return (__a & ~(vector int)__c) | (__b & (vector int)__c);
   6516 }
   6517 
   6518 static __inline__ vector int __ATTRS_o_ai vec_sel(vector int __a,
   6519                                                   vector int __b,
   6520                                                   vector bool int __c) {
   6521   return (__a & ~(vector int)__c) | (__b & (vector int)__c);
   6522 }
   6523 
   6524 static __inline__ vector unsigned int __ATTRS_o_ai vec_sel(
   6525     vector unsigned int __a, vector unsigned int __b, vector unsigned int __c) {
   6526   return (__a & ~__c) | (__b & __c);
   6527 }
   6528 
   6529 static __inline__ vector unsigned int __ATTRS_o_ai
   6530 vec_sel(vector unsigned int __a, vector unsigned int __b, vector bool int __c) {
   6531   return (__a & ~(vector unsigned int)__c) | (__b & (vector unsigned int)__c);
   6532 }
   6533 
   6534 static __inline__ vector bool int __ATTRS_o_ai
   6535 vec_sel(vector bool int __a, vector bool int __b, vector unsigned int __c) {
   6536   return (__a & ~(vector bool int)__c) | (__b & (vector bool int)__c);
   6537 }
   6538 
   6539 static __inline__ vector bool int __ATTRS_o_ai vec_sel(vector bool int __a,
   6540                                                        vector bool int __b,
   6541                                                        vector bool int __c) {
   6542   return (__a & ~__c) | (__b & __c);
   6543 }
   6544 
   6545 static __inline__ vector float __ATTRS_o_ai vec_sel(vector float __a,
   6546                                                     vector float __b,
   6547                                                     vector unsigned int __c) {
   6548   vector int __res = ((vector int)__a & ~(vector int)__c) |
   6549                      ((vector int)__b & (vector int)__c);
   6550   return (vector float)__res;
   6551 }
   6552 
   6553 static __inline__ vector float __ATTRS_o_ai vec_sel(vector float __a,
   6554                                                     vector float __b,
   6555                                                     vector bool int __c) {
   6556   vector int __res = ((vector int)__a & ~(vector int)__c) |
   6557                      ((vector int)__b & (vector int)__c);
   6558   return (vector float)__res;
   6559 }
   6560 
   6561 #ifdef __VSX__
   6562 static __inline__ vector double __ATTRS_o_ai
   6563 vec_sel(vector double __a, vector double __b, vector bool long long __c) {
   6564   vector long long __res = ((vector long long)__a & ~(vector long long)__c) |
   6565                            ((vector long long)__b & (vector long long)__c);
   6566   return (vector double)__res;
   6567 }
   6568 
   6569 static __inline__ vector double __ATTRS_o_ai
   6570 vec_sel(vector double __a, vector double __b, vector unsigned long long __c) {
   6571   vector long long __res = ((vector long long)__a & ~(vector long long)__c) |
   6572                            ((vector long long)__b & (vector long long)__c);
   6573   return (vector double)__res;
   6574 }
   6575 #endif
   6576 
   6577 /* vec_vsel */
   6578 
   6579 static __inline__ vector signed char __ATTRS_o_ai vec_vsel(
   6580     vector signed char __a, vector signed char __b, vector unsigned char __c) {
   6581   return (__a & ~(vector signed char)__c) | (__b & (vector signed char)__c);
   6582 }
   6583 
   6584 static __inline__ vector signed char __ATTRS_o_ai
   6585 vec_vsel(vector signed char __a, vector signed char __b, vector bool char __c) {
   6586   return (__a & ~(vector signed char)__c) | (__b & (vector signed char)__c);
   6587 }
   6588 
   6589 static __inline__ vector unsigned char __ATTRS_o_ai
   6590 vec_vsel(vector unsigned char __a, vector unsigned char __b,
   6591          vector unsigned char __c) {
   6592   return (__a & ~__c) | (__b & __c);
   6593 }
   6594 
   6595 static __inline__ vector unsigned char __ATTRS_o_ai vec_vsel(
   6596     vector unsigned char __a, vector unsigned char __b, vector bool char __c) {
   6597   return (__a & ~(vector unsigned char)__c) | (__b & (vector unsigned char)__c);
   6598 }
   6599 
   6600 static __inline__ vector bool char __ATTRS_o_ai
   6601 vec_vsel(vector bool char __a, vector bool char __b, vector unsigned char __c) {
   6602   return (__a & ~(vector bool char)__c) | (__b & (vector bool char)__c);
   6603 }
   6604 
   6605 static __inline__ vector bool char __ATTRS_o_ai vec_vsel(vector bool char __a,
   6606                                                          vector bool char __b,
   6607                                                          vector bool char __c) {
   6608   return (__a & ~__c) | (__b & __c);
   6609 }
   6610 
   6611 static __inline__ vector short __ATTRS_o_ai
   6612 vec_vsel(vector short __a, vector short __b, vector unsigned short __c) {
   6613   return (__a & ~(vector short)__c) | (__b & (vector short)__c);
   6614 }
   6615 
   6616 static __inline__ vector short __ATTRS_o_ai vec_vsel(vector short __a,
   6617                                                      vector short __b,
   6618                                                      vector bool short __c) {
   6619   return (__a & ~(vector short)__c) | (__b & (vector short)__c);
   6620 }
   6621 
   6622 static __inline__ vector unsigned short __ATTRS_o_ai
   6623 vec_vsel(vector unsigned short __a, vector unsigned short __b,
   6624          vector unsigned short __c) {
   6625   return (__a & ~__c) | (__b & __c);
   6626 }
   6627 
   6628 static __inline__ vector unsigned short __ATTRS_o_ai
   6629 vec_vsel(vector unsigned short __a, vector unsigned short __b,
   6630          vector bool short __c) {
   6631   return (__a & ~(vector unsigned short)__c) |
   6632          (__b & (vector unsigned short)__c);
   6633 }
   6634 
   6635 static __inline__ vector bool short __ATTRS_o_ai vec_vsel(
   6636     vector bool short __a, vector bool short __b, vector unsigned short __c) {
   6637   return (__a & ~(vector bool short)__c) | (__b & (vector bool short)__c);
   6638 }
   6639 
   6640 static __inline__ vector bool short __ATTRS_o_ai
   6641 vec_vsel(vector bool short __a, vector bool short __b, vector bool short __c) {
   6642   return (__a & ~__c) | (__b & __c);
   6643 }
   6644 
   6645 static __inline__ vector int __ATTRS_o_ai vec_vsel(vector int __a,
   6646                                                    vector int __b,
   6647                                                    vector unsigned int __c) {
   6648   return (__a & ~(vector int)__c) | (__b & (vector int)__c);
   6649 }
   6650 
   6651 static __inline__ vector int __ATTRS_o_ai vec_vsel(vector int __a,
   6652                                                    vector int __b,
   6653                                                    vector bool int __c) {
   6654   return (__a & ~(vector int)__c) | (__b & (vector int)__c);
   6655 }
   6656 
   6657 static __inline__ vector unsigned int __ATTRS_o_ai vec_vsel(
   6658     vector unsigned int __a, vector unsigned int __b, vector unsigned int __c) {
   6659   return (__a & ~__c) | (__b & __c);
   6660 }
   6661 
   6662 static __inline__ vector unsigned int __ATTRS_o_ai vec_vsel(
   6663     vector unsigned int __a, vector unsigned int __b, vector bool int __c) {
   6664   return (__a & ~(vector unsigned int)__c) | (__b & (vector unsigned int)__c);
   6665 }
   6666 
   6667 static __inline__ vector bool int __ATTRS_o_ai
   6668 vec_vsel(vector bool int __a, vector bool int __b, vector unsigned int __c) {
   6669   return (__a & ~(vector bool int)__c) | (__b & (vector bool int)__c);
   6670 }
   6671 
   6672 static __inline__ vector bool int __ATTRS_o_ai vec_vsel(vector bool int __a,
   6673                                                         vector bool int __b,
   6674                                                         vector bool int __c) {
   6675   return (__a & ~__c) | (__b & __c);
   6676 }
   6677 
   6678 static __inline__ vector float __ATTRS_o_ai vec_vsel(vector float __a,
   6679                                                      vector float __b,
   6680                                                      vector unsigned int __c) {
   6681   vector int __res = ((vector int)__a & ~(vector int)__c) |
   6682                      ((vector int)__b & (vector int)__c);
   6683   return (vector float)__res;
   6684 }
   6685 
   6686 static __inline__ vector float __ATTRS_o_ai vec_vsel(vector float __a,
   6687                                                      vector float __b,
   6688                                                      vector bool int __c) {
   6689   vector int __res = ((vector int)__a & ~(vector int)__c) |
   6690                      ((vector int)__b & (vector int)__c);
   6691   return (vector float)__res;
   6692 }
   6693 
   6694 /* vec_sl */
   6695 
   6696 static __inline__ vector signed char __ATTRS_o_ai
   6697 vec_sl(vector signed char __a, vector unsigned char __b) {
   6698   return __a << (vector signed char)__b;
   6699 }
   6700 
   6701 static __inline__ vector unsigned char __ATTRS_o_ai
   6702 vec_sl(vector unsigned char __a, vector unsigned char __b) {
   6703   return __a << __b;
   6704 }
   6705 
   6706 static __inline__ vector short __ATTRS_o_ai vec_sl(vector short __a,
   6707                                                    vector unsigned short __b) {
   6708   return __a << (vector short)__b;
   6709 }
   6710 
   6711 static __inline__ vector unsigned short __ATTRS_o_ai
   6712 vec_sl(vector unsigned short __a, vector unsigned short __b) {
   6713   return __a << __b;
   6714 }
   6715 
   6716 static __inline__ vector int __ATTRS_o_ai vec_sl(vector int __a,
   6717                                                  vector unsigned int __b) {
   6718   return __a << (vector int)__b;
   6719 }
   6720 
   6721 static __inline__ vector unsigned int __ATTRS_o_ai
   6722 vec_sl(vector unsigned int __a, vector unsigned int __b) {
   6723   return __a << __b;
   6724 }
   6725 
   6726 #ifdef __POWER8_VECTOR__
   6727 static __inline__ vector signed long long __ATTRS_o_ai
   6728 vec_sl(vector signed long long __a, vector unsigned long long __b) {
   6729   return __a << (vector long long)__b;
   6730 }
   6731 
   6732 static __inline__ vector unsigned long long __ATTRS_o_ai
   6733 vec_sl(vector unsigned long long __a, vector unsigned long long __b) {
   6734   return __a << __b;
   6735 }
   6736 #endif
   6737 
   6738 /* vec_vslb */
   6739 
   6740 #define __builtin_altivec_vslb vec_vslb
   6741 
   6742 static __inline__ vector signed char __ATTRS_o_ai
   6743 vec_vslb(vector signed char __a, vector unsigned char __b) {
   6744   return vec_sl(__a, __b);
   6745 }
   6746 
   6747 static __inline__ vector unsigned char __ATTRS_o_ai
   6748 vec_vslb(vector unsigned char __a, vector unsigned char __b) {
   6749   return vec_sl(__a, __b);
   6750 }
   6751 
   6752 /* vec_vslh */
   6753 
   6754 #define __builtin_altivec_vslh vec_vslh
   6755 
   6756 static __inline__ vector short __ATTRS_o_ai
   6757 vec_vslh(vector short __a, vector unsigned short __b) {
   6758   return vec_sl(__a, __b);
   6759 }
   6760 
   6761 static __inline__ vector unsigned short __ATTRS_o_ai
   6762 vec_vslh(vector unsigned short __a, vector unsigned short __b) {
   6763   return vec_sl(__a, __b);
   6764 }
   6765 
   6766 /* vec_vslw */
   6767 
   6768 #define __builtin_altivec_vslw vec_vslw
   6769 
   6770 static __inline__ vector int __ATTRS_o_ai vec_vslw(vector int __a,
   6771                                                    vector unsigned int __b) {
   6772   return vec_sl(__a, __b);
   6773 }
   6774 
   6775 static __inline__ vector unsigned int __ATTRS_o_ai
   6776 vec_vslw(vector unsigned int __a, vector unsigned int __b) {
   6777   return vec_sl(__a, __b);
   6778 }
   6779 
   6780 /* vec_sld */
   6781 
   6782 #define __builtin_altivec_vsldoi_4si vec_sld
   6783 
   6784 static __inline__ vector signed char __ATTRS_o_ai vec_sld(
   6785     vector signed char __a, vector signed char __b, unsigned const int __c) {
   6786   unsigned char __d = __c & 0x0F;
   6787 #ifdef __LITTLE_ENDIAN__
   6788   return vec_perm(
   6789       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
   6790                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
   6791                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
   6792                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
   6793 #else
   6794   return vec_perm(
   6795       __a, __b,
   6796       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
   6797                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
   6798                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
   6799 #endif
   6800 }
   6801 
   6802 static __inline__ vector unsigned char __ATTRS_o_ai
   6803 vec_sld(vector unsigned char __a, vector unsigned char __b,
   6804         unsigned const int __c) {
   6805   unsigned char __d = __c & 0x0F;
   6806 #ifdef __LITTLE_ENDIAN__
   6807   return vec_perm(
   6808       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
   6809                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
   6810                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
   6811                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
   6812 #else
   6813   return vec_perm(
   6814       __a, __b,
   6815       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
   6816                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
   6817                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
   6818 #endif
   6819 }
   6820 
   6821 static __inline__ vector bool char __ATTRS_o_ai
   6822 vec_sld(vector bool char __a, vector bool char __b, unsigned const int __c) {
   6823   unsigned char __d = __c & 0x0F;
   6824 #ifdef __LITTLE_ENDIAN__
   6825   return vec_perm(
   6826       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
   6827                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
   6828                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
   6829                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
   6830 #else
   6831   return vec_perm(
   6832       __a, __b,
   6833       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
   6834                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
   6835                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
   6836 #endif
   6837 }
   6838 
   6839 static __inline__ vector signed short __ATTRS_o_ai vec_sld(
   6840     vector signed short __a, vector signed short __b, unsigned const int __c) {
   6841   unsigned char __d = __c & 0x0F;
   6842 #ifdef __LITTLE_ENDIAN__
   6843   return vec_perm(
   6844       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
   6845                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
   6846                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
   6847                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
   6848 #else
   6849   return vec_perm(
   6850       __a, __b,
   6851       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
   6852                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
   6853                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
   6854 #endif
   6855 }
   6856 
   6857 static __inline__ vector unsigned short __ATTRS_o_ai
   6858 vec_sld(vector unsigned short __a, vector unsigned short __b,
   6859         unsigned const int __c) {
   6860   unsigned char __d = __c & 0x0F;
   6861 #ifdef __LITTLE_ENDIAN__
   6862   return vec_perm(
   6863       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
   6864                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
   6865                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
   6866                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
   6867 #else
   6868   return vec_perm(
   6869       __a, __b,
   6870       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
   6871                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
   6872                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
   6873 #endif
   6874 }
   6875 
   6876 static __inline__ vector bool short __ATTRS_o_ai
   6877 vec_sld(vector bool short __a, vector bool short __b, unsigned const int __c) {
   6878   unsigned char __d = __c & 0x0F;
   6879 #ifdef __LITTLE_ENDIAN__
   6880   return vec_perm(
   6881       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
   6882                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
   6883                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
   6884                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
   6885 #else
   6886   return vec_perm(
   6887       __a, __b,
   6888       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
   6889                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
   6890                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
   6891 #endif
   6892 }
   6893 
   6894 static __inline__ vector pixel __ATTRS_o_ai vec_sld(vector pixel __a,
   6895                                                     vector pixel __b,
   6896                                                     unsigned const int __c) {
   6897   unsigned char __d = __c & 0x0F;
   6898 #ifdef __LITTLE_ENDIAN__
   6899   return vec_perm(
   6900       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
   6901                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
   6902                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
   6903                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
   6904 #else
   6905   return vec_perm(
   6906       __a, __b,
   6907       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
   6908                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
   6909                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
   6910 #endif
   6911 }
   6912 
   6913 static __inline__ vector signed int __ATTRS_o_ai
   6914 vec_sld(vector signed int __a, vector signed int __b, unsigned const int __c) {
   6915   unsigned char __d = __c & 0x0F;
   6916 #ifdef __LITTLE_ENDIAN__
   6917   return vec_perm(
   6918       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
   6919                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
   6920                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
   6921                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
   6922 #else
   6923   return vec_perm(
   6924       __a, __b,
   6925       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
   6926                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
   6927                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
   6928 #endif
   6929 }
   6930 
   6931 static __inline__ vector unsigned int __ATTRS_o_ai vec_sld(
   6932     vector unsigned int __a, vector unsigned int __b, unsigned const int __c) {
   6933   unsigned char __d = __c & 0x0F;
   6934 #ifdef __LITTLE_ENDIAN__
   6935   return vec_perm(
   6936       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
   6937                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
   6938                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
   6939                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
   6940 #else
   6941   return vec_perm(
   6942       __a, __b,
   6943       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
   6944                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
   6945                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
   6946 #endif
   6947 }
   6948 
   6949 static __inline__ vector bool int __ATTRS_o_ai vec_sld(vector bool int __a,
   6950                                                        vector bool int __b,
   6951                                                        unsigned const int __c) {
   6952   unsigned char __d = __c & 0x0F;
   6953 #ifdef __LITTLE_ENDIAN__
   6954   return vec_perm(
   6955       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
   6956                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
   6957                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
   6958                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
   6959 #else
   6960   return vec_perm(
   6961       __a, __b,
   6962       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
   6963                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
   6964                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
   6965 #endif
   6966 }
   6967 
   6968 static __inline__ vector float __ATTRS_o_ai vec_sld(vector float __a,
   6969                                                     vector float __b,
   6970                                                     unsigned const int __c) {
   6971   unsigned char __d = __c & 0x0F;
   6972 #ifdef __LITTLE_ENDIAN__
   6973   return vec_perm(
   6974       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
   6975                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
   6976                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
   6977                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
   6978 #else
   6979   return vec_perm(
   6980       __a, __b,
   6981       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
   6982                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
   6983                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
   6984 #endif
   6985 }
   6986 
   6987 /* vec_vsldoi */
   6988 
   6989 static __inline__ vector signed char __ATTRS_o_ai
   6990 vec_vsldoi(vector signed char __a, vector signed char __b, unsigned char __c) {
   6991   unsigned char __d = __c & 0x0F;
   6992 #ifdef __LITTLE_ENDIAN__
   6993   return vec_perm(
   6994       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
   6995                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
   6996                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
   6997                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
   6998 #else
   6999   return vec_perm(
   7000       __a, __b,
   7001       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
   7002                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
   7003                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
   7004 #endif
   7005 }
   7006 
   7007 static __inline__ vector unsigned char __ATTRS_o_ai vec_vsldoi(
   7008     vector unsigned char __a, vector unsigned char __b, unsigned char __c) {
   7009   unsigned char __d = __c & 0x0F;
   7010 #ifdef __LITTLE_ENDIAN__
   7011   return vec_perm(
   7012       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
   7013                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
   7014                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
   7015                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
   7016 #else
   7017   return vec_perm(
   7018       __a, __b,
   7019       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
   7020                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
   7021                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
   7022 #endif
   7023 }
   7024 
   7025 static __inline__ vector short __ATTRS_o_ai vec_vsldoi(vector short __a,
   7026                                                        vector short __b,
   7027                                                        unsigned char __c) {
   7028   unsigned char __d = __c & 0x0F;
   7029 #ifdef __LITTLE_ENDIAN__
   7030   return vec_perm(
   7031       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
   7032                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
   7033                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
   7034                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
   7035 #else
   7036   return vec_perm(
   7037       __a, __b,
   7038       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
   7039                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
   7040                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
   7041 #endif
   7042 }
   7043 
   7044 static __inline__ vector unsigned short __ATTRS_o_ai vec_vsldoi(
   7045     vector unsigned short __a, vector unsigned short __b, unsigned char __c) {
   7046   unsigned char __d = __c & 0x0F;
   7047 #ifdef __LITTLE_ENDIAN__
   7048   return vec_perm(
   7049       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
   7050                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
   7051                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
   7052                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
   7053 #else
   7054   return vec_perm(
   7055       __a, __b,
   7056       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
   7057                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
   7058                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
   7059 #endif
   7060 }
   7061 
   7062 static __inline__ vector pixel __ATTRS_o_ai vec_vsldoi(vector pixel __a,
   7063                                                        vector pixel __b,
   7064                                                        unsigned char __c) {
   7065   unsigned char __d = __c & 0x0F;
   7066 #ifdef __LITTLE_ENDIAN__
   7067   return vec_perm(
   7068       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
   7069                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
   7070                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
   7071                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
   7072 #else
   7073   return vec_perm(
   7074       __a, __b,
   7075       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
   7076                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
   7077                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
   7078 #endif
   7079 }
   7080 
   7081 static __inline__ vector int __ATTRS_o_ai vec_vsldoi(vector int __a,
   7082                                                      vector int __b,
   7083                                                      unsigned char __c) {
   7084   unsigned char __d = __c & 0x0F;
   7085 #ifdef __LITTLE_ENDIAN__
   7086   return vec_perm(
   7087       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
   7088                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
   7089                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
   7090                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
   7091 #else
   7092   return vec_perm(
   7093       __a, __b,
   7094       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
   7095                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
   7096                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
   7097 #endif
   7098 }
   7099 
   7100 static __inline__ vector unsigned int __ATTRS_o_ai vec_vsldoi(
   7101     vector unsigned int __a, vector unsigned int __b, unsigned char __c) {
   7102   unsigned char __d = __c & 0x0F;
   7103 #ifdef __LITTLE_ENDIAN__
   7104   return vec_perm(
   7105       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
   7106                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
   7107                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
   7108                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
   7109 #else
   7110   return vec_perm(
   7111       __a, __b,
   7112       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
   7113                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
   7114                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
   7115 #endif
   7116 }
   7117 
   7118 static __inline__ vector float __ATTRS_o_ai vec_vsldoi(vector float __a,
   7119                                                        vector float __b,
   7120                                                        unsigned char __c) {
   7121   unsigned char __d = __c & 0x0F;
   7122 #ifdef __LITTLE_ENDIAN__
   7123   return vec_perm(
   7124       __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
   7125                                        20 - __d, 21 - __d, 22 - __d, 23 - __d,
   7126                                        24 - __d, 25 - __d, 26 - __d, 27 - __d,
   7127                                        28 - __d, 29 - __d, 30 - __d, 31 - __d));
   7128 #else
   7129   return vec_perm(
   7130       __a, __b,
   7131       (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
   7132                              __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
   7133                              __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
   7134 #endif
   7135 }
   7136 
   7137 /* vec_sll */
   7138 
   7139 static __inline__ vector signed char __ATTRS_o_ai
   7140 vec_sll(vector signed char __a, vector unsigned char __b) {
   7141   return (vector signed char)__builtin_altivec_vsl((vector int)__a,
   7142                                                    (vector int)__b);
   7143 }
   7144 
   7145 static __inline__ vector signed char __ATTRS_o_ai
   7146 vec_sll(vector signed char __a, vector unsigned short __b) {
   7147   return (vector signed char)__builtin_altivec_vsl((vector int)__a,
   7148                                                    (vector int)__b);
   7149 }
   7150 
   7151 static __inline__ vector signed char __ATTRS_o_ai
   7152 vec_sll(vector signed char __a, vector unsigned int __b) {
   7153   return (vector signed char)__builtin_altivec_vsl((vector int)__a,
   7154                                                    (vector int)__b);
   7155 }
   7156 
   7157 static __inline__ vector unsigned char __ATTRS_o_ai
   7158 vec_sll(vector unsigned char __a, vector unsigned char __b) {
   7159   return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
   7160                                                      (vector int)__b);
   7161 }
   7162 
   7163 static __inline__ vector unsigned char __ATTRS_o_ai
   7164 vec_sll(vector unsigned char __a, vector unsigned short __b) {
   7165   return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
   7166                                                      (vector int)__b);
   7167 }
   7168 
   7169 static __inline__ vector unsigned char __ATTRS_o_ai
   7170 vec_sll(vector unsigned char __a, vector unsigned int __b) {
   7171   return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
   7172                                                      (vector int)__b);
   7173 }
   7174 
   7175 static __inline__ vector bool char __ATTRS_o_ai
   7176 vec_sll(vector bool char __a, vector unsigned char __b) {
   7177   return (vector bool char)__builtin_altivec_vsl((vector int)__a,
   7178                                                  (vector int)__b);
   7179 }
   7180 
   7181 static __inline__ vector bool char __ATTRS_o_ai
   7182 vec_sll(vector bool char __a, vector unsigned short __b) {
   7183   return (vector bool char)__builtin_altivec_vsl((vector int)__a,
   7184                                                  (vector int)__b);
   7185 }
   7186 
   7187 static __inline__ vector bool char __ATTRS_o_ai
   7188 vec_sll(vector bool char __a, vector unsigned int __b) {
   7189   return (vector bool char)__builtin_altivec_vsl((vector int)__a,
   7190                                                  (vector int)__b);
   7191 }
   7192 
   7193 static __inline__ vector short __ATTRS_o_ai vec_sll(vector short __a,
   7194                                                     vector unsigned char __b) {
   7195   return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
   7196 }
   7197 
   7198 static __inline__ vector short __ATTRS_o_ai vec_sll(vector short __a,
   7199                                                     vector unsigned short __b) {
   7200   return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
   7201 }
   7202 
   7203 static __inline__ vector short __ATTRS_o_ai vec_sll(vector short __a,
   7204                                                     vector unsigned int __b) {
   7205   return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
   7206 }
   7207 
   7208 static __inline__ vector unsigned short __ATTRS_o_ai
   7209 vec_sll(vector unsigned short __a, vector unsigned char __b) {
   7210   return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
   7211                                                       (vector int)__b);
   7212 }
   7213 
   7214 static __inline__ vector unsigned short __ATTRS_o_ai
   7215 vec_sll(vector unsigned short __a, vector unsigned short __b) {
   7216   return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
   7217                                                       (vector int)__b);
   7218 }
   7219 
   7220 static __inline__ vector unsigned short __ATTRS_o_ai
   7221 vec_sll(vector unsigned short __a, vector unsigned int __b) {
   7222   return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
   7223                                                       (vector int)__b);
   7224 }
   7225 
   7226 static __inline__ vector bool short __ATTRS_o_ai
   7227 vec_sll(vector bool short __a, vector unsigned char __b) {
   7228   return (vector bool short)__builtin_altivec_vsl((vector int)__a,
   7229                                                   (vector int)__b);
   7230 }
   7231 
   7232 static __inline__ vector bool short __ATTRS_o_ai
   7233 vec_sll(vector bool short __a, vector unsigned short __b) {
   7234   return (vector bool short)__builtin_altivec_vsl((vector int)__a,
   7235                                                   (vector int)__b);
   7236 }
   7237 
   7238 static __inline__ vector bool short __ATTRS_o_ai
   7239 vec_sll(vector bool short __a, vector unsigned int __b) {
   7240   return (vector bool short)__builtin_altivec_vsl((vector int)__a,
   7241                                                   (vector int)__b);
   7242 }
   7243 
   7244 static __inline__ vector pixel __ATTRS_o_ai vec_sll(vector pixel __a,
   7245                                                     vector unsigned char __b) {
   7246   return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
   7247 }
   7248 
   7249 static __inline__ vector pixel __ATTRS_o_ai vec_sll(vector pixel __a,
   7250                                                     vector unsigned short __b) {
   7251   return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
   7252 }
   7253 
   7254 static __inline__ vector pixel __ATTRS_o_ai vec_sll(vector pixel __a,
   7255                                                     vector unsigned int __b) {
   7256   return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
   7257 }
   7258 
   7259 static __inline__ vector int __ATTRS_o_ai vec_sll(vector int __a,
   7260                                                   vector unsigned char __b) {
   7261   return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
   7262 }
   7263 
   7264 static __inline__ vector int __ATTRS_o_ai vec_sll(vector int __a,
   7265                                                   vector unsigned short __b) {
   7266   return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
   7267 }
   7268 
   7269 static __inline__ vector int __ATTRS_o_ai vec_sll(vector int __a,
   7270                                                   vector unsigned int __b) {
   7271   return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
   7272 }
   7273 
   7274 static __inline__ vector unsigned int __ATTRS_o_ai
   7275 vec_sll(vector unsigned int __a, vector unsigned char __b) {
   7276   return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
   7277                                                     (vector int)__b);
   7278 }
   7279 
   7280 static __inline__ vector unsigned int __ATTRS_o_ai
   7281 vec_sll(vector unsigned int __a, vector unsigned short __b) {
   7282   return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
   7283                                                     (vector int)__b);
   7284 }
   7285 
   7286 static __inline__ vector unsigned int __ATTRS_o_ai
   7287 vec_sll(vector unsigned int __a, vector unsigned int __b) {
   7288   return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
   7289                                                     (vector int)__b);
   7290 }
   7291 
   7292 static __inline__ vector bool int __ATTRS_o_ai
   7293 vec_sll(vector bool int __a, vector unsigned char __b) {
   7294   return (vector bool int)__builtin_altivec_vsl((vector int)__a,
   7295                                                 (vector int)__b);
   7296 }
   7297 
   7298 static __inline__ vector bool int __ATTRS_o_ai
   7299 vec_sll(vector bool int __a, vector unsigned short __b) {
   7300   return (vector bool int)__builtin_altivec_vsl((vector int)__a,
   7301                                                 (vector int)__b);
   7302 }
   7303 
   7304 static __inline__ vector bool int __ATTRS_o_ai
   7305 vec_sll(vector bool int __a, vector unsigned int __b) {
   7306   return (vector bool int)__builtin_altivec_vsl((vector int)__a,
   7307                                                 (vector int)__b);
   7308 }
   7309 
   7310 /* vec_vsl */
   7311 
   7312 static __inline__ vector signed char __ATTRS_o_ai
   7313 vec_vsl(vector signed char __a, vector unsigned char __b) {
   7314   return (vector signed char)__builtin_altivec_vsl((vector int)__a,
   7315                                                    (vector int)__b);
   7316 }
   7317 
   7318 static __inline__ vector signed char __ATTRS_o_ai
   7319 vec_vsl(vector signed char __a, vector unsigned short __b) {
   7320   return (vector signed char)__builtin_altivec_vsl((vector int)__a,
   7321                                                    (vector int)__b);
   7322 }
   7323 
   7324 static __inline__ vector signed char __ATTRS_o_ai
   7325 vec_vsl(vector signed char __a, vector unsigned int __b) {
   7326   return (vector signed char)__builtin_altivec_vsl((vector int)__a,
   7327                                                    (vector int)__b);
   7328 }
   7329 
   7330 static __inline__ vector unsigned char __ATTRS_o_ai
   7331 vec_vsl(vector unsigned char __a, vector unsigned char __b) {
   7332   return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
   7333                                                      (vector int)__b);
   7334 }
   7335 
   7336 static __inline__ vector unsigned char __ATTRS_o_ai
   7337 vec_vsl(vector unsigned char __a, vector unsigned short __b) {
   7338   return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
   7339                                                      (vector int)__b);
   7340 }
   7341 
   7342 static __inline__ vector unsigned char __ATTRS_o_ai
   7343 vec_vsl(vector unsigned char __a, vector unsigned int __b) {
   7344   return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
   7345                                                      (vector int)__b);
   7346 }
   7347 
   7348 static __inline__ vector bool char __ATTRS_o_ai
   7349 vec_vsl(vector bool char __a, vector unsigned char __b) {
   7350   return (vector bool char)__builtin_altivec_vsl((vector int)__a,
   7351                                                  (vector int)__b);
   7352 }
   7353 
   7354 static __inline__ vector bool char __ATTRS_o_ai
   7355 vec_vsl(vector bool char __a, vector unsigned short __b) {
   7356   return (vector bool char)__builtin_altivec_vsl((vector int)__a,
   7357                                                  (vector int)__b);
   7358 }
   7359 
   7360 static __inline__ vector bool char __ATTRS_o_ai
   7361 vec_vsl(vector bool char __a, vector unsigned int __b) {
   7362   return (vector bool char)__builtin_altivec_vsl((vector int)__a,
   7363                                                  (vector int)__b);
   7364 }
   7365 
   7366 static __inline__ vector short __ATTRS_o_ai vec_vsl(vector short __a,
   7367                                                     vector unsigned char __b) {
   7368   return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
   7369 }
   7370 
   7371 static __inline__ vector short __ATTRS_o_ai vec_vsl(vector short __a,
   7372                                                     vector unsigned short __b) {
   7373   return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
   7374 }
   7375 
   7376 static __inline__ vector short __ATTRS_o_ai vec_vsl(vector short __a,
   7377                                                     vector unsigned int __b) {
   7378   return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
   7379 }
   7380 
   7381 static __inline__ vector unsigned short __ATTRS_o_ai
   7382 vec_vsl(vector unsigned short __a, vector unsigned char __b) {
   7383   return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
   7384                                                       (vector int)__b);
   7385 }
   7386 
   7387 static __inline__ vector unsigned short __ATTRS_o_ai
   7388 vec_vsl(vector unsigned short __a, vector unsigned short __b) {
   7389   return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
   7390                                                       (vector int)__b);
   7391 }
   7392 
   7393 static __inline__ vector unsigned short __ATTRS_o_ai
   7394 vec_vsl(vector unsigned short __a, vector unsigned int __b) {
   7395   return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
   7396                                                       (vector int)__b);
   7397 }
   7398 
   7399 static __inline__ vector bool short __ATTRS_o_ai
   7400 vec_vsl(vector bool short __a, vector unsigned char __b) {
   7401   return (vector bool short)__builtin_altivec_vsl((vector int)__a,
   7402                                                   (vector int)__b);
   7403 }
   7404 
   7405 static __inline__ vector bool short __ATTRS_o_ai
   7406 vec_vsl(vector bool short __a, vector unsigned short __b) {
   7407   return (vector bool short)__builtin_altivec_vsl((vector int)__a,
   7408                                                   (vector int)__b);
   7409 }
   7410 
   7411 static __inline__ vector bool short __ATTRS_o_ai
   7412 vec_vsl(vector bool short __a, vector unsigned int __b) {
   7413   return (vector bool short)__builtin_altivec_vsl((vector int)__a,
   7414                                                   (vector int)__b);
   7415 }
   7416 
   7417 static __inline__ vector pixel __ATTRS_o_ai vec_vsl(vector pixel __a,
   7418                                                     vector unsigned char __b) {
   7419   return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
   7420 }
   7421 
   7422 static __inline__ vector pixel __ATTRS_o_ai vec_vsl(vector pixel __a,
   7423                                                     vector unsigned short __b) {
   7424   return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
   7425 }
   7426 
   7427 static __inline__ vector pixel __ATTRS_o_ai vec_vsl(vector pixel __a,
   7428                                                     vector unsigned int __b) {
   7429   return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
   7430 }
   7431 
   7432 static __inline__ vector int __ATTRS_o_ai vec_vsl(vector int __a,
   7433                                                   vector unsigned char __b) {
   7434   return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
   7435 }
   7436 
   7437 static __inline__ vector int __ATTRS_o_ai vec_vsl(vector int __a,
   7438                                                   vector unsigned short __b) {
   7439   return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
   7440 }
   7441 
   7442 static __inline__ vector int __ATTRS_o_ai vec_vsl(vector int __a,
   7443                                                   vector unsigned int __b) {
   7444   return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
   7445 }
   7446 
   7447 static __inline__ vector unsigned int __ATTRS_o_ai
   7448 vec_vsl(vector unsigned int __a, vector unsigned char __b) {
   7449   return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
   7450                                                     (vector int)__b);
   7451 }
   7452 
   7453 static __inline__ vector unsigned int __ATTRS_o_ai
   7454 vec_vsl(vector unsigned int __a, vector unsigned short __b) {
   7455   return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
   7456                                                     (vector int)__b);
   7457 }
   7458 
   7459 static __inline__ vector unsigned int __ATTRS_o_ai
   7460 vec_vsl(vector unsigned int __a, vector unsigned int __b) {
   7461   return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
   7462                                                     (vector int)__b);
   7463 }
   7464 
   7465 static __inline__ vector bool int __ATTRS_o_ai
   7466 vec_vsl(vector bool int __a, vector unsigned char __b) {
   7467   return (vector bool int)__builtin_altivec_vsl((vector int)__a,
   7468                                                 (vector int)__b);
   7469 }
   7470 
   7471 static __inline__ vector bool int __ATTRS_o_ai
   7472 vec_vsl(vector bool int __a, vector unsigned short __b) {
   7473   return (vector bool int)__builtin_altivec_vsl((vector int)__a,
   7474                                                 (vector int)__b);
   7475 }
   7476 
   7477 static __inline__ vector bool int __ATTRS_o_ai
   7478 vec_vsl(vector bool int __a, vector unsigned int __b) {
   7479   return (vector bool int)__builtin_altivec_vsl((vector int)__a,
   7480                                                 (vector int)__b);
   7481 }
   7482 
   7483 /* vec_slo */
   7484 
   7485 static __inline__ vector signed char __ATTRS_o_ai
   7486 vec_slo(vector signed char __a, vector signed char __b) {
   7487   return (vector signed char)__builtin_altivec_vslo((vector int)__a,
   7488                                                     (vector int)__b);
   7489 }
   7490 
   7491 static __inline__ vector signed char __ATTRS_o_ai
   7492 vec_slo(vector signed char __a, vector unsigned char __b) {
   7493   return (vector signed char)__builtin_altivec_vslo((vector int)__a,
   7494                                                     (vector int)__b);
   7495 }
   7496 
   7497 static __inline__ vector unsigned char __ATTRS_o_ai
   7498 vec_slo(vector unsigned char __a, vector signed char __b) {
   7499   return (vector unsigned char)__builtin_altivec_vslo((vector int)__a,
   7500                                                       (vector int)__b);
   7501 }
   7502 
   7503 static __inline__ vector unsigned char __ATTRS_o_ai
   7504 vec_slo(vector unsigned char __a, vector unsigned char __b) {
   7505   return (vector unsigned char)__builtin_altivec_vslo((vector int)__a,
   7506                                                       (vector int)__b);
   7507 }
   7508 
   7509 static __inline__ vector short __ATTRS_o_ai vec_slo(vector short __a,
   7510                                                     vector signed char __b) {
   7511   return (vector short)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
   7512 }
   7513 
   7514 static __inline__ vector short __ATTRS_o_ai vec_slo(vector short __a,
   7515                                                     vector unsigned char __b) {
   7516   return (vector short)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
   7517 }
   7518 
   7519 static __inline__ vector unsigned short __ATTRS_o_ai
   7520 vec_slo(vector unsigned short __a, vector signed char __b) {
   7521   return (vector unsigned short)__builtin_altivec_vslo((vector int)__a,
   7522                                                        (vector int)__b);
   7523 }
   7524 
   7525 static __inline__ vector unsigned short __ATTRS_o_ai
   7526 vec_slo(vector unsigned short __a, vector unsigned char __b) {
   7527   return (vector unsigned short)__builtin_altivec_vslo((vector int)__a,
   7528                                                        (vector int)__b);
   7529 }
   7530 
   7531 static __inline__ vector pixel __ATTRS_o_ai vec_slo(vector pixel __a,
   7532                                                     vector signed char __b) {
   7533   return (vector pixel)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
   7534 }
   7535 
   7536 static __inline__ vector pixel __ATTRS_o_ai vec_slo(vector pixel __a,
   7537                                                     vector unsigned char __b) {
   7538   return (vector pixel)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
   7539 }
   7540 
   7541 static __inline__ vector int __ATTRS_o_ai vec_slo(vector int __a,
   7542                                                   vector signed char __b) {
   7543   return (vector int)__builtin_altivec_vslo(__a, (vector int)__b);
   7544 }
   7545 
   7546 static __inline__ vector int __ATTRS_o_ai vec_slo(vector int __a,
   7547                                                   vector unsigned char __b) {
   7548   return (vector int)__builtin_altivec_vslo(__a, (vector int)__b);
   7549 }
   7550 
   7551 static __inline__ vector unsigned int __ATTRS_o_ai
   7552 vec_slo(vector unsigned int __a, vector signed char __b) {
   7553   return (vector unsigned int)__builtin_altivec_vslo((vector int)__a,
   7554                                                      (vector int)__b);
   7555 }
   7556 
   7557 static __inline__ vector unsigned int __ATTRS_o_ai
   7558 vec_slo(vector unsigned int __a, vector unsigned char __b) {
   7559   return (vector unsigned int)__builtin_altivec_vslo((vector int)__a,
   7560                                                      (vector int)__b);
   7561 }
   7562 
   7563 static __inline__ vector float __ATTRS_o_ai vec_slo(vector float __a,
   7564                                                     vector signed char __b) {
   7565   return (vector float)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
   7566 }
   7567 
   7568 static __inline__ vector float __ATTRS_o_ai vec_slo(vector float __a,
   7569                                                     vector unsigned char __b) {
   7570   return (vector float)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
   7571 }
   7572 
   7573 /* vec_vslo */
   7574 
   7575 static __inline__ vector signed char __ATTRS_o_ai
   7576 vec_vslo(vector signed char __a, vector signed char __b) {
   7577   return (vector signed char)__builtin_altivec_vslo((vector int)__a,
   7578                                                     (vector int)__b);
   7579 }
   7580 
   7581 static __inline__ vector signed char __ATTRS_o_ai
   7582 vec_vslo(vector signed char __a, vector unsigned char __b) {
   7583   return (vector signed char)__builtin_altivec_vslo((vector int)__a,
   7584                                                     (vector int)__b);
   7585 }
   7586 
   7587 static __inline__ vector unsigned char __ATTRS_o_ai
   7588 vec_vslo(vector unsigned char __a, vector signed char __b) {
   7589   return (vector unsigned char)__builtin_altivec_vslo((vector int)__a,
   7590                                                       (vector int)__b);
   7591 }
   7592 
   7593 static __inline__ vector unsigned char __ATTRS_o_ai
   7594 vec_vslo(vector unsigned char __a, vector unsigned char __b) {
   7595   return (vector unsigned char)__builtin_altivec_vslo((vector int)__a,
   7596                                                       (vector int)__b);
   7597 }
   7598 
   7599 static __inline__ vector short __ATTRS_o_ai vec_vslo(vector short __a,
   7600                                                      vector signed char __b) {
   7601   return (vector short)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
   7602 }
   7603 
   7604 static __inline__ vector short __ATTRS_o_ai vec_vslo(vector short __a,
   7605                                                      vector unsigned char __b) {
   7606   return (vector short)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
   7607 }
   7608 
   7609 static __inline__ vector unsigned short __ATTRS_o_ai
   7610 vec_vslo(vector unsigned short __a, vector signed char __b) {
   7611   return (vector unsigned short)__builtin_altivec_vslo((vector int)__a,
   7612                                                        (vector int)__b);
   7613 }
   7614 
   7615 static __inline__ vector unsigned short __ATTRS_o_ai
   7616 vec_vslo(vector unsigned short __a, vector unsigned char __b) {
   7617   return (vector unsigned short)__builtin_altivec_vslo((vector int)__a,
   7618                                                        (vector int)__b);
   7619 }
   7620 
   7621 static __inline__ vector pixel __ATTRS_o_ai vec_vslo(vector pixel __a,
   7622                                                      vector signed char __b) {
   7623   return (vector pixel)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
   7624 }
   7625 
   7626 static __inline__ vector pixel __ATTRS_o_ai vec_vslo(vector pixel __a,
   7627                                                      vector unsigned char __b) {
   7628   return (vector pixel)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
   7629 }
   7630 
   7631 static __inline__ vector int __ATTRS_o_ai vec_vslo(vector int __a,
   7632                                                    vector signed char __b) {
   7633   return (vector int)__builtin_altivec_vslo(__a, (vector int)__b);
   7634 }
   7635 
   7636 static __inline__ vector int __ATTRS_o_ai vec_vslo(vector int __a,
   7637                                                    vector unsigned char __b) {
   7638   return (vector int)__builtin_altivec_vslo(__a, (vector int)__b);
   7639 }
   7640 
   7641 static __inline__ vector unsigned int __ATTRS_o_ai
   7642 vec_vslo(vector unsigned int __a, vector signed char __b) {
   7643   return (vector unsigned int)__builtin_altivec_vslo((vector int)__a,
   7644                                                      (vector int)__b);
   7645 }
   7646 
   7647 static __inline__ vector unsigned int __ATTRS_o_ai
   7648 vec_vslo(vector unsigned int __a, vector unsigned char __b) {
   7649   return (vector unsigned int)__builtin_altivec_vslo((vector int)__a,
   7650                                                      (vector int)__b);
   7651 }
   7652 
   7653 static __inline__ vector float __ATTRS_o_ai vec_vslo(vector float __a,
   7654                                                      vector signed char __b) {
   7655   return (vector float)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
   7656 }
   7657 
   7658 static __inline__ vector float __ATTRS_o_ai vec_vslo(vector float __a,
   7659                                                      vector unsigned char __b) {
   7660   return (vector float)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
   7661 }
   7662 
   7663 /* vec_splat */
   7664 
   7665 static __inline__ vector signed char __ATTRS_o_ai
   7666 vec_splat(vector signed char __a, unsigned const int __b) {
   7667   return vec_perm(__a, __a, (vector unsigned char)(__b & 0x0F));
   7668 }
   7669 
   7670 static __inline__ vector unsigned char __ATTRS_o_ai
   7671 vec_splat(vector unsigned char __a, unsigned const int __b) {
   7672   return vec_perm(__a, __a, (vector unsigned char)(__b & 0x0F));
   7673 }
   7674 
   7675 static __inline__ vector bool char __ATTRS_o_ai
   7676 vec_splat(vector bool char __a, unsigned const int __b) {
   7677   return vec_perm(__a, __a, (vector unsigned char)(__b & 0x0F));
   7678 }
   7679 
   7680 static __inline__ vector signed short __ATTRS_o_ai
   7681 vec_splat(vector signed short __a, unsigned const int __b) {
   7682   unsigned char b0 = (__b & 0x07) * 2;
   7683   unsigned char b1 = b0 + 1;
   7684   return vec_perm(__a, __a,
   7685                   (vector unsigned char)(b0, b1, b0, b1, b0, b1, b0, b1, b0, b1,
   7686                                          b0, b1, b0, b1, b0, b1));
   7687 }
   7688 
   7689 static __inline__ vector unsigned short __ATTRS_o_ai
   7690 vec_splat(vector unsigned short __a, unsigned const int __b) {
   7691   unsigned char b0 = (__b & 0x07) * 2;
   7692   unsigned char b1 = b0 + 1;
   7693   return vec_perm(__a, __a,
   7694                   (vector unsigned char)(b0, b1, b0, b1, b0, b1, b0, b1, b0, b1,
   7695                                          b0, b1, b0, b1, b0, b1));
   7696 }
   7697 
   7698 static __inline__ vector bool short __ATTRS_o_ai
   7699 vec_splat(vector bool short __a, unsigned const int __b) {
   7700   unsigned char b0 = (__b & 0x07) * 2;
   7701   unsigned char b1 = b0 + 1;
   7702   return vec_perm(__a, __a,
   7703                   (vector unsigned char)(b0, b1, b0, b1, b0, b1, b0, b1, b0, b1,
   7704                                          b0, b1, b0, b1, b0, b1));
   7705 }
   7706 
   7707 static __inline__ vector pixel __ATTRS_o_ai vec_splat(vector pixel __a,
   7708                                                       unsigned const int __b) {
   7709   unsigned char b0 = (__b & 0x07) * 2;
   7710   unsigned char b1 = b0 + 1;
   7711   return vec_perm(__a, __a,
   7712                   (vector unsigned char)(b0, b1, b0, b1, b0, b1, b0, b1, b0, b1,
   7713                                          b0, b1, b0, b1, b0, b1));
   7714 }
   7715 
   7716 static __inline__ vector signed int __ATTRS_o_ai
   7717 vec_splat(vector signed int __a, unsigned const int __b) {
   7718   unsigned char b0 = (__b & 0x03) * 4;
   7719   unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3;
   7720   return vec_perm(__a, __a,
   7721                   (vector unsigned char)(b0, b1, b2, b3, b0, b1, b2, b3, b0, b1,
   7722                                          b2, b3, b0, b1, b2, b3));
   7723 }
   7724 
   7725 static __inline__ vector unsigned int __ATTRS_o_ai
   7726 vec_splat(vector unsigned int __a, unsigned const int __b) {
   7727   unsigned char b0 = (__b & 0x03) * 4;
   7728   unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3;
   7729   return vec_perm(__a, __a,
   7730                   (vector unsigned char)(b0, b1, b2, b3, b0, b1, b2, b3, b0, b1,
   7731                                          b2, b3, b0, b1, b2, b3));
   7732 }
   7733 
   7734 static __inline__ vector bool int __ATTRS_o_ai
   7735 vec_splat(vector bool int __a, unsigned const int __b) {
   7736   unsigned char b0 = (__b & 0x03) * 4;
   7737   unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3;
   7738   return vec_perm(__a, __a,
   7739                   (vector unsigned char)(b0, b1, b2, b3, b0, b1, b2, b3, b0, b1,
   7740                                          b2, b3, b0, b1, b2, b3));
   7741 }
   7742 
   7743 static __inline__ vector float __ATTRS_o_ai vec_splat(vector float __a,
   7744                                                       unsigned const int __b) {
   7745   unsigned char b0 = (__b & 0x03) * 4;
   7746   unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3;
   7747   return vec_perm(__a, __a,
   7748                   (vector unsigned char)(b0, b1, b2, b3, b0, b1, b2, b3, b0, b1,
   7749                                          b2, b3, b0, b1, b2, b3));
   7750 }
   7751 
   7752 #ifdef __VSX__
   7753 static __inline__ vector double __ATTRS_o_ai vec_splat(vector double __a,
   7754                                                        unsigned const int __b) {
   7755   unsigned char b0 = (__b & 0x01) * 8;
   7756   unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3, b4 = b0 + 4, b5 = b0 + 5,
   7757                 b6 = b0 + 6, b7 = b0 + 7;
   7758   return vec_perm(__a, __a,
   7759                   (vector unsigned char)(b0, b1, b2, b3, b4, b5, b6, b7, b0, b1,
   7760                                          b2, b3, b4, b5, b6, b7));
   7761 }
   7762 static __inline__ vector bool long long __ATTRS_o_ai
   7763 vec_splat(vector bool long long __a, unsigned const int __b) {
   7764   unsigned char b0 = (__b & 0x01) * 8;
   7765   unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3, b4 = b0 + 4, b5 = b0 + 5,
   7766                 b6 = b0 + 6, b7 = b0 + 7;
   7767   return vec_perm(__a, __a,
   7768                   (vector unsigned char)(b0, b1, b2, b3, b4, b5, b6, b7, b0, b1,
   7769                                          b2, b3, b4, b5, b6, b7));
   7770 }
   7771 static __inline__ vector signed long long __ATTRS_o_ai
   7772 vec_splat(vector signed long long __a, unsigned const int __b) {
   7773   unsigned char b0 = (__b & 0x01) * 8;
   7774   unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3, b4 = b0 + 4, b5 = b0 + 5,
   7775                 b6 = b0 + 6, b7 = b0 + 7;
   7776   return vec_perm(__a, __a,
   7777                   (vector unsigned char)(b0, b1, b2, b3, b4, b5, b6, b7, b0, b1,
   7778                                          b2, b3, b4, b5, b6, b7));
   7779 }
   7780 static __inline__ vector unsigned long long __ATTRS_o_ai
   7781 vec_splat(vector unsigned long long __a, unsigned const int __b) {
   7782   unsigned char b0 = (__b & 0x01) * 8;
   7783   unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3, b4 = b0 + 4, b5 = b0 + 5,
   7784                 b6 = b0 + 6, b7 = b0 + 7;
   7785   return vec_perm(__a, __a,
   7786                   (vector unsigned char)(b0, b1, b2, b3, b4, b5, b6, b7, b0, b1,
   7787                                          b2, b3, b4, b5, b6, b7));
   7788 }
   7789 #endif
   7790 
   7791 /* vec_vspltb */
   7792 
   7793 #define __builtin_altivec_vspltb vec_vspltb
   7794 
   7795 static __inline__ vector signed char __ATTRS_o_ai
   7796 vec_vspltb(vector signed char __a, unsigned char __b) {
   7797   return vec_perm(__a, __a, (vector unsigned char)(__b));
   7798 }
   7799 
   7800 static __inline__ vector unsigned char __ATTRS_o_ai
   7801 vec_vspltb(vector unsigned char __a, unsigned char __b) {
   7802   return vec_perm(__a, __a, (vector unsigned char)(__b));
   7803 }
   7804 
   7805 static __inline__ vector bool char __ATTRS_o_ai vec_vspltb(vector bool char __a,
   7806                                                            unsigned char __b) {
   7807   return vec_perm(__a, __a, (vector unsigned char)(__b));
   7808 }
   7809 
   7810 /* vec_vsplth */
   7811 
   7812 #define __builtin_altivec_vsplth vec_vsplth
   7813 
   7814 static __inline__ vector short __ATTRS_o_ai vec_vsplth(vector short __a,
   7815                                                        unsigned char __b) {
   7816   __b *= 2;
   7817   unsigned char b1 = __b + 1;
   7818   return vec_perm(__a, __a,
   7819                   (vector unsigned char)(__b, b1, __b, b1, __b, b1, __b, b1,
   7820                                          __b, b1, __b, b1, __b, b1, __b, b1));
   7821 }
   7822 
   7823 static __inline__ vector unsigned short __ATTRS_o_ai
   7824 vec_vsplth(vector unsigned short __a, unsigned char __b) {
   7825   __b *= 2;
   7826   unsigned char b1 = __b + 1;
   7827   return vec_perm(__a, __a,
   7828                   (vector unsigned char)(__b, b1, __b, b1, __b, b1, __b, b1,
   7829                                          __b, b1, __b, b1, __b, b1, __b, b1));
   7830 }
   7831 
   7832 static __inline__ vector bool short __ATTRS_o_ai
   7833 vec_vsplth(vector bool short __a, unsigned char __b) {
   7834   __b *= 2;
   7835   unsigned char b1 = __b + 1;
   7836   return vec_perm(__a, __a,
   7837                   (vector unsigned char)(__b, b1, __b, b1, __b, b1, __b, b1,
   7838                                          __b, b1, __b, b1, __b, b1, __b, b1));
   7839 }
   7840 
   7841 static __inline__ vector pixel __ATTRS_o_ai vec_vsplth(vector pixel __a,
   7842                                                        unsigned char __b) {
   7843   __b *= 2;
   7844   unsigned char b1 = __b + 1;
   7845   return vec_perm(__a, __a,
   7846                   (vector unsigned char)(__b, b1, __b, b1, __b, b1, __b, b1,
   7847                                          __b, b1, __b, b1, __b, b1, __b, b1));
   7848 }
   7849 
   7850 /* vec_vspltw */
   7851 
   7852 #define __builtin_altivec_vspltw vec_vspltw
   7853 
   7854 static __inline__ vector int __ATTRS_o_ai vec_vspltw(vector int __a,
   7855                                                      unsigned char __b) {
   7856   __b *= 4;
   7857   unsigned char b1 = __b + 1, b2 = __b + 2, b3 = __b + 3;
   7858   return vec_perm(__a, __a,
   7859                   (vector unsigned char)(__b, b1, b2, b3, __b, b1, b2, b3, __b,
   7860                                          b1, b2, b3, __b, b1, b2, b3));
   7861 }
   7862 
   7863 static __inline__ vector unsigned int __ATTRS_o_ai
   7864 vec_vspltw(vector unsigned int __a, unsigned char __b) {
   7865   __b *= 4;
   7866   unsigned char b1 = __b + 1, b2 = __b + 2, b3 = __b + 3;
   7867   return vec_perm(__a, __a,
   7868                   (vector unsigned char)(__b, b1, b2, b3, __b, b1, b2, b3, __b,
   7869                                          b1, b2, b3, __b, b1, b2, b3));
   7870 }
   7871 
   7872 static __inline__ vector bool int __ATTRS_o_ai vec_vspltw(vector bool int __a,
   7873                                                           unsigned char __b) {
   7874   __b *= 4;
   7875   unsigned char b1 = __b + 1, b2 = __b + 2, b3 = __b + 3;
   7876   return vec_perm(__a, __a,
   7877                   (vector unsigned char)(__b, b1, b2, b3, __b, b1, b2, b3, __b,
   7878                                          b1, b2, b3, __b, b1, b2, b3));
   7879 }
   7880 
   7881 static __inline__ vector float __ATTRS_o_ai vec_vspltw(vector float __a,
   7882                                                        unsigned char __b) {
   7883   __b *= 4;
   7884   unsigned char b1 = __b + 1, b2 = __b + 2, b3 = __b + 3;
   7885   return vec_perm(__a, __a,
   7886                   (vector unsigned char)(__b, b1, b2, b3, __b, b1, b2, b3, __b,
   7887                                          b1, b2, b3, __b, b1, b2, b3));
   7888 }
   7889 
   7890 /* vec_splat_s8 */
   7891 
   7892 #define __builtin_altivec_vspltisb vec_splat_s8
   7893 
   7894 // FIXME: parameter should be treated as 5-bit signed literal
   7895 static __inline__ vector signed char __ATTRS_o_ai
   7896 vec_splat_s8(signed char __a) {
   7897   return (vector signed char)(__a);
   7898 }
   7899 
   7900 /* vec_vspltisb */
   7901 
   7902 // FIXME: parameter should be treated as 5-bit signed literal
   7903 static __inline__ vector signed char __ATTRS_o_ai
   7904 vec_vspltisb(signed char __a) {
   7905   return (vector signed char)(__a);
   7906 }
   7907 
   7908 /* vec_splat_s16 */
   7909 
   7910 #define __builtin_altivec_vspltish vec_splat_s16
   7911 
   7912 // FIXME: parameter should be treated as 5-bit signed literal
   7913 static __inline__ vector short __ATTRS_o_ai vec_splat_s16(signed char __a) {
   7914   return (vector short)(__a);
   7915 }
   7916 
   7917 /* vec_vspltish */
   7918 
   7919 // FIXME: parameter should be treated as 5-bit signed literal
   7920 static __inline__ vector short __ATTRS_o_ai vec_vspltish(signed char __a) {
   7921   return (vector short)(__a);
   7922 }
   7923 
   7924 /* vec_splat_s32 */
   7925 
   7926 #define __builtin_altivec_vspltisw vec_splat_s32
   7927 
   7928 // FIXME: parameter should be treated as 5-bit signed literal
   7929 static __inline__ vector int __ATTRS_o_ai vec_splat_s32(signed char __a) {
   7930   return (vector int)(__a);
   7931 }
   7932 
   7933 /* vec_vspltisw */
   7934 
   7935 // FIXME: parameter should be treated as 5-bit signed literal
   7936 static __inline__ vector int __ATTRS_o_ai vec_vspltisw(signed char __a) {
   7937   return (vector int)(__a);
   7938 }
   7939 
   7940 /* vec_splat_u8 */
   7941 
   7942 // FIXME: parameter should be treated as 5-bit signed literal
   7943 static __inline__ vector unsigned char __ATTRS_o_ai
   7944 vec_splat_u8(unsigned char __a) {
   7945   return (vector unsigned char)(__a);
   7946 }
   7947 
   7948 /* vec_splat_u16 */
   7949 
   7950 // FIXME: parameter should be treated as 5-bit signed literal
   7951 static __inline__ vector unsigned short __ATTRS_o_ai
   7952 vec_splat_u16(signed char __a) {
   7953   return (vector unsigned short)(__a);
   7954 }
   7955 
   7956 /* vec_splat_u32 */
   7957 
   7958 // FIXME: parameter should be treated as 5-bit signed literal
   7959 static __inline__ vector unsigned int __ATTRS_o_ai
   7960 vec_splat_u32(signed char __a) {
   7961   return (vector unsigned int)(__a);
   7962 }
   7963 
   7964 /* vec_sr */
   7965 
   7966 static __inline__ vector signed char __ATTRS_o_ai
   7967 vec_sr(vector signed char __a, vector unsigned char __b) {
   7968   vector unsigned char __res = (vector unsigned char)__a >> __b;
   7969   return (vector signed char)__res;
   7970 }
   7971 
   7972 static __inline__ vector unsigned char __ATTRS_o_ai
   7973 vec_sr(vector unsigned char __a, vector unsigned char __b) {
   7974   return __a >> __b;
   7975 }
   7976 
   7977 static __inline__ vector signed short __ATTRS_o_ai
   7978 vec_sr(vector signed short __a, vector unsigned short __b) {
   7979   vector unsigned short __res = (vector unsigned short)__a >> __b;
   7980   return (vector signed short)__res;
   7981 }
   7982 
   7983 static __inline__ vector unsigned short __ATTRS_o_ai
   7984 vec_sr(vector unsigned short __a, vector unsigned short __b) {
   7985   return __a >> __b;
   7986 }
   7987 
   7988 static __inline__ vector signed int __ATTRS_o_ai
   7989 vec_sr(vector signed int __a, vector unsigned int __b) {
   7990   vector unsigned int __res = (vector unsigned int)__a >> __b;
   7991   return (vector signed int)__res;
   7992 }
   7993 
   7994 static __inline__ vector unsigned int __ATTRS_o_ai
   7995 vec_sr(vector unsigned int __a, vector unsigned int __b) {
   7996   return __a >> __b;
   7997 }
   7998 
   7999 #ifdef __POWER8_VECTOR__
   8000 static __inline__ vector signed long long __ATTRS_o_ai
   8001 vec_sr(vector signed long long __a, vector unsigned long long __b) {
   8002   vector unsigned long long __res = (vector unsigned long long)__a >> __b;
   8003   return (vector signed long long)__res;
   8004 }
   8005 
   8006 static __inline__ vector unsigned long long __ATTRS_o_ai
   8007 vec_sr(vector unsigned long long __a, vector unsigned long long __b) {
   8008   return __a >> __b;
   8009 }
   8010 #endif
   8011 
   8012 /* vec_vsrb */
   8013 
   8014 #define __builtin_altivec_vsrb vec_vsrb
   8015 
   8016 static __inline__ vector signed char __ATTRS_o_ai
   8017 vec_vsrb(vector signed char __a, vector unsigned char __b) {
   8018   return __a >> (vector signed char)__b;
   8019 }
   8020 
   8021 static __inline__ vector unsigned char __ATTRS_o_ai
   8022 vec_vsrb(vector unsigned char __a, vector unsigned char __b) {
   8023   return __a >> __b;
   8024 }
   8025 
   8026 /* vec_vsrh */
   8027 
   8028 #define __builtin_altivec_vsrh vec_vsrh
   8029 
   8030 static __inline__ vector short __ATTRS_o_ai
   8031 vec_vsrh(vector short __a, vector unsigned short __b) {
   8032   return __a >> (vector short)__b;
   8033 }
   8034 
   8035 static __inline__ vector unsigned short __ATTRS_o_ai
   8036 vec_vsrh(vector unsigned short __a, vector unsigned short __b) {
   8037   return __a >> __b;
   8038 }
   8039 
   8040 /* vec_vsrw */
   8041 
   8042 #define __builtin_altivec_vsrw vec_vsrw
   8043 
   8044 static __inline__ vector int __ATTRS_o_ai vec_vsrw(vector int __a,
   8045                                                    vector unsigned int __b) {
   8046   return __a >> (vector int)__b;
   8047 }
   8048 
   8049 static __inline__ vector unsigned int __ATTRS_o_ai
   8050 vec_vsrw(vector unsigned int __a, vector unsigned int __b) {
   8051   return __a >> __b;
   8052 }
   8053 
   8054 /* vec_sra */
   8055 
   8056 static __inline__ vector signed char __ATTRS_o_ai
   8057 vec_sra(vector signed char __a, vector unsigned char __b) {
   8058   return (vector signed char)__builtin_altivec_vsrab((vector char)__a, __b);
   8059 }
   8060 
   8061 static __inline__ vector unsigned char __ATTRS_o_ai
   8062 vec_sra(vector unsigned char __a, vector unsigned char __b) {
   8063   return (vector unsigned char)__builtin_altivec_vsrab((vector char)__a, __b);
   8064 }
   8065 
   8066 static __inline__ vector short __ATTRS_o_ai vec_sra(vector short __a,
   8067                                                     vector unsigned short __b) {
   8068   return __builtin_altivec_vsrah(__a, (vector unsigned short)__b);
   8069 }
   8070 
   8071 static __inline__ vector unsigned short __ATTRS_o_ai
   8072 vec_sra(vector unsigned short __a, vector unsigned short __b) {
   8073   return (vector unsigned short)__builtin_altivec_vsrah((vector short)__a, __b);
   8074 }
   8075 
   8076 static __inline__ vector int __ATTRS_o_ai vec_sra(vector int __a,
   8077                                                   vector unsigned int __b) {
   8078   return __builtin_altivec_vsraw(__a, __b);
   8079 }
   8080 
   8081 static __inline__ vector unsigned int __ATTRS_o_ai
   8082 vec_sra(vector unsigned int __a, vector unsigned int __b) {
   8083   return (vector unsigned int)__builtin_altivec_vsraw((vector int)__a, __b);
   8084 }
   8085 
   8086 #ifdef __POWER8_VECTOR__
   8087 static __inline__ vector signed long long __ATTRS_o_ai
   8088 vec_sra(vector signed long long __a, vector unsigned long long __b) {
   8089   return __a >> __b;
   8090 }
   8091 
   8092 static __inline__ vector unsigned long long __ATTRS_o_ai
   8093 vec_sra(vector unsigned long long __a, vector unsigned long long __b) {
   8094   return (vector unsigned long long)((vector signed long long)__a >> __b);
   8095 }
   8096 #endif
   8097 
   8098 /* vec_vsrab */
   8099 
   8100 static __inline__ vector signed char __ATTRS_o_ai
   8101 vec_vsrab(vector signed char __a, vector unsigned char __b) {
   8102   return (vector signed char)__builtin_altivec_vsrab((vector char)__a, __b);
   8103 }
   8104 
   8105 static __inline__ vector unsigned char __ATTRS_o_ai
   8106 vec_vsrab(vector unsigned char __a, vector unsigned char __b) {
   8107   return (vector unsigned char)__builtin_altivec_vsrab((vector char)__a, __b);
   8108 }
   8109 
   8110 /* vec_vsrah */
   8111 
   8112 static __inline__ vector short __ATTRS_o_ai
   8113 vec_vsrah(vector short __a, vector unsigned short __b) {
   8114   return __builtin_altivec_vsrah(__a, (vector unsigned short)__b);
   8115 }
   8116 
   8117 static __inline__ vector unsigned short __ATTRS_o_ai
   8118 vec_vsrah(vector unsigned short __a, vector unsigned short __b) {
   8119   return (vector unsigned short)__builtin_altivec_vsrah((vector short)__a, __b);
   8120 }
   8121 
   8122 /* vec_vsraw */
   8123 
   8124 static __inline__ vector int __ATTRS_o_ai vec_vsraw(vector int __a,
   8125                                                     vector unsigned int __b) {
   8126   return __builtin_altivec_vsraw(__a, __b);
   8127 }
   8128 
   8129 static __inline__ vector unsigned int __ATTRS_o_ai
   8130 vec_vsraw(vector unsigned int __a, vector unsigned int __b) {
   8131   return (vector unsigned int)__builtin_altivec_vsraw((vector int)__a, __b);
   8132 }
   8133 
   8134 /* vec_srl */
   8135 
   8136 static __inline__ vector signed char __ATTRS_o_ai
   8137 vec_srl(vector signed char __a, vector unsigned char __b) {
   8138   return (vector signed char)__builtin_altivec_vsr((vector int)__a,
   8139                                                    (vector int)__b);
   8140 }
   8141 
   8142 static __inline__ vector signed char __ATTRS_o_ai
   8143 vec_srl(vector signed char __a, vector unsigned short __b) {
   8144   return (vector signed char)__builtin_altivec_vsr((vector int)__a,
   8145                                                    (vector int)__b);
   8146 }
   8147 
   8148 static __inline__ vector signed char __ATTRS_o_ai
   8149 vec_srl(vector signed char __a, vector unsigned int __b) {
   8150   return (vector signed char)__builtin_altivec_vsr((vector int)__a,
   8151                                                    (vector int)__b);
   8152 }
   8153 
   8154 static __inline__ vector unsigned char __ATTRS_o_ai
   8155 vec_srl(vector unsigned char __a, vector unsigned char __b) {
   8156   return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
   8157                                                      (vector int)__b);
   8158 }
   8159 
   8160 static __inline__ vector unsigned char __ATTRS_o_ai
   8161 vec_srl(vector unsigned char __a, vector unsigned short __b) {
   8162   return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
   8163                                                      (vector int)__b);
   8164 }
   8165 
   8166 static __inline__ vector unsigned char __ATTRS_o_ai
   8167 vec_srl(vector unsigned char __a, vector unsigned int __b) {
   8168   return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
   8169                                                      (vector int)__b);
   8170 }
   8171 
   8172 static __inline__ vector bool char __ATTRS_o_ai
   8173 vec_srl(vector bool char __a, vector unsigned char __b) {
   8174   return (vector bool char)__builtin_altivec_vsr((vector int)__a,
   8175                                                  (vector int)__b);
   8176 }
   8177 
   8178 static __inline__ vector bool char __ATTRS_o_ai
   8179 vec_srl(vector bool char __a, vector unsigned short __b) {
   8180   return (vector bool char)__builtin_altivec_vsr((vector int)__a,
   8181                                                  (vector int)__b);
   8182 }
   8183 
   8184 static __inline__ vector bool char __ATTRS_o_ai
   8185 vec_srl(vector bool char __a, vector unsigned int __b) {
   8186   return (vector bool char)__builtin_altivec_vsr((vector int)__a,
   8187                                                  (vector int)__b);
   8188 }
   8189 
   8190 static __inline__ vector short __ATTRS_o_ai vec_srl(vector short __a,
   8191                                                     vector unsigned char __b) {
   8192   return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
   8193 }
   8194 
   8195 static __inline__ vector short __ATTRS_o_ai vec_srl(vector short __a,
   8196                                                     vector unsigned short __b) {
   8197   return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
   8198 }
   8199 
   8200 static __inline__ vector short __ATTRS_o_ai vec_srl(vector short __a,
   8201                                                     vector unsigned int __b) {
   8202   return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
   8203 }
   8204 
   8205 static __inline__ vector unsigned short __ATTRS_o_ai
   8206 vec_srl(vector unsigned short __a, vector unsigned char __b) {
   8207   return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
   8208                                                       (vector int)__b);
   8209 }
   8210 
   8211 static __inline__ vector unsigned short __ATTRS_o_ai
   8212 vec_srl(vector unsigned short __a, vector unsigned short __b) {
   8213   return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
   8214                                                       (vector int)__b);
   8215 }
   8216 
   8217 static __inline__ vector unsigned short __ATTRS_o_ai
   8218 vec_srl(vector unsigned short __a, vector unsigned int __b) {
   8219   return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
   8220                                                       (vector int)__b);
   8221 }
   8222 
   8223 static __inline__ vector bool short __ATTRS_o_ai
   8224 vec_srl(vector bool short __a, vector unsigned char __b) {
   8225   return (vector bool short)__builtin_altivec_vsr((vector int)__a,
   8226                                                   (vector int)__b);
   8227 }
   8228 
   8229 static __inline__ vector bool short __ATTRS_o_ai
   8230 vec_srl(vector bool short __a, vector unsigned short __b) {
   8231   return (vector bool short)__builtin_altivec_vsr((vector int)__a,
   8232                                                   (vector int)__b);
   8233 }
   8234 
   8235 static __inline__ vector bool short __ATTRS_o_ai
   8236 vec_srl(vector bool short __a, vector unsigned int __b) {
   8237   return (vector bool short)__builtin_altivec_vsr((vector int)__a,
   8238                                                   (vector int)__b);
   8239 }
   8240 
   8241 static __inline__ vector pixel __ATTRS_o_ai vec_srl(vector pixel __a,
   8242                                                     vector unsigned char __b) {
   8243   return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
   8244 }
   8245 
   8246 static __inline__ vector pixel __ATTRS_o_ai vec_srl(vector pixel __a,
   8247                                                     vector unsigned short __b) {
   8248   return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
   8249 }
   8250 
   8251 static __inline__ vector pixel __ATTRS_o_ai vec_srl(vector pixel __a,
   8252                                                     vector unsigned int __b) {
   8253   return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
   8254 }
   8255 
   8256 static __inline__ vector int __ATTRS_o_ai vec_srl(vector int __a,
   8257                                                   vector unsigned char __b) {
   8258   return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
   8259 }
   8260 
   8261 static __inline__ vector int __ATTRS_o_ai vec_srl(vector int __a,
   8262                                                   vector unsigned short __b) {
   8263   return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
   8264 }
   8265 
   8266 static __inline__ vector int __ATTRS_o_ai vec_srl(vector int __a,
   8267                                                   vector unsigned int __b) {
   8268   return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
   8269 }
   8270 
   8271 static __inline__ vector unsigned int __ATTRS_o_ai
   8272 vec_srl(vector unsigned int __a, vector unsigned char __b) {
   8273   return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
   8274                                                     (vector int)__b);
   8275 }
   8276 
   8277 static __inline__ vector unsigned int __ATTRS_o_ai
   8278 vec_srl(vector unsigned int __a, vector unsigned short __b) {
   8279   return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
   8280                                                     (vector int)__b);
   8281 }
   8282 
   8283 static __inline__ vector unsigned int __ATTRS_o_ai
   8284 vec_srl(vector unsigned int __a, vector unsigned int __b) {
   8285   return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
   8286                                                     (vector int)__b);
   8287 }
   8288 
   8289 static __inline__ vector bool int __ATTRS_o_ai
   8290 vec_srl(vector bool int __a, vector unsigned char __b) {
   8291   return (vector bool int)__builtin_altivec_vsr((vector int)__a,
   8292                                                 (vector int)__b);
   8293 }
   8294 
   8295 static __inline__ vector bool int __ATTRS_o_ai
   8296 vec_srl(vector bool int __a, vector unsigned short __b) {
   8297   return (vector bool int)__builtin_altivec_vsr((vector int)__a,
   8298                                                 (vector int)__b);
   8299 }
   8300 
   8301 static __inline__ vector bool int __ATTRS_o_ai
   8302 vec_srl(vector bool int __a, vector unsigned int __b) {
   8303   return (vector bool int)__builtin_altivec_vsr((vector int)__a,
   8304                                                 (vector int)__b);
   8305 }
   8306 
   8307 /* vec_vsr */
   8308 
   8309 static __inline__ vector signed char __ATTRS_o_ai
   8310 vec_vsr(vector signed char __a, vector unsigned char __b) {
   8311   return (vector signed char)__builtin_altivec_vsr((vector int)__a,
   8312                                                    (vector int)__b);
   8313 }
   8314 
   8315 static __inline__ vector signed char __ATTRS_o_ai
   8316 vec_vsr(vector signed char __a, vector unsigned short __b) {
   8317   return (vector signed char)__builtin_altivec_vsr((vector int)__a,
   8318                                                    (vector int)__b);
   8319 }
   8320 
   8321 static __inline__ vector signed char __ATTRS_o_ai
   8322 vec_vsr(vector signed char __a, vector unsigned int __b) {
   8323   return (vector signed char)__builtin_altivec_vsr((vector int)__a,
   8324                                                    (vector int)__b);
   8325 }
   8326 
   8327 static __inline__ vector unsigned char __ATTRS_o_ai
   8328 vec_vsr(vector unsigned char __a, vector unsigned char __b) {
   8329   return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
   8330                                                      (vector int)__b);
   8331 }
   8332 
   8333 static __inline__ vector unsigned char __ATTRS_o_ai
   8334 vec_vsr(vector unsigned char __a, vector unsigned short __b) {
   8335   return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
   8336                                                      (vector int)__b);
   8337 }
   8338 
   8339 static __inline__ vector unsigned char __ATTRS_o_ai
   8340 vec_vsr(vector unsigned char __a, vector unsigned int __b) {
   8341   return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
   8342                                                      (vector int)__b);
   8343 }
   8344 
   8345 static __inline__ vector bool char __ATTRS_o_ai
   8346 vec_vsr(vector bool char __a, vector unsigned char __b) {
   8347   return (vector bool char)__builtin_altivec_vsr((vector int)__a,
   8348                                                  (vector int)__b);
   8349 }
   8350 
   8351 static __inline__ vector bool char __ATTRS_o_ai
   8352 vec_vsr(vector bool char __a, vector unsigned short __b) {
   8353   return (vector bool char)__builtin_altivec_vsr((vector int)__a,
   8354                                                  (vector int)__b);
   8355 }
   8356 
   8357 static __inline__ vector bool char __ATTRS_o_ai
   8358 vec_vsr(vector bool char __a, vector unsigned int __b) {
   8359   return (vector bool char)__builtin_altivec_vsr((vector int)__a,
   8360                                                  (vector int)__b);
   8361 }
   8362 
   8363 static __inline__ vector short __ATTRS_o_ai vec_vsr(vector short __a,
   8364                                                     vector unsigned char __b) {
   8365   return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
   8366 }
   8367 
   8368 static __inline__ vector short __ATTRS_o_ai vec_vsr(vector short __a,
   8369                                                     vector unsigned short __b) {
   8370   return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
   8371 }
   8372 
   8373 static __inline__ vector short __ATTRS_o_ai vec_vsr(vector short __a,
   8374                                                     vector unsigned int __b) {
   8375   return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
   8376 }
   8377 
   8378 static __inline__ vector unsigned short __ATTRS_o_ai
   8379 vec_vsr(vector unsigned short __a, vector unsigned char __b) {
   8380   return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
   8381                                                       (vector int)__b);
   8382 }
   8383 
   8384 static __inline__ vector unsigned short __ATTRS_o_ai
   8385 vec_vsr(vector unsigned short __a, vector unsigned short __b) {
   8386   return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
   8387                                                       (vector int)__b);
   8388 }
   8389 
   8390 static __inline__ vector unsigned short __ATTRS_o_ai
   8391 vec_vsr(vector unsigned short __a, vector unsigned int __b) {
   8392   return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
   8393                                                       (vector int)__b);
   8394 }
   8395 
   8396 static __inline__ vector bool short __ATTRS_o_ai
   8397 vec_vsr(vector bool short __a, vector unsigned char __b) {
   8398   return (vector bool short)__builtin_altivec_vsr((vector int)__a,
   8399                                                   (vector int)__b);
   8400 }
   8401 
   8402 static __inline__ vector bool short __ATTRS_o_ai
   8403 vec_vsr(vector bool short __a, vector unsigned short __b) {
   8404   return (vector bool short)__builtin_altivec_vsr((vector int)__a,
   8405                                                   (vector int)__b);
   8406 }
   8407 
   8408 static __inline__ vector bool short __ATTRS_o_ai
   8409 vec_vsr(vector bool short __a, vector unsigned int __b) {
   8410   return (vector bool short)__builtin_altivec_vsr((vector int)__a,
   8411                                                   (vector int)__b);
   8412 }
   8413 
   8414 static __inline__ vector pixel __ATTRS_o_ai vec_vsr(vector pixel __a,
   8415                                                     vector unsigned char __b) {
   8416   return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
   8417 }
   8418 
   8419 static __inline__ vector pixel __ATTRS_o_ai vec_vsr(vector pixel __a,
   8420                                                     vector unsigned short __b) {
   8421   return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
   8422 }
   8423 
   8424 static __inline__ vector pixel __ATTRS_o_ai vec_vsr(vector pixel __a,
   8425                                                     vector unsigned int __b) {
   8426   return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
   8427 }
   8428 
   8429 static __inline__ vector int __ATTRS_o_ai vec_vsr(vector int __a,
   8430                                                   vector unsigned char __b) {
   8431   return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
   8432 }
   8433 
   8434 static __inline__ vector int __ATTRS_o_ai vec_vsr(vector int __a,
   8435                                                   vector unsigned short __b) {
   8436   return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
   8437 }
   8438 
   8439 static __inline__ vector int __ATTRS_o_ai vec_vsr(vector int __a,
   8440                                                   vector unsigned int __b) {
   8441   return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
   8442 }
   8443 
   8444 static __inline__ vector unsigned int __ATTRS_o_ai
   8445 vec_vsr(vector unsigned int __a, vector unsigned char __b) {
   8446   return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
   8447                                                     (vector int)__b);
   8448 }
   8449 
   8450 static __inline__ vector unsigned int __ATTRS_o_ai
   8451 vec_vsr(vector unsigned int __a, vector unsigned short __b) {
   8452   return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
   8453                                                     (vector int)__b);
   8454 }
   8455 
   8456 static __inline__ vector unsigned int __ATTRS_o_ai
   8457 vec_vsr(vector unsigned int __a, vector unsigned int __b) {
   8458   return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
   8459                                                     (vector int)__b);
   8460 }
   8461 
   8462 static __inline__ vector bool int __ATTRS_o_ai
   8463 vec_vsr(vector bool int __a, vector unsigned char __b) {
   8464   return (vector bool int)__builtin_altivec_vsr((vector int)__a,
   8465                                                 (vector int)__b);
   8466 }
   8467 
   8468 static __inline__ vector bool int __ATTRS_o_ai
   8469 vec_vsr(vector bool int __a, vector unsigned short __b) {
   8470   return (vector bool int)__builtin_altivec_vsr((vector int)__a,
   8471                                                 (vector int)__b);
   8472 }
   8473 
   8474 static __inline__ vector bool int __ATTRS_o_ai
   8475 vec_vsr(vector bool int __a, vector unsigned int __b) {
   8476   return (vector bool int)__builtin_altivec_vsr((vector int)__a,
   8477                                                 (vector int)__b);
   8478 }
   8479 
   8480 /* vec_sro */
   8481 
   8482 static __inline__ vector signed char __ATTRS_o_ai
   8483 vec_sro(vector signed char __a, vector signed char __b) {
   8484   return (vector signed char)__builtin_altivec_vsro((vector int)__a,
   8485                                                     (vector int)__b);
   8486 }
   8487 
   8488 static __inline__ vector signed char __ATTRS_o_ai
   8489 vec_sro(vector signed char __a, vector unsigned char __b) {
   8490   return (vector signed char)__builtin_altivec_vsro((vector int)__a,
   8491                                                     (vector int)__b);
   8492 }
   8493 
   8494 static __inline__ vector unsigned char __ATTRS_o_ai
   8495 vec_sro(vector unsigned char __a, vector signed char __b) {
   8496   return (vector unsigned char)__builtin_altivec_vsro((vector int)__a,
   8497                                                       (vector int)__b);
   8498 }
   8499 
   8500 static __inline__ vector unsigned char __ATTRS_o_ai
   8501 vec_sro(vector unsigned char __a, vector unsigned char __b) {
   8502   return (vector unsigned char)__builtin_altivec_vsro((vector int)__a,
   8503                                                       (vector int)__b);
   8504 }
   8505 
   8506 static __inline__ vector short __ATTRS_o_ai vec_sro(vector short __a,
   8507                                                     vector signed char __b) {
   8508   return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
   8509 }
   8510 
   8511 static __inline__ vector short __ATTRS_o_ai vec_sro(vector short __a,
   8512                                                     vector unsigned char __b) {
   8513   return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
   8514 }
   8515 
   8516 static __inline__ vector unsigned short __ATTRS_o_ai
   8517 vec_sro(vector unsigned short __a, vector signed char __b) {
   8518   return (vector unsigned short)__builtin_altivec_vsro((vector int)__a,
   8519                                                        (vector int)__b);
   8520 }
   8521 
   8522 static __inline__ vector unsigned short __ATTRS_o_ai
   8523 vec_sro(vector unsigned short __a, vector unsigned char __b) {
   8524   return (vector unsigned short)__builtin_altivec_vsro((vector int)__a,
   8525                                                        (vector int)__b);
   8526 }
   8527 
   8528 static __inline__ vector pixel __ATTRS_o_ai vec_sro(vector pixel __a,
   8529                                                     vector signed char __b) {
   8530   return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
   8531 }
   8532 
   8533 static __inline__ vector pixel __ATTRS_o_ai vec_sro(vector pixel __a,
   8534                                                     vector unsigned char __b) {
   8535   return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
   8536 }
   8537 
   8538 static __inline__ vector int __ATTRS_o_ai vec_sro(vector int __a,
   8539                                                   vector signed char __b) {
   8540   return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
   8541 }
   8542 
   8543 static __inline__ vector int __ATTRS_o_ai vec_sro(vector int __a,
   8544                                                   vector unsigned char __b) {
   8545   return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
   8546 }
   8547 
   8548 static __inline__ vector unsigned int __ATTRS_o_ai
   8549 vec_sro(vector unsigned int __a, vector signed char __b) {
   8550   return (vector unsigned int)__builtin_altivec_vsro((vector int)__a,
   8551                                                      (vector int)__b);
   8552 }
   8553 
   8554 static __inline__ vector unsigned int __ATTRS_o_ai
   8555 vec_sro(vector unsigned int __a, vector unsigned char __b) {
   8556   return (vector unsigned int)__builtin_altivec_vsro((vector int)__a,
   8557                                                      (vector int)__b);
   8558 }
   8559 
   8560 static __inline__ vector float __ATTRS_o_ai vec_sro(vector float __a,
   8561                                                     vector signed char __b) {
   8562   return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
   8563 }
   8564 
   8565 static __inline__ vector float __ATTRS_o_ai vec_sro(vector float __a,
   8566                                                     vector unsigned char __b) {
   8567   return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
   8568 }
   8569 
   8570 /* vec_vsro */
   8571 
   8572 static __inline__ vector signed char __ATTRS_o_ai
   8573 vec_vsro(vector signed char __a, vector signed char __b) {
   8574   return (vector signed char)__builtin_altivec_vsro((vector int)__a,
   8575                                                     (vector int)__b);
   8576 }
   8577 
   8578 static __inline__ vector signed char __ATTRS_o_ai
   8579 vec_vsro(vector signed char __a, vector unsigned char __b) {
   8580   return (vector signed char)__builtin_altivec_vsro((vector int)__a,
   8581                                                     (vector int)__b);
   8582 }
   8583 
   8584 static __inline__ vector unsigned char __ATTRS_o_ai
   8585 vec_vsro(vector unsigned char __a, vector signed char __b) {
   8586   return (vector unsigned char)__builtin_altivec_vsro((vector int)__a,
   8587                                                       (vector int)__b);
   8588 }
   8589 
   8590 static __inline__ vector unsigned char __ATTRS_o_ai
   8591 vec_vsro(vector unsigned char __a, vector unsigned char __b) {
   8592   return (vector unsigned char)__builtin_altivec_vsro((vector int)__a,
   8593                                                       (vector int)__b);
   8594 }
   8595 
   8596 static __inline__ vector short __ATTRS_o_ai vec_vsro(vector short __a,
   8597                                                      vector signed char __b) {
   8598   return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
   8599 }
   8600 
   8601 static __inline__ vector short __ATTRS_o_ai vec_vsro(vector short __a,
   8602                                                      vector unsigned char __b) {
   8603   return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
   8604 }
   8605 
   8606 static __inline__ vector unsigned short __ATTRS_o_ai
   8607 vec_vsro(vector unsigned short __a, vector signed char __b) {
   8608   return (vector unsigned short)__builtin_altivec_vsro((vector int)__a,
   8609                                                        (vector int)__b);
   8610 }
   8611 
   8612 static __inline__ vector unsigned short __ATTRS_o_ai
   8613 vec_vsro(vector unsigned short __a, vector unsigned char __b) {
   8614   return (vector unsigned short)__builtin_altivec_vsro((vector int)__a,
   8615                                                        (vector int)__b);
   8616 }
   8617 
   8618 static __inline__ vector pixel __ATTRS_o_ai vec_vsro(vector pixel __a,
   8619                                                      vector signed char __b) {
   8620   return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
   8621 }
   8622 
   8623 static __inline__ vector pixel __ATTRS_o_ai vec_vsro(vector pixel __a,
   8624                                                      vector unsigned char __b) {
   8625   return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
   8626 }
   8627 
   8628 static __inline__ vector int __ATTRS_o_ai vec_vsro(vector int __a,
   8629                                                    vector signed char __b) {
   8630   return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
   8631 }
   8632 
   8633 static __inline__ vector int __ATTRS_o_ai vec_vsro(vector int __a,
   8634                                                    vector unsigned char __b) {
   8635   return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
   8636 }
   8637 
   8638 static __inline__ vector unsigned int __ATTRS_o_ai
   8639 vec_vsro(vector unsigned int __a, vector signed char __b) {
   8640   return (vector unsigned int)__builtin_altivec_vsro((vector int)__a,
   8641                                                      (vector int)__b);
   8642 }
   8643 
   8644 static __inline__ vector unsigned int __ATTRS_o_ai
   8645 vec_vsro(vector unsigned int __a, vector unsigned char __b) {
   8646   return (vector unsigned int)__builtin_altivec_vsro((vector int)__a,
   8647                                                      (vector int)__b);
   8648 }
   8649 
   8650 static __inline__ vector float __ATTRS_o_ai vec_vsro(vector float __a,
   8651                                                      vector signed char __b) {
   8652   return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
   8653 }
   8654 
   8655 static __inline__ vector float __ATTRS_o_ai vec_vsro(vector float __a,
   8656                                                      vector unsigned char __b) {
   8657   return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
   8658 }
   8659 
   8660 /* vec_st */
   8661 
   8662 static __inline__ void __ATTRS_o_ai vec_st(vector signed char __a, int __b,
   8663                                            vector signed char *__c) {
   8664   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8665 }
   8666 
   8667 static __inline__ void __ATTRS_o_ai vec_st(vector signed char __a, int __b,
   8668                                            signed char *__c) {
   8669   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8670 }
   8671 
   8672 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned char __a, int __b,
   8673                                            vector unsigned char *__c) {
   8674   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8675 }
   8676 
   8677 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned char __a, int __b,
   8678                                            unsigned char *__c) {
   8679   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8680 }
   8681 
   8682 static __inline__ void __ATTRS_o_ai vec_st(vector bool char __a, int __b,
   8683                                            signed char *__c) {
   8684   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8685 }
   8686 
   8687 static __inline__ void __ATTRS_o_ai vec_st(vector bool char __a, int __b,
   8688                                            unsigned char *__c) {
   8689   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8690 }
   8691 
   8692 static __inline__ void __ATTRS_o_ai vec_st(vector bool char __a, int __b,
   8693                                            vector bool char *__c) {
   8694   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8695 }
   8696 
   8697 static __inline__ void __ATTRS_o_ai vec_st(vector short __a, int __b,
   8698                                            vector short *__c) {
   8699   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8700 }
   8701 
   8702 static __inline__ void __ATTRS_o_ai vec_st(vector short __a, int __b,
   8703                                            short *__c) {
   8704   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8705 }
   8706 
   8707 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned short __a, int __b,
   8708                                            vector unsigned short *__c) {
   8709   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8710 }
   8711 
   8712 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned short __a, int __b,
   8713                                            unsigned short *__c) {
   8714   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8715 }
   8716 
   8717 static __inline__ void __ATTRS_o_ai vec_st(vector bool short __a, int __b,
   8718                                            short *__c) {
   8719   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8720 }
   8721 
   8722 static __inline__ void __ATTRS_o_ai vec_st(vector bool short __a, int __b,
   8723                                            unsigned short *__c) {
   8724   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8725 }
   8726 
   8727 static __inline__ void __ATTRS_o_ai vec_st(vector bool short __a, int __b,
   8728                                            vector bool short *__c) {
   8729   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8730 }
   8731 
   8732 static __inline__ void __ATTRS_o_ai vec_st(vector pixel __a, int __b,
   8733                                            short *__c) {
   8734   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8735 }
   8736 
   8737 static __inline__ void __ATTRS_o_ai vec_st(vector pixel __a, int __b,
   8738                                            unsigned short *__c) {
   8739   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8740 }
   8741 
   8742 static __inline__ void __ATTRS_o_ai vec_st(vector pixel __a, int __b,
   8743                                            vector pixel *__c) {
   8744   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8745 }
   8746 
   8747 static __inline__ void __ATTRS_o_ai vec_st(vector int __a, int __b,
   8748                                            vector int *__c) {
   8749   __builtin_altivec_stvx(__a, __b, __c);
   8750 }
   8751 
   8752 static __inline__ void __ATTRS_o_ai vec_st(vector int __a, int __b, int *__c) {
   8753   __builtin_altivec_stvx(__a, __b, __c);
   8754 }
   8755 
   8756 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned int __a, int __b,
   8757                                            vector unsigned int *__c) {
   8758   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8759 }
   8760 
   8761 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned int __a, int __b,
   8762                                            unsigned int *__c) {
   8763   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8764 }
   8765 
   8766 static __inline__ void __ATTRS_o_ai vec_st(vector bool int __a, int __b,
   8767                                            int *__c) {
   8768   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8769 }
   8770 
   8771 static __inline__ void __ATTRS_o_ai vec_st(vector bool int __a, int __b,
   8772                                            unsigned int *__c) {
   8773   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8774 }
   8775 
   8776 static __inline__ void __ATTRS_o_ai vec_st(vector bool int __a, int __b,
   8777                                            vector bool int *__c) {
   8778   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8779 }
   8780 
   8781 static __inline__ void __ATTRS_o_ai vec_st(vector float __a, int __b,
   8782                                            vector float *__c) {
   8783   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8784 }
   8785 
   8786 static __inline__ void __ATTRS_o_ai vec_st(vector float __a, int __b,
   8787                                            float *__c) {
   8788   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8789 }
   8790 
   8791 /* vec_stvx */
   8792 
   8793 static __inline__ void __ATTRS_o_ai vec_stvx(vector signed char __a, int __b,
   8794                                              vector signed char *__c) {
   8795   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8796 }
   8797 
   8798 static __inline__ void __ATTRS_o_ai vec_stvx(vector signed char __a, int __b,
   8799                                              signed char *__c) {
   8800   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8801 }
   8802 
   8803 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned char __a, int __b,
   8804                                              vector unsigned char *__c) {
   8805   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8806 }
   8807 
   8808 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned char __a, int __b,
   8809                                              unsigned char *__c) {
   8810   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8811 }
   8812 
   8813 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool char __a, int __b,
   8814                                              signed char *__c) {
   8815   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8816 }
   8817 
   8818 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool char __a, int __b,
   8819                                              unsigned char *__c) {
   8820   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8821 }
   8822 
   8823 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool char __a, int __b,
   8824                                              vector bool char *__c) {
   8825   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8826 }
   8827 
   8828 static __inline__ void __ATTRS_o_ai vec_stvx(vector short __a, int __b,
   8829                                              vector short *__c) {
   8830   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8831 }
   8832 
   8833 static __inline__ void __ATTRS_o_ai vec_stvx(vector short __a, int __b,
   8834                                              short *__c) {
   8835   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8836 }
   8837 
   8838 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned short __a, int __b,
   8839                                              vector unsigned short *__c) {
   8840   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8841 }
   8842 
   8843 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned short __a, int __b,
   8844                                              unsigned short *__c) {
   8845   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8846 }
   8847 
   8848 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool short __a, int __b,
   8849                                              short *__c) {
   8850   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8851 }
   8852 
   8853 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool short __a, int __b,
   8854                                              unsigned short *__c) {
   8855   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8856 }
   8857 
   8858 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool short __a, int __b,
   8859                                              vector bool short *__c) {
   8860   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8861 }
   8862 
   8863 static __inline__ void __ATTRS_o_ai vec_stvx(vector pixel __a, int __b,
   8864                                              short *__c) {
   8865   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8866 }
   8867 
   8868 static __inline__ void __ATTRS_o_ai vec_stvx(vector pixel __a, int __b,
   8869                                              unsigned short *__c) {
   8870   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8871 }
   8872 
   8873 static __inline__ void __ATTRS_o_ai vec_stvx(vector pixel __a, int __b,
   8874                                              vector pixel *__c) {
   8875   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8876 }
   8877 
   8878 static __inline__ void __ATTRS_o_ai vec_stvx(vector int __a, int __b,
   8879                                              vector int *__c) {
   8880   __builtin_altivec_stvx(__a, __b, __c);
   8881 }
   8882 
   8883 static __inline__ void __ATTRS_o_ai vec_stvx(vector int __a, int __b,
   8884                                              int *__c) {
   8885   __builtin_altivec_stvx(__a, __b, __c);
   8886 }
   8887 
   8888 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned int __a, int __b,
   8889                                              vector unsigned int *__c) {
   8890   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8891 }
   8892 
   8893 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned int __a, int __b,
   8894                                              unsigned int *__c) {
   8895   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8896 }
   8897 
   8898 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool int __a, int __b,
   8899                                              int *__c) {
   8900   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8901 }
   8902 
   8903 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool int __a, int __b,
   8904                                              unsigned int *__c) {
   8905   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8906 }
   8907 
   8908 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool int __a, int __b,
   8909                                              vector bool int *__c) {
   8910   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8911 }
   8912 
   8913 static __inline__ void __ATTRS_o_ai vec_stvx(vector float __a, int __b,
   8914                                              vector float *__c) {
   8915   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8916 }
   8917 
   8918 static __inline__ void __ATTRS_o_ai vec_stvx(vector float __a, int __b,
   8919                                              float *__c) {
   8920   __builtin_altivec_stvx((vector int)__a, __b, __c);
   8921 }
   8922 
   8923 /* vec_ste */
   8924 
   8925 static __inline__ void __ATTRS_o_ai vec_ste(vector signed char __a, int __b,
   8926                                             signed char *__c) {
   8927   __builtin_altivec_stvebx((vector char)__a, __b, __c);
   8928 }
   8929 
   8930 static __inline__ void __ATTRS_o_ai vec_ste(vector unsigned char __a, int __b,
   8931                                             unsigned char *__c) {
   8932   __builtin_altivec_stvebx((vector char)__a, __b, __c);
   8933 }
   8934 
   8935 static __inline__ void __ATTRS_o_ai vec_ste(vector bool char __a, int __b,
   8936                                             signed char *__c) {
   8937   __builtin_altivec_stvebx((vector char)__a, __b, __c);
   8938 }
   8939 
   8940 static __inline__ void __ATTRS_o_ai vec_ste(vector bool char __a, int __b,
   8941                                             unsigned char *__c) {
   8942   __builtin_altivec_stvebx((vector char)__a, __b, __c);
   8943 }
   8944 
   8945 static __inline__ void __ATTRS_o_ai vec_ste(vector short __a, int __b,
   8946                                             short *__c) {
   8947   __builtin_altivec_stvehx(__a, __b, __c);
   8948 }
   8949 
   8950 static __inline__ void __ATTRS_o_ai vec_ste(vector unsigned short __a, int __b,
   8951                                             unsigned short *__c) {
   8952   __builtin_altivec_stvehx((vector short)__a, __b, __c);
   8953 }
   8954 
   8955 static __inline__ void __ATTRS_o_ai vec_ste(vector bool short __a, int __b,
   8956                                             short *__c) {
   8957   __builtin_altivec_stvehx((vector short)__a, __b, __c);
   8958 }
   8959 
   8960 static __inline__ void __ATTRS_o_ai vec_ste(vector bool short __a, int __b,
   8961                                             unsigned short *__c) {
   8962   __builtin_altivec_stvehx((vector short)__a, __b, __c);
   8963 }
   8964 
   8965 static __inline__ void __ATTRS_o_ai vec_ste(vector pixel __a, int __b,
   8966                                             short *__c) {
   8967   __builtin_altivec_stvehx((vector short)__a, __b, __c);
   8968 }
   8969 
   8970 static __inline__ void __ATTRS_o_ai vec_ste(vector pixel __a, int __b,
   8971                                             unsigned short *__c) {
   8972   __builtin_altivec_stvehx((vector short)__a, __b, __c);
   8973 }
   8974 
   8975 static __inline__ void __ATTRS_o_ai vec_ste(vector int __a, int __b, int *__c) {
   8976   __builtin_altivec_stvewx(__a, __b, __c);
   8977 }
   8978 
   8979 static __inline__ void __ATTRS_o_ai vec_ste(vector unsigned int __a, int __b,
   8980                                             unsigned int *__c) {
   8981   __builtin_altivec_stvewx((vector int)__a, __b, __c);
   8982 }
   8983 
   8984 static __inline__ void __ATTRS_o_ai vec_ste(vector bool int __a, int __b,
   8985                                             int *__c) {
   8986   __builtin_altivec_stvewx((vector int)__a, __b, __c);
   8987 }
   8988 
   8989 static __inline__ void __ATTRS_o_ai vec_ste(vector bool int __a, int __b,
   8990                                             unsigned int *__c) {
   8991   __builtin_altivec_stvewx((vector int)__a, __b, __c);
   8992 }
   8993 
   8994 static __inline__ void __ATTRS_o_ai vec_ste(vector float __a, int __b,
   8995                                             float *__c) {
   8996   __builtin_altivec_stvewx((vector int)__a, __b, __c);
   8997 }
   8998 
   8999 /* vec_stvebx */
   9000 
   9001 static __inline__ void __ATTRS_o_ai vec_stvebx(vector signed char __a, int __b,
   9002                                                signed char *__c) {
   9003   __builtin_altivec_stvebx((vector char)__a, __b, __c);
   9004 }
   9005 
   9006 static __inline__ void __ATTRS_o_ai vec_stvebx(vector unsigned char __a,
   9007                                                int __b, unsigned char *__c) {
   9008   __builtin_altivec_stvebx((vector char)__a, __b, __c);
   9009 }
   9010 
   9011 static __inline__ void __ATTRS_o_ai vec_stvebx(vector bool char __a, int __b,
   9012                                                signed char *__c) {
   9013   __builtin_altivec_stvebx((vector char)__a, __b, __c);
   9014 }
   9015 
   9016 static __inline__ void __ATTRS_o_ai vec_stvebx(vector bool char __a, int __b,
   9017                                                unsigned char *__c) {
   9018   __builtin_altivec_stvebx((vector char)__a, __b, __c);
   9019 }
   9020 
   9021 /* vec_stvehx */
   9022 
   9023 static __inline__ void __ATTRS_o_ai vec_stvehx(vector short __a, int __b,
   9024                                                short *__c) {
   9025   __builtin_altivec_stvehx(__a, __b, __c);
   9026 }
   9027 
   9028 static __inline__ void __ATTRS_o_ai vec_stvehx(vector unsigned short __a,
   9029                                                int __b, unsigned short *__c) {
   9030   __builtin_altivec_stvehx((vector short)__a, __b, __c);
   9031 }
   9032 
   9033 static __inline__ void __ATTRS_o_ai vec_stvehx(vector bool short __a, int __b,
   9034                                                short *__c) {
   9035   __builtin_altivec_stvehx((vector short)__a, __b, __c);
   9036 }
   9037 
   9038 static __inline__ void __ATTRS_o_ai vec_stvehx(vector bool short __a, int __b,
   9039                                                unsigned short *__c) {
   9040   __builtin_altivec_stvehx((vector short)__a, __b, __c);
   9041 }
   9042 
   9043 static __inline__ void __ATTRS_o_ai vec_stvehx(vector pixel __a, int __b,
   9044                                                short *__c) {
   9045   __builtin_altivec_stvehx((vector short)__a, __b, __c);
   9046 }
   9047 
   9048 static __inline__ void __ATTRS_o_ai vec_stvehx(vector pixel __a, int __b,
   9049                                                unsigned short *__c) {
   9050   __builtin_altivec_stvehx((vector short)__a, __b, __c);
   9051 }
   9052 
   9053 /* vec_stvewx */
   9054 
   9055 static __inline__ void __ATTRS_o_ai vec_stvewx(vector int __a, int __b,
   9056                                                int *__c) {
   9057   __builtin_altivec_stvewx(__a, __b, __c);
   9058 }
   9059 
   9060 static __inline__ void __ATTRS_o_ai vec_stvewx(vector unsigned int __a, int __b,
   9061                                                unsigned int *__c) {
   9062   __builtin_altivec_stvewx((vector int)__a, __b, __c);
   9063 }
   9064 
   9065 static __inline__ void __ATTRS_o_ai vec_stvewx(vector bool int __a, int __b,
   9066                                                int *__c) {
   9067   __builtin_altivec_stvewx((vector int)__a, __b, __c);
   9068 }
   9069 
   9070 static __inline__ void __ATTRS_o_ai vec_stvewx(vector bool int __a, int __b,
   9071                                                unsigned int *__c) {
   9072   __builtin_altivec_stvewx((vector int)__a, __b, __c);
   9073 }
   9074 
   9075 static __inline__ void __ATTRS_o_ai vec_stvewx(vector float __a, int __b,
   9076                                                float *__c) {
   9077   __builtin_altivec_stvewx((vector int)__a, __b, __c);
   9078 }
   9079 
   9080 /* vec_stl */
   9081 
   9082 static __inline__ void __ATTRS_o_ai vec_stl(vector signed char __a, int __b,
   9083                                             vector signed char *__c) {
   9084   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9085 }
   9086 
   9087 static __inline__ void __ATTRS_o_ai vec_stl(vector signed char __a, int __b,
   9088                                             signed char *__c) {
   9089   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9090 }
   9091 
   9092 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned char __a, int __b,
   9093                                             vector unsigned char *__c) {
   9094   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9095 }
   9096 
   9097 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned char __a, int __b,
   9098                                             unsigned char *__c) {
   9099   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9100 }
   9101 
   9102 static __inline__ void __ATTRS_o_ai vec_stl(vector bool char __a, int __b,
   9103                                             signed char *__c) {
   9104   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9105 }
   9106 
   9107 static __inline__ void __ATTRS_o_ai vec_stl(vector bool char __a, int __b,
   9108                                             unsigned char *__c) {
   9109   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9110 }
   9111 
   9112 static __inline__ void __ATTRS_o_ai vec_stl(vector bool char __a, int __b,
   9113                                             vector bool char *__c) {
   9114   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9115 }
   9116 
   9117 static __inline__ void __ATTRS_o_ai vec_stl(vector short __a, int __b,
   9118                                             vector short *__c) {
   9119   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9120 }
   9121 
   9122 static __inline__ void __ATTRS_o_ai vec_stl(vector short __a, int __b,
   9123                                             short *__c) {
   9124   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9125 }
   9126 
   9127 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned short __a, int __b,
   9128                                             vector unsigned short *__c) {
   9129   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9130 }
   9131 
   9132 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned short __a, int __b,
   9133                                             unsigned short *__c) {
   9134   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9135 }
   9136 
   9137 static __inline__ void __ATTRS_o_ai vec_stl(vector bool short __a, int __b,
   9138                                             short *__c) {
   9139   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9140 }
   9141 
   9142 static __inline__ void __ATTRS_o_ai vec_stl(vector bool short __a, int __b,
   9143                                             unsigned short *__c) {
   9144   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9145 }
   9146 
   9147 static __inline__ void __ATTRS_o_ai vec_stl(vector bool short __a, int __b,
   9148                                             vector bool short *__c) {
   9149   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9150 }
   9151 
   9152 static __inline__ void __ATTRS_o_ai vec_stl(vector pixel __a, int __b,
   9153                                             short *__c) {
   9154   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9155 }
   9156 
   9157 static __inline__ void __ATTRS_o_ai vec_stl(vector pixel __a, int __b,
   9158                                             unsigned short *__c) {
   9159   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9160 }
   9161 
   9162 static __inline__ void __ATTRS_o_ai vec_stl(vector pixel __a, int __b,
   9163                                             vector pixel *__c) {
   9164   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9165 }
   9166 
   9167 static __inline__ void __ATTRS_o_ai vec_stl(vector int __a, int __b,
   9168                                             vector int *__c) {
   9169   __builtin_altivec_stvxl(__a, __b, __c);
   9170 }
   9171 
   9172 static __inline__ void __ATTRS_o_ai vec_stl(vector int __a, int __b, int *__c) {
   9173   __builtin_altivec_stvxl(__a, __b, __c);
   9174 }
   9175 
   9176 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned int __a, int __b,
   9177                                             vector unsigned int *__c) {
   9178   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9179 }
   9180 
   9181 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned int __a, int __b,
   9182                                             unsigned int *__c) {
   9183   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9184 }
   9185 
   9186 static __inline__ void __ATTRS_o_ai vec_stl(vector bool int __a, int __b,
   9187                                             int *__c) {
   9188   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9189 }
   9190 
   9191 static __inline__ void __ATTRS_o_ai vec_stl(vector bool int __a, int __b,
   9192                                             unsigned int *__c) {
   9193   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9194 }
   9195 
   9196 static __inline__ void __ATTRS_o_ai vec_stl(vector bool int __a, int __b,
   9197                                             vector bool int *__c) {
   9198   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9199 }
   9200 
   9201 static __inline__ void __ATTRS_o_ai vec_stl(vector float __a, int __b,
   9202                                             vector float *__c) {
   9203   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9204 }
   9205 
   9206 static __inline__ void __ATTRS_o_ai vec_stl(vector float __a, int __b,
   9207                                             float *__c) {
   9208   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9209 }
   9210 
   9211 /* vec_stvxl */
   9212 
   9213 static __inline__ void __ATTRS_o_ai vec_stvxl(vector signed char __a, int __b,
   9214                                               vector signed char *__c) {
   9215   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9216 }
   9217 
   9218 static __inline__ void __ATTRS_o_ai vec_stvxl(vector signed char __a, int __b,
   9219                                               signed char *__c) {
   9220   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9221 }
   9222 
   9223 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned char __a, int __b,
   9224                                               vector unsigned char *__c) {
   9225   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9226 }
   9227 
   9228 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned char __a, int __b,
   9229                                               unsigned char *__c) {
   9230   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9231 }
   9232 
   9233 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool char __a, int __b,
   9234                                               signed char *__c) {
   9235   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9236 }
   9237 
   9238 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool char __a, int __b,
   9239                                               unsigned char *__c) {
   9240   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9241 }
   9242 
   9243 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool char __a, int __b,
   9244                                               vector bool char *__c) {
   9245   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9246 }
   9247 
   9248 static __inline__ void __ATTRS_o_ai vec_stvxl(vector short __a, int __b,
   9249                                               vector short *__c) {
   9250   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9251 }
   9252 
   9253 static __inline__ void __ATTRS_o_ai vec_stvxl(vector short __a, int __b,
   9254                                               short *__c) {
   9255   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9256 }
   9257 
   9258 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned short __a,
   9259                                               int __b,
   9260                                               vector unsigned short *__c) {
   9261   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9262 }
   9263 
   9264 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned short __a,
   9265                                               int __b, unsigned short *__c) {
   9266   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9267 }
   9268 
   9269 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool short __a, int __b,
   9270                                               short *__c) {
   9271   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9272 }
   9273 
   9274 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool short __a, int __b,
   9275                                               unsigned short *__c) {
   9276   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9277 }
   9278 
   9279 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool short __a, int __b,
   9280                                               vector bool short *__c) {
   9281   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9282 }
   9283 
   9284 static __inline__ void __ATTRS_o_ai vec_stvxl(vector pixel __a, int __b,
   9285                                               short *__c) {
   9286   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9287 }
   9288 
   9289 static __inline__ void __ATTRS_o_ai vec_stvxl(vector pixel __a, int __b,
   9290                                               unsigned short *__c) {
   9291   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9292 }
   9293 
   9294 static __inline__ void __ATTRS_o_ai vec_stvxl(vector pixel __a, int __b,
   9295                                               vector pixel *__c) {
   9296   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9297 }
   9298 
   9299 static __inline__ void __ATTRS_o_ai vec_stvxl(vector int __a, int __b,
   9300                                               vector int *__c) {
   9301   __builtin_altivec_stvxl(__a, __b, __c);
   9302 }
   9303 
   9304 static __inline__ void __ATTRS_o_ai vec_stvxl(vector int __a, int __b,
   9305                                               int *__c) {
   9306   __builtin_altivec_stvxl(__a, __b, __c);
   9307 }
   9308 
   9309 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned int __a, int __b,
   9310                                               vector unsigned int *__c) {
   9311   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9312 }
   9313 
   9314 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned int __a, int __b,
   9315                                               unsigned int *__c) {
   9316   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9317 }
   9318 
   9319 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool int __a, int __b,
   9320                                               int *__c) {
   9321   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9322 }
   9323 
   9324 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool int __a, int __b,
   9325                                               unsigned int *__c) {
   9326   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9327 }
   9328 
   9329 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool int __a, int __b,
   9330                                               vector bool int *__c) {
   9331   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9332 }
   9333 
   9334 static __inline__ void __ATTRS_o_ai vec_stvxl(vector float __a, int __b,
   9335                                               vector float *__c) {
   9336   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9337 }
   9338 
   9339 static __inline__ void __ATTRS_o_ai vec_stvxl(vector float __a, int __b,
   9340                                               float *__c) {
   9341   __builtin_altivec_stvxl((vector int)__a, __b, __c);
   9342 }
   9343 
   9344 /* vec_sub */
   9345 
   9346 static __inline__ vector signed char __ATTRS_o_ai
   9347 vec_sub(vector signed char __a, vector signed char __b) {
   9348   return __a - __b;
   9349 }
   9350 
   9351 static __inline__ vector signed char __ATTRS_o_ai
   9352 vec_sub(vector bool char __a, vector signed char __b) {
   9353   return (vector signed char)__a - __b;
   9354 }
   9355 
   9356 static __inline__ vector signed char __ATTRS_o_ai
   9357 vec_sub(vector signed char __a, vector bool char __b) {
   9358   return __a - (vector signed char)__b;
   9359 }
   9360 
   9361 static __inline__ vector unsigned char __ATTRS_o_ai
   9362 vec_sub(vector unsigned char __a, vector unsigned char __b) {
   9363   return __a - __b;
   9364 }
   9365 
   9366 static __inline__ vector unsigned char __ATTRS_o_ai
   9367 vec_sub(vector bool char __a, vector unsigned char __b) {
   9368   return (vector unsigned char)__a - __b;
   9369 }
   9370 
   9371 static __inline__ vector unsigned char __ATTRS_o_ai
   9372 vec_sub(vector unsigned char __a, vector bool char __b) {
   9373   return __a - (vector unsigned char)__b;
   9374 }
   9375 
   9376 static __inline__ vector short __ATTRS_o_ai vec_sub(vector short __a,
   9377                                                     vector short __b) {
   9378   return __a - __b;
   9379 }
   9380 
   9381 static __inline__ vector short __ATTRS_o_ai vec_sub(vector bool short __a,
   9382                                                     vector short __b) {
   9383   return (vector short)__a - __b;
   9384 }
   9385 
   9386 static __inline__ vector short __ATTRS_o_ai vec_sub(vector short __a,
   9387                                                     vector bool short __b) {
   9388   return __a - (vector short)__b;
   9389 }
   9390 
   9391 static __inline__ vector unsigned short __ATTRS_o_ai
   9392 vec_sub(vector unsigned short __a, vector unsigned short __b) {
   9393   return __a - __b;
   9394 }
   9395 
   9396 static __inline__ vector unsigned short __ATTRS_o_ai
   9397 vec_sub(vector bool short __a, vector unsigned short __b) {
   9398   return (vector unsigned short)__a - __b;
   9399 }
   9400 
   9401 static __inline__ vector unsigned short __ATTRS_o_ai
   9402 vec_sub(vector unsigned short __a, vector bool short __b) {
   9403   return __a - (vector unsigned short)__b;
   9404 }
   9405 
   9406 static __inline__ vector int __ATTRS_o_ai vec_sub(vector int __a,
   9407                                                   vector int __b) {
   9408   return __a - __b;
   9409 }
   9410 
   9411 static __inline__ vector int __ATTRS_o_ai vec_sub(vector bool int __a,
   9412                                                   vector int __b) {
   9413   return (vector int)__a - __b;
   9414 }
   9415 
   9416 static __inline__ vector int __ATTRS_o_ai vec_sub(vector int __a,
   9417                                                   vector bool int __b) {
   9418   return __a - (vector int)__b;
   9419 }
   9420 
   9421 static __inline__ vector unsigned int __ATTRS_o_ai
   9422 vec_sub(vector unsigned int __a, vector unsigned int __b) {
   9423   return __a - __b;
   9424 }
   9425 
   9426 static __inline__ vector unsigned int __ATTRS_o_ai
   9427 vec_sub(vector bool int __a, vector unsigned int __b) {
   9428   return (vector unsigned int)__a - __b;
   9429 }
   9430 
   9431 static __inline__ vector unsigned int __ATTRS_o_ai
   9432 vec_sub(vector unsigned int __a, vector bool int __b) {
   9433   return __a - (vector unsigned int)__b;
   9434 }
   9435 
   9436 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
   9437 static __inline__ vector signed __int128 __ATTRS_o_ai
   9438 vec_sub(vector signed __int128 __a, vector signed __int128 __b) {
   9439   return __a - __b;
   9440 }
   9441 
   9442 static __inline__ vector unsigned __int128 __ATTRS_o_ai
   9443 vec_sub(vector unsigned __int128 __a, vector unsigned __int128 __b) {
   9444   return __a - __b;
   9445 }
   9446 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
   9447 
   9448 #ifdef __VSX__
   9449 static __inline__ vector signed long long __ATTRS_o_ai
   9450 vec_sub(vector signed long long __a, vector signed long long __b) {
   9451   return __a - __b;
   9452 }
   9453 
   9454 static __inline__ vector unsigned long long __ATTRS_o_ai
   9455 vec_sub(vector unsigned long long __a, vector unsigned long long __b) {
   9456   return __a - __b;
   9457 }
   9458 
   9459 static __inline__ vector double __ATTRS_o_ai vec_sub(vector double __a,
   9460                                                      vector double __b) {
   9461   return __a - __b;
   9462 }
   9463 #endif
   9464 
   9465 static __inline__ vector float __ATTRS_o_ai vec_sub(vector float __a,
   9466                                                     vector float __b) {
   9467   return __a - __b;
   9468 }
   9469 
   9470 /* vec_vsububm */
   9471 
   9472 #define __builtin_altivec_vsububm vec_vsububm
   9473 
   9474 static __inline__ vector signed char __ATTRS_o_ai
   9475 vec_vsububm(vector signed char __a, vector signed char __b) {
   9476   return __a - __b;
   9477 }
   9478 
   9479 static __inline__ vector signed char __ATTRS_o_ai
   9480 vec_vsububm(vector bool char __a, vector signed char __b) {
   9481   return (vector signed char)__a - __b;
   9482 }
   9483 
   9484 static __inline__ vector signed char __ATTRS_o_ai
   9485 vec_vsububm(vector signed char __a, vector bool char __b) {
   9486   return __a - (vector signed char)__b;
   9487 }
   9488 
   9489 static __inline__ vector unsigned char __ATTRS_o_ai
   9490 vec_vsububm(vector unsigned char __a, vector unsigned char __b) {
   9491   return __a - __b;
   9492 }
   9493 
   9494 static __inline__ vector unsigned char __ATTRS_o_ai
   9495 vec_vsububm(vector bool char __a, vector unsigned char __b) {
   9496   return (vector unsigned char)__a - __b;
   9497 }
   9498 
   9499 static __inline__ vector unsigned char __ATTRS_o_ai
   9500 vec_vsububm(vector unsigned char __a, vector bool char __b) {
   9501   return __a - (vector unsigned char)__b;
   9502 }
   9503 
   9504 /* vec_vsubuhm */
   9505 
   9506 #define __builtin_altivec_vsubuhm vec_vsubuhm
   9507 
   9508 static __inline__ vector short __ATTRS_o_ai vec_vsubuhm(vector short __a,
   9509                                                         vector short __b) {
   9510   return __a - __b;
   9511 }
   9512 
   9513 static __inline__ vector short __ATTRS_o_ai vec_vsubuhm(vector bool short __a,
   9514                                                         vector short __b) {
   9515   return (vector short)__a - __b;
   9516 }
   9517 
   9518 static __inline__ vector short __ATTRS_o_ai vec_vsubuhm(vector short __a,
   9519                                                         vector bool short __b) {
   9520   return __a - (vector short)__b;
   9521 }
   9522 
   9523 static __inline__ vector unsigned short __ATTRS_o_ai
   9524 vec_vsubuhm(vector unsigned short __a, vector unsigned short __b) {
   9525   return __a - __b;
   9526 }
   9527 
   9528 static __inline__ vector unsigned short __ATTRS_o_ai
   9529 vec_vsubuhm(vector bool short __a, vector unsigned short __b) {
   9530   return (vector unsigned short)__a - __b;
   9531 }
   9532 
   9533 static __inline__ vector unsigned short __ATTRS_o_ai
   9534 vec_vsubuhm(vector unsigned short __a, vector bool short __b) {
   9535   return __a - (vector unsigned short)__b;
   9536 }
   9537 
   9538 /* vec_vsubuwm */
   9539 
   9540 #define __builtin_altivec_vsubuwm vec_vsubuwm
   9541 
   9542 static __inline__ vector int __ATTRS_o_ai vec_vsubuwm(vector int __a,
   9543                                                       vector int __b) {
   9544   return __a - __b;
   9545 }
   9546 
   9547 static __inline__ vector int __ATTRS_o_ai vec_vsubuwm(vector bool int __a,
   9548                                                       vector int __b) {
   9549   return (vector int)__a - __b;
   9550 }
   9551 
   9552 static __inline__ vector int __ATTRS_o_ai vec_vsubuwm(vector int __a,
   9553                                                       vector bool int __b) {
   9554   return __a - (vector int)__b;
   9555 }
   9556 
   9557 static __inline__ vector unsigned int __ATTRS_o_ai
   9558 vec_vsubuwm(vector unsigned int __a, vector unsigned int __b) {
   9559   return __a - __b;
   9560 }
   9561 
   9562 static __inline__ vector unsigned int __ATTRS_o_ai
   9563 vec_vsubuwm(vector bool int __a, vector unsigned int __b) {
   9564   return (vector unsigned int)__a - __b;
   9565 }
   9566 
   9567 static __inline__ vector unsigned int __ATTRS_o_ai
   9568 vec_vsubuwm(vector unsigned int __a, vector bool int __b) {
   9569   return __a - (vector unsigned int)__b;
   9570 }
   9571 
   9572 /* vec_vsubfp */
   9573 
   9574 #define __builtin_altivec_vsubfp vec_vsubfp
   9575 
   9576 static __inline__ vector float __attribute__((__always_inline__))
   9577 vec_vsubfp(vector float __a, vector float __b) {
   9578   return __a - __b;
   9579 }
   9580 
   9581 /* vec_subc */
   9582 
   9583 static __inline__ vector unsigned int __ATTRS_o_ai
   9584 vec_subc(vector unsigned int __a, vector unsigned int __b) {
   9585   return __builtin_altivec_vsubcuw(__a, __b);
   9586 }
   9587 
   9588 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
   9589 static __inline__ vector unsigned __int128 __ATTRS_o_ai
   9590 vec_subc(vector unsigned __int128 __a, vector unsigned __int128 __b) {
   9591   return __builtin_altivec_vsubcuq(__a, __b);
   9592 }
   9593 
   9594 static __inline__ vector signed __int128 __ATTRS_o_ai
   9595 vec_subc(vector signed __int128 __a, vector signed __int128 __b) {
   9596   return __builtin_altivec_vsubcuq(__a, __b);
   9597 }
   9598 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
   9599 
   9600 /* vec_vsubcuw */
   9601 
   9602 static __inline__ vector unsigned int __attribute__((__always_inline__))
   9603 vec_vsubcuw(vector unsigned int __a, vector unsigned int __b) {
   9604   return __builtin_altivec_vsubcuw(__a, __b);
   9605 }
   9606 
   9607 /* vec_subs */
   9608 
   9609 static __inline__ vector signed char __ATTRS_o_ai
   9610 vec_subs(vector signed char __a, vector signed char __b) {
   9611   return __builtin_altivec_vsubsbs(__a, __b);
   9612 }
   9613 
   9614 static __inline__ vector signed char __ATTRS_o_ai
   9615 vec_subs(vector bool char __a, vector signed char __b) {
   9616   return __builtin_altivec_vsubsbs((vector signed char)__a, __b);
   9617 }
   9618 
   9619 static __inline__ vector signed char __ATTRS_o_ai
   9620 vec_subs(vector signed char __a, vector bool char __b) {
   9621   return __builtin_altivec_vsubsbs(__a, (vector signed char)__b);
   9622 }
   9623 
   9624 static __inline__ vector unsigned char __ATTRS_o_ai
   9625 vec_subs(vector unsigned char __a, vector unsigned char __b) {
   9626   return __builtin_altivec_vsububs(__a, __b);
   9627 }
   9628 
   9629 static __inline__ vector unsigned char __ATTRS_o_ai
   9630 vec_subs(vector bool char __a, vector unsigned char __b) {
   9631   return __builtin_altivec_vsububs((vector unsigned char)__a, __b);
   9632 }
   9633 
   9634 static __inline__ vector unsigned char __ATTRS_o_ai
   9635 vec_subs(vector unsigned char __a, vector bool char __b) {
   9636   return __builtin_altivec_vsububs(__a, (vector unsigned char)__b);
   9637 }
   9638 
   9639 static __inline__ vector short __ATTRS_o_ai vec_subs(vector short __a,
   9640                                                      vector short __b) {
   9641   return __builtin_altivec_vsubshs(__a, __b);
   9642 }
   9643 
   9644 static __inline__ vector short __ATTRS_o_ai vec_subs(vector bool short __a,
   9645                                                      vector short __b) {
   9646   return __builtin_altivec_vsubshs((vector short)__a, __b);
   9647 }
   9648 
   9649 static __inline__ vector short __ATTRS_o_ai vec_subs(vector short __a,
   9650                                                      vector bool short __b) {
   9651   return __builtin_altivec_vsubshs(__a, (vector short)__b);
   9652 }
   9653 
   9654 static __inline__ vector unsigned short __ATTRS_o_ai
   9655 vec_subs(vector unsigned short __a, vector unsigned short __b) {
   9656   return __builtin_altivec_vsubuhs(__a, __b);
   9657 }
   9658 
   9659 static __inline__ vector unsigned short __ATTRS_o_ai
   9660 vec_subs(vector bool short __a, vector unsigned short __b) {
   9661   return __builtin_altivec_vsubuhs((vector unsigned short)__a, __b);
   9662 }
   9663 
   9664 static __inline__ vector unsigned short __ATTRS_o_ai
   9665 vec_subs(vector unsigned short __a, vector bool short __b) {
   9666   return __builtin_altivec_vsubuhs(__a, (vector unsigned short)__b);
   9667 }
   9668 
   9669 static __inline__ vector int __ATTRS_o_ai vec_subs(vector int __a,
   9670                                                    vector int __b) {
   9671   return __builtin_altivec_vsubsws(__a, __b);
   9672 }
   9673 
   9674 static __inline__ vector int __ATTRS_o_ai vec_subs(vector bool int __a,
   9675                                                    vector int __b) {
   9676   return __builtin_altivec_vsubsws((vector int)__a, __b);
   9677 }
   9678 
   9679 static __inline__ vector int __ATTRS_o_ai vec_subs(vector int __a,
   9680                                                    vector bool int __b) {
   9681   return __builtin_altivec_vsubsws(__a, (vector int)__b);
   9682 }
   9683 
   9684 static __inline__ vector unsigned int __ATTRS_o_ai
   9685 vec_subs(vector unsigned int __a, vector unsigned int __b) {
   9686   return __builtin_altivec_vsubuws(__a, __b);
   9687 }
   9688 
   9689 static __inline__ vector unsigned int __ATTRS_o_ai
   9690 vec_subs(vector bool int __a, vector unsigned int __b) {
   9691   return __builtin_altivec_vsubuws((vector unsigned int)__a, __b);
   9692 }
   9693 
   9694 static __inline__ vector unsigned int __ATTRS_o_ai
   9695 vec_subs(vector unsigned int __a, vector bool int __b) {
   9696   return __builtin_altivec_vsubuws(__a, (vector unsigned int)__b);
   9697 }
   9698 
   9699 /* vec_vsubsbs */
   9700 
   9701 static __inline__ vector signed char __ATTRS_o_ai
   9702 vec_vsubsbs(vector signed char __a, vector signed char __b) {
   9703   return __builtin_altivec_vsubsbs(__a, __b);
   9704 }
   9705 
   9706 static __inline__ vector signed char __ATTRS_o_ai
   9707 vec_vsubsbs(vector bool char __a, vector signed char __b) {
   9708   return __builtin_altivec_vsubsbs((vector signed char)__a, __b);
   9709 }
   9710 
   9711 static __inline__ vector signed char __ATTRS_o_ai
   9712 vec_vsubsbs(vector signed char __a, vector bool char __b) {
   9713   return __builtin_altivec_vsubsbs(__a, (vector signed char)__b);
   9714 }
   9715 
   9716 /* vec_vsububs */
   9717 
   9718 static __inline__ vector unsigned char __ATTRS_o_ai
   9719 vec_vsububs(vector unsigned char __a, vector unsigned char __b) {
   9720   return __builtin_altivec_vsububs(__a, __b);
   9721 }
   9722 
   9723 static __inline__ vector unsigned char __ATTRS_o_ai
   9724 vec_vsububs(vector bool char __a, vector unsigned char __b) {
   9725   return __builtin_altivec_vsububs((vector unsigned char)__a, __b);
   9726 }
   9727 
   9728 static __inline__ vector unsigned char __ATTRS_o_ai
   9729 vec_vsububs(vector unsigned char __a, vector bool char __b) {
   9730   return __builtin_altivec_vsububs(__a, (vector unsigned char)__b);
   9731 }
   9732 
   9733 /* vec_vsubshs */
   9734 
   9735 static __inline__ vector short __ATTRS_o_ai vec_vsubshs(vector short __a,
   9736                                                         vector short __b) {
   9737   return __builtin_altivec_vsubshs(__a, __b);
   9738 }
   9739 
   9740 static __inline__ vector short __ATTRS_o_ai vec_vsubshs(vector bool short __a,
   9741                                                         vector short __b) {
   9742   return __builtin_altivec_vsubshs((vector short)__a, __b);
   9743 }
   9744 
   9745 static __inline__ vector short __ATTRS_o_ai vec_vsubshs(vector short __a,
   9746                                                         vector bool short __b) {
   9747   return __builtin_altivec_vsubshs(__a, (vector short)__b);
   9748 }
   9749 
   9750 /* vec_vsubuhs */
   9751 
   9752 static __inline__ vector unsigned short __ATTRS_o_ai
   9753 vec_vsubuhs(vector unsigned short __a, vector unsigned short __b) {
   9754   return __builtin_altivec_vsubuhs(__a, __b);
   9755 }
   9756 
   9757 static __inline__ vector unsigned short __ATTRS_o_ai
   9758 vec_vsubuhs(vector bool short __a, vector unsigned short __b) {
   9759   return __builtin_altivec_vsubuhs((vector unsigned short)__a, __b);
   9760 }
   9761 
   9762 static __inline__ vector unsigned short __ATTRS_o_ai
   9763 vec_vsubuhs(vector unsigned short __a, vector bool short __b) {
   9764   return __builtin_altivec_vsubuhs(__a, (vector unsigned short)__b);
   9765 }
   9766 
   9767 /* vec_vsubsws */
   9768 
   9769 static __inline__ vector int __ATTRS_o_ai vec_vsubsws(vector int __a,
   9770                                                       vector int __b) {
   9771   return __builtin_altivec_vsubsws(__a, __b);
   9772 }
   9773 
   9774 static __inline__ vector int __ATTRS_o_ai vec_vsubsws(vector bool int __a,
   9775                                                       vector int __b) {
   9776   return __builtin_altivec_vsubsws((vector int)__a, __b);
   9777 }
   9778 
   9779 static __inline__ vector int __ATTRS_o_ai vec_vsubsws(vector int __a,
   9780                                                       vector bool int __b) {
   9781   return __builtin_altivec_vsubsws(__a, (vector int)__b);
   9782 }
   9783 
   9784 /* vec_vsubuws */
   9785 
   9786 static __inline__ vector unsigned int __ATTRS_o_ai
   9787 vec_vsubuws(vector unsigned int __a, vector unsigned int __b) {
   9788   return __builtin_altivec_vsubuws(__a, __b);
   9789 }
   9790 
   9791 static __inline__ vector unsigned int __ATTRS_o_ai
   9792 vec_vsubuws(vector bool int __a, vector unsigned int __b) {
   9793   return __builtin_altivec_vsubuws((vector unsigned int)__a, __b);
   9794 }
   9795 
   9796 static __inline__ vector unsigned int __ATTRS_o_ai
   9797 vec_vsubuws(vector unsigned int __a, vector bool int __b) {
   9798   return __builtin_altivec_vsubuws(__a, (vector unsigned int)__b);
   9799 }
   9800 
   9801 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
   9802 /* vec_vsubuqm */
   9803 
   9804 static __inline__ vector signed __int128 __ATTRS_o_ai
   9805 vec_vsubuqm(vector signed __int128 __a, vector signed __int128 __b) {
   9806   return __a - __b;
   9807 }
   9808 
   9809 static __inline__ vector unsigned __int128 __ATTRS_o_ai
   9810 vec_vsubuqm(vector unsigned __int128 __a, vector unsigned __int128 __b) {
   9811   return __a - __b;
   9812 }
   9813 
   9814 /* vec_vsubeuqm */
   9815 
   9816 static __inline__ vector signed __int128 __ATTRS_o_ai
   9817 vec_vsubeuqm(vector signed __int128 __a, vector signed __int128 __b,
   9818              vector signed __int128 __c) {
   9819   return __builtin_altivec_vsubeuqm(__a, __b, __c);
   9820 }
   9821 
   9822 static __inline__ vector unsigned __int128 __ATTRS_o_ai
   9823 vec_vsubeuqm(vector unsigned __int128 __a, vector unsigned __int128 __b,
   9824              vector unsigned __int128 __c) {
   9825   return __builtin_altivec_vsubeuqm(__a, __b, __c);
   9826 }
   9827 
   9828 /* vec_vsubcuq */
   9829 
   9830 static __inline__ vector signed __int128 __ATTRS_o_ai
   9831 vec_vsubcuq(vector signed __int128 __a, vector signed __int128 __b) {
   9832   return __builtin_altivec_vsubcuq(__a, __b);
   9833 }
   9834 
   9835 static __inline__ vector unsigned __int128 __ATTRS_o_ai
   9836 vec_vsubcuq(vector unsigned __int128 __a, vector unsigned __int128 __b) {
   9837   return __builtin_altivec_vsubcuq(__a, __b);
   9838 }
   9839 
   9840 /* vec_vsubecuq */
   9841 
   9842 static __inline__ vector signed __int128 __ATTRS_o_ai
   9843 vec_vsubecuq(vector signed __int128 __a, vector signed __int128 __b,
   9844              vector signed __int128 __c) {
   9845   return __builtin_altivec_vsubecuq(__a, __b, __c);
   9846 }
   9847 
   9848 static __inline__ vector unsigned __int128 __ATTRS_o_ai
   9849 vec_vsubecuq(vector unsigned __int128 __a, vector unsigned __int128 __b,
   9850              vector unsigned __int128 __c) {
   9851   return __builtin_altivec_vsubecuq(__a, __b, __c);
   9852 }
   9853 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
   9854 
   9855 /* vec_sum4s */
   9856 
   9857 static __inline__ vector int __ATTRS_o_ai vec_sum4s(vector signed char __a,
   9858                                                     vector int __b) {
   9859   return __builtin_altivec_vsum4sbs(__a, __b);
   9860 }
   9861 
   9862 static __inline__ vector unsigned int __ATTRS_o_ai
   9863 vec_sum4s(vector unsigned char __a, vector unsigned int __b) {
   9864   return __builtin_altivec_vsum4ubs(__a, __b);
   9865 }
   9866 
   9867 static __inline__ vector int __ATTRS_o_ai vec_sum4s(vector signed short __a,
   9868                                                     vector int __b) {
   9869   return __builtin_altivec_vsum4shs(__a, __b);
   9870 }
   9871 
   9872 /* vec_vsum4sbs */
   9873 
   9874 static __inline__ vector int __attribute__((__always_inline__))
   9875 vec_vsum4sbs(vector signed char __a, vector int __b) {
   9876   return __builtin_altivec_vsum4sbs(__a, __b);
   9877 }
   9878 
   9879 /* vec_vsum4ubs */
   9880 
   9881 static __inline__ vector unsigned int __attribute__((__always_inline__))
   9882 vec_vsum4ubs(vector unsigned char __a, vector unsigned int __b) {
   9883   return __builtin_altivec_vsum4ubs(__a, __b);
   9884 }
   9885 
   9886 /* vec_vsum4shs */
   9887 
   9888 static __inline__ vector int __attribute__((__always_inline__))
   9889 vec_vsum4shs(vector signed short __a, vector int __b) {
   9890   return __builtin_altivec_vsum4shs(__a, __b);
   9891 }
   9892 
   9893 /* vec_sum2s */
   9894 
   9895 /* The vsum2sws instruction has a big-endian bias, so that the second
   9896    input vector and the result always reference big-endian elements
   9897    1 and 3 (little-endian element 0 and 2).  For ease of porting the
   9898    programmer wants elements 1 and 3 in both cases, so for little
   9899    endian we must perform some permutes.  */
   9900 
   9901 static __inline__ vector signed int __attribute__((__always_inline__))
   9902 vec_sum2s(vector int __a, vector int __b) {
   9903 #ifdef __LITTLE_ENDIAN__
   9904   vector int __c = (vector signed int)vec_perm(
   9905       __b, __b, (vector unsigned char)(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15,
   9906                                        8, 9, 10, 11));
   9907   __c = __builtin_altivec_vsum2sws(__a, __c);
   9908   return (vector signed int)vec_perm(
   9909       __c, __c, (vector unsigned char)(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15,
   9910                                        8, 9, 10, 11));
   9911 #else
   9912   return __builtin_altivec_vsum2sws(__a, __b);
   9913 #endif
   9914 }
   9915 
   9916 /* vec_vsum2sws */
   9917 
   9918 static __inline__ vector signed int __attribute__((__always_inline__))
   9919 vec_vsum2sws(vector int __a, vector int __b) {
   9920 #ifdef __LITTLE_ENDIAN__
   9921   vector int __c = (vector signed int)vec_perm(
   9922       __b, __b, (vector unsigned char)(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15,
   9923                                        8, 9, 10, 11));
   9924   __c = __builtin_altivec_vsum2sws(__a, __c);
   9925   return (vector signed int)vec_perm(
   9926       __c, __c, (vector unsigned char)(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15,
   9927                                        8, 9, 10, 11));
   9928 #else
   9929   return __builtin_altivec_vsum2sws(__a, __b);
   9930 #endif
   9931 }
   9932 
   9933 /* vec_sums */
   9934 
   9935 /* The vsumsws instruction has a big-endian bias, so that the second
   9936    input vector and the result always reference big-endian element 3
   9937    (little-endian element 0).  For ease of porting the programmer
   9938    wants element 3 in both cases, so for little endian we must perform
   9939    some permutes.  */
   9940 
   9941 static __inline__ vector signed int __attribute__((__always_inline__))
   9942 vec_sums(vector signed int __a, vector signed int __b) {
   9943 #ifdef __LITTLE_ENDIAN__
   9944   __b = (vector signed int)vec_splat(__b, 3);
   9945   __b = __builtin_altivec_vsumsws(__a, __b);
   9946   return (vector signed int)(0, 0, 0, __b[0]);
   9947 #else
   9948   return __builtin_altivec_vsumsws(__a, __b);
   9949 #endif
   9950 }
   9951 
   9952 /* vec_vsumsws */
   9953 
   9954 static __inline__ vector signed int __attribute__((__always_inline__))
   9955 vec_vsumsws(vector signed int __a, vector signed int __b) {
   9956 #ifdef __LITTLE_ENDIAN__
   9957   __b = (vector signed int)vec_splat(__b, 3);
   9958   __b = __builtin_altivec_vsumsws(__a, __b);
   9959   return (vector signed int)(0, 0, 0, __b[0]);
   9960 #else
   9961   return __builtin_altivec_vsumsws(__a, __b);
   9962 #endif
   9963 }
   9964 
   9965 /* vec_trunc */
   9966 
   9967 static __inline__ vector float __ATTRS_o_ai vec_trunc(vector float __a) {
   9968 #ifdef __VSX__
   9969   return __builtin_vsx_xvrspiz(__a);
   9970 #else
   9971   return __builtin_altivec_vrfiz(__a);
   9972 #endif
   9973 }
   9974 
   9975 #ifdef __VSX__
   9976 static __inline__ vector double __ATTRS_o_ai vec_trunc(vector double __a) {
   9977   return __builtin_vsx_xvrdpiz(__a);
   9978 }
   9979 #endif
   9980 
   9981 /* vec_vrfiz */
   9982 
   9983 static __inline__ vector float __attribute__((__always_inline__))
   9984 vec_vrfiz(vector float __a) {
   9985   return __builtin_altivec_vrfiz(__a);
   9986 }
   9987 
   9988 /* vec_unpackh */
   9989 
   9990 /* The vector unpack instructions all have a big-endian bias, so for
   9991    little endian we must reverse the meanings of "high" and "low."  */
   9992 
   9993 static __inline__ vector short __ATTRS_o_ai
   9994 vec_unpackh(vector signed char __a) {
   9995 #ifdef __LITTLE_ENDIAN__
   9996   return __builtin_altivec_vupklsb((vector char)__a);
   9997 #else
   9998   return __builtin_altivec_vupkhsb((vector char)__a);
   9999 #endif
   10000 }
   10001 
   10002 static __inline__ vector bool short __ATTRS_o_ai
   10003 vec_unpackh(vector bool char __a) {
   10004 #ifdef __LITTLE_ENDIAN__
   10005   return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
   10006 #else
   10007   return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
   10008 #endif
   10009 }
   10010 
   10011 static __inline__ vector int __ATTRS_o_ai vec_unpackh(vector short __a) {
   10012 #ifdef __LITTLE_ENDIAN__
   10013   return __builtin_altivec_vupklsh(__a);
   10014 #else
   10015   return __builtin_altivec_vupkhsh(__a);
   10016 #endif
   10017 }
   10018 
   10019 static __inline__ vector bool int __ATTRS_o_ai
   10020 vec_unpackh(vector bool short __a) {
   10021 #ifdef __LITTLE_ENDIAN__
   10022   return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
   10023 #else
   10024   return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
   10025 #endif
   10026 }
   10027 
   10028 static __inline__ vector unsigned int __ATTRS_o_ai
   10029 vec_unpackh(vector pixel __a) {
   10030 #ifdef __LITTLE_ENDIAN__
   10031   return (vector unsigned int)__builtin_altivec_vupklpx((vector short)__a);
   10032 #else
   10033   return (vector unsigned int)__builtin_altivec_vupkhpx((vector short)__a);
   10034 #endif
   10035 }
   10036 
   10037 #ifdef __POWER8_VECTOR__
   10038 static __inline__ vector long long __ATTRS_o_ai vec_unpackh(vector int __a) {
   10039 #ifdef __LITTLE_ENDIAN__
   10040   return __builtin_altivec_vupklsw(__a);
   10041 #else
   10042   return __builtin_altivec_vupkhsw(__a);
   10043 #endif
   10044 }
   10045 
   10046 static __inline__ vector bool long long __ATTRS_o_ai
   10047 vec_unpackh(vector bool int __a) {
   10048 #ifdef __LITTLE_ENDIAN__
   10049   return (vector bool long long)__builtin_altivec_vupklsw((vector int)__a);
   10050 #else
   10051   return (vector bool long long)__builtin_altivec_vupkhsw((vector int)__a);
   10052 #endif
   10053 }
   10054 #endif
   10055 
   10056 /* vec_vupkhsb */
   10057 
   10058 static __inline__ vector short __ATTRS_o_ai
   10059 vec_vupkhsb(vector signed char __a) {
   10060 #ifdef __LITTLE_ENDIAN__
   10061   return __builtin_altivec_vupklsb((vector char)__a);
   10062 #else
   10063   return __builtin_altivec_vupkhsb((vector char)__a);
   10064 #endif
   10065 }
   10066 
   10067 static __inline__ vector bool short __ATTRS_o_ai
   10068 vec_vupkhsb(vector bool char __a) {
   10069 #ifdef __LITTLE_ENDIAN__
   10070   return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
   10071 #else
   10072   return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
   10073 #endif
   10074 }
   10075 
   10076 /* vec_vupkhsh */
   10077 
   10078 static __inline__ vector int __ATTRS_o_ai vec_vupkhsh(vector short __a) {
   10079 #ifdef __LITTLE_ENDIAN__
   10080   return __builtin_altivec_vupklsh(__a);
   10081 #else
   10082   return __builtin_altivec_vupkhsh(__a);
   10083 #endif
   10084 }
   10085 
   10086 static __inline__ vector bool int __ATTRS_o_ai
   10087 vec_vupkhsh(vector bool short __a) {
   10088 #ifdef __LITTLE_ENDIAN__
   10089   return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
   10090 #else
   10091   return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
   10092 #endif
   10093 }
   10094 
   10095 static __inline__ vector unsigned int __ATTRS_o_ai
   10096 vec_vupkhsh(vector pixel __a) {
   10097 #ifdef __LITTLE_ENDIAN__
   10098   return (vector unsigned int)__builtin_altivec_vupklpx((vector short)__a);
   10099 #else
   10100   return (vector unsigned int)__builtin_altivec_vupkhpx((vector short)__a);
   10101 #endif
   10102 }
   10103 
   10104 /* vec_vupkhsw */
   10105 
   10106 #ifdef __POWER8_VECTOR__
   10107 static __inline__ vector long long __ATTRS_o_ai vec_vupkhsw(vector int __a) {
   10108 #ifdef __LITTLE_ENDIAN__
   10109   return __builtin_altivec_vupklsw(__a);
   10110 #else
   10111   return __builtin_altivec_vupkhsw(__a);
   10112 #endif
   10113 }
   10114 
   10115 static __inline__ vector bool long long __ATTRS_o_ai
   10116 vec_vupkhsw(vector bool int __a) {
   10117 #ifdef __LITTLE_ENDIAN__
   10118   return (vector bool long long)__builtin_altivec_vupklsw((vector int)__a);
   10119 #else
   10120   return (vector bool long long)__builtin_altivec_vupkhsw((vector int)__a);
   10121 #endif
   10122 }
   10123 #endif
   10124 
   10125 /* vec_unpackl */
   10126 
   10127 static __inline__ vector short __ATTRS_o_ai
   10128 vec_unpackl(vector signed char __a) {
   10129 #ifdef __LITTLE_ENDIAN__
   10130   return __builtin_altivec_vupkhsb((vector char)__a);
   10131 #else
   10132   return __builtin_altivec_vupklsb((vector char)__a);
   10133 #endif
   10134 }
   10135 
   10136 static __inline__ vector bool short __ATTRS_o_ai
   10137 vec_unpackl(vector bool char __a) {
   10138 #ifdef __LITTLE_ENDIAN__
   10139   return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
   10140 #else
   10141   return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
   10142 #endif
   10143 }
   10144 
   10145 static __inline__ vector int __ATTRS_o_ai vec_unpackl(vector short __a) {
   10146 #ifdef __LITTLE_ENDIAN__
   10147   return __builtin_altivec_vupkhsh(__a);
   10148 #else
   10149   return __builtin_altivec_vupklsh(__a);
   10150 #endif
   10151 }
   10152 
   10153 static __inline__ vector bool int __ATTRS_o_ai
   10154 vec_unpackl(vector bool short __a) {
   10155 #ifdef __LITTLE_ENDIAN__
   10156   return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
   10157 #else
   10158   return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
   10159 #endif
   10160 }
   10161 
   10162 static __inline__ vector unsigned int __ATTRS_o_ai
   10163 vec_unpackl(vector pixel __a) {
   10164 #ifdef __LITTLE_ENDIAN__
   10165   return (vector unsigned int)__builtin_altivec_vupkhpx((vector short)__a);
   10166 #else
   10167   return (vector unsigned int)__builtin_altivec_vupklpx((vector short)__a);
   10168 #endif
   10169 }
   10170 
   10171 #ifdef __POWER8_VECTOR__
   10172 static __inline__ vector long long __ATTRS_o_ai vec_unpackl(vector int __a) {
   10173 #ifdef __LITTLE_ENDIAN__
   10174   return __builtin_altivec_vupkhsw(__a);
   10175 #else
   10176   return __builtin_altivec_vupklsw(__a);
   10177 #endif
   10178 }
   10179 
   10180 static __inline__ vector bool long long __ATTRS_o_ai
   10181 vec_unpackl(vector bool int __a) {
   10182 #ifdef __LITTLE_ENDIAN__
   10183   return (vector bool long long)__builtin_altivec_vupkhsw((vector int)__a);
   10184 #else
   10185   return (vector bool long long)__builtin_altivec_vupklsw((vector int)__a);
   10186 #endif
   10187 }
   10188 #endif
   10189 
   10190 /* vec_vupklsb */
   10191 
   10192 static __inline__ vector short __ATTRS_o_ai
   10193 vec_vupklsb(vector signed char __a) {
   10194 #ifdef __LITTLE_ENDIAN__
   10195   return __builtin_altivec_vupkhsb((vector char)__a);
   10196 #else
   10197   return __builtin_altivec_vupklsb((vector char)__a);
   10198 #endif
   10199 }
   10200 
   10201 static __inline__ vector bool short __ATTRS_o_ai
   10202 vec_vupklsb(vector bool char __a) {
   10203 #ifdef __LITTLE_ENDIAN__
   10204   return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
   10205 #else
   10206   return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
   10207 #endif
   10208 }
   10209 
   10210 /* vec_vupklsh */
   10211 
   10212 static __inline__ vector int __ATTRS_o_ai vec_vupklsh(vector short __a) {
   10213 #ifdef __LITTLE_ENDIAN__
   10214   return __builtin_altivec_vupkhsh(__a);
   10215 #else
   10216   return __builtin_altivec_vupklsh(__a);
   10217 #endif
   10218 }
   10219 
   10220 static __inline__ vector bool int __ATTRS_o_ai
   10221 vec_vupklsh(vector bool short __a) {
   10222 #ifdef __LITTLE_ENDIAN__
   10223   return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
   10224 #else
   10225   return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
   10226 #endif
   10227 }
   10228 
   10229 static __inline__ vector unsigned int __ATTRS_o_ai
   10230 vec_vupklsh(vector pixel __a) {
   10231 #ifdef __LITTLE_ENDIAN__
   10232   return (vector unsigned int)__builtin_altivec_vupkhpx((vector short)__a);
   10233 #else
   10234   return (vector unsigned int)__builtin_altivec_vupklpx((vector short)__a);
   10235 #endif
   10236 }
   10237 
   10238 /* vec_vupklsw */
   10239 
   10240 #ifdef __POWER8_VECTOR__
   10241 static __inline__ vector long long __ATTRS_o_ai vec_vupklsw(vector int __a) {
   10242 #ifdef __LITTLE_ENDIAN__
   10243   return __builtin_altivec_vupkhsw(__a);
   10244 #else
   10245   return __builtin_altivec_vupklsw(__a);
   10246 #endif
   10247 }
   10248 
   10249 static __inline__ vector bool long long __ATTRS_o_ai
   10250 vec_vupklsw(vector bool int __a) {
   10251 #ifdef __LITTLE_ENDIAN__
   10252   return (vector bool long long)__builtin_altivec_vupkhsw((vector int)__a);
   10253 #else
   10254   return (vector bool long long)__builtin_altivec_vupklsw((vector int)__a);
   10255 #endif
   10256 }
   10257 #endif
   10258 
   10259 /* vec_vsx_ld */
   10260 
   10261 #ifdef __VSX__
   10262 
   10263 static __inline__ vector bool int __ATTRS_o_ai
   10264 vec_vsx_ld(int __a, const vector bool int *__b) {
   10265   return (vector bool int)__builtin_vsx_lxvw4x(__a, __b);
   10266 }
   10267 
   10268 static __inline__ vector signed int __ATTRS_o_ai
   10269 vec_vsx_ld(int __a, const vector signed int *__b) {
   10270   return (vector signed int)__builtin_vsx_lxvw4x(__a, __b);
   10271 }
   10272 
   10273 static __inline__ vector signed int __ATTRS_o_ai
   10274 vec_vsx_ld(int __a, const signed int *__b) {
   10275   return (vector signed int)__builtin_vsx_lxvw4x(__a, __b);
   10276 }
   10277 
   10278 static __inline__ vector unsigned int __ATTRS_o_ai
   10279 vec_vsx_ld(int __a, const vector unsigned int *__b) {
   10280   return (vector unsigned int)__builtin_vsx_lxvw4x(__a, __b);
   10281 }
   10282 
   10283 static __inline__ vector unsigned int __ATTRS_o_ai
   10284 vec_vsx_ld(int __a, const unsigned int *__b) {
   10285   return (vector unsigned int)__builtin_vsx_lxvw4x(__a, __b);
   10286 }
   10287 
   10288 static __inline__ vector float __ATTRS_o_ai
   10289 vec_vsx_ld(int __a, const vector float *__b) {
   10290   return (vector float)__builtin_vsx_lxvw4x(__a, __b);
   10291 }
   10292 
   10293 static __inline__ vector float __ATTRS_o_ai vec_vsx_ld(int __a,
   10294                                                        const float *__b) {
   10295   return (vector float)__builtin_vsx_lxvw4x(__a, __b);
   10296 }
   10297 
   10298 static __inline__ vector signed long long __ATTRS_o_ai
   10299 vec_vsx_ld(int __a, const vector signed long long *__b) {
   10300   return (vector signed long long)__builtin_vsx_lxvd2x(__a, __b);
   10301 }
   10302 
   10303 static __inline__ vector unsigned long long __ATTRS_o_ai
   10304 vec_vsx_ld(int __a, const vector unsigned long long *__b) {
   10305   return (vector unsigned long long)__builtin_vsx_lxvd2x(__a, __b);
   10306 }
   10307 
   10308 static __inline__ vector double __ATTRS_o_ai
   10309 vec_vsx_ld(int __a, const vector double *__b) {
   10310   return (vector double)__builtin_vsx_lxvd2x(__a, __b);
   10311 }
   10312 
   10313 static __inline__ vector double __ATTRS_o_ai
   10314 vec_vsx_ld(int __a, const double *__b) {
   10315   return (vector double)__builtin_vsx_lxvd2x(__a, __b);
   10316 }
   10317 
   10318 static __inline__ vector bool short __ATTRS_o_ai
   10319 vec_vsx_ld(int __a, const vector bool short *__b) {
   10320   return (vector bool short)__builtin_vsx_lxvw4x(__a, __b);
   10321 }
   10322 
   10323 static __inline__ vector signed short __ATTRS_o_ai
   10324 vec_vsx_ld(int __a, const vector signed short *__b) {
   10325   return (vector signed short)__builtin_vsx_lxvw4x(__a, __b);
   10326 }
   10327 
   10328 static __inline__ vector signed short __ATTRS_o_ai
   10329 vec_vsx_ld(int __a, const signed short *__b) {
   10330   return (vector signed short)__builtin_vsx_lxvw4x(__a, __b);
   10331 }
   10332 
   10333 static __inline__ vector unsigned short __ATTRS_o_ai
   10334 vec_vsx_ld(int __a, const vector unsigned short *__b) {
   10335   return (vector unsigned short)__builtin_vsx_lxvw4x(__a, __b);
   10336 }
   10337 
   10338 static __inline__ vector unsigned short __ATTRS_o_ai
   10339 vec_vsx_ld(int __a, const unsigned short *__b) {
   10340   return (vector unsigned short)__builtin_vsx_lxvw4x(__a, __b);
   10341 }
   10342 
   10343 static __inline__ vector bool char __ATTRS_o_ai
   10344 vec_vsx_ld(int __a, const vector bool char *__b) {
   10345   return (vector bool char)__builtin_vsx_lxvw4x(__a, __b);
   10346 }
   10347 
   10348 static __inline__ vector signed char __ATTRS_o_ai
   10349 vec_vsx_ld(int __a, const vector signed char *__b) {
   10350   return (vector signed char)__builtin_vsx_lxvw4x(__a, __b);
   10351 }
   10352 
   10353 static __inline__ vector signed char __ATTRS_o_ai
   10354 vec_vsx_ld(int __a, const signed char *__b) {
   10355   return (vector signed char)__builtin_vsx_lxvw4x(__a, __b);
   10356 }
   10357 
   10358 static __inline__ vector unsigned char __ATTRS_o_ai
   10359 vec_vsx_ld(int __a, const vector unsigned char *__b) {
   10360   return (vector unsigned char)__builtin_vsx_lxvw4x(__a, __b);
   10361 }
   10362 
   10363 static __inline__ vector unsigned char __ATTRS_o_ai
   10364 vec_vsx_ld(int __a, const unsigned char *__b) {
   10365   return (vector unsigned char)__builtin_vsx_lxvw4x(__a, __b);
   10366 }
   10367 
   10368 #endif
   10369 
   10370 /* vec_vsx_st */
   10371 
   10372 #ifdef __VSX__
   10373 
   10374 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool int __a, int __b,
   10375                                                vector bool int *__c) {
   10376   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
   10377 }
   10378 
   10379 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool int __a, int __b,
   10380                                                signed int *__c) {
   10381   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
   10382 }
   10383 
   10384 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool int __a, int __b,
   10385                                                unsigned int *__c) {
   10386   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
   10387 }
   10388 
   10389 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed int __a, int __b,
   10390                                                vector signed int *__c) {
   10391   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
   10392 }
   10393 
   10394 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed int __a, int __b,
   10395                                                signed int *__c) {
   10396   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
   10397 }
   10398 
   10399 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned int __a, int __b,
   10400                                                vector unsigned int *__c) {
   10401   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
   10402 }
   10403 
   10404 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned int __a, int __b,
   10405                                                unsigned int *__c) {
   10406   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
   10407 }
   10408 
   10409 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector float __a, int __b,
   10410                                                vector float *__c) {
   10411   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
   10412 }
   10413 
   10414 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector float __a, int __b,
   10415                                                float *__c) {
   10416   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
   10417 }
   10418 
   10419 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed long long __a,
   10420                                                int __b,
   10421                                                vector signed long long *__c) {
   10422   __builtin_vsx_stxvd2x((vector double)__a, __b, __c);
   10423 }
   10424 
   10425 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned long long __a,
   10426                                                int __b,
   10427                                                vector unsigned long long *__c) {
   10428   __builtin_vsx_stxvd2x((vector double)__a, __b, __c);
   10429 }
   10430 
   10431 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector double __a, int __b,
   10432                                                vector double *__c) {
   10433   __builtin_vsx_stxvd2x((vector double)__a, __b, __c);
   10434 }
   10435 
   10436 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector double __a, int __b,
   10437                                                double *__c) {
   10438   __builtin_vsx_stxvd2x((vector double)__a, __b, __c);
   10439 }
   10440 
   10441 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool short __a, int __b,
   10442                                                vector bool short *__c) {
   10443   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
   10444 }
   10445 
   10446 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool short __a, int __b,
   10447                                                signed short *__c) {
   10448   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
   10449 }
   10450 
   10451 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool short __a, int __b,
   10452                                                unsigned short *__c) {
   10453   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
   10454 }
   10455 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed short __a, int __b,
   10456                                                vector signed short *__c) {
   10457   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
   10458 }
   10459 
   10460 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed short __a, int __b,
   10461                                                signed short *__c) {
   10462   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
   10463 }
   10464 
   10465 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned short __a,
   10466                                                int __b,
   10467                                                vector unsigned short *__c) {
   10468   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
   10469 }
   10470 
   10471 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned short __a,
   10472                                                int __b, unsigned short *__c) {
   10473   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
   10474 }
   10475 
   10476 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool char __a, int __b,
   10477                                                vector bool char *__c) {
   10478   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
   10479 }
   10480 
   10481 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool char __a, int __b,
   10482                                                signed char *__c) {
   10483   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
   10484 }
   10485 
   10486 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool char __a, int __b,
   10487                                                unsigned char *__c) {
   10488   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
   10489 }
   10490 
   10491 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed char __a, int __b,
   10492                                                vector signed char *__c) {
   10493   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
   10494 }
   10495 
   10496 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed char __a, int __b,
   10497                                                signed char *__c) {
   10498   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
   10499 }
   10500 
   10501 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned char __a,
   10502                                                int __b,
   10503                                                vector unsigned char *__c) {
   10504   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
   10505 }
   10506 
   10507 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned char __a,
   10508                                                int __b, unsigned char *__c) {
   10509   __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
   10510 }
   10511 
   10512 #endif
   10513 
   10514 /* vec_xor */
   10515 
   10516 #define __builtin_altivec_vxor vec_xor
   10517 
   10518 static __inline__ vector signed char __ATTRS_o_ai
   10519 vec_xor(vector signed char __a, vector signed char __b) {
   10520   return __a ^ __b;
   10521 }
   10522 
   10523 static __inline__ vector signed char __ATTRS_o_ai
   10524 vec_xor(vector bool char __a, vector signed char __b) {
   10525   return (vector signed char)__a ^ __b;
   10526 }
   10527 
   10528 static __inline__ vector signed char __ATTRS_o_ai
   10529 vec_xor(vector signed char __a, vector bool char __b) {
   10530   return __a ^ (vector signed char)__b;
   10531 }
   10532 
   10533 static __inline__ vector unsigned char __ATTRS_o_ai
   10534 vec_xor(vector unsigned char __a, vector unsigned char __b) {
   10535   return __a ^ __b;
   10536 }
   10537 
   10538 static __inline__ vector unsigned char __ATTRS_o_ai
   10539 vec_xor(vector bool char __a, vector unsigned char __b) {
   10540   return (vector unsigned char)__a ^ __b;
   10541 }
   10542 
   10543 static __inline__ vector unsigned char __ATTRS_o_ai
   10544 vec_xor(vector unsigned char __a, vector bool char __b) {
   10545   return __a ^ (vector unsigned char)__b;
   10546 }
   10547 
   10548 static __inline__ vector bool char __ATTRS_o_ai vec_xor(vector bool char __a,
   10549                                                         vector bool char __b) {
   10550   return __a ^ __b;
   10551 }
   10552 
   10553 static __inline__ vector short __ATTRS_o_ai vec_xor(vector short __a,
   10554                                                     vector short __b) {
   10555   return __a ^ __b;
   10556 }
   10557 
   10558 static __inline__ vector short __ATTRS_o_ai vec_xor(vector bool short __a,
   10559                                                     vector short __b) {
   10560   return (vector short)__a ^ __b;
   10561 }
   10562 
   10563 static __inline__ vector short __ATTRS_o_ai vec_xor(vector short __a,
   10564                                                     vector bool short __b) {
   10565   return __a ^ (vector short)__b;
   10566 }
   10567 
   10568 static __inline__ vector unsigned short __ATTRS_o_ai
   10569 vec_xor(vector unsigned short __a, vector unsigned short __b) {
   10570   return __a ^ __b;
   10571 }
   10572 
   10573 static __inline__ vector unsigned short __ATTRS_o_ai
   10574 vec_xor(vector bool short __a, vector unsigned short __b) {
   10575   return (vector unsigned short)__a ^ __b;
   10576 }
   10577 
   10578 static __inline__ vector unsigned short __ATTRS_o_ai
   10579 vec_xor(vector unsigned short __a, vector bool short __b) {
   10580   return __a ^ (vector unsigned short)__b;
   10581 }
   10582 
   10583 static __inline__ vector bool short __ATTRS_o_ai
   10584 vec_xor(vector bool short __a, vector bool short __b) {
   10585   return __a ^ __b;
   10586 }
   10587 
   10588 static __inline__ vector int __ATTRS_o_ai vec_xor(vector int __a,
   10589                                                   vector int __b) {
   10590   return __a ^ __b;
   10591 }
   10592 
   10593 static __inline__ vector int __ATTRS_o_ai vec_xor(vector bool int __a,
   10594                                                   vector int __b) {
   10595   return (vector int)__a ^ __b;
   10596 }
   10597 
   10598 static __inline__ vector int __ATTRS_o_ai vec_xor(vector int __a,
   10599                                                   vector bool int __b) {
   10600   return __a ^ (vector int)__b;
   10601 }
   10602 
   10603 static __inline__ vector unsigned int __ATTRS_o_ai
   10604 vec_xor(vector unsigned int __a, vector unsigned int __b) {
   10605   return __a ^ __b;
   10606 }
   10607 
   10608 static __inline__ vector unsigned int __ATTRS_o_ai
   10609 vec_xor(vector bool int __a, vector unsigned int __b) {
   10610   return (vector unsigned int)__a ^ __b;
   10611 }
   10612 
   10613 static __inline__ vector unsigned int __ATTRS_o_ai
   10614 vec_xor(vector unsigned int __a, vector bool int __b) {
   10615   return __a ^ (vector unsigned int)__b;
   10616 }
   10617 
   10618 static __inline__ vector bool int __ATTRS_o_ai vec_xor(vector bool int __a,
   10619                                                        vector bool int __b) {
   10620   return __a ^ __b;
   10621 }
   10622 
   10623 static __inline__ vector float __ATTRS_o_ai vec_xor(vector float __a,
   10624                                                     vector float __b) {
   10625   vector unsigned int __res =
   10626       (vector unsigned int)__a ^ (vector unsigned int)__b;
   10627   return (vector float)__res;
   10628 }
   10629 
   10630 static __inline__ vector float __ATTRS_o_ai vec_xor(vector bool int __a,
   10631                                                     vector float __b) {
   10632   vector unsigned int __res =
   10633       (vector unsigned int)__a ^ (vector unsigned int)__b;
   10634   return (vector float)__res;
   10635 }
   10636 
   10637 static __inline__ vector float __ATTRS_o_ai vec_xor(vector float __a,
   10638                                                     vector bool int __b) {
   10639   vector unsigned int __res =
   10640       (vector unsigned int)__a ^ (vector unsigned int)__b;
   10641   return (vector float)__res;
   10642 }
   10643 
   10644 #ifdef __VSX__
   10645 static __inline__ vector signed long long __ATTRS_o_ai
   10646 vec_xor(vector signed long long __a, vector signed long long __b) {
   10647   return __a ^ __b;
   10648 }
   10649 
   10650 static __inline__ vector signed long long __ATTRS_o_ai
   10651 vec_xor(vector bool long long __a, vector signed long long __b) {
   10652   return (vector signed long long)__a ^ __b;
   10653 }
   10654 
   10655 static __inline__ vector signed long long __ATTRS_o_ai
   10656 vec_xor(vector signed long long __a, vector bool long long __b) {
   10657   return __a ^ (vector signed long long)__b;
   10658 }
   10659 
   10660 static __inline__ vector unsigned long long __ATTRS_o_ai
   10661 vec_xor(vector unsigned long long __a, vector unsigned long long __b) {
   10662   return __a ^ __b;
   10663 }
   10664 
   10665 static __inline__ vector unsigned long long __ATTRS_o_ai
   10666 vec_xor(vector bool long long __a, vector unsigned long long __b) {
   10667   return (vector unsigned long long)__a ^ __b;
   10668 }
   10669 
   10670 static __inline__ vector unsigned long long __ATTRS_o_ai
   10671 vec_xor(vector unsigned long long __a, vector bool long long __b) {
   10672   return __a ^ (vector unsigned long long)__b;
   10673 }
   10674 
   10675 static __inline__ vector bool long long __ATTRS_o_ai
   10676 vec_xor(vector bool long long __a, vector bool long long __b) {
   10677   return __a ^ __b;
   10678 }
   10679 
   10680 static __inline__ vector double __ATTRS_o_ai vec_xor(vector double __a,
   10681                                                      vector double __b) {
   10682   return (vector double)((vector unsigned long long)__a ^
   10683                          (vector unsigned long long)__b);
   10684 }
   10685 
   10686 static __inline__ vector double __ATTRS_o_ai
   10687 vec_xor(vector double __a, vector bool long long __b) {
   10688   return (vector double)((vector unsigned long long)__a ^
   10689                          (vector unsigned long long)__b);
   10690 }
   10691 
   10692 static __inline__ vector double __ATTRS_o_ai vec_xor(vector bool long long __a,
   10693                                                      vector double __b) {
   10694   return (vector double)((vector unsigned long long)__a ^
   10695                          (vector unsigned long long)__b);
   10696 }
   10697 #endif
   10698 
   10699 /* vec_vxor */
   10700 
   10701 static __inline__ vector signed char __ATTRS_o_ai
   10702 vec_vxor(vector signed char __a, vector signed char __b) {
   10703   return __a ^ __b;
   10704 }
   10705 
   10706 static __inline__ vector signed char __ATTRS_o_ai
   10707 vec_vxor(vector bool char __a, vector signed char __b) {
   10708   return (vector signed char)__a ^ __b;
   10709 }
   10710 
   10711 static __inline__ vector signed char __ATTRS_o_ai
   10712 vec_vxor(vector signed char __a, vector bool char __b) {
   10713   return __a ^ (vector signed char)__b;
   10714 }
   10715 
   10716 static __inline__ vector unsigned char __ATTRS_o_ai
   10717 vec_vxor(vector unsigned char __a, vector unsigned char __b) {
   10718   return __a ^ __b;
   10719 }
   10720 
   10721 static __inline__ vector unsigned char __ATTRS_o_ai
   10722 vec_vxor(vector bool char __a, vector unsigned char __b) {
   10723   return (vector unsigned char)__a ^ __b;
   10724 }
   10725 
   10726 static __inline__ vector unsigned char __ATTRS_o_ai
   10727 vec_vxor(vector unsigned char __a, vector bool char __b) {
   10728   return __a ^ (vector unsigned char)__b;
   10729 }
   10730 
   10731 static __inline__ vector bool char __ATTRS_o_ai vec_vxor(vector bool char __a,
   10732                                                          vector bool char __b) {
   10733   return __a ^ __b;
   10734 }
   10735 
   10736 static __inline__ vector short __ATTRS_o_ai vec_vxor(vector short __a,
   10737                                                      vector short __b) {
   10738   return __a ^ __b;
   10739 }
   10740 
   10741 static __inline__ vector short __ATTRS_o_ai vec_vxor(vector bool short __a,
   10742                                                      vector short __b) {
   10743   return (vector short)__a ^ __b;
   10744 }
   10745 
   10746 static __inline__ vector short __ATTRS_o_ai vec_vxor(vector short __a,
   10747                                                      vector bool short __b) {
   10748   return __a ^ (vector short)__b;
   10749 }
   10750 
   10751 static __inline__ vector unsigned short __ATTRS_o_ai
   10752 vec_vxor(vector unsigned short __a, vector unsigned short __b) {
   10753   return __a ^ __b;
   10754 }
   10755 
   10756 static __inline__ vector unsigned short __ATTRS_o_ai
   10757 vec_vxor(vector bool short __a, vector unsigned short __b) {
   10758   return (vector unsigned short)__a ^ __b;
   10759 }
   10760 
   10761 static __inline__ vector unsigned short __ATTRS_o_ai
   10762 vec_vxor(vector unsigned short __a, vector bool short __b) {
   10763   return __a ^ (vector unsigned short)__b;
   10764 }
   10765 
   10766 static __inline__ vector bool short __ATTRS_o_ai
   10767 vec_vxor(vector bool short __a, vector bool short __b) {
   10768   return __a ^ __b;
   10769 }
   10770 
   10771 static __inline__ vector int __ATTRS_o_ai vec_vxor(vector int __a,
   10772                                                    vector int __b) {
   10773   return __a ^ __b;
   10774 }
   10775 
   10776 static __inline__ vector int __ATTRS_o_ai vec_vxor(vector bool int __a,
   10777                                                    vector int __b) {
   10778   return (vector int)__a ^ __b;
   10779 }
   10780 
   10781 static __inline__ vector int __ATTRS_o_ai vec_vxor(vector int __a,
   10782                                                    vector bool int __b) {
   10783   return __a ^ (vector int)__b;
   10784 }
   10785 
   10786 static __inline__ vector unsigned int __ATTRS_o_ai
   10787 vec_vxor(vector unsigned int __a, vector unsigned int __b) {
   10788   return __a ^ __b;
   10789 }
   10790 
   10791 static __inline__ vector unsigned int __ATTRS_o_ai
   10792 vec_vxor(vector bool int __a, vector unsigned int __b) {
   10793   return (vector unsigned int)__a ^ __b;
   10794 }
   10795 
   10796 static __inline__ vector unsigned int __ATTRS_o_ai
   10797 vec_vxor(vector unsigned int __a, vector bool int __b) {
   10798   return __a ^ (vector unsigned int)__b;
   10799 }
   10800 
   10801 static __inline__ vector bool int __ATTRS_o_ai vec_vxor(vector bool int __a,
   10802                                                         vector bool int __b) {
   10803   return __a ^ __b;
   10804 }
   10805 
   10806 static __inline__ vector float __ATTRS_o_ai vec_vxor(vector float __a,
   10807                                                      vector float __b) {
   10808   vector unsigned int __res =
   10809       (vector unsigned int)__a ^ (vector unsigned int)__b;
   10810   return (vector float)__res;
   10811 }
   10812 
   10813 static __inline__ vector float __ATTRS_o_ai vec_vxor(vector bool int __a,
   10814                                                      vector float __b) {
   10815   vector unsigned int __res =
   10816       (vector unsigned int)__a ^ (vector unsigned int)__b;
   10817   return (vector float)__res;
   10818 }
   10819 
   10820 static __inline__ vector float __ATTRS_o_ai vec_vxor(vector float __a,
   10821                                                      vector bool int __b) {
   10822   vector unsigned int __res =
   10823       (vector unsigned int)__a ^ (vector unsigned int)__b;
   10824   return (vector float)__res;
   10825 }
   10826 
   10827 #ifdef __VSX__
   10828 static __inline__ vector signed long long __ATTRS_o_ai
   10829 vec_vxor(vector signed long long __a, vector signed long long __b) {
   10830   return __a ^ __b;
   10831 }
   10832 
   10833 static __inline__ vector signed long long __ATTRS_o_ai
   10834 vec_vxor(vector bool long long __a, vector signed long long __b) {
   10835   return (vector signed long long)__a ^ __b;
   10836 }
   10837 
   10838 static __inline__ vector signed long long __ATTRS_o_ai
   10839 vec_vxor(vector signed long long __a, vector bool long long __b) {
   10840   return __a ^ (vector signed long long)__b;
   10841 }
   10842 
   10843 static __inline__ vector unsigned long long __ATTRS_o_ai
   10844 vec_vxor(vector unsigned long long __a, vector unsigned long long __b) {
   10845   return __a ^ __b;
   10846 }
   10847 
   10848 static __inline__ vector unsigned long long __ATTRS_o_ai
   10849 vec_vxor(vector bool long long __a, vector unsigned long long __b) {
   10850   return (vector unsigned long long)__a ^ __b;
   10851 }
   10852 
   10853 static __inline__ vector unsigned long long __ATTRS_o_ai
   10854 vec_vxor(vector unsigned long long __a, vector bool long long __b) {
   10855   return __a ^ (vector unsigned long long)__b;
   10856 }
   10857 
   10858 static __inline__ vector bool long long __ATTRS_o_ai
   10859 vec_vxor(vector bool long long __a, vector bool long long __b) {
   10860   return __a ^ __b;
   10861 }
   10862 #endif
   10863 
   10864 /* ------------------------ extensions for CBEA ----------------------------- */
   10865 
   10866 /* vec_extract */
   10867 
   10868 static __inline__ signed char __ATTRS_o_ai vec_extract(vector signed char __a,
   10869                                                        int __b) {
   10870   return __a[__b];
   10871 }
   10872 
   10873 static __inline__ unsigned char __ATTRS_o_ai
   10874 vec_extract(vector unsigned char __a, int __b) {
   10875   return __a[__b];
   10876 }
   10877 
   10878 static __inline__ unsigned char __ATTRS_o_ai vec_extract(vector bool char __a,
   10879                                                          int __b) {
   10880   return __a[__b];
   10881 }
   10882 
   10883 static __inline__ signed short __ATTRS_o_ai vec_extract(vector signed short __a,
   10884                                                         int __b) {
   10885   return __a[__b];
   10886 }
   10887 
   10888 static __inline__ unsigned short __ATTRS_o_ai
   10889 vec_extract(vector unsigned short __a, int __b) {
   10890   return __a[__b];
   10891 }
   10892 
   10893 static __inline__ unsigned short __ATTRS_o_ai vec_extract(vector bool short __a,
   10894                                                           int __b) {
   10895   return __a[__b];
   10896 }
   10897 
   10898 static __inline__ signed int __ATTRS_o_ai vec_extract(vector signed int __a,
   10899                                                       int __b) {
   10900   return __a[__b];
   10901 }
   10902 
   10903 static __inline__ unsigned int __ATTRS_o_ai vec_extract(vector unsigned int __a,
   10904                                                         int __b) {
   10905   return __a[__b];
   10906 }
   10907 
   10908 static __inline__ unsigned int __ATTRS_o_ai vec_extract(vector bool int __a,
   10909                                                         int __b) {
   10910   return __a[__b];
   10911 }
   10912 
   10913 #ifdef __VSX__
   10914 static __inline__ signed long long __ATTRS_o_ai
   10915 vec_extract(vector signed long long __a, int __b) {
   10916   return __a[__b];
   10917 }
   10918 
   10919 static __inline__ unsigned long long __ATTRS_o_ai
   10920 vec_extract(vector unsigned long long __a, int __b) {
   10921   return __a[__b];
   10922 }
   10923 
   10924 static __inline__ unsigned long long __ATTRS_o_ai
   10925 vec_extract(vector bool long long __a, int __b) {
   10926   return __a[__b];
   10927 }
   10928 
   10929 static __inline__ double __ATTRS_o_ai vec_extract(vector double __a, int __b) {
   10930   return __a[__b];
   10931 }
   10932 #endif
   10933 
   10934 static __inline__ float __ATTRS_o_ai vec_extract(vector float __a, int __b) {
   10935   return __a[__b];
   10936 }
   10937 
   10938 /* vec_insert */
   10939 
   10940 static __inline__ vector signed char __ATTRS_o_ai
   10941 vec_insert(signed char __a, vector signed char __b, int __c) {
   10942   __b[__c] = __a;
   10943   return __b;
   10944 }
   10945 
   10946 static __inline__ vector unsigned char __ATTRS_o_ai
   10947 vec_insert(unsigned char __a, vector unsigned char __b, int __c) {
   10948   __b[__c] = __a;
   10949   return __b;
   10950 }
   10951 
   10952 static __inline__ vector bool char __ATTRS_o_ai vec_insert(unsigned char __a,
   10953                                                            vector bool char __b,
   10954                                                            int __c) {
   10955   __b[__c] = __a;
   10956   return __b;
   10957 }
   10958 
   10959 static __inline__ vector signed short __ATTRS_o_ai
   10960 vec_insert(signed short __a, vector signed short __b, int __c) {
   10961   __b[__c] = __a;
   10962   return __b;
   10963 }
   10964 
   10965 static __inline__ vector unsigned short __ATTRS_o_ai
   10966 vec_insert(unsigned short __a, vector unsigned short __b, int __c) {
   10967   __b[__c] = __a;
   10968   return __b;
   10969 }
   10970 
   10971 static __inline__ vector bool short __ATTRS_o_ai
   10972 vec_insert(unsigned short __a, vector bool short __b, int __c) {
   10973   __b[__c] = __a;
   10974   return __b;
   10975 }
   10976 
   10977 static __inline__ vector signed int __ATTRS_o_ai
   10978 vec_insert(signed int __a, vector signed int __b, int __c) {
   10979   __b[__c] = __a;
   10980   return __b;
   10981 }
   10982 
   10983 static __inline__ vector unsigned int __ATTRS_o_ai
   10984 vec_insert(unsigned int __a, vector unsigned int __b, int __c) {
   10985   __b[__c] = __a;
   10986   return __b;
   10987 }
   10988 
   10989 static __inline__ vector bool int __ATTRS_o_ai vec_insert(unsigned int __a,
   10990                                                           vector bool int __b,
   10991                                                           int __c) {
   10992   __b[__c] = __a;
   10993   return __b;
   10994 }
   10995 
   10996 #ifdef __VSX__
   10997 static __inline__ vector signed long long __ATTRS_o_ai
   10998 vec_insert(signed long long __a, vector signed long long __b, int __c) {
   10999   __b[__c] = __a;
   11000   return __b;
   11001 }
   11002 
   11003 static __inline__ vector unsigned long long __ATTRS_o_ai
   11004 vec_insert(unsigned long long __a, vector unsigned long long __b, int __c) {
   11005   __b[__c] = __a;
   11006   return __b;
   11007 }
   11008 
   11009 static __inline__ vector bool long long __ATTRS_o_ai
   11010 vec_insert(unsigned long long __a, vector bool long long __b, int __c) {
   11011   __b[__c] = __a;
   11012   return __b;
   11013 }
   11014 static __inline__ vector double __ATTRS_o_ai vec_insert(double __a,
   11015                                                         vector double __b,
   11016                                                         int __c) {
   11017   __b[__c] = __a;
   11018   return __b;
   11019 }
   11020 #endif
   11021 
   11022 static __inline__ vector float __ATTRS_o_ai vec_insert(float __a,
   11023                                                        vector float __b,
   11024                                                        int __c) {
   11025   __b[__c] = __a;
   11026   return __b;
   11027 }
   11028 
   11029 /* vec_lvlx */
   11030 
   11031 static __inline__ vector signed char __ATTRS_o_ai
   11032 vec_lvlx(int __a, const signed char *__b) {
   11033   return vec_perm(vec_ld(__a, __b), (vector signed char)(0),
   11034                   vec_lvsl(__a, __b));
   11035 }
   11036 
   11037 static __inline__ vector signed char __ATTRS_o_ai
   11038 vec_lvlx(int __a, const vector signed char *__b) {
   11039   return vec_perm(vec_ld(__a, __b), (vector signed char)(0),
   11040                   vec_lvsl(__a, (unsigned char *)__b));
   11041 }
   11042 
   11043 static __inline__ vector unsigned char __ATTRS_o_ai
   11044 vec_lvlx(int __a, const unsigned char *__b) {
   11045   return vec_perm(vec_ld(__a, __b), (vector unsigned char)(0),
   11046                   vec_lvsl(__a, __b));
   11047 }
   11048 
   11049 static __inline__ vector unsigned char __ATTRS_o_ai
   11050 vec_lvlx(int __a, const vector unsigned char *__b) {
   11051   return vec_perm(vec_ld(__a, __b), (vector unsigned char)(0),
   11052                   vec_lvsl(__a, (unsigned char *)__b));
   11053 }
   11054 
   11055 static __inline__ vector bool char __ATTRS_o_ai
   11056 vec_lvlx(int __a, const vector bool char *__b) {
   11057   return vec_perm(vec_ld(__a, __b), (vector bool char)(0),
   11058                   vec_lvsl(__a, (unsigned char *)__b));
   11059 }
   11060 
   11061 static __inline__ vector short __ATTRS_o_ai vec_lvlx(int __a,
   11062                                                      const short *__b) {
   11063   return vec_perm(vec_ld(__a, __b), (vector short)(0), vec_lvsl(__a, __b));
   11064 }
   11065 
   11066 static __inline__ vector short __ATTRS_o_ai vec_lvlx(int __a,
   11067                                                      const vector short *__b) {
   11068   return vec_perm(vec_ld(__a, __b), (vector short)(0),
   11069                   vec_lvsl(__a, (unsigned char *)__b));
   11070 }
   11071 
   11072 static __inline__ vector unsigned short __ATTRS_o_ai
   11073 vec_lvlx(int __a, const unsigned short *__b) {
   11074   return vec_perm(vec_ld(__a, __b), (vector unsigned short)(0),
   11075                   vec_lvsl(__a, __b));
   11076 }
   11077 
   11078 static __inline__ vector unsigned short __ATTRS_o_ai
   11079 vec_lvlx(int __a, const vector unsigned short *__b) {
   11080   return vec_perm(vec_ld(__a, __b), (vector unsigned short)(0),
   11081                   vec_lvsl(__a, (unsigned char *)__b));
   11082 }
   11083 
   11084 static __inline__ vector bool short __ATTRS_o_ai
   11085 vec_lvlx(int __a, const vector bool short *__b) {
   11086   return vec_perm(vec_ld(__a, __b), (vector bool short)(0),
   11087                   vec_lvsl(__a, (unsigned char *)__b));
   11088 }
   11089 
   11090 static __inline__ vector pixel __ATTRS_o_ai vec_lvlx(int __a,
   11091                                                      const vector pixel *__b) {
   11092   return vec_perm(vec_ld(__a, __b), (vector pixel)(0),
   11093                   vec_lvsl(__a, (unsigned char *)__b));
   11094 }
   11095 
   11096 static __inline__ vector int __ATTRS_o_ai vec_lvlx(int __a, const int *__b) {
   11097   return vec_perm(vec_ld(__a, __b), (vector int)(0), vec_lvsl(__a, __b));
   11098 }
   11099 
   11100 static __inline__ vector int __ATTRS_o_ai vec_lvlx(int __a,
   11101                                                    const vector int *__b) {
   11102   return vec_perm(vec_ld(__a, __b), (vector int)(0),
   11103                   vec_lvsl(__a, (unsigned char *)__b));
   11104 }
   11105 
   11106 static __inline__ vector unsigned int __ATTRS_o_ai
   11107 vec_lvlx(int __a, const unsigned int *__b) {
   11108   return vec_perm(vec_ld(__a, __b), (vector unsigned int)(0),
   11109                   vec_lvsl(__a, __b));
   11110 }
   11111 
   11112 static __inline__ vector unsigned int __ATTRS_o_ai
   11113 vec_lvlx(int __a, const vector unsigned int *__b) {
   11114   return vec_perm(vec_ld(__a, __b), (vector unsigned int)(0),
   11115                   vec_lvsl(__a, (unsigned char *)__b));
   11116 }
   11117 
   11118 static __inline__ vector bool int __ATTRS_o_ai
   11119 vec_lvlx(int __a, const vector bool int *__b) {
   11120   return vec_perm(vec_ld(__a, __b), (vector bool int)(0),
   11121                   vec_lvsl(__a, (unsigned char *)__b));
   11122 }
   11123 
   11124 static __inline__ vector float __ATTRS_o_ai vec_lvlx(int __a,
   11125                                                      const float *__b) {
   11126   return vec_perm(vec_ld(__a, __b), (vector float)(0), vec_lvsl(__a, __b));
   11127 }
   11128 
   11129 static __inline__ vector float __ATTRS_o_ai vec_lvlx(int __a,
   11130                                                      const vector float *__b) {
   11131   return vec_perm(vec_ld(__a, __b), (vector float)(0),
   11132                   vec_lvsl(__a, (unsigned char *)__b));
   11133 }
   11134 
   11135 /* vec_lvlxl */
   11136 
   11137 static __inline__ vector signed char __ATTRS_o_ai
   11138 vec_lvlxl(int __a, const signed char *__b) {
   11139   return vec_perm(vec_ldl(__a, __b), (vector signed char)(0),
   11140                   vec_lvsl(__a, __b));
   11141 }
   11142 
   11143 static __inline__ vector signed char __ATTRS_o_ai
   11144 vec_lvlxl(int __a, const vector signed char *__b) {
   11145   return vec_perm(vec_ldl(__a, __b), (vector signed char)(0),
   11146                   vec_lvsl(__a, (unsigned char *)__b));
   11147 }
   11148 
   11149 static __inline__ vector unsigned char __ATTRS_o_ai
   11150 vec_lvlxl(int __a, const unsigned char *__b) {
   11151   return vec_perm(vec_ldl(__a, __b), (vector unsigned char)(0),
   11152                   vec_lvsl(__a, __b));
   11153 }
   11154 
   11155 static __inline__ vector unsigned char __ATTRS_o_ai
   11156 vec_lvlxl(int __a, const vector unsigned char *__b) {
   11157   return vec_perm(vec_ldl(__a, __b), (vector unsigned char)(0),
   11158                   vec_lvsl(__a, (unsigned char *)__b));
   11159 }
   11160 
   11161 static __inline__ vector bool char __ATTRS_o_ai
   11162 vec_lvlxl(int __a, const vector bool char *__b) {
   11163   return vec_perm(vec_ldl(__a, __b), (vector bool char)(0),
   11164                   vec_lvsl(__a, (unsigned char *)__b));
   11165 }
   11166 
   11167 static __inline__ vector short __ATTRS_o_ai vec_lvlxl(int __a,
   11168                                                       const short *__b) {
   11169   return vec_perm(vec_ldl(__a, __b), (vector short)(0), vec_lvsl(__a, __b));
   11170 }
   11171 
   11172 static __inline__ vector short __ATTRS_o_ai vec_lvlxl(int __a,
   11173                                                       const vector short *__b) {
   11174   return vec_perm(vec_ldl(__a, __b), (vector short)(0),
   11175                   vec_lvsl(__a, (unsigned char *)__b));
   11176 }
   11177 
   11178 static __inline__ vector unsigned short __ATTRS_o_ai
   11179 vec_lvlxl(int __a, const unsigned short *__b) {
   11180   return vec_perm(vec_ldl(__a, __b), (vector unsigned short)(0),
   11181                   vec_lvsl(__a, __b));
   11182 }
   11183 
   11184 static __inline__ vector unsigned short __ATTRS_o_ai
   11185 vec_lvlxl(int __a, const vector unsigned short *__b) {
   11186   return vec_perm(vec_ldl(__a, __b), (vector unsigned short)(0),
   11187                   vec_lvsl(__a, (unsigned char *)__b));
   11188 }
   11189 
   11190 static __inline__ vector bool short __ATTRS_o_ai
   11191 vec_lvlxl(int __a, const vector bool short *__b) {
   11192   return vec_perm(vec_ldl(__a, __b), (vector bool short)(0),
   11193                   vec_lvsl(__a, (unsigned char *)__b));
   11194 }
   11195 
   11196 static __inline__ vector pixel __ATTRS_o_ai vec_lvlxl(int __a,
   11197                                                       const vector pixel *__b) {
   11198   return vec_perm(vec_ldl(__a, __b), (vector pixel)(0),
   11199                   vec_lvsl(__a, (unsigned char *)__b));
   11200 }
   11201 
   11202 static __inline__ vector int __ATTRS_o_ai vec_lvlxl(int __a, const int *__b) {
   11203   return vec_perm(vec_ldl(__a, __b), (vector int)(0), vec_lvsl(__a, __b));
   11204 }
   11205 
   11206 static __inline__ vector int __ATTRS_o_ai vec_lvlxl(int __a,
   11207                                                     const vector int *__b) {
   11208   return vec_perm(vec_ldl(__a, __b), (vector int)(0),
   11209                   vec_lvsl(__a, (unsigned char *)__b));
   11210 }
   11211 
   11212 static __inline__ vector unsigned int __ATTRS_o_ai
   11213 vec_lvlxl(int __a, const unsigned int *__b) {
   11214   return vec_perm(vec_ldl(__a, __b), (vector unsigned int)(0),
   11215                   vec_lvsl(__a, __b));
   11216 }
   11217 
   11218 static __inline__ vector unsigned int __ATTRS_o_ai
   11219 vec_lvlxl(int __a, const vector unsigned int *__b) {
   11220   return vec_perm(vec_ldl(__a, __b), (vector unsigned int)(0),
   11221                   vec_lvsl(__a, (unsigned char *)__b));
   11222 }
   11223 
   11224 static __inline__ vector bool int __ATTRS_o_ai
   11225 vec_lvlxl(int __a, const vector bool int *__b) {
   11226   return vec_perm(vec_ldl(__a, __b), (vector bool int)(0),
   11227                   vec_lvsl(__a, (unsigned char *)__b));
   11228 }
   11229 
   11230 static __inline__ vector float __ATTRS_o_ai vec_lvlxl(int __a,
   11231                                                       const float *__b) {
   11232   return vec_perm(vec_ldl(__a, __b), (vector float)(0), vec_lvsl(__a, __b));
   11233 }
   11234 
   11235 static __inline__ vector float __ATTRS_o_ai vec_lvlxl(int __a,
   11236                                                       vector float *__b) {
   11237   return vec_perm(vec_ldl(__a, __b), (vector float)(0),
   11238                   vec_lvsl(__a, (unsigned char *)__b));
   11239 }
   11240 
   11241 /* vec_lvrx */
   11242 
   11243 static __inline__ vector signed char __ATTRS_o_ai
   11244 vec_lvrx(int __a, const signed char *__b) {
   11245   return vec_perm((vector signed char)(0), vec_ld(__a, __b),
   11246                   vec_lvsl(__a, __b));
   11247 }
   11248 
   11249 static __inline__ vector signed char __ATTRS_o_ai
   11250 vec_lvrx(int __a, const vector signed char *__b) {
   11251   return vec_perm((vector signed char)(0), vec_ld(__a, __b),
   11252                   vec_lvsl(__a, (unsigned char *)__b));
   11253 }
   11254 
   11255 static __inline__ vector unsigned char __ATTRS_o_ai
   11256 vec_lvrx(int __a, const unsigned char *__b) {
   11257   return vec_perm((vector unsigned char)(0), vec_ld(__a, __b),
   11258                   vec_lvsl(__a, __b));
   11259 }
   11260 
   11261 static __inline__ vector unsigned char __ATTRS_o_ai
   11262 vec_lvrx(int __a, const vector unsigned char *__b) {
   11263   return vec_perm((vector unsigned char)(0), vec_ld(__a, __b),
   11264                   vec_lvsl(__a, (unsigned char *)__b));
   11265 }
   11266 
   11267 static __inline__ vector bool char __ATTRS_o_ai
   11268 vec_lvrx(int __a, const vector bool char *__b) {
   11269   return vec_perm((vector bool char)(0), vec_ld(__a, __b),
   11270                   vec_lvsl(__a, (unsigned char *)__b));
   11271 }
   11272 
   11273 static __inline__ vector short __ATTRS_o_ai vec_lvrx(int __a,
   11274                                                      const short *__b) {
   11275   return vec_perm((vector short)(0), vec_ld(__a, __b), vec_lvsl(__a, __b));
   11276 }
   11277 
   11278 static __inline__ vector short __ATTRS_o_ai vec_lvrx(int __a,
   11279                                                      const vector short *__b) {
   11280   return vec_perm((vector short)(0), vec_ld(__a, __b),
   11281                   vec_lvsl(__a, (unsigned char *)__b));
   11282 }
   11283 
   11284 static __inline__ vector unsigned short __ATTRS_o_ai
   11285 vec_lvrx(int __a, const unsigned short *__b) {
   11286   return vec_perm((vector unsigned short)(0), vec_ld(__a, __b),
   11287                   vec_lvsl(__a, __b));
   11288 }
   11289 
   11290 static __inline__ vector unsigned short __ATTRS_o_ai
   11291 vec_lvrx(int __a, const vector unsigned short *__b) {
   11292   return vec_perm((vector unsigned short)(0), vec_ld(__a, __b),
   11293                   vec_lvsl(__a, (unsigned char *)__b));
   11294 }
   11295 
   11296 static __inline__ vector bool short __ATTRS_o_ai
   11297 vec_lvrx(int __a, const vector bool short *__b) {
   11298   return vec_perm((vector bool short)(0), vec_ld(__a, __b),
   11299                   vec_lvsl(__a, (unsigned char *)__b));
   11300 }
   11301 
   11302 static __inline__ vector pixel __ATTRS_o_ai vec_lvrx(int __a,
   11303                                                      const vector pixel *__b) {
   11304   return vec_perm((vector pixel)(0), vec_ld(__a, __b),
   11305                   vec_lvsl(__a, (unsigned char *)__b));
   11306 }
   11307 
   11308 static __inline__ vector int __ATTRS_o_ai vec_lvrx(int __a, const int *__b) {
   11309   return vec_perm((vector int)(0), vec_ld(__a, __b), vec_lvsl(__a, __b));
   11310 }
   11311 
   11312 static __inline__ vector int __ATTRS_o_ai vec_lvrx(int __a,
   11313                                                    const vector int *__b) {
   11314   return vec_perm((vector int)(0), vec_ld(__a, __b),
   11315                   vec_lvsl(__a, (unsigned char *)__b));
   11316 }
   11317 
   11318 static __inline__ vector unsigned int __ATTRS_o_ai
   11319 vec_lvrx(int __a, const unsigned int *__b) {
   11320   return vec_perm((vector unsigned int)(0), vec_ld(__a, __b),
   11321                   vec_lvsl(__a, __b));
   11322 }
   11323 
   11324 static __inline__ vector unsigned int __ATTRS_o_ai
   11325 vec_lvrx(int __a, const vector unsigned int *__b) {
   11326   return vec_perm((vector unsigned int)(0), vec_ld(__a, __b),
   11327                   vec_lvsl(__a, (unsigned char *)__b));
   11328 }
   11329 
   11330 static __inline__ vector bool int __ATTRS_o_ai
   11331 vec_lvrx(int __a, const vector bool int *__b) {
   11332   return vec_perm((vector bool int)(0), vec_ld(__a, __b),
   11333                   vec_lvsl(__a, (unsigned char *)__b));
   11334 }
   11335 
   11336 static __inline__ vector float __ATTRS_o_ai vec_lvrx(int __a,
   11337                                                      const float *__b) {
   11338   return vec_perm((vector float)(0), vec_ld(__a, __b), vec_lvsl(__a, __b));
   11339 }
   11340 
   11341 static __inline__ vector float __ATTRS_o_ai vec_lvrx(int __a,
   11342                                                      const vector float *__b) {
   11343   return vec_perm((vector float)(0), vec_ld(__a, __b),
   11344                   vec_lvsl(__a, (unsigned char *)__b));
   11345 }
   11346 
   11347 /* vec_lvrxl */
   11348 
   11349 static __inline__ vector signed char __ATTRS_o_ai
   11350 vec_lvrxl(int __a, const signed char *__b) {
   11351   return vec_perm((vector signed char)(0), vec_ldl(__a, __b),
   11352                   vec_lvsl(__a, __b));
   11353 }
   11354 
   11355 static __inline__ vector signed char __ATTRS_o_ai
   11356 vec_lvrxl(int __a, const vector signed char *__b) {
   11357   return vec_perm((vector signed char)(0), vec_ldl(__a, __b),
   11358                   vec_lvsl(__a, (unsigned char *)__b));
   11359 }
   11360 
   11361 static __inline__ vector unsigned char __ATTRS_o_ai
   11362 vec_lvrxl(int __a, const unsigned char *__b) {
   11363   return vec_perm((vector unsigned char)(0), vec_ldl(__a, __b),
   11364                   vec_lvsl(__a, __b));
   11365 }
   11366 
   11367 static __inline__ vector unsigned char __ATTRS_o_ai
   11368 vec_lvrxl(int __a, const vector unsigned char *__b) {
   11369   return vec_perm((vector unsigned char)(0), vec_ldl(__a, __b),
   11370                   vec_lvsl(__a, (unsigned char *)__b));
   11371 }
   11372 
   11373 static __inline__ vector bool char __ATTRS_o_ai
   11374 vec_lvrxl(int __a, const vector bool char *__b) {
   11375   return vec_perm((vector bool char)(0), vec_ldl(__a, __b),
   11376                   vec_lvsl(__a, (unsigned char *)__b));
   11377 }
   11378 
   11379 static __inline__ vector short __ATTRS_o_ai vec_lvrxl(int __a,
   11380                                                       const short *__b) {
   11381   return vec_perm((vector short)(0), vec_ldl(__a, __b), vec_lvsl(__a, __b));
   11382 }
   11383 
   11384 static __inline__ vector short __ATTRS_o_ai vec_lvrxl(int __a,
   11385                                                       const vector short *__b) {
   11386   return vec_perm((vector short)(0), vec_ldl(__a, __b),
   11387                   vec_lvsl(__a, (unsigned char *)__b));
   11388 }
   11389 
   11390 static __inline__ vector unsigned short __ATTRS_o_ai
   11391 vec_lvrxl(int __a, const unsigned short *__b) {
   11392   return vec_perm((vector unsigned short)(0), vec_ldl(__a, __b),
   11393                   vec_lvsl(__a, __b));
   11394 }
   11395 
   11396 static __inline__ vector unsigned short __ATTRS_o_ai
   11397 vec_lvrxl(int __a, const vector unsigned short *__b) {
   11398   return vec_perm((vector unsigned short)(0), vec_ldl(__a, __b),
   11399                   vec_lvsl(__a, (unsigned char *)__b));
   11400 }
   11401 
   11402 static __inline__ vector bool short __ATTRS_o_ai
   11403 vec_lvrxl(int __a, const vector bool short *__b) {
   11404   return vec_perm((vector bool short)(0), vec_ldl(__a, __b),
   11405                   vec_lvsl(__a, (unsigned char *)__b));
   11406 }
   11407 
   11408 static __inline__ vector pixel __ATTRS_o_ai vec_lvrxl(int __a,
   11409                                                       const vector pixel *__b) {
   11410   return vec_perm((vector pixel)(0), vec_ldl(__a, __b),
   11411                   vec_lvsl(__a, (unsigned char *)__b));
   11412 }
   11413 
   11414 static __inline__ vector int __ATTRS_o_ai vec_lvrxl(int __a, const int *__b) {
   11415   return vec_perm((vector int)(0), vec_ldl(__a, __b), vec_lvsl(__a, __b));
   11416 }
   11417 
   11418 static __inline__ vector int __ATTRS_o_ai vec_lvrxl(int __a,
   11419                                                     const vector int *__b) {
   11420   return vec_perm((vector int)(0), vec_ldl(__a, __b),
   11421                   vec_lvsl(__a, (unsigned char *)__b));
   11422 }
   11423 
   11424 static __inline__ vector unsigned int __ATTRS_o_ai
   11425 vec_lvrxl(int __a, const unsigned int *__b) {
   11426   return vec_perm((vector unsigned int)(0), vec_ldl(__a, __b),
   11427                   vec_lvsl(__a, __b));
   11428 }
   11429 
   11430 static __inline__ vector unsigned int __ATTRS_o_ai
   11431 vec_lvrxl(int __a, const vector unsigned int *__b) {
   11432   return vec_perm((vector unsigned int)(0), vec_ldl(__a, __b),
   11433                   vec_lvsl(__a, (unsigned char *)__b));
   11434 }
   11435 
   11436 static __inline__ vector bool int __ATTRS_o_ai
   11437 vec_lvrxl(int __a, const vector bool int *__b) {
   11438   return vec_perm((vector bool int)(0), vec_ldl(__a, __b),
   11439                   vec_lvsl(__a, (unsigned char *)__b));
   11440 }
   11441 
   11442 static __inline__ vector float __ATTRS_o_ai vec_lvrxl(int __a,
   11443                                                       const float *__b) {
   11444   return vec_perm((vector float)(0), vec_ldl(__a, __b), vec_lvsl(__a, __b));
   11445 }
   11446 
   11447 static __inline__ vector float __ATTRS_o_ai vec_lvrxl(int __a,
   11448                                                       const vector float *__b) {
   11449   return vec_perm((vector float)(0), vec_ldl(__a, __b),
   11450                   vec_lvsl(__a, (unsigned char *)__b));
   11451 }
   11452 
   11453 /* vec_stvlx */
   11454 
   11455 static __inline__ void __ATTRS_o_ai vec_stvlx(vector signed char __a, int __b,
   11456                                               signed char *__c) {
   11457   return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
   11458                 __c);
   11459 }
   11460 
   11461 static __inline__ void __ATTRS_o_ai vec_stvlx(vector signed char __a, int __b,
   11462                                               vector signed char *__c) {
   11463   return vec_st(
   11464       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
   11465       __b, __c);
   11466 }
   11467 
   11468 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned char __a, int __b,
   11469                                               unsigned char *__c) {
   11470   return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
   11471                 __c);
   11472 }
   11473 
   11474 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned char __a, int __b,
   11475                                               vector unsigned char *__c) {
   11476   return vec_st(
   11477       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
   11478       __b, __c);
   11479 }
   11480 
   11481 static __inline__ void __ATTRS_o_ai vec_stvlx(vector bool char __a, int __b,
   11482                                               vector bool char *__c) {
   11483   return vec_st(
   11484       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
   11485       __b, __c);
   11486 }
   11487 
   11488 static __inline__ void __ATTRS_o_ai vec_stvlx(vector short __a, int __b,
   11489                                               short *__c) {
   11490   return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
   11491                 __c);
   11492 }
   11493 
   11494 static __inline__ void __ATTRS_o_ai vec_stvlx(vector short __a, int __b,
   11495                                               vector short *__c) {
   11496   return vec_st(
   11497       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
   11498       __b, __c);
   11499 }
   11500 
   11501 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned short __a,
   11502                                               int __b, unsigned short *__c) {
   11503   return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
   11504                 __c);
   11505 }
   11506 
   11507 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned short __a,
   11508                                               int __b,
   11509                                               vector unsigned short *__c) {
   11510   return vec_st(
   11511       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
   11512       __b, __c);
   11513 }
   11514 
   11515 static __inline__ void __ATTRS_o_ai vec_stvlx(vector bool short __a, int __b,
   11516                                               vector bool short *__c) {
   11517   return vec_st(
   11518       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
   11519       __b, __c);
   11520 }
   11521 
   11522 static __inline__ void __ATTRS_o_ai vec_stvlx(vector pixel __a, int __b,
   11523                                               vector pixel *__c) {
   11524   return vec_st(
   11525       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
   11526       __b, __c);
   11527 }
   11528 
   11529 static __inline__ void __ATTRS_o_ai vec_stvlx(vector int __a, int __b,
   11530                                               int *__c) {
   11531   return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
   11532                 __c);
   11533 }
   11534 
   11535 static __inline__ void __ATTRS_o_ai vec_stvlx(vector int __a, int __b,
   11536                                               vector int *__c) {
   11537   return vec_st(
   11538       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
   11539       __b, __c);
   11540 }
   11541 
   11542 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned int __a, int __b,
   11543                                               unsigned int *__c) {
   11544   return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
   11545                 __c);
   11546 }
   11547 
   11548 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned int __a, int __b,
   11549                                               vector unsigned int *__c) {
   11550   return vec_st(
   11551       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
   11552       __b, __c);
   11553 }
   11554 
   11555 static __inline__ void __ATTRS_o_ai vec_stvlx(vector bool int __a, int __b,
   11556                                               vector bool int *__c) {
   11557   return vec_st(
   11558       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
   11559       __b, __c);
   11560 }
   11561 
   11562 static __inline__ void __ATTRS_o_ai vec_stvlx(vector float __a, int __b,
   11563                                               vector float *__c) {
   11564   return vec_st(
   11565       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
   11566       __b, __c);
   11567 }
   11568 
   11569 /* vec_stvlxl */
   11570 
   11571 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector signed char __a, int __b,
   11572                                                signed char *__c) {
   11573   return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
   11574                  __c);
   11575 }
   11576 
   11577 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector signed char __a, int __b,
   11578                                                vector signed char *__c) {
   11579   return vec_stl(
   11580       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
   11581       __b, __c);
   11582 }
   11583 
   11584 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned char __a,
   11585                                                int __b, unsigned char *__c) {
   11586   return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
   11587                  __c);
   11588 }
   11589 
   11590 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned char __a,
   11591                                                int __b,
   11592                                                vector unsigned char *__c) {
   11593   return vec_stl(
   11594       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
   11595       __b, __c);
   11596 }
   11597 
   11598 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector bool char __a, int __b,
   11599                                                vector bool char *__c) {
   11600   return vec_stl(
   11601       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
   11602       __b, __c);
   11603 }
   11604 
   11605 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector short __a, int __b,
   11606                                                short *__c) {
   11607   return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
   11608                  __c);
   11609 }
   11610 
   11611 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector short __a, int __b,
   11612                                                vector short *__c) {
   11613   return vec_stl(
   11614       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
   11615       __b, __c);
   11616 }
   11617 
   11618 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned short __a,
   11619                                                int __b, unsigned short *__c) {
   11620   return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
   11621                  __c);
   11622 }
   11623 
   11624 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned short __a,
   11625                                                int __b,
   11626                                                vector unsigned short *__c) {
   11627   return vec_stl(
   11628       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
   11629       __b, __c);
   11630 }
   11631 
   11632 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector bool short __a, int __b,
   11633                                                vector bool short *__c) {
   11634   return vec_stl(
   11635       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
   11636       __b, __c);
   11637 }
   11638 
   11639 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector pixel __a, int __b,
   11640                                                vector pixel *__c) {
   11641   return vec_stl(
   11642       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
   11643       __b, __c);
   11644 }
   11645 
   11646 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector int __a, int __b,
   11647                                                int *__c) {
   11648   return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
   11649                  __c);
   11650 }
   11651 
   11652 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector int __a, int __b,
   11653                                                vector int *__c) {
   11654   return vec_stl(
   11655       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
   11656       __b, __c);
   11657 }
   11658 
   11659 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned int __a, int __b,
   11660                                                unsigned int *__c) {
   11661   return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
   11662                  __c);
   11663 }
   11664 
   11665 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned int __a, int __b,
   11666                                                vector unsigned int *__c) {
   11667   return vec_stl(
   11668       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
   11669       __b, __c);
   11670 }
   11671 
   11672 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector bool int __a, int __b,
   11673                                                vector bool int *__c) {
   11674   return vec_stl(
   11675       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
   11676       __b, __c);
   11677 }
   11678 
   11679 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector float __a, int __b,
   11680                                                vector float *__c) {
   11681   return vec_stl(
   11682       vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
   11683       __b, __c);
   11684 }
   11685 
   11686 /* vec_stvrx */
   11687 
   11688 static __inline__ void __ATTRS_o_ai vec_stvrx(vector signed char __a, int __b,
   11689                                               signed char *__c) {
   11690   return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
   11691                 __c);
   11692 }
   11693 
   11694 static __inline__ void __ATTRS_o_ai vec_stvrx(vector signed char __a, int __b,
   11695                                               vector signed char *__c) {
   11696   return vec_st(
   11697       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
   11698       __b, __c);
   11699 }
   11700 
   11701 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned char __a, int __b,
   11702                                               unsigned char *__c) {
   11703   return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
   11704                 __c);
   11705 }
   11706 
   11707 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned char __a, int __b,
   11708                                               vector unsigned char *__c) {
   11709   return vec_st(
   11710       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
   11711       __b, __c);
   11712 }
   11713 
   11714 static __inline__ void __ATTRS_o_ai vec_stvrx(vector bool char __a, int __b,
   11715                                               vector bool char *__c) {
   11716   return vec_st(
   11717       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
   11718       __b, __c);
   11719 }
   11720 
   11721 static __inline__ void __ATTRS_o_ai vec_stvrx(vector short __a, int __b,
   11722                                               short *__c) {
   11723   return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
   11724                 __c);
   11725 }
   11726 
   11727 static __inline__ void __ATTRS_o_ai vec_stvrx(vector short __a, int __b,
   11728                                               vector short *__c) {
   11729   return vec_st(
   11730       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
   11731       __b, __c);
   11732 }
   11733 
   11734 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned short __a,
   11735                                               int __b, unsigned short *__c) {
   11736   return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
   11737                 __c);
   11738 }
   11739 
   11740 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned short __a,
   11741                                               int __b,
   11742                                               vector unsigned short *__c) {
   11743   return vec_st(
   11744       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
   11745       __b, __c);
   11746 }
   11747 
   11748 static __inline__ void __ATTRS_o_ai vec_stvrx(vector bool short __a, int __b,
   11749                                               vector bool short *__c) {
   11750   return vec_st(
   11751       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
   11752       __b, __c);
   11753 }
   11754 
   11755 static __inline__ void __ATTRS_o_ai vec_stvrx(vector pixel __a, int __b,
   11756                                               vector pixel *__c) {
   11757   return vec_st(
   11758       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
   11759       __b, __c);
   11760 }
   11761 
   11762 static __inline__ void __ATTRS_o_ai vec_stvrx(vector int __a, int __b,
   11763                                               int *__c) {
   11764   return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
   11765                 __c);
   11766 }
   11767 
   11768 static __inline__ void __ATTRS_o_ai vec_stvrx(vector int __a, int __b,
   11769                                               vector int *__c) {
   11770   return vec_st(
   11771       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
   11772       __b, __c);
   11773 }
   11774 
   11775 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned int __a, int __b,
   11776                                               unsigned int *__c) {
   11777   return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
   11778                 __c);
   11779 }
   11780 
   11781 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned int __a, int __b,
   11782                                               vector unsigned int *__c) {
   11783   return vec_st(
   11784       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
   11785       __b, __c);
   11786 }
   11787 
   11788 static __inline__ void __ATTRS_o_ai vec_stvrx(vector bool int __a, int __b,
   11789                                               vector bool int *__c) {
   11790   return vec_st(
   11791       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
   11792       __b, __c);
   11793 }
   11794 
   11795 static __inline__ void __ATTRS_o_ai vec_stvrx(vector float __a, int __b,
   11796                                               vector float *__c) {
   11797   return vec_st(
   11798       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
   11799       __b, __c);
   11800 }
   11801 
   11802 /* vec_stvrxl */
   11803 
   11804 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector signed char __a, int __b,
   11805                                                signed char *__c) {
   11806   return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
   11807                  __c);
   11808 }
   11809 
   11810 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector signed char __a, int __b,
   11811                                                vector signed char *__c) {
   11812   return vec_stl(
   11813       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
   11814       __b, __c);
   11815 }
   11816 
   11817 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned char __a,
   11818                                                int __b, unsigned char *__c) {
   11819   return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
   11820                  __c);
   11821 }
   11822 
   11823 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned char __a,
   11824                                                int __b,
   11825                                                vector unsigned char *__c) {
   11826   return vec_stl(
   11827       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
   11828       __b, __c);
   11829 }
   11830 
   11831 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector bool char __a, int __b,
   11832                                                vector bool char *__c) {
   11833   return vec_stl(
   11834       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
   11835       __b, __c);
   11836 }
   11837 
   11838 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector short __a, int __b,
   11839                                                short *__c) {
   11840   return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
   11841                  __c);
   11842 }
   11843 
   11844 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector short __a, int __b,
   11845                                                vector short *__c) {
   11846   return vec_stl(
   11847       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
   11848       __b, __c);
   11849 }
   11850 
   11851 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned short __a,
   11852                                                int __b, unsigned short *__c) {
   11853   return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
   11854                  __c);
   11855 }
   11856 
   11857 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned short __a,
   11858                                                int __b,
   11859                                                vector unsigned short *__c) {
   11860   return vec_stl(
   11861       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
   11862       __b, __c);
   11863 }
   11864 
   11865 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector bool short __a, int __b,
   11866                                                vector bool short *__c) {
   11867   return vec_stl(
   11868       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
   11869       __b, __c);
   11870 }
   11871 
   11872 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector pixel __a, int __b,
   11873                                                vector pixel *__c) {
   11874   return vec_stl(
   11875       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
   11876       __b, __c);
   11877 }
   11878 
   11879 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector int __a, int __b,
   11880                                                int *__c) {
   11881   return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
   11882                  __c);
   11883 }
   11884 
   11885 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector int __a, int __b,
   11886                                                vector int *__c) {
   11887   return vec_stl(
   11888       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
   11889       __b, __c);
   11890 }
   11891 
   11892 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned int __a, int __b,
   11893                                                unsigned int *__c) {
   11894   return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
   11895                  __c);
   11896 }
   11897 
   11898 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned int __a, int __b,
   11899                                                vector unsigned int *__c) {
   11900   return vec_stl(
   11901       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
   11902       __b, __c);
   11903 }
   11904 
   11905 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector bool int __a, int __b,
   11906                                                vector bool int *__c) {
   11907   return vec_stl(
   11908       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
   11909       __b, __c);
   11910 }
   11911 
   11912 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector float __a, int __b,
   11913                                                vector float *__c) {
   11914   return vec_stl(
   11915       vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
   11916       __b, __c);
   11917 }
   11918 
   11919 /* vec_promote */
   11920 
   11921 static __inline__ vector signed char __ATTRS_o_ai vec_promote(signed char __a,
   11922                                                               int __b) {
   11923   vector signed char __res = (vector signed char)(0);
   11924   __res[__b] = __a;
   11925   return __res;
   11926 }
   11927 
   11928 static __inline__ vector unsigned char __ATTRS_o_ai
   11929 vec_promote(unsigned char __a, int __b) {
   11930   vector unsigned char __res = (vector unsigned char)(0);
   11931   __res[__b] = __a;
   11932   return __res;
   11933 }
   11934 
   11935 static __inline__ vector short __ATTRS_o_ai vec_promote(short __a, int __b) {
   11936   vector short __res = (vector short)(0);
   11937   __res[__b] = __a;
   11938   return __res;
   11939 }
   11940 
   11941 static __inline__ vector unsigned short __ATTRS_o_ai
   11942 vec_promote(unsigned short __a, int __b) {
   11943   vector unsigned short __res = (vector unsigned short)(0);
   11944   __res[__b] = __a;
   11945   return __res;
   11946 }
   11947 
   11948 static __inline__ vector int __ATTRS_o_ai vec_promote(int __a, int __b) {
   11949   vector int __res = (vector int)(0);
   11950   __res[__b] = __a;
   11951   return __res;
   11952 }
   11953 
   11954 static __inline__ vector unsigned int __ATTRS_o_ai vec_promote(unsigned int __a,
   11955                                                                int __b) {
   11956   vector unsigned int __res = (vector unsigned int)(0);
   11957   __res[__b] = __a;
   11958   return __res;
   11959 }
   11960 
   11961 static __inline__ vector float __ATTRS_o_ai vec_promote(float __a, int __b) {
   11962   vector float __res = (vector float)(0);
   11963   __res[__b] = __a;
   11964   return __res;
   11965 }
   11966 
   11967 /* vec_splats */
   11968 
   11969 static __inline__ vector signed char __ATTRS_o_ai vec_splats(signed char __a) {
   11970   return (vector signed char)(__a);
   11971 }
   11972 
   11973 static __inline__ vector unsigned char __ATTRS_o_ai
   11974 vec_splats(unsigned char __a) {
   11975   return (vector unsigned char)(__a);
   11976 }
   11977 
   11978 static __inline__ vector short __ATTRS_o_ai vec_splats(short __a) {
   11979   return (vector short)(__a);
   11980 }
   11981 
   11982 static __inline__ vector unsigned short __ATTRS_o_ai
   11983 vec_splats(unsigned short __a) {
   11984   return (vector unsigned short)(__a);
   11985 }
   11986 
   11987 static __inline__ vector int __ATTRS_o_ai vec_splats(int __a) {
   11988   return (vector int)(__a);
   11989 }
   11990 
   11991 static __inline__ vector unsigned int __ATTRS_o_ai
   11992 vec_splats(unsigned int __a) {
   11993   return (vector unsigned int)(__a);
   11994 }
   11995 
   11996 #ifdef __VSX__
   11997 static __inline__ vector signed long long __ATTRS_o_ai
   11998 vec_splats(signed long long __a) {
   11999   return (vector signed long long)(__a);
   12000 }
   12001 
   12002 static __inline__ vector unsigned long long __ATTRS_o_ai
   12003 vec_splats(unsigned long long __a) {
   12004   return (vector unsigned long long)(__a);
   12005 }
   12006 
   12007 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
   12008 static __inline__ vector signed __int128 __ATTRS_o_ai
   12009 vec_splats(signed __int128 __a) {
   12010   return (vector signed __int128)(__a);
   12011 }
   12012 
   12013 static __inline__ vector unsigned __int128 __ATTRS_o_ai
   12014 vec_splats(unsigned __int128 __a) {
   12015   return (vector unsigned __int128)(__a);
   12016 }
   12017 
   12018 #endif
   12019 
   12020 static __inline__ vector double __ATTRS_o_ai vec_splats(double __a) {
   12021   return (vector double)(__a);
   12022 }
   12023 #endif
   12024 
   12025 static __inline__ vector float __ATTRS_o_ai vec_splats(float __a) {
   12026   return (vector float)(__a);
   12027 }
   12028 
   12029 /* ----------------------------- predicates --------------------------------- */
   12030 
   12031 /* vec_all_eq */
   12032 
   12033 static __inline__ int __ATTRS_o_ai vec_all_eq(vector signed char __a,
   12034                                               vector signed char __b) {
   12035   return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
   12036                                       (vector char)__b);
   12037 }
   12038 
   12039 static __inline__ int __ATTRS_o_ai vec_all_eq(vector signed char __a,
   12040                                               vector bool char __b) {
   12041   return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
   12042                                       (vector char)__b);
   12043 }
   12044 
   12045 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned char __a,
   12046                                               vector unsigned char __b) {
   12047   return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
   12048                                       (vector char)__b);
   12049 }
   12050 
   12051 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned char __a,
   12052                                               vector bool char __b) {
   12053   return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
   12054                                       (vector char)__b);
   12055 }
   12056 
   12057 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool char __a,
   12058                                               vector signed char __b) {
   12059   return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
   12060                                       (vector char)__b);
   12061 }
   12062 
   12063 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool char __a,
   12064                                               vector unsigned char __b) {
   12065   return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
   12066                                       (vector char)__b);
   12067 }
   12068 
   12069 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool char __a,
   12070                                               vector bool char __b) {
   12071   return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
   12072                                       (vector char)__b);
   12073 }
   12074 
   12075 static __inline__ int __ATTRS_o_ai vec_all_eq(vector short __a,
   12076                                               vector short __b) {
   12077   return __builtin_altivec_vcmpequh_p(__CR6_LT, __a, __b);
   12078 }
   12079 
   12080 static __inline__ int __ATTRS_o_ai vec_all_eq(vector short __a,
   12081                                               vector bool short __b) {
   12082   return __builtin_altivec_vcmpequh_p(__CR6_LT, __a, (vector short)__b);
   12083 }
   12084 
   12085 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned short __a,
   12086                                               vector unsigned short __b) {
   12087   return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
   12088                                       (vector short)__b);
   12089 }
   12090 
   12091 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned short __a,
   12092                                               vector bool short __b) {
   12093   return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
   12094                                       (vector short)__b);
   12095 }
   12096 
   12097 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool short __a,
   12098                                               vector short __b) {
   12099   return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
   12100                                       (vector short)__b);
   12101 }
   12102 
   12103 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool short __a,
   12104                                               vector unsigned short __b) {
   12105   return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
   12106                                       (vector short)__b);
   12107 }
   12108 
   12109 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool short __a,
   12110                                               vector bool short __b) {
   12111   return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
   12112                                       (vector short)__b);
   12113 }
   12114 
   12115 static __inline__ int __ATTRS_o_ai vec_all_eq(vector pixel __a,
   12116                                               vector pixel __b) {
   12117   return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
   12118                                       (vector short)__b);
   12119 }
   12120 
   12121 static __inline__ int __ATTRS_o_ai vec_all_eq(vector int __a, vector int __b) {
   12122   return __builtin_altivec_vcmpequw_p(__CR6_LT, __a, __b);
   12123 }
   12124 
   12125 static __inline__ int __ATTRS_o_ai vec_all_eq(vector int __a,
   12126                                               vector bool int __b) {
   12127   return __builtin_altivec_vcmpequw_p(__CR6_LT, __a, (vector int)__b);
   12128 }
   12129 
   12130 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned int __a,
   12131                                               vector unsigned int __b) {
   12132   return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
   12133                                       (vector int)__b);
   12134 }
   12135 
   12136 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned int __a,
   12137                                               vector bool int __b) {
   12138   return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
   12139                                       (vector int)__b);
   12140 }
   12141 
   12142 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool int __a,
   12143                                               vector int __b) {
   12144   return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
   12145                                       (vector int)__b);
   12146 }
   12147 
   12148 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool int __a,
   12149                                               vector unsigned int __b) {
   12150   return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
   12151                                       (vector int)__b);
   12152 }
   12153 
   12154 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool int __a,
   12155                                               vector bool int __b) {
   12156   return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
   12157                                       (vector int)__b);
   12158 }
   12159 
   12160 #ifdef __POWER8_VECTOR__
   12161 static __inline__ int __ATTRS_o_ai vec_all_eq(vector signed long long __a,
   12162                                               vector signed long long __b) {
   12163   return __builtin_altivec_vcmpequd_p(__CR6_LT, __a, __b);
   12164 }
   12165 
   12166 static __inline__ int __ATTRS_o_ai vec_all_eq(vector long long __a,
   12167                                               vector bool long long __b) {
   12168   return __builtin_altivec_vcmpequd_p(__CR6_LT, __a, (vector long long)__b);
   12169 }
   12170 
   12171 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned long long __a,
   12172                                               vector unsigned long long __b) {
   12173   return __builtin_altivec_vcmpequd_p(__CR6_LT, (vector long long)__a,
   12174                                       (vector long long)__b);
   12175 }
   12176 
   12177 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned long long __a,
   12178                                               vector bool long long __b) {
   12179   return __builtin_altivec_vcmpequd_p(__CR6_LT, (vector long long)__a,
   12180                                       (vector long long)__b);
   12181 }
   12182 
   12183 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool long long __a,
   12184                                               vector long long __b) {
   12185   return __builtin_altivec_vcmpequd_p(__CR6_LT, (vector long long)__a,
   12186                                       (vector long long)__b);
   12187 }
   12188 
   12189 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool long long __a,
   12190                                               vector unsigned long long __b) {
   12191   return __builtin_altivec_vcmpequd_p(__CR6_LT, (vector long long)__a,
   12192                                       (vector long long)__b);
   12193 }
   12194 
   12195 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool long long __a,
   12196                                               vector bool long long __b) {
   12197   return __builtin_altivec_vcmpequd_p(__CR6_LT, (vector long long)__a,
   12198                                       (vector long long)__b);
   12199 }
   12200 #endif
   12201 
   12202 static __inline__ int __ATTRS_o_ai vec_all_eq(vector float __a,
   12203                                               vector float __b) {
   12204 #ifdef __VSX__
   12205   return __builtin_vsx_xvcmpeqsp_p(__CR6_LT, __a, __b);
   12206 #else
   12207   return __builtin_altivec_vcmpeqfp_p(__CR6_LT, __a, __b);
   12208 #endif
   12209 }
   12210 
   12211 #ifdef __VSX__
   12212 static __inline__ int __ATTRS_o_ai vec_all_eq(vector double __a,
   12213                                               vector double __b) {
   12214   return __builtin_vsx_xvcmpeqdp_p(__CR6_LT, __a, __b);
   12215 }
   12216 #endif
   12217 
   12218 /* vec_all_ge */
   12219 
   12220 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed char __a,
   12221                                               vector signed char __b) {
   12222   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, __b, __a);
   12223 }
   12224 
   12225 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed char __a,
   12226                                               vector bool char __b) {
   12227   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, (vector signed char)__b, __a);
   12228 }
   12229 
   12230 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned char __a,
   12231                                               vector unsigned char __b) {
   12232   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __b, __a);
   12233 }
   12234 
   12235 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned char __a,
   12236                                               vector bool char __b) {
   12237   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__b, __a);
   12238 }
   12239 
   12240 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool char __a,
   12241                                               vector signed char __b) {
   12242   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__b,
   12243                                       (vector unsigned char)__a);
   12244 }
   12245 
   12246 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool char __a,
   12247                                               vector unsigned char __b) {
   12248   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __b, (vector unsigned char)__a);
   12249 }
   12250 
   12251 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool char __a,
   12252                                               vector bool char __b) {
   12253   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__b,
   12254                                       (vector unsigned char)__a);
   12255 }
   12256 
   12257 static __inline__ int __ATTRS_o_ai vec_all_ge(vector short __a,
   12258                                               vector short __b) {
   12259   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, __b, __a);
   12260 }
   12261 
   12262 static __inline__ int __ATTRS_o_ai vec_all_ge(vector short __a,
   12263                                               vector bool short __b) {
   12264   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, (vector short)__b, __a);
   12265 }
   12266 
   12267 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned short __a,
   12268                                               vector unsigned short __b) {
   12269   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __b, __a);
   12270 }
   12271 
   12272 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned short __a,
   12273                                               vector bool short __b) {
   12274   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__b,
   12275                                       __a);
   12276 }
   12277 
   12278 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool short __a,
   12279                                               vector short __b) {
   12280   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__b,
   12281                                       (vector unsigned short)__a);
   12282 }
   12283 
   12284 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool short __a,
   12285                                               vector unsigned short __b) {
   12286   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __b,
   12287                                       (vector unsigned short)__a);
   12288 }
   12289 
   12290 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool short __a,
   12291                                               vector bool short __b) {
   12292   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__b,
   12293                                       (vector unsigned short)__a);
   12294 }
   12295 
   12296 static __inline__ int __ATTRS_o_ai vec_all_ge(vector int __a, vector int __b) {
   12297   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, __b, __a);
   12298 }
   12299 
   12300 static __inline__ int __ATTRS_o_ai vec_all_ge(vector int __a,
   12301                                               vector bool int __b) {
   12302   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, (vector int)__b, __a);
   12303 }
   12304 
   12305 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned int __a,
   12306                                               vector unsigned int __b) {
   12307   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __b, __a);
   12308 }
   12309 
   12310 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned int __a,
   12311                                               vector bool int __b) {
   12312   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__b, __a);
   12313 }
   12314 
   12315 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool int __a,
   12316                                               vector int __b) {
   12317   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__b,
   12318                                       (vector unsigned int)__a);
   12319 }
   12320 
   12321 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool int __a,
   12322                                               vector unsigned int __b) {
   12323   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __b, (vector unsigned int)__a);
   12324 }
   12325 
   12326 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool int __a,
   12327                                               vector bool int __b) {
   12328   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__b,
   12329                                       (vector unsigned int)__a);
   12330 }
   12331 
   12332 #ifdef __POWER8_VECTOR__
   12333 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed long long __a,
   12334                                               vector signed long long __b) {
   12335   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, __b, __a);
   12336 }
   12337 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed long long __a,
   12338                                               vector bool long long __b) {
   12339   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, (vector signed long long)__b,
   12340                                       __a);
   12341 }
   12342 
   12343 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned long long __a,
   12344                                               vector unsigned long long __b) {
   12345   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __b, __a);
   12346 }
   12347 
   12348 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned long long __a,
   12349                                               vector bool long long __b) {
   12350   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__b,
   12351                                       __a);
   12352 }
   12353 
   12354 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool long long __a,
   12355                                               vector signed long long __b) {
   12356   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__b,
   12357                                       (vector unsigned long long)__a);
   12358 }
   12359 
   12360 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool long long __a,
   12361                                               vector unsigned long long __b) {
   12362   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __b,
   12363                                       (vector unsigned long long)__a);
   12364 }
   12365 
   12366 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool long long __a,
   12367                                               vector bool long long __b) {
   12368   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__b,
   12369                                       (vector unsigned long long)__a);
   12370 }
   12371 #endif
   12372 
   12373 static __inline__ int __ATTRS_o_ai vec_all_ge(vector float __a,
   12374                                               vector float __b) {
   12375 #ifdef __VSX__
   12376   return __builtin_vsx_xvcmpgesp_p(__CR6_LT, __a, __b);
   12377 #else
   12378   return __builtin_altivec_vcmpgefp_p(__CR6_LT, __a, __b);
   12379 #endif
   12380 }
   12381 
   12382 #ifdef __VSX__
   12383 static __inline__ int __ATTRS_o_ai vec_all_ge(vector double __a,
   12384                                               vector double __b) {
   12385   return __builtin_vsx_xvcmpgedp_p(__CR6_LT, __a, __b);
   12386 }
   12387 #endif
   12388 
   12389 /* vec_all_gt */
   12390 
   12391 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed char __a,
   12392                                               vector signed char __b) {
   12393   return __builtin_altivec_vcmpgtsb_p(__CR6_LT, __a, __b);
   12394 }
   12395 
   12396 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed char __a,
   12397                                               vector bool char __b) {
   12398   return __builtin_altivec_vcmpgtsb_p(__CR6_LT, __a, (vector signed char)__b);
   12399 }
   12400 
   12401 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned char __a,
   12402                                               vector unsigned char __b) {
   12403   return __builtin_altivec_vcmpgtub_p(__CR6_LT, __a, __b);
   12404 }
   12405 
   12406 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned char __a,
   12407                                               vector bool char __b) {
   12408   return __builtin_altivec_vcmpgtub_p(__CR6_LT, __a, (vector unsigned char)__b);
   12409 }
   12410 
   12411 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool char __a,
   12412                                               vector signed char __b) {
   12413   return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__a,
   12414                                       (vector unsigned char)__b);
   12415 }
   12416 
   12417 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool char __a,
   12418                                               vector unsigned char __b) {
   12419   return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__a, __b);
   12420 }
   12421 
   12422 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool char __a,
   12423                                               vector bool char __b) {
   12424   return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__a,
   12425                                       (vector unsigned char)__b);
   12426 }
   12427 
   12428 static __inline__ int __ATTRS_o_ai vec_all_gt(vector short __a,
   12429                                               vector short __b) {
   12430   return __builtin_altivec_vcmpgtsh_p(__CR6_LT, __a, __b);
   12431 }
   12432 
   12433 static __inline__ int __ATTRS_o_ai vec_all_gt(vector short __a,
   12434                                               vector bool short __b) {
   12435   return __builtin_altivec_vcmpgtsh_p(__CR6_LT, __a, (vector short)__b);
   12436 }
   12437 
   12438 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned short __a,
   12439                                               vector unsigned short __b) {
   12440   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __a, __b);
   12441 }
   12442 
   12443 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned short __a,
   12444                                               vector bool short __b) {
   12445   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __a,
   12446                                       (vector unsigned short)__b);
   12447 }
   12448 
   12449 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool short __a,
   12450                                               vector short __b) {
   12451   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__a,
   12452                                       (vector unsigned short)__b);
   12453 }
   12454 
   12455 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool short __a,
   12456                                               vector unsigned short __b) {
   12457   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__a,
   12458                                       __b);
   12459 }
   12460 
   12461 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool short __a,
   12462                                               vector bool short __b) {
   12463   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__a,
   12464                                       (vector unsigned short)__b);
   12465 }
   12466 
   12467 static __inline__ int __ATTRS_o_ai vec_all_gt(vector int __a, vector int __b) {
   12468   return __builtin_altivec_vcmpgtsw_p(__CR6_LT, __a, __b);
   12469 }
   12470 
   12471 static __inline__ int __ATTRS_o_ai vec_all_gt(vector int __a,
   12472                                               vector bool int __b) {
   12473   return __builtin_altivec_vcmpgtsw_p(__CR6_LT, __a, (vector int)__b);
   12474 }
   12475 
   12476 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned int __a,
   12477                                               vector unsigned int __b) {
   12478   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __a, __b);
   12479 }
   12480 
   12481 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned int __a,
   12482                                               vector bool int __b) {
   12483   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __a, (vector unsigned int)__b);
   12484 }
   12485 
   12486 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool int __a,
   12487                                               vector int __b) {
   12488   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__a,
   12489                                       (vector unsigned int)__b);
   12490 }
   12491 
   12492 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool int __a,
   12493                                               vector unsigned int __b) {
   12494   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__a, __b);
   12495 }
   12496 
   12497 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool int __a,
   12498                                               vector bool int __b) {
   12499   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__a,
   12500                                       (vector unsigned int)__b);
   12501 }
   12502 
   12503 #ifdef __POWER8_VECTOR__
   12504 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed long long __a,
   12505                                               vector signed long long __b) {
   12506   return __builtin_altivec_vcmpgtsd_p(__CR6_LT, __a, __b);
   12507 }
   12508 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed long long __a,
   12509                                               vector bool long long __b) {
   12510   return __builtin_altivec_vcmpgtsd_p(__CR6_LT, __a,
   12511                                       (vector signed long long)__b);
   12512 }
   12513 
   12514 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned long long __a,
   12515                                               vector unsigned long long __b) {
   12516   return __builtin_altivec_vcmpgtud_p(__CR6_LT, __a, __b);
   12517 }
   12518 
   12519 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned long long __a,
   12520                                               vector bool long long __b) {
   12521   return __builtin_altivec_vcmpgtud_p(__CR6_LT, __a,
   12522                                       (vector unsigned long long)__b);
   12523 }
   12524 
   12525 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool long long __a,
   12526                                               vector signed long long __b) {
   12527   return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__a,
   12528                                       (vector unsigned long long)__b);
   12529 }
   12530 
   12531 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool long long __a,
   12532                                               vector unsigned long long __b) {
   12533   return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__a,
   12534                                       __b);
   12535 }
   12536 
   12537 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool long long __a,
   12538                                               vector bool long long __b) {
   12539   return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__a,
   12540                                       (vector unsigned long long)__b);
   12541 }
   12542 #endif
   12543 
   12544 static __inline__ int __ATTRS_o_ai vec_all_gt(vector float __a,
   12545                                               vector float __b) {
   12546 #ifdef __VSX__
   12547   return __builtin_vsx_xvcmpgtsp_p(__CR6_LT, __a, __b);
   12548 #else
   12549   return __builtin_altivec_vcmpgtfp_p(__CR6_LT, __a, __b);
   12550 #endif
   12551 }
   12552 
   12553 #ifdef __VSX__
   12554 static __inline__ int __ATTRS_o_ai vec_all_gt(vector double __a,
   12555                                               vector double __b) {
   12556   return __builtin_vsx_xvcmpgtdp_p(__CR6_LT, __a, __b);
   12557 }
   12558 #endif
   12559 
   12560 /* vec_all_in */
   12561 
   12562 static __inline__ int __attribute__((__always_inline__))
   12563 vec_all_in(vector float __a, vector float __b) {
   12564   return __builtin_altivec_vcmpbfp_p(__CR6_EQ, __a, __b);
   12565 }
   12566 
   12567 /* vec_all_le */
   12568 
   12569 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed char __a,
   12570                                               vector signed char __b) {
   12571   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, __a, __b);
   12572 }
   12573 
   12574 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed char __a,
   12575                                               vector bool char __b) {
   12576   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, __a, (vector signed char)__b);
   12577 }
   12578 
   12579 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned char __a,
   12580                                               vector unsigned char __b) {
   12581   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __a, __b);
   12582 }
   12583 
   12584 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned char __a,
   12585                                               vector bool char __b) {
   12586   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __a, (vector unsigned char)__b);
   12587 }
   12588 
   12589 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool char __a,
   12590                                               vector signed char __b) {
   12591   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__a,
   12592                                       (vector unsigned char)__b);
   12593 }
   12594 
   12595 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool char __a,
   12596                                               vector unsigned char __b) {
   12597   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__a, __b);
   12598 }
   12599 
   12600 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool char __a,
   12601                                               vector bool char __b) {
   12602   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__a,
   12603                                       (vector unsigned char)__b);
   12604 }
   12605 
   12606 static __inline__ int __ATTRS_o_ai vec_all_le(vector short __a,
   12607                                               vector short __b) {
   12608   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, __a, __b);
   12609 }
   12610 
   12611 static __inline__ int __ATTRS_o_ai vec_all_le(vector short __a,
   12612                                               vector bool short __b) {
   12613   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, __a, (vector short)__b);
   12614 }
   12615 
   12616 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned short __a,
   12617                                               vector unsigned short __b) {
   12618   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __a, __b);
   12619 }
   12620 
   12621 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned short __a,
   12622                                               vector bool short __b) {
   12623   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __a,
   12624                                       (vector unsigned short)__b);
   12625 }
   12626 
   12627 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool short __a,
   12628                                               vector short __b) {
   12629   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__a,
   12630                                       (vector unsigned short)__b);
   12631 }
   12632 
   12633 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool short __a,
   12634                                               vector unsigned short __b) {
   12635   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__a,
   12636                                       __b);
   12637 }
   12638 
   12639 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool short __a,
   12640                                               vector bool short __b) {
   12641   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__a,
   12642                                       (vector unsigned short)__b);
   12643 }
   12644 
   12645 static __inline__ int __ATTRS_o_ai vec_all_le(vector int __a, vector int __b) {
   12646   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, __a, __b);
   12647 }
   12648 
   12649 static __inline__ int __ATTRS_o_ai vec_all_le(vector int __a,
   12650                                               vector bool int __b) {
   12651   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, __a, (vector int)__b);
   12652 }
   12653 
   12654 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned int __a,
   12655                                               vector unsigned int __b) {
   12656   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __a, __b);
   12657 }
   12658 
   12659 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned int __a,
   12660                                               vector bool int __b) {
   12661   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __a, (vector unsigned int)__b);
   12662 }
   12663 
   12664 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool int __a,
   12665                                               vector int __b) {
   12666   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__a,
   12667                                       (vector unsigned int)__b);
   12668 }
   12669 
   12670 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool int __a,
   12671                                               vector unsigned int __b) {
   12672   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__a, __b);
   12673 }
   12674 
   12675 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool int __a,
   12676                                               vector bool int __b) {
   12677   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__a,
   12678                                       (vector unsigned int)__b);
   12679 }
   12680 
   12681 #ifdef __POWER8_VECTOR__
   12682 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed long long __a,
   12683                                               vector signed long long __b) {
   12684   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, __a, __b);
   12685 }
   12686 
   12687 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned long long __a,
   12688                                               vector unsigned long long __b) {
   12689   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __a, __b);
   12690 }
   12691 
   12692 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed long long __a,
   12693                                               vector bool long long __b) {
   12694   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, __a,
   12695                                       (vector signed long long)__b);
   12696 }
   12697 
   12698 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned long long __a,
   12699                                               vector bool long long __b) {
   12700   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __a,
   12701                                       (vector unsigned long long)__b);
   12702 }
   12703 
   12704 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool long long __a,
   12705                                               vector signed long long __b) {
   12706   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__a,
   12707                                       (vector unsigned long long)__b);
   12708 }
   12709 
   12710 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool long long __a,
   12711                                               vector unsigned long long __b) {
   12712   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__a,
   12713                                       __b);
   12714 }
   12715 
   12716 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool long long __a,
   12717                                               vector bool long long __b) {
   12718   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__a,
   12719                                       (vector unsigned long long)__b);
   12720 }
   12721 #endif
   12722 
   12723 static __inline__ int __ATTRS_o_ai vec_all_le(vector float __a,
   12724                                               vector float __b) {
   12725 #ifdef __VSX__
   12726   return __builtin_vsx_xvcmpgesp_p(__CR6_LT, __b, __a);
   12727 #else
   12728   return __builtin_altivec_vcmpgefp_p(__CR6_LT, __b, __a);
   12729 #endif
   12730 }
   12731 
   12732 #ifdef __VSX__
   12733 static __inline__ int __ATTRS_o_ai vec_all_le(vector double __a,
   12734                                               vector double __b) {
   12735   return __builtin_vsx_xvcmpgedp_p(__CR6_LT, __b, __a);
   12736 }
   12737 #endif
   12738 
   12739 /* vec_all_lt */
   12740 
   12741 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed char __a,
   12742                                               vector signed char __b) {
   12743   return __builtin_altivec_vcmpgtsb_p(__CR6_LT, __b, __a);
   12744 }
   12745 
   12746 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed char __a,
   12747                                               vector bool char __b) {
   12748   return __builtin_altivec_vcmpgtsb_p(__CR6_LT, (vector signed char)__b, __a);
   12749 }
   12750 
   12751 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned char __a,
   12752                                               vector unsigned char __b) {
   12753   return __builtin_altivec_vcmpgtub_p(__CR6_LT, __b, __a);
   12754 }
   12755 
   12756 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned char __a,
   12757                                               vector bool char __b) {
   12758   return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__b, __a);
   12759 }
   12760 
   12761 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool char __a,
   12762                                               vector signed char __b) {
   12763   return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__b,
   12764                                       (vector unsigned char)__a);
   12765 }
   12766 
   12767 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool char __a,
   12768                                               vector unsigned char __b) {
   12769   return __builtin_altivec_vcmpgtub_p(__CR6_LT, __b, (vector unsigned char)__a);
   12770 }
   12771 
   12772 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool char __a,
   12773                                               vector bool char __b) {
   12774   return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__b,
   12775                                       (vector unsigned char)__a);
   12776 }
   12777 
   12778 static __inline__ int __ATTRS_o_ai vec_all_lt(vector short __a,
   12779                                               vector short __b) {
   12780   return __builtin_altivec_vcmpgtsh_p(__CR6_LT, __b, __a);
   12781 }
   12782 
   12783 static __inline__ int __ATTRS_o_ai vec_all_lt(vector short __a,
   12784                                               vector bool short __b) {
   12785   return __builtin_altivec_vcmpgtsh_p(__CR6_LT, (vector short)__b, __a);
   12786 }
   12787 
   12788 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned short __a,
   12789                                               vector unsigned short __b) {
   12790   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __b, __a);
   12791 }
   12792 
   12793 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned short __a,
   12794                                               vector bool short __b) {
   12795   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__b,
   12796                                       __a);
   12797 }
   12798 
   12799 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool short __a,
   12800                                               vector short __b) {
   12801   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__b,
   12802                                       (vector unsigned short)__a);
   12803 }
   12804 
   12805 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool short __a,
   12806                                               vector unsigned short __b) {
   12807   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __b,
   12808                                       (vector unsigned short)__a);
   12809 }
   12810 
   12811 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool short __a,
   12812                                               vector bool short __b) {
   12813   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__b,
   12814                                       (vector unsigned short)__a);
   12815 }
   12816 
   12817 static __inline__ int __ATTRS_o_ai vec_all_lt(vector int __a, vector int __b) {
   12818   return __builtin_altivec_vcmpgtsw_p(__CR6_LT, __b, __a);
   12819 }
   12820 
   12821 static __inline__ int __ATTRS_o_ai vec_all_lt(vector int __a,
   12822                                               vector bool int __b) {
   12823   return __builtin_altivec_vcmpgtsw_p(__CR6_LT, (vector int)__b, __a);
   12824 }
   12825 
   12826 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned int __a,
   12827                                               vector unsigned int __b) {
   12828   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __b, __a);
   12829 }
   12830 
   12831 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned int __a,
   12832                                               vector bool int __b) {
   12833   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__b, __a);
   12834 }
   12835 
   12836 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool int __a,
   12837                                               vector int __b) {
   12838   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__b,
   12839                                       (vector unsigned int)__a);
   12840 }
   12841 
   12842 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool int __a,
   12843                                               vector unsigned int __b) {
   12844   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __b, (vector unsigned int)__a);
   12845 }
   12846 
   12847 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool int __a,
   12848                                               vector bool int __b) {
   12849   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__b,
   12850                                       (vector unsigned int)__a);
   12851 }
   12852 
   12853 #ifdef __POWER8_VECTOR__
   12854 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed long long __a,
   12855                                               vector signed long long __b) {
   12856   return __builtin_altivec_vcmpgtsd_p(__CR6_LT, __b, __a);
   12857 }
   12858 
   12859 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned long long __a,
   12860                                               vector unsigned long long __b) {
   12861   return __builtin_altivec_vcmpgtud_p(__CR6_LT, __b, __a);
   12862 }
   12863 
   12864 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed long long __a,
   12865                                               vector bool long long __b) {
   12866   return __builtin_altivec_vcmpgtsd_p(__CR6_LT, (vector signed long long)__b,
   12867                                       __a);
   12868 }
   12869 
   12870 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned long long __a,
   12871                                               vector bool long long __b) {
   12872   return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__b,
   12873                                       __a);
   12874 }
   12875 
   12876 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool long long __a,
   12877                                               vector signed long long __b) {
   12878   return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__b,
   12879                                       (vector unsigned long long)__a);
   12880 }
   12881 
   12882 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool long long __a,
   12883                                               vector unsigned long long __b) {
   12884   return __builtin_altivec_vcmpgtud_p(__CR6_LT, __b,
   12885                                       (vector unsigned long long)__a);
   12886 }
   12887 
   12888 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool long long __a,
   12889                                               vector bool long long __b) {
   12890   return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__b,
   12891                                       (vector unsigned long long)__a);
   12892 }
   12893 #endif
   12894 
   12895 static __inline__ int __ATTRS_o_ai vec_all_lt(vector float __a,
   12896                                               vector float __b) {
   12897 #ifdef __VSX__
   12898   return __builtin_vsx_xvcmpgtsp_p(__CR6_LT, __b, __a);
   12899 #else
   12900   return __builtin_altivec_vcmpgtfp_p(__CR6_LT, __b, __a);
   12901 #endif
   12902 }
   12903 
   12904 #ifdef __VSX__
   12905 static __inline__ int __ATTRS_o_ai vec_all_lt(vector double __a,
   12906                                               vector double __b) {
   12907   return __builtin_vsx_xvcmpgtdp_p(__CR6_LT, __b, __a);
   12908 }
   12909 #endif
   12910 
   12911 /* vec_all_nan */
   12912 
   12913 static __inline__ int __ATTRS_o_ai vec_all_nan(vector float __a) {
   12914 #ifdef __VSX__
   12915   return __builtin_vsx_xvcmpeqsp_p(__CR6_EQ, __a, __a);
   12916 #else
   12917   return __builtin_altivec_vcmpeqfp_p(__CR6_EQ, __a, __a);
   12918 #endif
   12919 }
   12920 
   12921 #ifdef __VSX__
   12922 static __inline__ int __ATTRS_o_ai vec_all_nan(vector double __a) {
   12923   return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ, __a, __a);
   12924 }
   12925 #endif
   12926 
   12927 /* vec_all_ne */
   12928 
   12929 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed char __a,
   12930                                               vector signed char __b) {
   12931   return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
   12932                                       (vector char)__b);
   12933 }
   12934 
   12935 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed char __a,
   12936                                               vector bool char __b) {
   12937   return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
   12938                                       (vector char)__b);
   12939 }
   12940 
   12941 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned char __a,
   12942                                               vector unsigned char __b) {
   12943   return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
   12944                                       (vector char)__b);
   12945 }
   12946 
   12947 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned char __a,
   12948                                               vector bool char __b) {
   12949   return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
   12950                                       (vector char)__b);
   12951 }
   12952 
   12953 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool char __a,
   12954                                               vector signed char __b) {
   12955   return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
   12956                                       (vector char)__b);
   12957 }
   12958 
   12959 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool char __a,
   12960                                               vector unsigned char __b) {
   12961   return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
   12962                                       (vector char)__b);
   12963 }
   12964 
   12965 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool char __a,
   12966                                               vector bool char __b) {
   12967   return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
   12968                                       (vector char)__b);
   12969 }
   12970 
   12971 static __inline__ int __ATTRS_o_ai vec_all_ne(vector short __a,
   12972                                               vector short __b) {
   12973   return __builtin_altivec_vcmpequh_p(__CR6_EQ, __a, __b);
   12974 }
   12975 
   12976 static __inline__ int __ATTRS_o_ai vec_all_ne(vector short __a,
   12977                                               vector bool short __b) {
   12978   return __builtin_altivec_vcmpequh_p(__CR6_EQ, __a, (vector short)__b);
   12979 }
   12980 
   12981 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned short __a,
   12982                                               vector unsigned short __b) {
   12983   return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
   12984                                       (vector short)__b);
   12985 }
   12986 
   12987 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned short __a,
   12988                                               vector bool short __b) {
   12989   return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
   12990                                       (vector short)__b);
   12991 }
   12992 
   12993 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool short __a,
   12994                                               vector short __b) {
   12995   return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
   12996                                       (vector short)__b);
   12997 }
   12998 
   12999 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool short __a,
   13000                                               vector unsigned short __b) {
   13001   return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
   13002                                       (vector short)__b);
   13003 }
   13004 
   13005 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool short __a,
   13006                                               vector bool short __b) {
   13007   return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
   13008                                       (vector short)__b);
   13009 }
   13010 
   13011 static __inline__ int __ATTRS_o_ai vec_all_ne(vector pixel __a,
   13012                                               vector pixel __b) {
   13013   return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
   13014                                       (vector short)__b);
   13015 }
   13016 
   13017 static __inline__ int __ATTRS_o_ai vec_all_ne(vector int __a, vector int __b) {
   13018   return __builtin_altivec_vcmpequw_p(__CR6_EQ, __a, __b);
   13019 }
   13020 
   13021 static __inline__ int __ATTRS_o_ai vec_all_ne(vector int __a,
   13022                                               vector bool int __b) {
   13023   return __builtin_altivec_vcmpequw_p(__CR6_EQ, __a, (vector int)__b);
   13024 }
   13025 
   13026 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned int __a,
   13027                                               vector unsigned int __b) {
   13028   return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
   13029                                       (vector int)__b);
   13030 }
   13031 
   13032 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned int __a,
   13033                                               vector bool int __b) {
   13034   return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
   13035                                       (vector int)__b);
   13036 }
   13037 
   13038 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool int __a,
   13039                                               vector int __b) {
   13040   return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
   13041                                       (vector int)__b);
   13042 }
   13043 
   13044 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool int __a,
   13045                                               vector unsigned int __b) {
   13046   return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
   13047                                       (vector int)__b);
   13048 }
   13049 
   13050 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool int __a,
   13051                                               vector bool int __b) {
   13052   return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
   13053                                       (vector int)__b);
   13054 }
   13055 
   13056 #ifdef __POWER8_VECTOR__
   13057 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed long long __a,
   13058                                               vector signed long long __b) {
   13059   return __builtin_altivec_vcmpequd_p(__CR6_EQ, __a, __b);
   13060 }
   13061 
   13062 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned long long __a,
   13063                                               vector unsigned long long __b) {
   13064   return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector long long)__a,
   13065                                       (vector long long)__b);
   13066 }
   13067 
   13068 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed long long __a,
   13069                                               vector bool long long __b) {
   13070   return __builtin_altivec_vcmpequd_p(__CR6_EQ, __a,
   13071                                       (vector signed long long)__b);
   13072 }
   13073 
   13074 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned long long __a,
   13075                                               vector bool long long __b) {
   13076   return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector signed long long)__a,
   13077                                       (vector signed long long)__b);
   13078 }
   13079 
   13080 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool long long __a,
   13081                                               vector signed long long __b) {
   13082   return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector signed long long)__a,
   13083                                       (vector signed long long)__b);
   13084 }
   13085 
   13086 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool long long __a,
   13087                                               vector unsigned long long __b) {
   13088   return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector signed long long)__a,
   13089                                       (vector signed long long)__b);
   13090 }
   13091 
   13092 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool long long __a,
   13093                                               vector bool long long __b) {
   13094   return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector signed long long)__a,
   13095                                       (vector signed long long)__b);
   13096 }
   13097 #endif
   13098 
   13099 static __inline__ int __ATTRS_o_ai vec_all_ne(vector float __a,
   13100                                               vector float __b) {
   13101 #ifdef __VSX__
   13102   return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ, __a, __b);
   13103 #else
   13104   return __builtin_altivec_vcmpeqfp_p(__CR6_EQ, __a, __b);
   13105 #endif
   13106 }
   13107 
   13108 #ifdef __VSX__
   13109 static __inline__ int __ATTRS_o_ai vec_all_ne(vector double __a,
   13110                                               vector double __b) {
   13111   return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ, __a, __b);
   13112 }
   13113 #endif
   13114 
   13115 /* vec_all_nge */
   13116 
   13117 static __inline__ int __ATTRS_o_ai vec_all_nge(vector float __a,
   13118                                                vector float __b) {
   13119 #ifdef __VSX__
   13120   return __builtin_vsx_xvcmpgesp_p(__CR6_EQ, __a, __b);
   13121 #else
   13122   return __builtin_altivec_vcmpgefp_p(__CR6_EQ, __a, __b);
   13123 #endif
   13124 }
   13125 
   13126 #ifdef __VSX__
   13127 static __inline__ int __ATTRS_o_ai vec_all_nge(vector double __a,
   13128                                                vector double __b) {
   13129   return __builtin_vsx_xvcmpgedp_p(__CR6_EQ, __a, __b);
   13130 }
   13131 #endif
   13132 
   13133 /* vec_all_ngt */
   13134 
   13135 static __inline__ int __ATTRS_o_ai vec_all_ngt(vector float __a,
   13136                                                vector float __b) {
   13137 #ifdef __VSX__
   13138   return __builtin_vsx_xvcmpgtsp_p(__CR6_EQ, __a, __b);
   13139 #else
   13140   return __builtin_altivec_vcmpgtfp_p(__CR6_EQ, __a, __b);
   13141 #endif
   13142 }
   13143 
   13144 #ifdef __VSX__
   13145 static __inline__ int __ATTRS_o_ai vec_all_ngt(vector double __a,
   13146                                                vector double __b) {
   13147   return __builtin_vsx_xvcmpgtdp_p(__CR6_EQ, __a, __b);
   13148 }
   13149 #endif
   13150 
   13151 /* vec_all_nle */
   13152 
   13153 static __inline__ int __attribute__((__always_inline__))
   13154 vec_all_nle(vector float __a, vector float __b) {
   13155   return __builtin_altivec_vcmpgefp_p(__CR6_EQ, __b, __a);
   13156 }
   13157 
   13158 /* vec_all_nlt */
   13159 
   13160 static __inline__ int __attribute__((__always_inline__))
   13161 vec_all_nlt(vector float __a, vector float __b) {
   13162   return __builtin_altivec_vcmpgtfp_p(__CR6_EQ, __b, __a);
   13163 }
   13164 
   13165 /* vec_all_numeric */
   13166 
   13167 static __inline__ int __attribute__((__always_inline__))
   13168 vec_all_numeric(vector float __a) {
   13169   return __builtin_altivec_vcmpeqfp_p(__CR6_LT, __a, __a);
   13170 }
   13171 
   13172 /* vec_any_eq */
   13173 
   13174 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed char __a,
   13175                                               vector signed char __b) {
   13176   return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
   13177                                       (vector char)__b);
   13178 }
   13179 
   13180 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed char __a,
   13181                                               vector bool char __b) {
   13182   return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
   13183                                       (vector char)__b);
   13184 }
   13185 
   13186 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned char __a,
   13187                                               vector unsigned char __b) {
   13188   return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
   13189                                       (vector char)__b);
   13190 }
   13191 
   13192 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned char __a,
   13193                                               vector bool char __b) {
   13194   return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
   13195                                       (vector char)__b);
   13196 }
   13197 
   13198 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool char __a,
   13199                                               vector signed char __b) {
   13200   return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
   13201                                       (vector char)__b);
   13202 }
   13203 
   13204 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool char __a,
   13205                                               vector unsigned char __b) {
   13206   return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
   13207                                       (vector char)__b);
   13208 }
   13209 
   13210 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool char __a,
   13211                                               vector bool char __b) {
   13212   return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
   13213                                       (vector char)__b);
   13214 }
   13215 
   13216 static __inline__ int __ATTRS_o_ai vec_any_eq(vector short __a,
   13217                                               vector short __b) {
   13218   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, __a, __b);
   13219 }
   13220 
   13221 static __inline__ int __ATTRS_o_ai vec_any_eq(vector short __a,
   13222                                               vector bool short __b) {
   13223   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, __a, (vector short)__b);
   13224 }
   13225 
   13226 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned short __a,
   13227                                               vector unsigned short __b) {
   13228   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
   13229                                       (vector short)__b);
   13230 }
   13231 
   13232 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned short __a,
   13233                                               vector bool short __b) {
   13234   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
   13235                                       (vector short)__b);
   13236 }
   13237 
   13238 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool short __a,
   13239                                               vector short __b) {
   13240   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
   13241                                       (vector short)__b);
   13242 }
   13243 
   13244 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool short __a,
   13245                                               vector unsigned short __b) {
   13246   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
   13247                                       (vector short)__b);
   13248 }
   13249 
   13250 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool short __a,
   13251                                               vector bool short __b) {
   13252   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
   13253                                       (vector short)__b);
   13254 }
   13255 
   13256 static __inline__ int __ATTRS_o_ai vec_any_eq(vector pixel __a,
   13257                                               vector pixel __b) {
   13258   return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
   13259                                       (vector short)__b);
   13260 }
   13261 
   13262 static __inline__ int __ATTRS_o_ai vec_any_eq(vector int __a, vector int __b) {
   13263   return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, __a, __b);
   13264 }
   13265 
   13266 static __inline__ int __ATTRS_o_ai vec_any_eq(vector int __a,
   13267                                               vector bool int __b) {
   13268   return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, __a, (vector int)__b);
   13269 }
   13270 
   13271 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned int __a,
   13272                                               vector unsigned int __b) {
   13273   return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
   13274                                       (vector int)__b);
   13275 }
   13276 
   13277 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned int __a,
   13278                                               vector bool int __b) {
   13279   return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
   13280                                       (vector int)__b);
   13281 }
   13282 
   13283 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool int __a,
   13284                                               vector int __b) {
   13285   return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
   13286                                       (vector int)__b);
   13287 }
   13288 
   13289 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool int __a,
   13290                                               vector unsigned int __b) {
   13291   return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
   13292                                       (vector int)__b);
   13293 }
   13294 
   13295 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool int __a,
   13296                                               vector bool int __b) {
   13297   return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
   13298                                       (vector int)__b);
   13299 }
   13300 
   13301 #ifdef __POWER8_VECTOR__
   13302 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed long long __a,
   13303                                               vector signed long long __b) {
   13304   return __builtin_altivec_vcmpequd_p(__CR6_EQ_REV, __a, __b);
   13305 }
   13306 
   13307 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned long long __a,
   13308                                               vector unsigned long long __b) {
   13309   return __builtin_altivec_vcmpequd_p(__CR6_EQ_REV, (vector long long)__a,
   13310                                       (vector long long)__b);
   13311 }
   13312 
   13313 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed long long __a,
   13314                                               vector bool long long __b) {
   13315   return __builtin_altivec_vcmpequd_p(__CR6_EQ_REV, __a,
   13316                                       (vector signed long long)__b);
   13317 }
   13318 
   13319 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned long long __a,
   13320                                               vector bool long long __b) {
   13321   return __builtin_altivec_vcmpequd_p(
   13322       __CR6_EQ_REV, (vector signed long long)__a, (vector signed long long)__b);
   13323 }
   13324 
   13325 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool long long __a,
   13326                                               vector signed long long __b) {
   13327   return __builtin_altivec_vcmpequd_p(
   13328       __CR6_EQ_REV, (vector signed long long)__a, (vector signed long long)__b);
   13329 }
   13330 
   13331 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool long long __a,
   13332                                               vector unsigned long long __b) {
   13333   return __builtin_altivec_vcmpequd_p(
   13334       __CR6_EQ_REV, (vector signed long long)__a, (vector signed long long)__b);
   13335 }
   13336 
   13337 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool long long __a,
   13338                                               vector bool long long __b) {
   13339   return __builtin_altivec_vcmpequd_p(
   13340       __CR6_EQ_REV, (vector signed long long)__a, (vector signed long long)__b);
   13341 }
   13342 #endif
   13343 
   13344 static __inline__ int __ATTRS_o_ai vec_any_eq(vector float __a,
   13345                                               vector float __b) {
   13346 #ifdef __VSX__
   13347   return __builtin_vsx_xvcmpeqsp_p(__CR6_EQ_REV, __a, __b);
   13348 #else
   13349   return __builtin_altivec_vcmpeqfp_p(__CR6_EQ_REV, __a, __b);
   13350 #endif
   13351 }
   13352 
   13353 #ifdef __VSX__
   13354 static __inline__ int __ATTRS_o_ai vec_any_eq(vector double __a,
   13355                                               vector double __b) {
   13356   return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ_REV, __a, __b);
   13357 }
   13358 #endif
   13359 
   13360 /* vec_any_ge */
   13361 
   13362 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed char __a,
   13363                                               vector signed char __b) {
   13364   return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, __b, __a);
   13365 }
   13366 
   13367 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed char __a,
   13368                                               vector bool char __b) {
   13369   return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, (vector signed char)__b,
   13370                                       __a);
   13371 }
   13372 
   13373 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned char __a,
   13374                                               vector unsigned char __b) {
   13375   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __b, __a);
   13376 }
   13377 
   13378 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned char __a,
   13379                                               vector bool char __b) {
   13380   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__b,
   13381                                       __a);
   13382 }
   13383 
   13384 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool char __a,
   13385                                               vector signed char __b) {
   13386   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__b,
   13387                                       (vector unsigned char)__a);
   13388 }
   13389 
   13390 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool char __a,
   13391                                               vector unsigned char __b) {
   13392   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __b,
   13393                                       (vector unsigned char)__a);
   13394 }
   13395 
   13396 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool char __a,
   13397                                               vector bool char __b) {
   13398   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__b,
   13399                                       (vector unsigned char)__a);
   13400 }
   13401 
   13402 static __inline__ int __ATTRS_o_ai vec_any_ge(vector short __a,
   13403                                               vector short __b) {
   13404   return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, __b, __a);
   13405 }
   13406 
   13407 static __inline__ int __ATTRS_o_ai vec_any_ge(vector short __a,
   13408                                               vector bool short __b) {
   13409   return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, (vector short)__b, __a);
   13410 }
   13411 
   13412 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned short __a,
   13413                                               vector unsigned short __b) {
   13414   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __b, __a);
   13415 }
   13416 
   13417 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned short __a,
   13418                                               vector bool short __b) {
   13419   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__b,
   13420                                       __a);
   13421 }
   13422 
   13423 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool short __a,
   13424                                               vector short __b) {
   13425   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__b,
   13426                                       (vector unsigned short)__a);
   13427 }
   13428 
   13429 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool short __a,
   13430                                               vector unsigned short __b) {
   13431   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __b,
   13432                                       (vector unsigned short)__a);
   13433 }
   13434 
   13435 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool short __a,
   13436                                               vector bool short __b) {
   13437   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__b,
   13438                                       (vector unsigned short)__a);
   13439 }
   13440 
   13441 static __inline__ int __ATTRS_o_ai vec_any_ge(vector int __a, vector int __b) {
   13442   return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, __b, __a);
   13443 }
   13444 
   13445 static __inline__ int __ATTRS_o_ai vec_any_ge(vector int __a,
   13446                                               vector bool int __b) {
   13447   return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, (vector int)__b, __a);
   13448 }
   13449 
   13450 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned int __a,
   13451                                               vector unsigned int __b) {
   13452   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __b, __a);
   13453 }
   13454 
   13455 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned int __a,
   13456                                               vector bool int __b) {
   13457   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__b,
   13458                                       __a);
   13459 }
   13460 
   13461 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool int __a,
   13462                                               vector int __b) {
   13463   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__b,
   13464                                       (vector unsigned int)__a);
   13465 }
   13466 
   13467 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool int __a,
   13468                                               vector unsigned int __b) {
   13469   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __b,
   13470                                       (vector unsigned int)__a);
   13471 }
   13472 
   13473 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool int __a,
   13474                                               vector bool int __b) {
   13475   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__b,
   13476                                       (vector unsigned int)__a);
   13477 }
   13478 
   13479 #ifdef __POWER8_VECTOR__
   13480 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed long long __a,
   13481                                               vector signed long long __b) {
   13482   return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV, __b, __a);
   13483 }
   13484 
   13485 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned long long __a,
   13486                                               vector unsigned long long __b) {
   13487   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __b, __a);
   13488 }
   13489 
   13490 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed long long __a,
   13491                                               vector bool long long __b) {
   13492   return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV,
   13493                                       (vector signed long long)__b, __a);
   13494 }
   13495 
   13496 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned long long __a,
   13497                                               vector bool long long __b) {
   13498   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
   13499                                       (vector unsigned long long)__b, __a);
   13500 }
   13501 
   13502 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool long long __a,
   13503                                               vector signed long long __b) {
   13504   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
   13505                                       (vector unsigned long long)__b,
   13506                                       (vector unsigned long long)__a);
   13507 }
   13508 
   13509 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool long long __a,
   13510                                               vector unsigned long long __b) {
   13511   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __b,
   13512                                       (vector unsigned long long)__a);
   13513 }
   13514 
   13515 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool long long __a,
   13516                                               vector bool long long __b) {
   13517   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
   13518                                       (vector unsigned long long)__b,
   13519                                       (vector unsigned long long)__a);
   13520 }
   13521 #endif
   13522 
   13523 static __inline__ int __ATTRS_o_ai vec_any_ge(vector float __a,
   13524                                               vector float __b) {
   13525 #ifdef __VSX__
   13526   return __builtin_vsx_xvcmpgesp_p(__CR6_EQ_REV, __a, __b);
   13527 #else
   13528   return __builtin_altivec_vcmpgefp_p(__CR6_EQ_REV, __a, __b);
   13529 #endif
   13530 }
   13531 
   13532 #ifdef __VSX__
   13533 static __inline__ int __ATTRS_o_ai vec_any_ge(vector double __a,
   13534                                               vector double __b) {
   13535   return __builtin_vsx_xvcmpgedp_p(__CR6_EQ_REV, __a, __b);
   13536 }
   13537 #endif
   13538 
   13539 /* vec_any_gt */
   13540 
   13541 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed char __a,
   13542                                               vector signed char __b) {
   13543   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, __a, __b);
   13544 }
   13545 
   13546 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed char __a,
   13547                                               vector bool char __b) {
   13548   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, __a,
   13549                                       (vector signed char)__b);
   13550 }
   13551 
   13552 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned char __a,
   13553                                               vector unsigned char __b) {
   13554   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __a, __b);
   13555 }
   13556 
   13557 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned char __a,
   13558                                               vector bool char __b) {
   13559   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __a,
   13560                                       (vector unsigned char)__b);
   13561 }
   13562 
   13563 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool char __a,
   13564                                               vector signed char __b) {
   13565   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__a,
   13566                                       (vector unsigned char)__b);
   13567 }
   13568 
   13569 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool char __a,
   13570                                               vector unsigned char __b) {
   13571   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__a,
   13572                                       __b);
   13573 }
   13574 
   13575 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool char __a,
   13576                                               vector bool char __b) {
   13577   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__a,
   13578                                       (vector unsigned char)__b);
   13579 }
   13580 
   13581 static __inline__ int __ATTRS_o_ai vec_any_gt(vector short __a,
   13582                                               vector short __b) {
   13583   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, __a, __b);
   13584 }
   13585 
   13586 static __inline__ int __ATTRS_o_ai vec_any_gt(vector short __a,
   13587                                               vector bool short __b) {
   13588   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, __a, (vector short)__b);
   13589 }
   13590 
   13591 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned short __a,
   13592                                               vector unsigned short __b) {
   13593   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __a, __b);
   13594 }
   13595 
   13596 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned short __a,
   13597                                               vector bool short __b) {
   13598   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __a,
   13599                                       (vector unsigned short)__b);
   13600 }
   13601 
   13602 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool short __a,
   13603                                               vector short __b) {
   13604   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__a,
   13605                                       (vector unsigned short)__b);
   13606 }
   13607 
   13608 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool short __a,
   13609                                               vector unsigned short __b) {
   13610   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__a,
   13611                                       __b);
   13612 }
   13613 
   13614 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool short __a,
   13615                                               vector bool short __b) {
   13616   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__a,
   13617                                       (vector unsigned short)__b);
   13618 }
   13619 
   13620 static __inline__ int __ATTRS_o_ai vec_any_gt(vector int __a, vector int __b) {
   13621   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, __a, __b);
   13622 }
   13623 
   13624 static __inline__ int __ATTRS_o_ai vec_any_gt(vector int __a,
   13625                                               vector bool int __b) {
   13626   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, __a, (vector int)__b);
   13627 }
   13628 
   13629 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned int __a,
   13630                                               vector unsigned int __b) {
   13631   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __a, __b);
   13632 }
   13633 
   13634 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned int __a,
   13635                                               vector bool int __b) {
   13636   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __a,
   13637                                       (vector unsigned int)__b);
   13638 }
   13639 
   13640 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool int __a,
   13641                                               vector int __b) {
   13642   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__a,
   13643                                       (vector unsigned int)__b);
   13644 }
   13645 
   13646 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool int __a,
   13647                                               vector unsigned int __b) {
   13648   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__a,
   13649                                       __b);
   13650 }
   13651 
   13652 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool int __a,
   13653                                               vector bool int __b) {
   13654   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__a,
   13655                                       (vector unsigned int)__b);
   13656 }
   13657 
   13658 #ifdef __POWER8_VECTOR__
   13659 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed long long __a,
   13660                                               vector signed long long __b) {
   13661   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV, __a, __b);
   13662 }
   13663 
   13664 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned long long __a,
   13665                                               vector unsigned long long __b) {
   13666   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __a, __b);
   13667 }
   13668 
   13669 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed long long __a,
   13670                                               vector bool long long __b) {
   13671   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV, __a,
   13672                                       (vector signed long long)__b);
   13673 }
   13674 
   13675 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned long long __a,
   13676                                               vector bool long long __b) {
   13677   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __a,
   13678                                       (vector unsigned long long)__b);
   13679 }
   13680 
   13681 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool long long __a,
   13682                                               vector signed long long __b) {
   13683   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
   13684                                       (vector unsigned long long)__a,
   13685                                       (vector unsigned long long)__b);
   13686 }
   13687 
   13688 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool long long __a,
   13689                                               vector unsigned long long __b) {
   13690   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
   13691                                       (vector unsigned long long)__a, __b);
   13692 }
   13693 
   13694 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool long long __a,
   13695                                               vector bool long long __b) {
   13696   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
   13697                                       (vector unsigned long long)__a,
   13698                                       (vector unsigned long long)__b);
   13699 }
   13700 #endif
   13701 
   13702 static __inline__ int __ATTRS_o_ai vec_any_gt(vector float __a,
   13703                                               vector float __b) {
   13704 #ifdef __VSX__
   13705   return __builtin_vsx_xvcmpgtsp_p(__CR6_EQ_REV, __a, __b);
   13706 #else
   13707   return __builtin_altivec_vcmpgtfp_p(__CR6_EQ_REV, __a, __b);
   13708 #endif
   13709 }
   13710 
   13711 #ifdef __VSX__
   13712 static __inline__ int __ATTRS_o_ai vec_any_gt(vector double __a,
   13713                                               vector double __b) {
   13714   return __builtin_vsx_xvcmpgtdp_p(__CR6_EQ_REV, __a, __b);
   13715 }
   13716 #endif
   13717 
   13718 /* vec_any_le */
   13719 
   13720 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed char __a,
   13721                                               vector signed char __b) {
   13722   return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, __a, __b);
   13723 }
   13724 
   13725 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed char __a,
   13726                                               vector bool char __b) {
   13727   return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, __a,
   13728                                       (vector signed char)__b);
   13729 }
   13730 
   13731 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned char __a,
   13732                                               vector unsigned char __b) {
   13733   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __a, __b);
   13734 }
   13735 
   13736 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned char __a,
   13737                                               vector bool char __b) {
   13738   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __a,
   13739                                       (vector unsigned char)__b);
   13740 }
   13741 
   13742 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool char __a,
   13743                                               vector signed char __b) {
   13744   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__a,
   13745                                       (vector unsigned char)__b);
   13746 }
   13747 
   13748 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool char __a,
   13749                                               vector unsigned char __b) {
   13750   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__a,
   13751                                       __b);
   13752 }
   13753 
   13754 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool char __a,
   13755                                               vector bool char __b) {
   13756   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__a,
   13757                                       (vector unsigned char)__b);
   13758 }
   13759 
   13760 static __inline__ int __ATTRS_o_ai vec_any_le(vector short __a,
   13761                                               vector short __b) {
   13762   return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, __a, __b);
   13763 }
   13764 
   13765 static __inline__ int __ATTRS_o_ai vec_any_le(vector short __a,
   13766                                               vector bool short __b) {
   13767   return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, __a, (vector short)__b);
   13768 }
   13769 
   13770 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned short __a,
   13771                                               vector unsigned short __b) {
   13772   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __a, __b);
   13773 }
   13774 
   13775 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned short __a,
   13776                                               vector bool short __b) {
   13777   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __a,
   13778                                       (vector unsigned short)__b);
   13779 }
   13780 
   13781 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool short __a,
   13782                                               vector short __b) {
   13783   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__a,
   13784                                       (vector unsigned short)__b);
   13785 }
   13786 
   13787 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool short __a,
   13788                                               vector unsigned short __b) {
   13789   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__a,
   13790                                       __b);
   13791 }
   13792 
   13793 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool short __a,
   13794                                               vector bool short __b) {
   13795   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__a,
   13796                                       (vector unsigned short)__b);
   13797 }
   13798 
   13799 static __inline__ int __ATTRS_o_ai vec_any_le(vector int __a, vector int __b) {
   13800   return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, __a, __b);
   13801 }
   13802 
   13803 static __inline__ int __ATTRS_o_ai vec_any_le(vector int __a,
   13804                                               vector bool int __b) {
   13805   return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, __a, (vector int)__b);
   13806 }
   13807 
   13808 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned int __a,
   13809                                               vector unsigned int __b) {
   13810   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __a, __b);
   13811 }
   13812 
   13813 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned int __a,
   13814                                               vector bool int __b) {
   13815   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __a,
   13816                                       (vector unsigned int)__b);
   13817 }
   13818 
   13819 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool int __a,
   13820                                               vector int __b) {
   13821   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__a,
   13822                                       (vector unsigned int)__b);
   13823 }
   13824 
   13825 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool int __a,
   13826                                               vector unsigned int __b) {
   13827   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__a,
   13828                                       __b);
   13829 }
   13830 
   13831 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool int __a,
   13832                                               vector bool int __b) {
   13833   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__a,
   13834                                       (vector unsigned int)__b);
   13835 }
   13836 
   13837 #ifdef __POWER8_VECTOR__
   13838 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed long long __a,
   13839                                               vector signed long long __b) {
   13840   return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV, __a, __b);
   13841 }
   13842 
   13843 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned long long __a,
   13844                                               vector unsigned long long __b) {
   13845   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __a, __b);
   13846 }
   13847 
   13848 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed long long __a,
   13849                                               vector bool long long __b) {
   13850   return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV, __a,
   13851                                       (vector signed long long)__b);
   13852 }
   13853 
   13854 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned long long __a,
   13855                                               vector bool long long __b) {
   13856   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __a,
   13857                                       (vector unsigned long long)__b);
   13858 }
   13859 
   13860 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool long long __a,
   13861                                               vector signed long long __b) {
   13862   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
   13863                                       (vector unsigned long long)__a,
   13864                                       (vector unsigned long long)__b);
   13865 }
   13866 
   13867 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool long long __a,
   13868                                               vector unsigned long long __b) {
   13869   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
   13870                                       (vector unsigned long long)__a, __b);
   13871 }
   13872 
   13873 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool long long __a,
   13874                                               vector bool long long __b) {
   13875   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
   13876                                       (vector unsigned long long)__a,
   13877                                       (vector unsigned long long)__b);
   13878 }
   13879 #endif
   13880 
   13881 static __inline__ int __ATTRS_o_ai vec_any_le(vector float __a,
   13882                                               vector float __b) {
   13883 #ifdef __VSX__
   13884   return __builtin_vsx_xvcmpgesp_p(__CR6_EQ_REV, __b, __a);
   13885 #else
   13886   return __builtin_altivec_vcmpgefp_p(__CR6_EQ_REV, __b, __a);
   13887 #endif
   13888 }
   13889 
   13890 #ifdef __VSX__
   13891 static __inline__ int __ATTRS_o_ai vec_any_le(vector double __a,
   13892                                               vector double __b) {
   13893   return __builtin_vsx_xvcmpgedp_p(__CR6_EQ_REV, __b, __a);
   13894 }
   13895 #endif
   13896 
   13897 /* vec_any_lt */
   13898 
   13899 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed char __a,
   13900                                               vector signed char __b) {
   13901   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, __b, __a);
   13902 }
   13903 
   13904 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed char __a,
   13905                                               vector bool char __b) {
   13906   return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, (vector signed char)__b,
   13907                                       __a);
   13908 }
   13909 
   13910 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned char __a,
   13911                                               vector unsigned char __b) {
   13912   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __b, __a);
   13913 }
   13914 
   13915 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned char __a,
   13916                                               vector bool char __b) {
   13917   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__b,
   13918                                       __a);
   13919 }
   13920 
   13921 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool char __a,
   13922                                               vector signed char __b) {
   13923   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__b,
   13924                                       (vector unsigned char)__a);
   13925 }
   13926 
   13927 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool char __a,
   13928                                               vector unsigned char __b) {
   13929   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __b,
   13930                                       (vector unsigned char)__a);
   13931 }
   13932 
   13933 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool char __a,
   13934                                               vector bool char __b) {
   13935   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__b,
   13936                                       (vector unsigned char)__a);
   13937 }
   13938 
   13939 static __inline__ int __ATTRS_o_ai vec_any_lt(vector short __a,
   13940                                               vector short __b) {
   13941   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, __b, __a);
   13942 }
   13943 
   13944 static __inline__ int __ATTRS_o_ai vec_any_lt(vector short __a,
   13945                                               vector bool short __b) {
   13946   return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, (vector short)__b, __a);
   13947 }
   13948 
   13949 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned short __a,
   13950                                               vector unsigned short __b) {
   13951   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __b, __a);
   13952 }
   13953 
   13954 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned short __a,
   13955                                               vector bool short __b) {
   13956   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__b,
   13957                                       __a);
   13958 }
   13959 
   13960 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool short __a,
   13961                                               vector short __b) {
   13962   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__b,
   13963                                       (vector unsigned short)__a);
   13964 }
   13965 
   13966 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool short __a,
   13967                                               vector unsigned short __b) {
   13968   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __b,
   13969                                       (vector unsigned short)__a);
   13970 }
   13971 
   13972 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool short __a,
   13973                                               vector bool short __b) {
   13974   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__b,
   13975                                       (vector unsigned short)__a);
   13976 }
   13977 
   13978 static __inline__ int __ATTRS_o_ai vec_any_lt(vector int __a, vector int __b) {
   13979   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, __b, __a);
   13980 }
   13981 
   13982 static __inline__ int __ATTRS_o_ai vec_any_lt(vector int __a,
   13983                                               vector bool int __b) {
   13984   return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, (vector int)__b, __a);
   13985 }
   13986 
   13987 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned int __a,
   13988                                               vector unsigned int __b) {
   13989   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __b, __a);
   13990 }
   13991 
   13992 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned int __a,
   13993                                               vector bool int __b) {
   13994   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__b,
   13995                                       __a);
   13996 }
   13997 
   13998 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool int __a,
   13999                                               vector int __b) {
   14000   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__b,
   14001                                       (vector unsigned int)__a);
   14002 }
   14003 
   14004 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool int __a,
   14005                                               vector unsigned int __b) {
   14006   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __b,
   14007                                       (vector unsigned int)__a);
   14008 }
   14009 
   14010 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool int __a,
   14011                                               vector bool int __b) {
   14012   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__b,
   14013                                       (vector unsigned int)__a);
   14014 }
   14015 
   14016 #ifdef __POWER8_VECTOR__
   14017 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed long long __a,
   14018                                               vector signed long long __b) {
   14019   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV, __b, __a);
   14020 }
   14021 
   14022 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned long long __a,
   14023                                               vector unsigned long long __b) {
   14024   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __b, __a);
   14025 }
   14026 
   14027 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed long long __a,
   14028                                               vector bool long long __b) {
   14029   return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV,
   14030                                       (vector signed long long)__b, __a);
   14031 }
   14032 
   14033 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned long long __a,
   14034                                               vector bool long long __b) {
   14035   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
   14036                                       (vector unsigned long long)__b, __a);
   14037 }
   14038 
   14039 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool long long __a,
   14040                                               vector signed long long __b) {
   14041   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
   14042                                       (vector unsigned long long)__b,
   14043                                       (vector unsigned long long)__a);
   14044 }
   14045 
   14046 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool long long __a,
   14047                                               vector unsigned long long __b) {
   14048   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __b,
   14049                                       (vector unsigned long long)__a);
   14050 }
   14051 
   14052 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool long long __a,
   14053                                               vector bool long long __b) {
   14054   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
   14055                                       (vector unsigned long long)__b,
   14056                                       (vector unsigned long long)__a);
   14057 }
   14058 #endif
   14059 
   14060 static __inline__ int __ATTRS_o_ai vec_any_lt(vector float __a,
   14061                                               vector float __b) {
   14062 #ifdef __VSX__
   14063   return __builtin_vsx_xvcmpgtsp_p(__CR6_EQ_REV, __b, __a);
   14064 #else
   14065   return __builtin_altivec_vcmpgtfp_p(__CR6_EQ_REV, __b, __a);
   14066 #endif
   14067 }
   14068 
   14069 #ifdef __VSX__
   14070 static __inline__ int __ATTRS_o_ai vec_any_lt(vector double __a,
   14071                                               vector double __b) {
   14072   return __builtin_vsx_xvcmpgtdp_p(__CR6_EQ_REV, __b, __a);
   14073 }
   14074 #endif
   14075 
   14076 /* vec_any_nan */
   14077 
   14078 static __inline__ int __attribute__((__always_inline__))
   14079 vec_any_nan(vector float __a) {
   14080   return __builtin_altivec_vcmpeqfp_p(__CR6_LT_REV, __a, __a);
   14081 }
   14082 
   14083 /* vec_any_ne */
   14084 
   14085 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed char __a,
   14086                                               vector signed char __b) {
   14087   return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
   14088                                       (vector char)__b);
   14089 }
   14090 
   14091 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed char __a,
   14092                                               vector bool char __b) {
   14093   return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
   14094                                       (vector char)__b);
   14095 }
   14096 
   14097 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned char __a,
   14098                                               vector unsigned char __b) {
   14099   return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
   14100                                       (vector char)__b);
   14101 }
   14102 
   14103 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned char __a,
   14104                                               vector bool char __b) {
   14105   return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
   14106                                       (vector char)__b);
   14107 }
   14108 
   14109 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool char __a,
   14110                                               vector signed char __b) {
   14111   return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
   14112                                       (vector char)__b);
   14113 }
   14114 
   14115 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool char __a,
   14116                                               vector unsigned char __b) {
   14117   return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
   14118                                       (vector char)__b);
   14119 }
   14120 
   14121 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool char __a,
   14122                                               vector bool char __b) {
   14123   return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
   14124                                       (vector char)__b);
   14125 }
   14126 
   14127 static __inline__ int __ATTRS_o_ai vec_any_ne(vector short __a,
   14128                                               vector short __b) {
   14129   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, __a, __b);
   14130 }
   14131 
   14132 static __inline__ int __ATTRS_o_ai vec_any_ne(vector short __a,
   14133                                               vector bool short __b) {
   14134   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, __a, (vector short)__b);
   14135 }
   14136 
   14137 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned short __a,
   14138                                               vector unsigned short __b) {
   14139   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
   14140                                       (vector short)__b);
   14141 }
   14142 
   14143 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned short __a,
   14144                                               vector bool short __b) {
   14145   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
   14146                                       (vector short)__b);
   14147 }
   14148 
   14149 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool short __a,
   14150                                               vector short __b) {
   14151   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
   14152                                       (vector short)__b);
   14153 }
   14154 
   14155 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool short __a,
   14156                                               vector unsigned short __b) {
   14157   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
   14158                                       (vector short)__b);
   14159 }
   14160 
   14161 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool short __a,
   14162                                               vector bool short __b) {
   14163   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
   14164                                       (vector short)__b);
   14165 }
   14166 
   14167 static __inline__ int __ATTRS_o_ai vec_any_ne(vector pixel __a,
   14168                                               vector pixel __b) {
   14169   return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
   14170                                       (vector short)__b);
   14171 }
   14172 
   14173 static __inline__ int __ATTRS_o_ai vec_any_ne(vector int __a, vector int __b) {
   14174   return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, __a, __b);
   14175 }
   14176 
   14177 static __inline__ int __ATTRS_o_ai vec_any_ne(vector int __a,
   14178                                               vector bool int __b) {
   14179   return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, __a, (vector int)__b);
   14180 }
   14181 
   14182 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned int __a,
   14183                                               vector unsigned int __b) {
   14184   return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
   14185                                       (vector int)__b);
   14186 }
   14187 
   14188 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned int __a,
   14189                                               vector bool int __b) {
   14190   return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
   14191                                       (vector int)__b);
   14192 }
   14193 
   14194 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool int __a,
   14195                                               vector int __b) {
   14196   return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
   14197                                       (vector int)__b);
   14198 }
   14199 
   14200 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool int __a,
   14201                                               vector unsigned int __b) {
   14202   return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
   14203                                       (vector int)__b);
   14204 }
   14205 
   14206 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool int __a,
   14207                                               vector bool int __b) {
   14208   return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
   14209                                       (vector int)__b);
   14210 }
   14211 
   14212 #ifdef __POWER8_VECTOR__
   14213 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed long long __a,
   14214                                               vector signed long long __b) {
   14215   return __builtin_altivec_vcmpequd_p(__CR6_LT_REV, __a, __b);
   14216 }
   14217 
   14218 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned long long __a,
   14219                                               vector unsigned long long __b) {
   14220   return __builtin_altivec_vcmpequd_p(__CR6_LT_REV, (vector long long)__a,
   14221                                       (vector long long)__b);
   14222 }
   14223 
   14224 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed long long __a,
   14225                                               vector bool long long __b) {
   14226   return __builtin_altivec_vcmpequd_p(__CR6_LT_REV, __a,
   14227                                       (vector signed long long)__b);
   14228 }
   14229 
   14230 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned long long __a,
   14231                                               vector bool long long __b) {
   14232   return __builtin_altivec_vcmpequd_p(
   14233       __CR6_LT_REV, (vector signed long long)__a, (vector signed long long)__b);
   14234 }
   14235 
   14236 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool long long __a,
   14237                                               vector signed long long __b) {
   14238   return __builtin_altivec_vcmpequd_p(
   14239       __CR6_LT_REV, (vector signed long long)__a, (vector signed long long)__b);
   14240 }
   14241 
   14242 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool long long __a,
   14243                                               vector unsigned long long __b) {
   14244   return __builtin_altivec_vcmpequd_p(
   14245       __CR6_LT_REV, (vector signed long long)__a, (vector signed long long)__b);
   14246 }
   14247 
   14248 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool long long __a,
   14249                                               vector bool long long __b) {
   14250   return __builtin_altivec_vcmpequd_p(
   14251       __CR6_LT_REV, (vector signed long long)__a, (vector signed long long)__b);
   14252 }
   14253 #endif
   14254 
   14255 static __inline__ int __ATTRS_o_ai vec_any_ne(vector float __a,
   14256                                               vector float __b) {
   14257 #ifdef __VSX__
   14258   return __builtin_vsx_xvcmpeqsp_p(__CR6_LT_REV, __a, __b);
   14259 #else
   14260   return __builtin_altivec_vcmpeqfp_p(__CR6_LT_REV, __a, __b);
   14261 #endif
   14262 }
   14263 
   14264 #ifdef __VSX__
   14265 static __inline__ int __ATTRS_o_ai vec_any_ne(vector double __a,
   14266                                               vector double __b) {
   14267   return __builtin_vsx_xvcmpeqdp_p(__CR6_LT_REV, __a, __b);
   14268 }
   14269 #endif
   14270 
   14271 /* vec_any_nge */
   14272 
   14273 static __inline__ int __attribute__((__always_inline__))
   14274 vec_any_nge(vector float __a, vector float __b) {
   14275   return __builtin_altivec_vcmpgefp_p(__CR6_LT_REV, __a, __b);
   14276 }
   14277 
   14278 /* vec_any_ngt */
   14279 
   14280 static __inline__ int __attribute__((__always_inline__))
   14281 vec_any_ngt(vector float __a, vector float __b) {
   14282   return __builtin_altivec_vcmpgtfp_p(__CR6_LT_REV, __a, __b);
   14283 }
   14284 
   14285 /* vec_any_nle */
   14286 
   14287 static __inline__ int __attribute__((__always_inline__))
   14288 vec_any_nle(vector float __a, vector float __b) {
   14289   return __builtin_altivec_vcmpgefp_p(__CR6_LT_REV, __b, __a);
   14290 }
   14291 
   14292 /* vec_any_nlt */
   14293 
   14294 static __inline__ int __attribute__((__always_inline__))
   14295 vec_any_nlt(vector float __a, vector float __b) {
   14296   return __builtin_altivec_vcmpgtfp_p(__CR6_LT_REV, __b, __a);
   14297 }
   14298 
   14299 /* vec_any_numeric */
   14300 
   14301 static __inline__ int __attribute__((__always_inline__))
   14302 vec_any_numeric(vector float __a) {
   14303   return __builtin_altivec_vcmpeqfp_p(__CR6_EQ_REV, __a, __a);
   14304 }
   14305 
   14306 /* vec_any_out */
   14307 
   14308 static __inline__ int __attribute__((__always_inline__))
   14309 vec_any_out(vector float __a, vector float __b) {
   14310   return __builtin_altivec_vcmpbfp_p(__CR6_EQ_REV, __a, __b);
   14311 }
   14312 
   14313 /* Power 8 Crypto functions
   14314 Note: We diverge from the current GCC implementation with regard
   14315 to cryptography and related functions as follows:
   14316 - Only the SHA and AES instructions and builtins are disabled by -mno-crypto
   14317 - The remaining ones are only available on Power8 and up so
   14318   require -mpower8-vector
   14319 The justification for this is that export requirements require that
   14320 Category:Vector.Crypto is optional (i.e. compliant hardware may not provide
   14321 support). As a result, we need to be able to turn off support for those.
   14322 The remaining ones (currently controlled by -mcrypto for GCC) still
   14323 need to be provided on compliant hardware even if Vector.Crypto is not
   14324 provided.
   14325 */
   14326 #ifdef __CRYPTO__
   14327 #define vec_sbox_be __builtin_altivec_crypto_vsbox
   14328 #define vec_cipher_be __builtin_altivec_crypto_vcipher
   14329 #define vec_cipherlast_be __builtin_altivec_crypto_vcipherlast
   14330 #define vec_ncipher_be __builtin_altivec_crypto_vncipher
   14331 #define vec_ncipherlast_be __builtin_altivec_crypto_vncipherlast
   14332 
   14333 static __inline__ vector unsigned long long __attribute__((__always_inline__))
   14334 __builtin_crypto_vsbox(vector unsigned long long __a) {
   14335   return __builtin_altivec_crypto_vsbox(__a);
   14336 }
   14337 
   14338 static __inline__ vector unsigned long long __attribute__((__always_inline__))
   14339 __builtin_crypto_vcipher(vector unsigned long long __a,
   14340                          vector unsigned long long __b) {
   14341   return __builtin_altivec_crypto_vcipher(__a, __b);
   14342 }
   14343 
   14344 static __inline__ vector unsigned long long __attribute__((__always_inline__))
   14345 __builtin_crypto_vcipherlast(vector unsigned long long __a,
   14346                              vector unsigned long long __b) {
   14347   return __builtin_altivec_crypto_vcipherlast(__a, __b);
   14348 }
   14349 
   14350 static __inline__ vector unsigned long long __attribute__((__always_inline__))
   14351 __builtin_crypto_vncipher(vector unsigned long long __a,
   14352                           vector unsigned long long __b) {
   14353   return __builtin_altivec_crypto_vncipher(__a, __b);
   14354 }
   14355 
   14356 static __inline__ vector unsigned long long __attribute__((__always_inline__))
   14357 __builtin_crypto_vncipherlast(vector unsigned long long __a,
   14358                               vector unsigned long long __b) {
   14359   return __builtin_altivec_crypto_vncipherlast(__a, __b);
   14360 }
   14361 
   14362 #define __builtin_crypto_vshasigmad __builtin_altivec_crypto_vshasigmad
   14363 #define __builtin_crypto_vshasigmaw __builtin_altivec_crypto_vshasigmaw
   14364 
   14365 #define vec_shasigma_be(X, Y, Z)                                               \
   14366   _Generic((X), vector unsigned int                                            \
   14367            : __builtin_crypto_vshasigmaw, vector unsigned long long            \
   14368            : __builtin_crypto_vshasigmad)((X), (Y), (Z))
   14369 #endif
   14370 
   14371 #ifdef __POWER8_VECTOR__
   14372 static __inline__ vector unsigned char __ATTRS_o_ai
   14373 __builtin_crypto_vpermxor(vector unsigned char __a, vector unsigned char __b,
   14374                           vector unsigned char __c) {
   14375   return __builtin_altivec_crypto_vpermxor(__a, __b, __c);
   14376 }
   14377 
   14378 static __inline__ vector unsigned short __ATTRS_o_ai
   14379 __builtin_crypto_vpermxor(vector unsigned short __a, vector unsigned short __b,
   14380                           vector unsigned short __c) {
   14381   return (vector unsigned short)__builtin_altivec_crypto_vpermxor(
   14382       (vector unsigned char)__a, (vector unsigned char)__b,
   14383       (vector unsigned char)__c);
   14384 }
   14385 
   14386 static __inline__ vector unsigned int __ATTRS_o_ai __builtin_crypto_vpermxor(
   14387     vector unsigned int __a, vector unsigned int __b, vector unsigned int __c) {
   14388   return (vector unsigned int)__builtin_altivec_crypto_vpermxor(
   14389       (vector unsigned char)__a, (vector unsigned char)__b,
   14390       (vector unsigned char)__c);
   14391 }
   14392 
   14393 static __inline__ vector unsigned long long __ATTRS_o_ai
   14394 __builtin_crypto_vpermxor(vector unsigned long long __a,
   14395                           vector unsigned long long __b,
   14396                           vector unsigned long long __c) {
   14397   return (vector unsigned long long)__builtin_altivec_crypto_vpermxor(
   14398       (vector unsigned char)__a, (vector unsigned char)__b,
   14399       (vector unsigned char)__c);
   14400 }
   14401 
   14402 static __inline__ vector unsigned char __ATTRS_o_ai
   14403 __builtin_crypto_vpmsumb(vector unsigned char __a, vector unsigned char __b) {
   14404   return __builtin_altivec_crypto_vpmsumb(__a, __b);
   14405 }
   14406 
   14407 static __inline__ vector unsigned short __ATTRS_o_ai
   14408 __builtin_crypto_vpmsumb(vector unsigned short __a, vector unsigned short __b) {
   14409   return __builtin_altivec_crypto_vpmsumh(__a, __b);
   14410 }
   14411 
   14412 static __inline__ vector unsigned int __ATTRS_o_ai
   14413 __builtin_crypto_vpmsumb(vector unsigned int __a, vector unsigned int __b) {
   14414   return __builtin_altivec_crypto_vpmsumw(__a, __b);
   14415 }
   14416 
   14417 static __inline__ vector unsigned long long __ATTRS_o_ai
   14418 __builtin_crypto_vpmsumb(vector unsigned long long __a,
   14419                          vector unsigned long long __b) {
   14420   return __builtin_altivec_crypto_vpmsumd(__a, __b);
   14421 }
   14422 
   14423 static __inline__ vector signed char __ATTRS_o_ai
   14424 vec_vgbbd(vector signed char __a) {
   14425   return __builtin_altivec_vgbbd((vector unsigned char)__a);
   14426 }
   14427 
   14428 #define vec_pmsum_be __builtin_crypto_vpmsumb
   14429 #define vec_gb __builtin_altivec_vgbbd
   14430 
   14431 static __inline__ vector unsigned char __ATTRS_o_ai
   14432 vec_vgbbd(vector unsigned char __a) {
   14433   return __builtin_altivec_vgbbd(__a);
   14434 }
   14435 
   14436 static __inline__ vector long long __ATTRS_o_ai
   14437 vec_vbpermq(vector signed char __a, vector signed char __b) {
   14438   return __builtin_altivec_vbpermq((vector unsigned char)__a,
   14439                                    (vector unsigned char)__b);
   14440 }
   14441 
   14442 static __inline__ vector long long __ATTRS_o_ai
   14443 vec_vbpermq(vector unsigned char __a, vector unsigned char __b) {
   14444   return __builtin_altivec_vbpermq(__a, __b);
   14445 }
   14446 
   14447 #ifdef __powerpc64__
   14448 static __inline__ vector unsigned long long __attribute__((__always_inline__))
   14449 vec_bperm(vector unsigned __int128 __a, vector unsigned char __b) {
   14450   return __builtin_altivec_vbpermq((vector unsigned char)__a,
   14451                                    (vector unsigned char)__b);
   14452 }
   14453 #endif
   14454 #endif
   14455 
   14456 #undef __ATTRS_o_ai
   14457 
   14458 #endif /* __ALTIVEC_H */
   14459