clang  8.0.0
altivec.h
Go to the documentation of this file.
1 /*===---- altivec.h - Standard header for type generic math ---------------===*\
2  *
3  * Permission is hereby granted, free of charge, to any person obtaining a copy
4  * of this software and associated documentation files (the "Software"), to deal
5  * in the Software without restriction, including without limitation the rights
6  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7  * copies of the Software, and to permit persons to whom the Software is
8  * furnished to do so, subject to the following conditions:
9  *
10  * The above copyright notice and this permission notice shall be included in
11  * all copies or substantial portions of the Software.
12  *
13  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19  * THE SOFTWARE.
20  *
21 \*===----------------------------------------------------------------------===*/
22 
23 #ifndef __ALTIVEC_H
24 #define __ALTIVEC_H
25 
26 #ifndef __ALTIVEC__
27 #error "AltiVec support not enabled"
28 #endif
29 
30 /* Constants for mapping CR6 bits to predicate result. */
31 
32 #define __CR6_EQ 0
33 #define __CR6_EQ_REV 1
34 #define __CR6_LT 2
35 #define __CR6_LT_REV 3
36 
37 /* Constants for vec_test_data_class */
38 #define __VEC_CLASS_FP_SUBNORMAL_N (1 << 0)
39 #define __VEC_CLASS_FP_SUBNORMAL_P (1 << 1)
40 #define __VEC_CLASS_FP_SUBNORMAL (__VEC_CLASS_FP_SUBNORMAL_P | \
41  __VEC_CLASS_FP_SUBNORMAL_N)
42 #define __VEC_CLASS_FP_ZERO_N (1<<2)
43 #define __VEC_CLASS_FP_ZERO_P (1<<3)
44 #define __VEC_CLASS_FP_ZERO (__VEC_CLASS_FP_ZERO_P | \
45  __VEC_CLASS_FP_ZERO_N)
46 #define __VEC_CLASS_FP_INFINITY_N (1<<4)
47 #define __VEC_CLASS_FP_INFINITY_P (1<<5)
48 #define __VEC_CLASS_FP_INFINITY (__VEC_CLASS_FP_INFINITY_P | \
49  __VEC_CLASS_FP_INFINITY_N)
50 #define __VEC_CLASS_FP_NAN (1<<6)
51 #define __VEC_CLASS_FP_NOT_NORMAL (__VEC_CLASS_FP_NAN | \
52  __VEC_CLASS_FP_SUBNORMAL | \
53  __VEC_CLASS_FP_ZERO | \
54  __VEC_CLASS_FP_INFINITY)
55 
56 #define __ATTRS_o_ai __attribute__((__overloadable__, __always_inline__))
57 
58 #ifdef __POWER9_VECTOR__
59 #include <stddef.h>
60 #endif
61 
62 static __inline__ vector signed char __ATTRS_o_ai vec_perm(
63  vector signed char __a, vector signed char __b, vector unsigned char __c);
64 
65 static __inline__ vector unsigned char __ATTRS_o_ai
66 vec_perm(vector unsigned char __a, vector unsigned char __b,
67  vector unsigned char __c);
68 
69 static __inline__ vector bool char __ATTRS_o_ai
70 vec_perm(vector bool char __a, vector bool char __b, vector unsigned char __c);
71 
72 static __inline__ vector short __ATTRS_o_ai vec_perm(vector signed short __a,
73  vector signed short __b,
74  vector unsigned char __c);
75 
76 static __inline__ vector unsigned short __ATTRS_o_ai
77 vec_perm(vector unsigned short __a, vector unsigned short __b,
78  vector unsigned char __c);
79 
80 static __inline__ vector bool short __ATTRS_o_ai vec_perm(
81  vector bool short __a, vector bool short __b, vector unsigned char __c);
82 
83 static __inline__ vector pixel __ATTRS_o_ai vec_perm(vector pixel __a,
84  vector pixel __b,
85  vector unsigned char __c);
86 
87 static __inline__ vector int __ATTRS_o_ai vec_perm(vector signed int __a,
88  vector signed int __b,
89  vector unsigned char __c);
90 
91 static __inline__ vector unsigned int __ATTRS_o_ai vec_perm(
92  vector unsigned int __a, vector unsigned int __b, vector unsigned char __c);
93 
94 static __inline__ vector bool int __ATTRS_o_ai
95 vec_perm(vector bool int __a, vector bool int __b, vector unsigned char __c);
96 
97 static __inline__ vector float __ATTRS_o_ai vec_perm(vector float __a,
98  vector float __b,
99  vector unsigned char __c);
100 
101 #ifdef __VSX__
102 static __inline__ vector long long __ATTRS_o_ai
103 vec_perm(vector signed long long __a, vector signed long long __b,
104  vector unsigned char __c);
105 
106 static __inline__ vector unsigned long long __ATTRS_o_ai
107 vec_perm(vector unsigned long long __a, vector unsigned long long __b,
108  vector unsigned char __c);
109 
110 static __inline__ vector bool long long __ATTRS_o_ai
111 vec_perm(vector bool long long __a, vector bool long long __b,
112  vector unsigned char __c);
113 
114 static __inline__ vector double __ATTRS_o_ai vec_perm(vector double __a,
115  vector double __b,
116  vector unsigned char __c);
117 #endif
118 
119 static __inline__ vector unsigned char __ATTRS_o_ai
120 vec_xor(vector unsigned char __a, vector unsigned char __b);
121 
122 /* vec_abs */
123 
124 #define __builtin_altivec_abs_v16qi vec_abs
125 #define __builtin_altivec_abs_v8hi vec_abs
126 #define __builtin_altivec_abs_v4si vec_abs
127 
128 static __inline__ vector signed char __ATTRS_o_ai
129 vec_abs(vector signed char __a) {
130  return __builtin_altivec_vmaxsb(__a, -__a);
131 }
132 
133 static __inline__ vector signed short __ATTRS_o_ai
134 vec_abs(vector signed short __a) {
135  return __builtin_altivec_vmaxsh(__a, -__a);
136 }
137 
138 static __inline__ vector signed int __ATTRS_o_ai
139 vec_abs(vector signed int __a) {
140  return __builtin_altivec_vmaxsw(__a, -__a);
141 }
142 
143 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
144 static __inline__ vector signed long long __ATTRS_o_ai
145 vec_abs(vector signed long long __a) {
146  return __builtin_altivec_vmaxsd(__a, -__a);
147 }
148 #endif
149 
150 static __inline__ vector float __ATTRS_o_ai vec_abs(vector float __a) {
151 #ifdef __VSX__
152  return __builtin_vsx_xvabssp(__a);
153 #else
154  vector unsigned int __res =
155  (vector unsigned int)__a & (vector unsigned int)(0x7FFFFFFF);
156  return (vector float)__res;
157 #endif
158 }
159 
160 #ifdef __VSX__
161 static __inline__ vector double __ATTRS_o_ai vec_abs(vector double __a) {
162  return __builtin_vsx_xvabsdp(__a);
163 }
164 #endif
165 
166 /* vec_abss */
167 #define __builtin_altivec_abss_v16qi vec_abss
168 #define __builtin_altivec_abss_v8hi vec_abss
169 #define __builtin_altivec_abss_v4si vec_abss
170 
171 static __inline__ vector signed char __ATTRS_o_ai
172 vec_abss(vector signed char __a) {
173  return __builtin_altivec_vmaxsb(
174  __a, __builtin_altivec_vsubsbs((vector signed char)(0), __a));
175 }
176 
177 static __inline__ vector signed short __ATTRS_o_ai
178 vec_abss(vector signed short __a) {
179  return __builtin_altivec_vmaxsh(
180  __a, __builtin_altivec_vsubshs((vector signed short)(0), __a));
181 }
182 
183 static __inline__ vector signed int __ATTRS_o_ai
184 vec_abss(vector signed int __a) {
185  return __builtin_altivec_vmaxsw(
186  __a, __builtin_altivec_vsubsws((vector signed int)(0), __a));
187 }
188 
189 /* vec_absd */
190 #if defined(__POWER9_VECTOR__)
191 
192 static __inline__ vector unsigned char __ATTRS_o_ai
193 vec_absd(vector unsigned char __a, vector unsigned char __b) {
194  return __builtin_altivec_vabsdub(__a, __b);
195 }
196 
197 static __inline__ vector unsigned short __ATTRS_o_ai
198 vec_absd(vector unsigned short __a, vector unsigned short __b) {
199  return __builtin_altivec_vabsduh(__a, __b);
200 }
201 
202 static __inline__ vector unsigned int __ATTRS_o_ai
203 vec_absd(vector unsigned int __a, vector unsigned int __b) {
204  return __builtin_altivec_vabsduw(__a, __b);
205 }
206 
207 #endif /* End __POWER9_VECTOR__ */
208 
209 /* vec_add */
210 
211 static __inline__ vector signed char __ATTRS_o_ai
212 vec_add(vector signed char __a, vector signed char __b) {
213  return __a + __b;
214 }
215 
216 static __inline__ vector signed char __ATTRS_o_ai
217 vec_add(vector bool char __a, vector signed char __b) {
218  return (vector signed char)__a + __b;
219 }
220 
221 static __inline__ vector signed char __ATTRS_o_ai
222 vec_add(vector signed char __a, vector bool char __b) {
223  return __a + (vector signed char)__b;
224 }
225 
226 static __inline__ vector unsigned char __ATTRS_o_ai
227 vec_add(vector unsigned char __a, vector unsigned char __b) {
228  return __a + __b;
229 }
230 
231 static __inline__ vector unsigned char __ATTRS_o_ai
232 vec_add(vector bool char __a, vector unsigned char __b) {
233  return (vector unsigned char)__a + __b;
234 }
235 
236 static __inline__ vector unsigned char __ATTRS_o_ai
237 vec_add(vector unsigned char __a, vector bool char __b) {
238  return __a + (vector unsigned char)__b;
239 }
240 
241 static __inline__ vector short __ATTRS_o_ai vec_add(vector short __a,
242  vector short __b) {
243  return __a + __b;
244 }
245 
246 static __inline__ vector short __ATTRS_o_ai vec_add(vector bool short __a,
247  vector short __b) {
248  return (vector short)__a + __b;
249 }
250 
251 static __inline__ vector short __ATTRS_o_ai vec_add(vector short __a,
252  vector bool short __b) {
253  return __a + (vector short)__b;
254 }
255 
256 static __inline__ vector unsigned short __ATTRS_o_ai
257 vec_add(vector unsigned short __a, vector unsigned short __b) {
258  return __a + __b;
259 }
260 
261 static __inline__ vector unsigned short __ATTRS_o_ai
262 vec_add(vector bool short __a, vector unsigned short __b) {
263  return (vector unsigned short)__a + __b;
264 }
265 
266 static __inline__ vector unsigned short __ATTRS_o_ai
267 vec_add(vector unsigned short __a, vector bool short __b) {
268  return __a + (vector unsigned short)__b;
269 }
270 
271 static __inline__ vector int __ATTRS_o_ai vec_add(vector int __a,
272  vector int __b) {
273  return __a + __b;
274 }
275 
276 static __inline__ vector int __ATTRS_o_ai vec_add(vector bool int __a,
277  vector int __b) {
278  return (vector int)__a + __b;
279 }
280 
281 static __inline__ vector int __ATTRS_o_ai vec_add(vector int __a,
282  vector bool int __b) {
283  return __a + (vector int)__b;
284 }
285 
286 static __inline__ vector unsigned int __ATTRS_o_ai
287 vec_add(vector unsigned int __a, vector unsigned int __b) {
288  return __a + __b;
289 }
290 
291 static __inline__ vector unsigned int __ATTRS_o_ai
292 vec_add(vector bool int __a, vector unsigned int __b) {
293  return (vector unsigned int)__a + __b;
294 }
295 
296 static __inline__ vector unsigned int __ATTRS_o_ai
297 vec_add(vector unsigned int __a, vector bool int __b) {
298  return __a + (vector unsigned int)__b;
299 }
300 
301 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
302 static __inline__ vector signed long long __ATTRS_o_ai
303 vec_add(vector signed long long __a, vector signed long long __b) {
304  return __a + __b;
305 }
306 
307 static __inline__ vector unsigned long long __ATTRS_o_ai
308 vec_add(vector unsigned long long __a, vector unsigned long long __b) {
309  return __a + __b;
310 }
311 
312 static __inline__ vector signed __int128 __ATTRS_o_ai
313 vec_add(vector signed __int128 __a, vector signed __int128 __b) {
314  return __a + __b;
315 }
316 
317 static __inline__ vector unsigned __int128 __ATTRS_o_ai
318 vec_add(vector unsigned __int128 __a, vector unsigned __int128 __b) {
319  return __a + __b;
320 }
321 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
322 
323 static __inline__ vector float __ATTRS_o_ai vec_add(vector float __a,
324  vector float __b) {
325  return __a + __b;
326 }
327 
328 #ifdef __VSX__
329 static __inline__ vector double __ATTRS_o_ai vec_add(vector double __a,
330  vector double __b) {
331  return __a + __b;
332 }
333 #endif // __VSX__
334 
335 /* vec_adde */
336 
337 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
338 static __inline__ vector signed __int128 __ATTRS_o_ai
339 vec_adde(vector signed __int128 __a, vector signed __int128 __b,
340  vector signed __int128 __c) {
341  return __builtin_altivec_vaddeuqm(__a, __b, __c);
342 }
343 
344 static __inline__ vector unsigned __int128 __ATTRS_o_ai
345 vec_adde(vector unsigned __int128 __a, vector unsigned __int128 __b,
346  vector unsigned __int128 __c) {
347  return __builtin_altivec_vaddeuqm(__a, __b, __c);
348 }
349 #endif
350 
351 static __inline__ vector signed int __ATTRS_o_ai
352 vec_adde(vector signed int __a, vector signed int __b,
353  vector signed int __c) {
354  vector signed int __mask = {1, 1, 1, 1};
355  vector signed int __carry = __c & __mask;
356  return vec_add(vec_add(__a, __b), __carry);
357 }
358 
359 static __inline__ vector unsigned int __ATTRS_o_ai
360 vec_adde(vector unsigned int __a, vector unsigned int __b,
361  vector unsigned int __c) {
362  vector unsigned int __mask = {1, 1, 1, 1};
363  vector unsigned int __carry = __c & __mask;
364  return vec_add(vec_add(__a, __b), __carry);
365 }
366 
367 /* vec_addec */
368 
369 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
370 static __inline__ vector signed __int128 __ATTRS_o_ai
371 vec_addec(vector signed __int128 __a, vector signed __int128 __b,
372  vector signed __int128 __c) {
373  return __builtin_altivec_vaddecuq(__a, __b, __c);
374 }
375 
376 static __inline__ vector unsigned __int128 __ATTRS_o_ai
377 vec_addec(vector unsigned __int128 __a, vector unsigned __int128 __b,
378  vector unsigned __int128 __c) {
379  return __builtin_altivec_vaddecuq(__a, __b, __c);
380 }
381 
382 static __inline__ vector signed int __ATTRS_o_ai
383 vec_addec(vector signed int __a, vector signed int __b,
384  vector signed int __c) {
385 
386  signed int __result[4];
387  for (int i = 0; i < 4; i++) {
388  unsigned int __tempa = (unsigned int) __a[i];
389  unsigned int __tempb = (unsigned int) __b[i];
390  unsigned int __tempc = (unsigned int) __c[i];
391  __tempc = __tempc & 0x00000001;
392  unsigned long long __longa = (unsigned long long) __tempa;
393  unsigned long long __longb = (unsigned long long) __tempb;
394  unsigned long long __longc = (unsigned long long) __tempc;
395  unsigned long long __sum = __longa + __longb + __longc;
396  unsigned long long __res = (__sum >> 32) & 0x01;
397  unsigned long long __tempres = (unsigned int) __res;
398  __result[i] = (signed int) __tempres;
399  }
400 
401  vector signed int ret = { __result[0], __result[1], __result[2], __result[3] };
402  return ret;
403 }
404 
405 static __inline__ vector unsigned int __ATTRS_o_ai
406 vec_addec(vector unsigned int __a, vector unsigned int __b,
407  vector unsigned int __c) {
408 
409  unsigned int __result[4];
410  for (int i = 0; i < 4; i++) {
411  unsigned int __tempc = __c[i] & 1;
412  unsigned long long __longa = (unsigned long long) __a[i];
413  unsigned long long __longb = (unsigned long long) __b[i];
414  unsigned long long __longc = (unsigned long long) __tempc;
415  unsigned long long __sum = __longa + __longb + __longc;
416  unsigned long long __res = (__sum >> 32) & 0x01;
417  unsigned long long __tempres = (unsigned int) __res;
418  __result[i] = (signed int) __tempres;
419  }
420 
421  vector unsigned int ret = { __result[0], __result[1], __result[2], __result[3] };
422  return ret;
423 }
424 
425 #endif
426 
427 /* vec_vaddubm */
428 
429 #define __builtin_altivec_vaddubm vec_vaddubm
430 
431 static __inline__ vector signed char __ATTRS_o_ai
432 vec_vaddubm(vector signed char __a, vector signed char __b) {
433  return __a + __b;
434 }
435 
436 static __inline__ vector signed char __ATTRS_o_ai
437 vec_vaddubm(vector bool char __a, vector signed char __b) {
438  return (vector signed char)__a + __b;
439 }
440 
441 static __inline__ vector signed char __ATTRS_o_ai
442 vec_vaddubm(vector signed char __a, vector bool char __b) {
443  return __a + (vector signed char)__b;
444 }
445 
446 static __inline__ vector unsigned char __ATTRS_o_ai
447 vec_vaddubm(vector unsigned char __a, vector unsigned char __b) {
448  return __a + __b;
449 }
450 
451 static __inline__ vector unsigned char __ATTRS_o_ai
452 vec_vaddubm(vector bool char __a, vector unsigned char __b) {
453  return (vector unsigned char)__a + __b;
454 }
455 
456 static __inline__ vector unsigned char __ATTRS_o_ai
457 vec_vaddubm(vector unsigned char __a, vector bool char __b) {
458  return __a + (vector unsigned char)__b;
459 }
460 
461 /* vec_vadduhm */
462 
463 #define __builtin_altivec_vadduhm vec_vadduhm
464 
465 static __inline__ vector short __ATTRS_o_ai vec_vadduhm(vector short __a,
466  vector short __b) {
467  return __a + __b;
468 }
469 
470 static __inline__ vector short __ATTRS_o_ai vec_vadduhm(vector bool short __a,
471  vector short __b) {
472  return (vector short)__a + __b;
473 }
474 
475 static __inline__ vector short __ATTRS_o_ai vec_vadduhm(vector short __a,
476  vector bool short __b) {
477  return __a + (vector short)__b;
478 }
479 
480 static __inline__ vector unsigned short __ATTRS_o_ai
481 vec_vadduhm(vector unsigned short __a, vector unsigned short __b) {
482  return __a + __b;
483 }
484 
485 static __inline__ vector unsigned short __ATTRS_o_ai
486 vec_vadduhm(vector bool short __a, vector unsigned short __b) {
487  return (vector unsigned short)__a + __b;
488 }
489 
490 static __inline__ vector unsigned short __ATTRS_o_ai
491 vec_vadduhm(vector unsigned short __a, vector bool short __b) {
492  return __a + (vector unsigned short)__b;
493 }
494 
495 /* vec_vadduwm */
496 
497 #define __builtin_altivec_vadduwm vec_vadduwm
498 
499 static __inline__ vector int __ATTRS_o_ai vec_vadduwm(vector int __a,
500  vector int __b) {
501  return __a + __b;
502 }
503 
504 static __inline__ vector int __ATTRS_o_ai vec_vadduwm(vector bool int __a,
505  vector int __b) {
506  return (vector int)__a + __b;
507 }
508 
509 static __inline__ vector int __ATTRS_o_ai vec_vadduwm(vector int __a,
510  vector bool int __b) {
511  return __a + (vector int)__b;
512 }
513 
514 static __inline__ vector unsigned int __ATTRS_o_ai
515 vec_vadduwm(vector unsigned int __a, vector unsigned int __b) {
516  return __a + __b;
517 }
518 
519 static __inline__ vector unsigned int __ATTRS_o_ai
520 vec_vadduwm(vector bool int __a, vector unsigned int __b) {
521  return (vector unsigned int)__a + __b;
522 }
523 
524 static __inline__ vector unsigned int __ATTRS_o_ai
525 vec_vadduwm(vector unsigned int __a, vector bool int __b) {
526  return __a + (vector unsigned int)__b;
527 }
528 
529 /* vec_vaddfp */
530 
531 #define __builtin_altivec_vaddfp vec_vaddfp
532 
533 static __inline__ vector float __attribute__((__always_inline__))
534 vec_vaddfp(vector float __a, vector float __b) {
535  return __a + __b;
536 }
537 
538 /* vec_addc */
539 
540 static __inline__ vector signed int __ATTRS_o_ai
541 vec_addc(vector signed int __a, vector signed int __b) {
542  return (vector signed int)__builtin_altivec_vaddcuw((vector unsigned int)__a,
543  (vector unsigned int)__b);
544 }
545 
546 static __inline__ vector unsigned int __ATTRS_o_ai
547 vec_addc(vector unsigned int __a, vector unsigned int __b) {
548  return __builtin_altivec_vaddcuw(__a, __b);
549 }
550 
551 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
552 static __inline__ vector signed __int128 __ATTRS_o_ai
553 vec_addc(vector signed __int128 __a, vector signed __int128 __b) {
554  return (vector signed __int128)__builtin_altivec_vaddcuq(
555  (vector unsigned __int128)__a, (vector unsigned __int128)__b);
556 }
557 
558 static __inline__ vector unsigned __int128 __ATTRS_o_ai
559 vec_addc(vector unsigned __int128 __a, vector unsigned __int128 __b) {
560  return __builtin_altivec_vaddcuq(__a, __b);
561 }
562 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
563 
564 /* vec_vaddcuw */
565 
566 static __inline__ vector unsigned int __attribute__((__always_inline__))
567 vec_vaddcuw(vector unsigned int __a, vector unsigned int __b) {
568  return __builtin_altivec_vaddcuw(__a, __b);
569 }
570 
571 /* vec_adds */
572 
573 static __inline__ vector signed char __ATTRS_o_ai
574 vec_adds(vector signed char __a, vector signed char __b) {
575  return __builtin_altivec_vaddsbs(__a, __b);
576 }
577 
578 static __inline__ vector signed char __ATTRS_o_ai
579 vec_adds(vector bool char __a, vector signed char __b) {
580  return __builtin_altivec_vaddsbs((vector signed char)__a, __b);
581 }
582 
583 static __inline__ vector signed char __ATTRS_o_ai
584 vec_adds(vector signed char __a, vector bool char __b) {
585  return __builtin_altivec_vaddsbs(__a, (vector signed char)__b);
586 }
587 
588 static __inline__ vector unsigned char __ATTRS_o_ai
589 vec_adds(vector unsigned char __a, vector unsigned char __b) {
590  return __builtin_altivec_vaddubs(__a, __b);
591 }
592 
593 static __inline__ vector unsigned char __ATTRS_o_ai
594 vec_adds(vector bool char __a, vector unsigned char __b) {
595  return __builtin_altivec_vaddubs((vector unsigned char)__a, __b);
596 }
597 
598 static __inline__ vector unsigned char __ATTRS_o_ai
599 vec_adds(vector unsigned char __a, vector bool char __b) {
600  return __builtin_altivec_vaddubs(__a, (vector unsigned char)__b);
601 }
602 
603 static __inline__ vector short __ATTRS_o_ai vec_adds(vector short __a,
604  vector short __b) {
605  return __builtin_altivec_vaddshs(__a, __b);
606 }
607 
608 static __inline__ vector short __ATTRS_o_ai vec_adds(vector bool short __a,
609  vector short __b) {
610  return __builtin_altivec_vaddshs((vector short)__a, __b);
611 }
612 
613 static __inline__ vector short __ATTRS_o_ai vec_adds(vector short __a,
614  vector bool short __b) {
615  return __builtin_altivec_vaddshs(__a, (vector short)__b);
616 }
617 
618 static __inline__ vector unsigned short __ATTRS_o_ai
619 vec_adds(vector unsigned short __a, vector unsigned short __b) {
620  return __builtin_altivec_vadduhs(__a, __b);
621 }
622 
623 static __inline__ vector unsigned short __ATTRS_o_ai
624 vec_adds(vector bool short __a, vector unsigned short __b) {
625  return __builtin_altivec_vadduhs((vector unsigned short)__a, __b);
626 }
627 
628 static __inline__ vector unsigned short __ATTRS_o_ai
629 vec_adds(vector unsigned short __a, vector bool short __b) {
630  return __builtin_altivec_vadduhs(__a, (vector unsigned short)__b);
631 }
632 
633 static __inline__ vector int __ATTRS_o_ai vec_adds(vector int __a,
634  vector int __b) {
635  return __builtin_altivec_vaddsws(__a, __b);
636 }
637 
638 static __inline__ vector int __ATTRS_o_ai vec_adds(vector bool int __a,
639  vector int __b) {
640  return __builtin_altivec_vaddsws((vector int)__a, __b);
641 }
642 
643 static __inline__ vector int __ATTRS_o_ai vec_adds(vector int __a,
644  vector bool int __b) {
645  return __builtin_altivec_vaddsws(__a, (vector int)__b);
646 }
647 
648 static __inline__ vector unsigned int __ATTRS_o_ai
649 vec_adds(vector unsigned int __a, vector unsigned int __b) {
650  return __builtin_altivec_vadduws(__a, __b);
651 }
652 
653 static __inline__ vector unsigned int __ATTRS_o_ai
654 vec_adds(vector bool int __a, vector unsigned int __b) {
655  return __builtin_altivec_vadduws((vector unsigned int)__a, __b);
656 }
657 
658 static __inline__ vector unsigned int __ATTRS_o_ai
659 vec_adds(vector unsigned int __a, vector bool int __b) {
660  return __builtin_altivec_vadduws(__a, (vector unsigned int)__b);
661 }
662 
663 /* vec_vaddsbs */
664 
665 static __inline__ vector signed char __ATTRS_o_ai
666 vec_vaddsbs(vector signed char __a, vector signed char __b) {
667  return __builtin_altivec_vaddsbs(__a, __b);
668 }
669 
670 static __inline__ vector signed char __ATTRS_o_ai
671 vec_vaddsbs(vector bool char __a, vector signed char __b) {
672  return __builtin_altivec_vaddsbs((vector signed char)__a, __b);
673 }
674 
675 static __inline__ vector signed char __ATTRS_o_ai
676 vec_vaddsbs(vector signed char __a, vector bool char __b) {
677  return __builtin_altivec_vaddsbs(__a, (vector signed char)__b);
678 }
679 
680 /* vec_vaddubs */
681 
682 static __inline__ vector unsigned char __ATTRS_o_ai
683 vec_vaddubs(vector unsigned char __a, vector unsigned char __b) {
684  return __builtin_altivec_vaddubs(__a, __b);
685 }
686 
687 static __inline__ vector unsigned char __ATTRS_o_ai
688 vec_vaddubs(vector bool char __a, vector unsigned char __b) {
689  return __builtin_altivec_vaddubs((vector unsigned char)__a, __b);
690 }
691 
692 static __inline__ vector unsigned char __ATTRS_o_ai
693 vec_vaddubs(vector unsigned char __a, vector bool char __b) {
694  return __builtin_altivec_vaddubs(__a, (vector unsigned char)__b);
695 }
696 
697 /* vec_vaddshs */
698 
699 static __inline__ vector short __ATTRS_o_ai vec_vaddshs(vector short __a,
700  vector short __b) {
701  return __builtin_altivec_vaddshs(__a, __b);
702 }
703 
704 static __inline__ vector short __ATTRS_o_ai vec_vaddshs(vector bool short __a,
705  vector short __b) {
706  return __builtin_altivec_vaddshs((vector short)__a, __b);
707 }
708 
709 static __inline__ vector short __ATTRS_o_ai vec_vaddshs(vector short __a,
710  vector bool short __b) {
711  return __builtin_altivec_vaddshs(__a, (vector short)__b);
712 }
713 
714 /* vec_vadduhs */
715 
716 static __inline__ vector unsigned short __ATTRS_o_ai
717 vec_vadduhs(vector unsigned short __a, vector unsigned short __b) {
718  return __builtin_altivec_vadduhs(__a, __b);
719 }
720 
721 static __inline__ vector unsigned short __ATTRS_o_ai
722 vec_vadduhs(vector bool short __a, vector unsigned short __b) {
723  return __builtin_altivec_vadduhs((vector unsigned short)__a, __b);
724 }
725 
726 static __inline__ vector unsigned short __ATTRS_o_ai
727 vec_vadduhs(vector unsigned short __a, vector bool short __b) {
728  return __builtin_altivec_vadduhs(__a, (vector unsigned short)__b);
729 }
730 
731 /* vec_vaddsws */
732 
733 static __inline__ vector int __ATTRS_o_ai vec_vaddsws(vector int __a,
734  vector int __b) {
735  return __builtin_altivec_vaddsws(__a, __b);
736 }
737 
738 static __inline__ vector int __ATTRS_o_ai vec_vaddsws(vector bool int __a,
739  vector int __b) {
740  return __builtin_altivec_vaddsws((vector int)__a, __b);
741 }
742 
743 static __inline__ vector int __ATTRS_o_ai vec_vaddsws(vector int __a,
744  vector bool int __b) {
745  return __builtin_altivec_vaddsws(__a, (vector int)__b);
746 }
747 
748 /* vec_vadduws */
749 
750 static __inline__ vector unsigned int __ATTRS_o_ai
751 vec_vadduws(vector unsigned int __a, vector unsigned int __b) {
752  return __builtin_altivec_vadduws(__a, __b);
753 }
754 
755 static __inline__ vector unsigned int __ATTRS_o_ai
756 vec_vadduws(vector bool int __a, vector unsigned int __b) {
757  return __builtin_altivec_vadduws((vector unsigned int)__a, __b);
758 }
759 
760 static __inline__ vector unsigned int __ATTRS_o_ai
761 vec_vadduws(vector unsigned int __a, vector bool int __b) {
762  return __builtin_altivec_vadduws(__a, (vector unsigned int)__b);
763 }
764 
765 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
766 /* vec_vadduqm */
767 
768 static __inline__ vector signed __int128 __ATTRS_o_ai
769 vec_vadduqm(vector signed __int128 __a, vector signed __int128 __b) {
770  return __a + __b;
771 }
772 
773 static __inline__ vector unsigned __int128 __ATTRS_o_ai
774 vec_vadduqm(vector unsigned __int128 __a, vector unsigned __int128 __b) {
775  return __a + __b;
776 }
777 
778 /* vec_vaddeuqm */
779 
780 static __inline__ vector signed __int128 __ATTRS_o_ai
781 vec_vaddeuqm(vector signed __int128 __a, vector signed __int128 __b,
782  vector signed __int128 __c) {
783  return __builtin_altivec_vaddeuqm(__a, __b, __c);
784 }
785 
786 static __inline__ vector unsigned __int128 __ATTRS_o_ai
787 vec_vaddeuqm(vector unsigned __int128 __a, vector unsigned __int128 __b,
788  vector unsigned __int128 __c) {
789  return __builtin_altivec_vaddeuqm(__a, __b, __c);
790 }
791 
792 /* vec_vaddcuq */
793 
794 static __inline__ vector signed __int128 __ATTRS_o_ai
795 vec_vaddcuq(vector signed __int128 __a, vector signed __int128 __b) {
796  return __builtin_altivec_vaddcuq(__a, __b);
797 }
798 
799 static __inline__ vector unsigned __int128 __ATTRS_o_ai
800 vec_vaddcuq(vector unsigned __int128 __a, vector unsigned __int128 __b) {
801  return __builtin_altivec_vaddcuq(__a, __b);
802 }
803 
804 /* vec_vaddecuq */
805 
806 static __inline__ vector signed __int128 __ATTRS_o_ai
807 vec_vaddecuq(vector signed __int128 __a, vector signed __int128 __b,
808  vector signed __int128 __c) {
809  return __builtin_altivec_vaddecuq(__a, __b, __c);
810 }
811 
812 static __inline__ vector unsigned __int128 __ATTRS_o_ai
813 vec_vaddecuq(vector unsigned __int128 __a, vector unsigned __int128 __b,
814  vector unsigned __int128 __c) {
815  return __builtin_altivec_vaddecuq(__a, __b, __c);
816 }
817 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
818 
819 /* vec_and */
820 
821 #define __builtin_altivec_vand vec_and
822 
823 static __inline__ vector signed char __ATTRS_o_ai
824 vec_and(vector signed char __a, vector signed char __b) {
825  return __a & __b;
826 }
827 
828 static __inline__ vector signed char __ATTRS_o_ai
829 vec_and(vector bool char __a, vector signed char __b) {
830  return (vector signed char)__a & __b;
831 }
832 
833 static __inline__ vector signed char __ATTRS_o_ai
834 vec_and(vector signed char __a, vector bool char __b) {
835  return __a & (vector signed char)__b;
836 }
837 
838 static __inline__ vector unsigned char __ATTRS_o_ai
839 vec_and(vector unsigned char __a, vector unsigned char __b) {
840  return __a & __b;
841 }
842 
843 static __inline__ vector unsigned char __ATTRS_o_ai
844 vec_and(vector bool char __a, vector unsigned char __b) {
845  return (vector unsigned char)__a & __b;
846 }
847 
848 static __inline__ vector unsigned char __ATTRS_o_ai
849 vec_and(vector unsigned char __a, vector bool char __b) {
850  return __a & (vector unsigned char)__b;
851 }
852 
853 static __inline__ vector bool char __ATTRS_o_ai vec_and(vector bool char __a,
854  vector bool char __b) {
855  return __a & __b;
856 }
857 
858 static __inline__ vector short __ATTRS_o_ai vec_and(vector short __a,
859  vector short __b) {
860  return __a & __b;
861 }
862 
863 static __inline__ vector short __ATTRS_o_ai vec_and(vector bool short __a,
864  vector short __b) {
865  return (vector short)__a & __b;
866 }
867 
868 static __inline__ vector short __ATTRS_o_ai vec_and(vector short __a,
869  vector bool short __b) {
870  return __a & (vector short)__b;
871 }
872 
873 static __inline__ vector unsigned short __ATTRS_o_ai
874 vec_and(vector unsigned short __a, vector unsigned short __b) {
875  return __a & __b;
876 }
877 
878 static __inline__ vector unsigned short __ATTRS_o_ai
879 vec_and(vector bool short __a, vector unsigned short __b) {
880  return (vector unsigned short)__a & __b;
881 }
882 
883 static __inline__ vector unsigned short __ATTRS_o_ai
884 vec_and(vector unsigned short __a, vector bool short __b) {
885  return __a & (vector unsigned short)__b;
886 }
887 
888 static __inline__ vector bool short __ATTRS_o_ai
889 vec_and(vector bool short __a, vector bool short __b) {
890  return __a & __b;
891 }
892 
893 static __inline__ vector int __ATTRS_o_ai vec_and(vector int __a,
894  vector int __b) {
895  return __a & __b;
896 }
897 
898 static __inline__ vector int __ATTRS_o_ai vec_and(vector bool int __a,
899  vector int __b) {
900  return (vector int)__a & __b;
901 }
902 
903 static __inline__ vector int __ATTRS_o_ai vec_and(vector int __a,
904  vector bool int __b) {
905  return __a & (vector int)__b;
906 }
907 
908 static __inline__ vector unsigned int __ATTRS_o_ai
909 vec_and(vector unsigned int __a, vector unsigned int __b) {
910  return __a & __b;
911 }
912 
913 static __inline__ vector unsigned int __ATTRS_o_ai
914 vec_and(vector bool int __a, vector unsigned int __b) {
915  return (vector unsigned int)__a & __b;
916 }
917 
918 static __inline__ vector unsigned int __ATTRS_o_ai
919 vec_and(vector unsigned int __a, vector bool int __b) {
920  return __a & (vector unsigned int)__b;
921 }
922 
923 static __inline__ vector bool int __ATTRS_o_ai vec_and(vector bool int __a,
924  vector bool int __b) {
925  return __a & __b;
926 }
927 
928 static __inline__ vector float __ATTRS_o_ai vec_and(vector float __a,
929  vector float __b) {
930  vector unsigned int __res =
931  (vector unsigned int)__a & (vector unsigned int)__b;
932  return (vector float)__res;
933 }
934 
935 static __inline__ vector float __ATTRS_o_ai vec_and(vector bool int __a,
936  vector float __b) {
937  vector unsigned int __res =
938  (vector unsigned int)__a & (vector unsigned int)__b;
939  return (vector float)__res;
940 }
941 
942 static __inline__ vector float __ATTRS_o_ai vec_and(vector float __a,
943  vector bool int __b) {
944  vector unsigned int __res =
945  (vector unsigned int)__a & (vector unsigned int)__b;
946  return (vector float)__res;
947 }
948 
949 #ifdef __VSX__
950 static __inline__ vector double __ATTRS_o_ai vec_and(vector bool long long __a,
951  vector double __b) {
952  vector unsigned long long __res =
953  (vector unsigned long long)__a & (vector unsigned long long)__b;
954  return (vector double)__res;
955 }
956 
957 static __inline__ vector double __ATTRS_o_ai
958 vec_and(vector double __a, vector bool long long __b) {
959  vector unsigned long long __res =
960  (vector unsigned long long)__a & (vector unsigned long long)__b;
961  return (vector double)__res;
962 }
963 
964 static __inline__ vector double __ATTRS_o_ai vec_and(vector double __a,
965  vector double __b) {
966  vector unsigned long long __res =
967  (vector unsigned long long)__a & (vector unsigned long long)__b;
968  return (vector double)__res;
969 }
970 
971 static __inline__ vector signed long long __ATTRS_o_ai
972 vec_and(vector signed long long __a, vector signed long long __b) {
973  return __a & __b;
974 }
975 
976 static __inline__ vector signed long long __ATTRS_o_ai
977 vec_and(vector bool long long __a, vector signed long long __b) {
978  return (vector signed long long)__a & __b;
979 }
980 
981 static __inline__ vector signed long long __ATTRS_o_ai
982 vec_and(vector signed long long __a, vector bool long long __b) {
983  return __a & (vector signed long long)__b;
984 }
985 
986 static __inline__ vector unsigned long long __ATTRS_o_ai
987 vec_and(vector unsigned long long __a, vector unsigned long long __b) {
988  return __a & __b;
989 }
990 
991 static __inline__ vector unsigned long long __ATTRS_o_ai
992 vec_and(vector bool long long __a, vector unsigned long long __b) {
993  return (vector unsigned long long)__a & __b;
994 }
995 
996 static __inline__ vector unsigned long long __ATTRS_o_ai
997 vec_and(vector unsigned long long __a, vector bool long long __b) {
998  return __a & (vector unsigned long long)__b;
999 }
1000 
1001 static __inline__ vector bool long long __ATTRS_o_ai
1002 vec_and(vector bool long long __a, vector bool long long __b) {
1003  return __a & __b;
1004 }
1005 #endif
1006 
1007 /* vec_vand */
1008 
1009 static __inline__ vector signed char __ATTRS_o_ai
1010 vec_vand(vector signed char __a, vector signed char __b) {
1011  return __a & __b;
1012 }
1013 
1014 static __inline__ vector signed char __ATTRS_o_ai
1015 vec_vand(vector bool char __a, vector signed char __b) {
1016  return (vector signed char)__a & __b;
1017 }
1018 
1019 static __inline__ vector signed char __ATTRS_o_ai
1020 vec_vand(vector signed char __a, vector bool char __b) {
1021  return __a & (vector signed char)__b;
1022 }
1023 
1024 static __inline__ vector unsigned char __ATTRS_o_ai
1025 vec_vand(vector unsigned char __a, vector unsigned char __b) {
1026  return __a & __b;
1027 }
1028 
1029 static __inline__ vector unsigned char __ATTRS_o_ai
1030 vec_vand(vector bool char __a, vector unsigned char __b) {
1031  return (vector unsigned char)__a & __b;
1032 }
1033 
1034 static __inline__ vector unsigned char __ATTRS_o_ai
1035 vec_vand(vector unsigned char __a, vector bool char __b) {
1036  return __a & (vector unsigned char)__b;
1037 }
1038 
1039 static __inline__ vector bool char __ATTRS_o_ai vec_vand(vector bool char __a,
1040  vector bool char __b) {
1041  return __a & __b;
1042 }
1043 
1044 static __inline__ vector short __ATTRS_o_ai vec_vand(vector short __a,
1045  vector short __b) {
1046  return __a & __b;
1047 }
1048 
1049 static __inline__ vector short __ATTRS_o_ai vec_vand(vector bool short __a,
1050  vector short __b) {
1051  return (vector short)__a & __b;
1052 }
1053 
1054 static __inline__ vector short __ATTRS_o_ai vec_vand(vector short __a,
1055  vector bool short __b) {
1056  return __a & (vector short)__b;
1057 }
1058 
1059 static __inline__ vector unsigned short __ATTRS_o_ai
1060 vec_vand(vector unsigned short __a, vector unsigned short __b) {
1061  return __a & __b;
1062 }
1063 
1064 static __inline__ vector unsigned short __ATTRS_o_ai
1065 vec_vand(vector bool short __a, vector unsigned short __b) {
1066  return (vector unsigned short)__a & __b;
1067 }
1068 
1069 static __inline__ vector unsigned short __ATTRS_o_ai
1070 vec_vand(vector unsigned short __a, vector bool short __b) {
1071  return __a & (vector unsigned short)__b;
1072 }
1073 
1074 static __inline__ vector bool short __ATTRS_o_ai
1075 vec_vand(vector bool short __a, vector bool short __b) {
1076  return __a & __b;
1077 }
1078 
1079 static __inline__ vector int __ATTRS_o_ai vec_vand(vector int __a,
1080  vector int __b) {
1081  return __a & __b;
1082 }
1083 
1084 static __inline__ vector int __ATTRS_o_ai vec_vand(vector bool int __a,
1085  vector int __b) {
1086  return (vector int)__a & __b;
1087 }
1088 
1089 static __inline__ vector int __ATTRS_o_ai vec_vand(vector int __a,
1090  vector bool int __b) {
1091  return __a & (vector int)__b;
1092 }
1093 
1094 static __inline__ vector unsigned int __ATTRS_o_ai
1095 vec_vand(vector unsigned int __a, vector unsigned int __b) {
1096  return __a & __b;
1097 }
1098 
1099 static __inline__ vector unsigned int __ATTRS_o_ai
1100 vec_vand(vector bool int __a, vector unsigned int __b) {
1101  return (vector unsigned int)__a & __b;
1102 }
1103 
1104 static __inline__ vector unsigned int __ATTRS_o_ai
1105 vec_vand(vector unsigned int __a, vector bool int __b) {
1106  return __a & (vector unsigned int)__b;
1107 }
1108 
1109 static __inline__ vector bool int __ATTRS_o_ai vec_vand(vector bool int __a,
1110  vector bool int __b) {
1111  return __a & __b;
1112 }
1113 
1114 static __inline__ vector float __ATTRS_o_ai vec_vand(vector float __a,
1115  vector float __b) {
1116  vector unsigned int __res =
1117  (vector unsigned int)__a & (vector unsigned int)__b;
1118  return (vector float)__res;
1119 }
1120 
1121 static __inline__ vector float __ATTRS_o_ai vec_vand(vector bool int __a,
1122  vector float __b) {
1123  vector unsigned int __res =
1124  (vector unsigned int)__a & (vector unsigned int)__b;
1125  return (vector float)__res;
1126 }
1127 
1128 static __inline__ vector float __ATTRS_o_ai vec_vand(vector float __a,
1129  vector bool int __b) {
1130  vector unsigned int __res =
1131  (vector unsigned int)__a & (vector unsigned int)__b;
1132  return (vector float)__res;
1133 }
1134 
1135 #ifdef __VSX__
1136 static __inline__ vector signed long long __ATTRS_o_ai
1137 vec_vand(vector signed long long __a, vector signed long long __b) {
1138  return __a & __b;
1139 }
1140 
1141 static __inline__ vector signed long long __ATTRS_o_ai
1142 vec_vand(vector bool long long __a, vector signed long long __b) {
1143  return (vector signed long long)__a & __b;
1144 }
1145 
1146 static __inline__ vector signed long long __ATTRS_o_ai
1147 vec_vand(vector signed long long __a, vector bool long long __b) {
1148  return __a & (vector signed long long)__b;
1149 }
1150 
1151 static __inline__ vector unsigned long long __ATTRS_o_ai
1152 vec_vand(vector unsigned long long __a, vector unsigned long long __b) {
1153  return __a & __b;
1154 }
1155 
1156 static __inline__ vector unsigned long long __ATTRS_o_ai
1157 vec_vand(vector bool long long __a, vector unsigned long long __b) {
1158  return (vector unsigned long long)__a & __b;
1159 }
1160 
1161 static __inline__ vector unsigned long long __ATTRS_o_ai
1162 vec_vand(vector unsigned long long __a, vector bool long long __b) {
1163  return __a & (vector unsigned long long)__b;
1164 }
1165 
1166 static __inline__ vector bool long long __ATTRS_o_ai
1167 vec_vand(vector bool long long __a, vector bool long long __b) {
1168  return __a & __b;
1169 }
1170 #endif
1171 
1172 /* vec_andc */
1173 
1174 #define __builtin_altivec_vandc vec_andc
1175 
1176 static __inline__ vector signed char __ATTRS_o_ai
1177 vec_andc(vector signed char __a, vector signed char __b) {
1178  return __a & ~__b;
1179 }
1180 
1181 static __inline__ vector signed char __ATTRS_o_ai
1182 vec_andc(vector bool char __a, vector signed char __b) {
1183  return (vector signed char)__a & ~__b;
1184 }
1185 
1186 static __inline__ vector signed char __ATTRS_o_ai
1187 vec_andc(vector signed char __a, vector bool char __b) {
1188  return __a & ~(vector signed char)__b;
1189 }
1190 
1191 static __inline__ vector unsigned char __ATTRS_o_ai
1192 vec_andc(vector unsigned char __a, vector unsigned char __b) {
1193  return __a & ~__b;
1194 }
1195 
1196 static __inline__ vector unsigned char __ATTRS_o_ai
1197 vec_andc(vector bool char __a, vector unsigned char __b) {
1198  return (vector unsigned char)__a & ~__b;
1199 }
1200 
1201 static __inline__ vector unsigned char __ATTRS_o_ai
1202 vec_andc(vector unsigned char __a, vector bool char __b) {
1203  return __a & ~(vector unsigned char)__b;
1204 }
1205 
1206 static __inline__ vector bool char __ATTRS_o_ai vec_andc(vector bool char __a,
1207  vector bool char __b) {
1208  return __a & ~__b;
1209 }
1210 
1211 static __inline__ vector short __ATTRS_o_ai vec_andc(vector short __a,
1212  vector short __b) {
1213  return __a & ~__b;
1214 }
1215 
1216 static __inline__ vector short __ATTRS_o_ai vec_andc(vector bool short __a,
1217  vector short __b) {
1218  return (vector short)__a & ~__b;
1219 }
1220 
1221 static __inline__ vector short __ATTRS_o_ai vec_andc(vector short __a,
1222  vector bool short __b) {
1223  return __a & ~(vector short)__b;
1224 }
1225 
1226 static __inline__ vector unsigned short __ATTRS_o_ai
1227 vec_andc(vector unsigned short __a, vector unsigned short __b) {
1228  return __a & ~__b;
1229 }
1230 
1231 static __inline__ vector unsigned short __ATTRS_o_ai
1232 vec_andc(vector bool short __a, vector unsigned short __b) {
1233  return (vector unsigned short)__a & ~__b;
1234 }
1235 
1236 static __inline__ vector unsigned short __ATTRS_o_ai
1237 vec_andc(vector unsigned short __a, vector bool short __b) {
1238  return __a & ~(vector unsigned short)__b;
1239 }
1240 
1241 static __inline__ vector bool short __ATTRS_o_ai
1242 vec_andc(vector bool short __a, vector bool short __b) {
1243  return __a & ~__b;
1244 }
1245 
1246 static __inline__ vector int __ATTRS_o_ai vec_andc(vector int __a,
1247  vector int __b) {
1248  return __a & ~__b;
1249 }
1250 
1251 static __inline__ vector int __ATTRS_o_ai vec_andc(vector bool int __a,
1252  vector int __b) {
1253  return (vector int)__a & ~__b;
1254 }
1255 
1256 static __inline__ vector int __ATTRS_o_ai vec_andc(vector int __a,
1257  vector bool int __b) {
1258  return __a & ~(vector int)__b;
1259 }
1260 
1261 static __inline__ vector unsigned int __ATTRS_o_ai
1262 vec_andc(vector unsigned int __a, vector unsigned int __b) {
1263  return __a & ~__b;
1264 }
1265 
1266 static __inline__ vector unsigned int __ATTRS_o_ai
1267 vec_andc(vector bool int __a, vector unsigned int __b) {
1268  return (vector unsigned int)__a & ~__b;
1269 }
1270 
1271 static __inline__ vector unsigned int __ATTRS_o_ai
1272 vec_andc(vector unsigned int __a, vector bool int __b) {
1273  return __a & ~(vector unsigned int)__b;
1274 }
1275 
1276 static __inline__ vector bool int __ATTRS_o_ai vec_andc(vector bool int __a,
1277  vector bool int __b) {
1278  return __a & ~__b;
1279 }
1280 
1281 static __inline__ vector float __ATTRS_o_ai vec_andc(vector float __a,
1282  vector float __b) {
1283  vector unsigned int __res =
1284  (vector unsigned int)__a & ~(vector unsigned int)__b;
1285  return (vector float)__res;
1286 }
1287 
1288 static __inline__ vector float __ATTRS_o_ai vec_andc(vector bool int __a,
1289  vector float __b) {
1290  vector unsigned int __res =
1291  (vector unsigned int)__a & ~(vector unsigned int)__b;
1292  return (vector float)__res;
1293 }
1294 
1295 static __inline__ vector float __ATTRS_o_ai vec_andc(vector float __a,
1296  vector bool int __b) {
1297  vector unsigned int __res =
1298  (vector unsigned int)__a & ~(vector unsigned int)__b;
1299  return (vector float)__res;
1300 }
1301 
1302 #ifdef __VSX__
1303 static __inline__ vector double __ATTRS_o_ai vec_andc(vector bool long long __a,
1304  vector double __b) {
1305  vector unsigned long long __res =
1306  (vector unsigned long long)__a & ~(vector unsigned long long)__b;
1307  return (vector double)__res;
1308 }
1309 
1310 static __inline__ vector double __ATTRS_o_ai
1311 vec_andc(vector double __a, vector bool long long __b) {
1312  vector unsigned long long __res =
1313  (vector unsigned long long)__a & ~(vector unsigned long long)__b;
1314  return (vector double)__res;
1315 }
1316 
1317 static __inline__ vector double __ATTRS_o_ai vec_andc(vector double __a,
1318  vector double __b) {
1319  vector unsigned long long __res =
1320  (vector unsigned long long)__a & ~(vector unsigned long long)__b;
1321  return (vector double)__res;
1322 }
1323 
1324 static __inline__ vector signed long long __ATTRS_o_ai
1325 vec_andc(vector signed long long __a, vector signed long long __b) {
1326  return __a & ~__b;
1327 }
1328 
1329 static __inline__ vector signed long long __ATTRS_o_ai
1330 vec_andc(vector bool long long __a, vector signed long long __b) {
1331  return (vector signed long long)__a & ~__b;
1332 }
1333 
1334 static __inline__ vector signed long long __ATTRS_o_ai
1335 vec_andc(vector signed long long __a, vector bool long long __b) {
1336  return __a & ~(vector signed long long)__b;
1337 }
1338 
1339 static __inline__ vector unsigned long long __ATTRS_o_ai
1340 vec_andc(vector unsigned long long __a, vector unsigned long long __b) {
1341  return __a & ~__b;
1342 }
1343 
1344 static __inline__ vector unsigned long long __ATTRS_o_ai
1345 vec_andc(vector bool long long __a, vector unsigned long long __b) {
1346  return (vector unsigned long long)__a & ~__b;
1347 }
1348 
1349 static __inline__ vector unsigned long long __ATTRS_o_ai
1350 vec_andc(vector unsigned long long __a, vector bool long long __b) {
1351  return __a & ~(vector unsigned long long)__b;
1352 }
1353 
1354 static __inline__ vector bool long long __ATTRS_o_ai
1355 vec_andc(vector bool long long __a, vector bool long long __b) {
1356  return __a & ~__b;
1357 }
1358 #endif
1359 
1360 /* vec_vandc */
1361 
1362 static __inline__ vector signed char __ATTRS_o_ai
1363 vec_vandc(vector signed char __a, vector signed char __b) {
1364  return __a & ~__b;
1365 }
1366 
1367 static __inline__ vector signed char __ATTRS_o_ai
1368 vec_vandc(vector bool char __a, vector signed char __b) {
1369  return (vector signed char)__a & ~__b;
1370 }
1371 
1372 static __inline__ vector signed char __ATTRS_o_ai
1373 vec_vandc(vector signed char __a, vector bool char __b) {
1374  return __a & ~(vector signed char)__b;
1375 }
1376 
1377 static __inline__ vector unsigned char __ATTRS_o_ai
1378 vec_vandc(vector unsigned char __a, vector unsigned char __b) {
1379  return __a & ~__b;
1380 }
1381 
1382 static __inline__ vector unsigned char __ATTRS_o_ai
1383 vec_vandc(vector bool char __a, vector unsigned char __b) {
1384  return (vector unsigned char)__a & ~__b;
1385 }
1386 
1387 static __inline__ vector unsigned char __ATTRS_o_ai
1388 vec_vandc(vector unsigned char __a, vector bool char __b) {
1389  return __a & ~(vector unsigned char)__b;
1390 }
1391 
1392 static __inline__ vector bool char __ATTRS_o_ai
1393 vec_vandc(vector bool char __a, vector bool char __b) {
1394  return __a & ~__b;
1395 }
1396 
1397 static __inline__ vector short __ATTRS_o_ai vec_vandc(vector short __a,
1398  vector short __b) {
1399  return __a & ~__b;
1400 }
1401 
1402 static __inline__ vector short __ATTRS_o_ai vec_vandc(vector bool short __a,
1403  vector short __b) {
1404  return (vector short)__a & ~__b;
1405 }
1406 
1407 static __inline__ vector short __ATTRS_o_ai vec_vandc(vector short __a,
1408  vector bool short __b) {
1409  return __a & ~(vector short)__b;
1410 }
1411 
1412 static __inline__ vector unsigned short __ATTRS_o_ai
1413 vec_vandc(vector unsigned short __a, vector unsigned short __b) {
1414  return __a & ~__b;
1415 }
1416 
1417 static __inline__ vector unsigned short __ATTRS_o_ai
1418 vec_vandc(vector bool short __a, vector unsigned short __b) {
1419  return (vector unsigned short)__a & ~__b;
1420 }
1421 
1422 static __inline__ vector unsigned short __ATTRS_o_ai
1423 vec_vandc(vector unsigned short __a, vector bool short __b) {
1424  return __a & ~(vector unsigned short)__b;
1425 }
1426 
1427 static __inline__ vector bool short __ATTRS_o_ai
1428 vec_vandc(vector bool short __a, vector bool short __b) {
1429  return __a & ~__b;
1430 }
1431 
1432 static __inline__ vector int __ATTRS_o_ai vec_vandc(vector int __a,
1433  vector int __b) {
1434  return __a & ~__b;
1435 }
1436 
1437 static __inline__ vector int __ATTRS_o_ai vec_vandc(vector bool int __a,
1438  vector int __b) {
1439  return (vector int)__a & ~__b;
1440 }
1441 
1442 static __inline__ vector int __ATTRS_o_ai vec_vandc(vector int __a,
1443  vector bool int __b) {
1444  return __a & ~(vector int)__b;
1445 }
1446 
1447 static __inline__ vector unsigned int __ATTRS_o_ai
1448 vec_vandc(vector unsigned int __a, vector unsigned int __b) {
1449  return __a & ~__b;
1450 }
1451 
1452 static __inline__ vector unsigned int __ATTRS_o_ai
1453 vec_vandc(vector bool int __a, vector unsigned int __b) {
1454  return (vector unsigned int)__a & ~__b;
1455 }
1456 
1457 static __inline__ vector unsigned int __ATTRS_o_ai
1458 vec_vandc(vector unsigned int __a, vector bool int __b) {
1459  return __a & ~(vector unsigned int)__b;
1460 }
1461 
1462 static __inline__ vector bool int __ATTRS_o_ai vec_vandc(vector bool int __a,
1463  vector bool int __b) {
1464  return __a & ~__b;
1465 }
1466 
1467 static __inline__ vector float __ATTRS_o_ai vec_vandc(vector float __a,
1468  vector float __b) {
1469  vector unsigned int __res =
1470  (vector unsigned int)__a & ~(vector unsigned int)__b;
1471  return (vector float)__res;
1472 }
1473 
1474 static __inline__ vector float __ATTRS_o_ai vec_vandc(vector bool int __a,
1475  vector float __b) {
1476  vector unsigned int __res =
1477  (vector unsigned int)__a & ~(vector unsigned int)__b;
1478  return (vector float)__res;
1479 }
1480 
1481 static __inline__ vector float __ATTRS_o_ai vec_vandc(vector float __a,
1482  vector bool int __b) {
1483  vector unsigned int __res =
1484  (vector unsigned int)__a & ~(vector unsigned int)__b;
1485  return (vector float)__res;
1486 }
1487 
1488 #ifdef __VSX__
1489 static __inline__ vector signed long long __ATTRS_o_ai
1490 vec_vandc(vector signed long long __a, vector signed long long __b) {
1491  return __a & ~__b;
1492 }
1493 
1494 static __inline__ vector signed long long __ATTRS_o_ai
1495 vec_vandc(vector bool long long __a, vector signed long long __b) {
1496  return (vector signed long long)__a & ~__b;
1497 }
1498 
1499 static __inline__ vector signed long long __ATTRS_o_ai
1500 vec_vandc(vector signed long long __a, vector bool long long __b) {
1501  return __a & ~(vector signed long long)__b;
1502 }
1503 
1504 static __inline__ vector unsigned long long __ATTRS_o_ai
1505 vec_vandc(vector unsigned long long __a, vector unsigned long long __b) {
1506  return __a & ~__b;
1507 }
1508 
1509 static __inline__ vector unsigned long long __ATTRS_o_ai
1510 vec_vandc(vector bool long long __a, vector unsigned long long __b) {
1511  return (vector unsigned long long)__a & ~__b;
1512 }
1513 
1514 static __inline__ vector unsigned long long __ATTRS_o_ai
1515 vec_vandc(vector unsigned long long __a, vector bool long long __b) {
1516  return __a & ~(vector unsigned long long)__b;
1517 }
1518 
1519 static __inline__ vector bool long long __ATTRS_o_ai
1520 vec_vandc(vector bool long long __a, vector bool long long __b) {
1521  return __a & ~__b;
1522 }
1523 #endif
1524 
1525 /* vec_avg */
1526 
1527 static __inline__ vector signed char __ATTRS_o_ai
1528 vec_avg(vector signed char __a, vector signed char __b) {
1529  return __builtin_altivec_vavgsb(__a, __b);
1530 }
1531 
1532 static __inline__ vector unsigned char __ATTRS_o_ai
1533 vec_avg(vector unsigned char __a, vector unsigned char __b) {
1534  return __builtin_altivec_vavgub(__a, __b);
1535 }
1536 
1537 static __inline__ vector short __ATTRS_o_ai vec_avg(vector short __a,
1538  vector short __b) {
1539  return __builtin_altivec_vavgsh(__a, __b);
1540 }
1541 
1542 static __inline__ vector unsigned short __ATTRS_o_ai
1543 vec_avg(vector unsigned short __a, vector unsigned short __b) {
1544  return __builtin_altivec_vavguh(__a, __b);
1545 }
1546 
1547 static __inline__ vector int __ATTRS_o_ai vec_avg(vector int __a,
1548  vector int __b) {
1549  return __builtin_altivec_vavgsw(__a, __b);
1550 }
1551 
1552 static __inline__ vector unsigned int __ATTRS_o_ai
1553 vec_avg(vector unsigned int __a, vector unsigned int __b) {
1554  return __builtin_altivec_vavguw(__a, __b);
1555 }
1556 
1557 /* vec_vavgsb */
1558 
1559 static __inline__ vector signed char __attribute__((__always_inline__))
1560 vec_vavgsb(vector signed char __a, vector signed char __b) {
1561  return __builtin_altivec_vavgsb(__a, __b);
1562 }
1563 
1564 /* vec_vavgub */
1565 
1566 static __inline__ vector unsigned char __attribute__((__always_inline__))
1567 vec_vavgub(vector unsigned char __a, vector unsigned char __b) {
1568  return __builtin_altivec_vavgub(__a, __b);
1569 }
1570 
1571 /* vec_vavgsh */
1572 
1573 static __inline__ vector short __attribute__((__always_inline__))
1574 vec_vavgsh(vector short __a, vector short __b) {
1575  return __builtin_altivec_vavgsh(__a, __b);
1576 }
1577 
1578 /* vec_vavguh */
1579 
1580 static __inline__ vector unsigned short __attribute__((__always_inline__))
1581 vec_vavguh(vector unsigned short __a, vector unsigned short __b) {
1582  return __builtin_altivec_vavguh(__a, __b);
1583 }
1584 
1585 /* vec_vavgsw */
1586 
1587 static __inline__ vector int __attribute__((__always_inline__))
1588 vec_vavgsw(vector int __a, vector int __b) {
1589  return __builtin_altivec_vavgsw(__a, __b);
1590 }
1591 
1592 /* vec_vavguw */
1593 
1594 static __inline__ vector unsigned int __attribute__((__always_inline__))
1595 vec_vavguw(vector unsigned int __a, vector unsigned int __b) {
1596  return __builtin_altivec_vavguw(__a, __b);
1597 }
1598 
1599 /* vec_ceil */
1600 
1601 static __inline__ vector float __ATTRS_o_ai vec_ceil(vector float __a) {
1602 #ifdef __VSX__
1603  return __builtin_vsx_xvrspip(__a);
1604 #else
1605  return __builtin_altivec_vrfip(__a);
1606 #endif
1607 }
1608 
1609 #ifdef __VSX__
1610 static __inline__ vector double __ATTRS_o_ai vec_ceil(vector double __a) {
1611  return __builtin_vsx_xvrdpip(__a);
1612 }
1613 #endif
1614 
1615 /* vec_vrfip */
1616 
1617 static __inline__ vector float __attribute__((__always_inline__))
1618 vec_vrfip(vector float __a) {
1619  return __builtin_altivec_vrfip(__a);
1620 }
1621 
1622 /* vec_cmpb */
1623 
1624 static __inline__ vector int __attribute__((__always_inline__))
1625 vec_cmpb(vector float __a, vector float __b) {
1626  return __builtin_altivec_vcmpbfp(__a, __b);
1627 }
1628 
1629 /* vec_vcmpbfp */
1630 
1631 static __inline__ vector int __attribute__((__always_inline__))
1632 vec_vcmpbfp(vector float __a, vector float __b) {
1633  return __builtin_altivec_vcmpbfp(__a, __b);
1634 }
1635 
1636 /* vec_cmpeq */
1637 
1638 static __inline__ vector bool char __ATTRS_o_ai
1639 vec_cmpeq(vector signed char __a, vector signed char __b) {
1640  return (vector bool char)__builtin_altivec_vcmpequb((vector char)__a,
1641  (vector char)__b);
1642 }
1643 
1644 static __inline__ vector bool char __ATTRS_o_ai
1645 vec_cmpeq(vector unsigned char __a, vector unsigned char __b) {
1646  return (vector bool char)__builtin_altivec_vcmpequb((vector char)__a,
1647  (vector char)__b);
1648 }
1649 
1650 static __inline__ vector bool char __ATTRS_o_ai
1651 vec_cmpeq(vector bool char __a, vector bool char __b) {
1652  return (vector bool char)__builtin_altivec_vcmpequb((vector char)__a,
1653  (vector char)__b);
1654 }
1655 
1656 static __inline__ vector bool short __ATTRS_o_ai vec_cmpeq(vector short __a,
1657  vector short __b) {
1658  return (vector bool short)__builtin_altivec_vcmpequh(__a, __b);
1659 }
1660 
1661 static __inline__ vector bool short __ATTRS_o_ai
1662 vec_cmpeq(vector unsigned short __a, vector unsigned short __b) {
1663  return (vector bool short)__builtin_altivec_vcmpequh((vector short)__a,
1664  (vector short)__b);
1665 }
1666 
1667 static __inline__ vector bool short __ATTRS_o_ai
1668 vec_cmpeq(vector bool short __a, vector bool short __b) {
1669  return (vector bool short)__builtin_altivec_vcmpequh((vector short)__a,
1670  (vector short)__b);
1671 }
1672 
1673 static __inline__ vector bool int __ATTRS_o_ai vec_cmpeq(vector int __a,
1674  vector int __b) {
1675  return (vector bool int)__builtin_altivec_vcmpequw(__a, __b);
1676 }
1677 
1678 static __inline__ vector bool int __ATTRS_o_ai
1679 vec_cmpeq(vector unsigned int __a, vector unsigned int __b) {
1680  return (vector bool int)__builtin_altivec_vcmpequw((vector int)__a,
1681  (vector int)__b);
1682 }
1683 
1684 static __inline__ vector bool int __ATTRS_o_ai vec_cmpeq(vector bool int __a,
1685  vector bool int __b) {
1686  return (vector bool int)__builtin_altivec_vcmpequw((vector int)__a,
1687  (vector int)__b);
1688 }
1689 
1690 #ifdef __POWER8_VECTOR__
1691 static __inline__ vector bool long long __ATTRS_o_ai
1692 vec_cmpeq(vector signed long long __a, vector signed long long __b) {
1693  return (vector bool long long)__builtin_altivec_vcmpequd(__a, __b);
1694 }
1695 
1696 static __inline__ vector bool long long __ATTRS_o_ai
1697 vec_cmpeq(vector unsigned long long __a, vector unsigned long long __b) {
1698  return (vector bool long long)__builtin_altivec_vcmpequd(
1699  (vector long long)__a, (vector long long)__b);
1700 }
1701 
1702 static __inline__ vector bool long long __ATTRS_o_ai
1703 vec_cmpeq(vector bool long long __a, vector bool long long __b) {
1704  return (vector bool long long)__builtin_altivec_vcmpequd(
1705  (vector long long)__a, (vector long long)__b);
1706 }
1707 
1708 #endif
1709 
1710 static __inline__ vector bool int __ATTRS_o_ai vec_cmpeq(vector float __a,
1711  vector float __b) {
1712 #ifdef __VSX__
1713  return (vector bool int)__builtin_vsx_xvcmpeqsp(__a, __b);
1714 #else
1715  return (vector bool int)__builtin_altivec_vcmpeqfp(__a, __b);
1716 #endif
1717 }
1718 
1719 #ifdef __VSX__
1720 static __inline__ vector bool long long __ATTRS_o_ai
1721 vec_cmpeq(vector double __a, vector double __b) {
1722  return (vector bool long long)__builtin_vsx_xvcmpeqdp(__a, __b);
1723 }
1724 #endif
1725 
1726 #ifdef __POWER9_VECTOR__
1727 /* vec_cmpne */
1728 
1729 static __inline__ vector bool char __ATTRS_o_ai
1730 vec_cmpne(vector bool char __a, vector bool char __b) {
1731  return (vector bool char)__builtin_altivec_vcmpneb((vector char)__a,
1732  (vector char)__b);
1733 }
1734 
1735 static __inline__ vector bool char __ATTRS_o_ai
1736 vec_cmpne(vector signed char __a, vector signed char __b) {
1737  return (vector bool char)__builtin_altivec_vcmpneb((vector char)__a,
1738  (vector char)__b);
1739 }
1740 
1741 static __inline__ vector bool char __ATTRS_o_ai
1742 vec_cmpne(vector unsigned char __a, vector unsigned char __b) {
1743  return (vector bool char)__builtin_altivec_vcmpneb((vector char)__a,
1744  (vector char)__b);
1745 }
1746 
1747 static __inline__ vector bool short __ATTRS_o_ai
1748 vec_cmpne(vector bool short __a, vector bool short __b) {
1749  return (vector bool short)__builtin_altivec_vcmpneh((vector short)__a,
1750  (vector short)__b);
1751 }
1752 
1753 static __inline__ vector bool short __ATTRS_o_ai
1754 vec_cmpne(vector signed short __a, vector signed short __b) {
1755  return (vector bool short)__builtin_altivec_vcmpneh((vector short)__a,
1756  (vector short)__b);
1757 }
1758 
1759 static __inline__ vector bool short __ATTRS_o_ai
1760 vec_cmpne(vector unsigned short __a, vector unsigned short __b) {
1761  return (vector bool short)__builtin_altivec_vcmpneh((vector short)__a,
1762  (vector short)__b);
1763 }
1764 
1765 static __inline__ vector bool int __ATTRS_o_ai
1766 vec_cmpne(vector bool int __a, vector bool int __b) {
1767  return (vector bool int)__builtin_altivec_vcmpnew((vector int)__a,
1768  (vector int)__b);
1769 }
1770 
1771 static __inline__ vector bool int __ATTRS_o_ai
1772 vec_cmpne(vector signed int __a, vector signed int __b) {
1773  return (vector bool int)__builtin_altivec_vcmpnew((vector int)__a,
1774  (vector int)__b);
1775 }
1776 
1777 static __inline__ vector bool int __ATTRS_o_ai
1778 vec_cmpne(vector unsigned int __a, vector unsigned int __b) {
1779  return (vector bool int)__builtin_altivec_vcmpnew((vector int)__a,
1780  (vector int)__b);
1781 }
1782 
1783 static __inline__ vector bool long long __ATTRS_o_ai
1784 vec_cmpne(vector bool long long __a, vector bool long long __b) {
1785  return (vector bool long long)
1786  ~(__builtin_altivec_vcmpequd((vector long long)__a, (vector long long)__b));
1787 }
1788 
1789 static __inline__ vector bool long long __ATTRS_o_ai
1790 vec_cmpne(vector signed long long __a, vector signed long long __b) {
1791  return (vector bool long long)
1792  ~(__builtin_altivec_vcmpequd((vector long long)__a, (vector long long)__b));
1793 }
1794 
1795 static __inline__ vector bool long long __ATTRS_o_ai
1796 vec_cmpne(vector unsigned long long __a, vector unsigned long long __b) {
1797  return (vector bool long long)
1798  ~(__builtin_altivec_vcmpequd((vector long long)__a, (vector long long)__b));
1799 }
1800 
1801 static __inline__ vector bool int __ATTRS_o_ai
1802 vec_cmpne(vector float __a, vector float __b) {
1803  return (vector bool int)__builtin_altivec_vcmpnew((vector int)__a,
1804  (vector int)__b);
1805 }
1806 
1807 static __inline__ vector bool long long __ATTRS_o_ai
1808 vec_cmpne(vector double __a, vector double __b) {
1809  return (vector bool long long)
1810  ~(__builtin_altivec_vcmpequd((vector long long)__a, (vector long long)__b));
1811 }
1812 
1813 /* vec_cmpnez */
1814 
1815 static __inline__ vector bool char __ATTRS_o_ai
1816 vec_cmpnez(vector signed char __a, vector signed char __b) {
1817  return (vector bool char)__builtin_altivec_vcmpnezb((vector char)__a,
1818  (vector char)__b);
1819 }
1820 
1821 static __inline__ vector bool char __ATTRS_o_ai
1822 vec_cmpnez(vector unsigned char __a, vector unsigned char __b) {
1823  return (vector bool char)__builtin_altivec_vcmpnezb((vector char)__a,
1824  (vector char)__b);
1825 }
1826 
1827 static __inline__ vector bool short __ATTRS_o_ai
1828 vec_cmpnez(vector signed short __a, vector signed short __b) {
1829  return (vector bool short)__builtin_altivec_vcmpnezh((vector short)__a,
1830  (vector short)__b);
1831 }
1832 
1833 static __inline__ vector bool short __ATTRS_o_ai
1834 vec_cmpnez(vector unsigned short __a, vector unsigned short __b) {
1835  return (vector bool short)__builtin_altivec_vcmpnezh((vector short)__a,
1836  (vector short)__b);
1837 }
1838 
1839 static __inline__ vector bool int __ATTRS_o_ai
1840 vec_cmpnez(vector signed int __a, vector signed int __b) {
1841  return (vector bool int)__builtin_altivec_vcmpnezw((vector int)__a,
1842  (vector int)__b);
1843 }
1844 
1845 static __inline__ vector bool int __ATTRS_o_ai
1846 vec_cmpnez(vector unsigned int __a, vector unsigned int __b) {
1847  return (vector bool int)__builtin_altivec_vcmpnezw((vector int)__a,
1848  (vector int)__b);
1849 }
1850 
1851 static __inline__ signed int __ATTRS_o_ai
1852 vec_cntlz_lsbb(vector signed char __a) {
1853 #ifdef __LITTLE_ENDIAN__
1854  return __builtin_altivec_vctzlsbb(__a);
1855 #else
1856  return __builtin_altivec_vclzlsbb(__a);
1857 #endif
1858 }
1859 
1860 static __inline__ signed int __ATTRS_o_ai
1861 vec_cntlz_lsbb(vector unsigned char __a) {
1862 #ifdef __LITTLE_ENDIAN__
1863  return __builtin_altivec_vctzlsbb(__a);
1864 #else
1865  return __builtin_altivec_vclzlsbb(__a);
1866 #endif
1867 }
1868 
1869 static __inline__ signed int __ATTRS_o_ai
1870 vec_cnttz_lsbb(vector signed char __a) {
1871 #ifdef __LITTLE_ENDIAN__
1872  return __builtin_altivec_vclzlsbb(__a);
1873 #else
1874  return __builtin_altivec_vctzlsbb(__a);
1875 #endif
1876 }
1877 
1878 static __inline__ signed int __ATTRS_o_ai
1879 vec_cnttz_lsbb(vector unsigned char __a) {
1880 #ifdef __LITTLE_ENDIAN__
1881  return __builtin_altivec_vclzlsbb(__a);
1882 #else
1883  return __builtin_altivec_vctzlsbb(__a);
1884 #endif
1885 }
1886 
1887 static __inline__ vector unsigned int __ATTRS_o_ai
1888 vec_parity_lsbb(vector unsigned int __a) {
1889  return __builtin_altivec_vprtybw(__a);
1890 }
1891 
1892 static __inline__ vector unsigned int __ATTRS_o_ai
1893 vec_parity_lsbb(vector signed int __a) {
1894  return __builtin_altivec_vprtybw(__a);
1895 }
1896 
1897 static __inline__ vector unsigned __int128 __ATTRS_o_ai
1898 vec_parity_lsbb(vector unsigned __int128 __a) {
1899  return __builtin_altivec_vprtybq(__a);
1900 }
1901 
1902 static __inline__ vector unsigned __int128 __ATTRS_o_ai
1903 vec_parity_lsbb(vector signed __int128 __a) {
1904  return __builtin_altivec_vprtybq(__a);
1905 }
1906 
1907 static __inline__ vector unsigned long long __ATTRS_o_ai
1908 vec_parity_lsbb(vector unsigned long long __a) {
1909  return __builtin_altivec_vprtybd(__a);
1910 }
1911 
1912 static __inline__ vector unsigned long long __ATTRS_o_ai
1913 vec_parity_lsbb(vector signed long long __a) {
1914  return __builtin_altivec_vprtybd(__a);
1915 }
1916 
1917 #endif
1918 
1919 /* vec_cmpgt */
1920 
1921 static __inline__ vector bool char __ATTRS_o_ai
1922 vec_cmpgt(vector signed char __a, vector signed char __b) {
1923  return (vector bool char)__builtin_altivec_vcmpgtsb(__a, __b);
1924 }
1925 
1926 static __inline__ vector bool char __ATTRS_o_ai
1927 vec_cmpgt(vector unsigned char __a, vector unsigned char __b) {
1928  return (vector bool char)__builtin_altivec_vcmpgtub(__a, __b);
1929 }
1930 
1931 static __inline__ vector bool short __ATTRS_o_ai vec_cmpgt(vector short __a,
1932  vector short __b) {
1933  return (vector bool short)__builtin_altivec_vcmpgtsh(__a, __b);
1934 }
1935 
1936 static __inline__ vector bool short __ATTRS_o_ai
1937 vec_cmpgt(vector unsigned short __a, vector unsigned short __b) {
1938  return (vector bool short)__builtin_altivec_vcmpgtuh(__a, __b);
1939 }
1940 
1941 static __inline__ vector bool int __ATTRS_o_ai vec_cmpgt(vector int __a,
1942  vector int __b) {
1943  return (vector bool int)__builtin_altivec_vcmpgtsw(__a, __b);
1944 }
1945 
1946 static __inline__ vector bool int __ATTRS_o_ai
1947 vec_cmpgt(vector unsigned int __a, vector unsigned int __b) {
1948  return (vector bool int)__builtin_altivec_vcmpgtuw(__a, __b);
1949 }
1950 
1951 #ifdef __POWER8_VECTOR__
1952 static __inline__ vector bool long long __ATTRS_o_ai
1953 vec_cmpgt(vector signed long long __a, vector signed long long __b) {
1954  return (vector bool long long)__builtin_altivec_vcmpgtsd(__a, __b);
1955 }
1956 
1957 static __inline__ vector bool long long __ATTRS_o_ai
1958 vec_cmpgt(vector unsigned long long __a, vector unsigned long long __b) {
1959  return (vector bool long long)__builtin_altivec_vcmpgtud(__a, __b);
1960 }
1961 #endif
1962 
1963 static __inline__ vector bool int __ATTRS_o_ai vec_cmpgt(vector float __a,
1964  vector float __b) {
1965 #ifdef __VSX__
1966  return (vector bool int)__builtin_vsx_xvcmpgtsp(__a, __b);
1967 #else
1968  return (vector bool int)__builtin_altivec_vcmpgtfp(__a, __b);
1969 #endif
1970 }
1971 
1972 #ifdef __VSX__
1973 static __inline__ vector bool long long __ATTRS_o_ai
1974 vec_cmpgt(vector double __a, vector double __b) {
1975  return (vector bool long long)__builtin_vsx_xvcmpgtdp(__a, __b);
1976 }
1977 #endif
1978 
1979 /* vec_cmpge */
1980 
1981 static __inline__ vector bool char __ATTRS_o_ai
1982 vec_cmpge(vector signed char __a, vector signed char __b) {
1983  return ~(vec_cmpgt(__b, __a));
1984 }
1985 
1986 static __inline__ vector bool char __ATTRS_o_ai
1987 vec_cmpge(vector unsigned char __a, vector unsigned char __b) {
1988  return ~(vec_cmpgt(__b, __a));
1989 }
1990 
1991 static __inline__ vector bool short __ATTRS_o_ai
1992 vec_cmpge(vector signed short __a, vector signed short __b) {
1993  return ~(vec_cmpgt(__b, __a));
1994 }
1995 
1996 static __inline__ vector bool short __ATTRS_o_ai
1997 vec_cmpge(vector unsigned short __a, vector unsigned short __b) {
1998  return ~(vec_cmpgt(__b, __a));
1999 }
2000 
2001 static __inline__ vector bool int __ATTRS_o_ai
2002 vec_cmpge(vector signed int __a, vector signed int __b) {
2003  return ~(vec_cmpgt(__b, __a));
2004 }
2005 
2006 static __inline__ vector bool int __ATTRS_o_ai
2007 vec_cmpge(vector unsigned int __a, vector unsigned int __b) {
2008  return ~(vec_cmpgt(__b, __a));
2009 }
2010 
2011 static __inline__ vector bool int __ATTRS_o_ai vec_cmpge(vector float __a,
2012  vector float __b) {
2013 #ifdef __VSX__
2014  return (vector bool int)__builtin_vsx_xvcmpgesp(__a, __b);
2015 #else
2016  return (vector bool int)__builtin_altivec_vcmpgefp(__a, __b);
2017 #endif
2018 }
2019 
2020 #ifdef __VSX__
2021 static __inline__ vector bool long long __ATTRS_o_ai
2022 vec_cmpge(vector double __a, vector double __b) {
2023  return (vector bool long long)__builtin_vsx_xvcmpgedp(__a, __b);
2024 }
2025 #endif
2026 
2027 #ifdef __POWER8_VECTOR__
2028 static __inline__ vector bool long long __ATTRS_o_ai
2029 vec_cmpge(vector signed long long __a, vector signed long long __b) {
2030  return ~(vec_cmpgt(__b, __a));
2031 }
2032 
2033 static __inline__ vector bool long long __ATTRS_o_ai
2034 vec_cmpge(vector unsigned long long __a, vector unsigned long long __b) {
2035  return ~(vec_cmpgt(__b, __a));
2036 }
2037 #endif
2038 
2039 /* vec_vcmpgefp */
2040 
2041 static __inline__ vector bool int __attribute__((__always_inline__))
2042 vec_vcmpgefp(vector float __a, vector float __b) {
2043  return (vector bool int)__builtin_altivec_vcmpgefp(__a, __b);
2044 }
2045 
2046 /* vec_vcmpgtsb */
2047 
2048 static __inline__ vector bool char __attribute__((__always_inline__))
2049 vec_vcmpgtsb(vector signed char __a, vector signed char __b) {
2050  return (vector bool char)__builtin_altivec_vcmpgtsb(__a, __b);
2051 }
2052 
2053 /* vec_vcmpgtub */
2054 
2055 static __inline__ vector bool char __attribute__((__always_inline__))
2056 vec_vcmpgtub(vector unsigned char __a, vector unsigned char __b) {
2057  return (vector bool char)__builtin_altivec_vcmpgtub(__a, __b);
2058 }
2059 
2060 /* vec_vcmpgtsh */
2061 
2062 static __inline__ vector bool short __attribute__((__always_inline__))
2063 vec_vcmpgtsh(vector short __a, vector short __b) {
2064  return (vector bool short)__builtin_altivec_vcmpgtsh(__a, __b);
2065 }
2066 
2067 /* vec_vcmpgtuh */
2068 
2069 static __inline__ vector bool short __attribute__((__always_inline__))
2070 vec_vcmpgtuh(vector unsigned short __a, vector unsigned short __b) {
2071  return (vector bool short)__builtin_altivec_vcmpgtuh(__a, __b);
2072 }
2073 
2074 /* vec_vcmpgtsw */
2075 
2076 static __inline__ vector bool int __attribute__((__always_inline__))
2077 vec_vcmpgtsw(vector int __a, vector int __b) {
2078  return (vector bool int)__builtin_altivec_vcmpgtsw(__a, __b);
2079 }
2080 
2081 /* vec_vcmpgtuw */
2082 
2083 static __inline__ vector bool int __attribute__((__always_inline__))
2084 vec_vcmpgtuw(vector unsigned int __a, vector unsigned int __b) {
2085  return (vector bool int)__builtin_altivec_vcmpgtuw(__a, __b);
2086 }
2087 
2088 /* vec_vcmpgtfp */
2089 
2090 static __inline__ vector bool int __attribute__((__always_inline__))
2091 vec_vcmpgtfp(vector float __a, vector float __b) {
2092  return (vector bool int)__builtin_altivec_vcmpgtfp(__a, __b);
2093 }
2094 
2095 /* vec_cmple */
2096 
2097 static __inline__ vector bool char __ATTRS_o_ai
2098 vec_cmple(vector signed char __a, vector signed char __b) {
2099  return vec_cmpge(__b, __a);
2100 }
2101 
2102 static __inline__ vector bool char __ATTRS_o_ai
2103 vec_cmple(vector unsigned char __a, vector unsigned char __b) {
2104  return vec_cmpge(__b, __a);
2105 }
2106 
2107 static __inline__ vector bool short __ATTRS_o_ai
2108 vec_cmple(vector signed short __a, vector signed short __b) {
2109  return vec_cmpge(__b, __a);
2110 }
2111 
2112 static __inline__ vector bool short __ATTRS_o_ai
2113 vec_cmple(vector unsigned short __a, vector unsigned short __b) {
2114  return vec_cmpge(__b, __a);
2115 }
2116 
2117 static __inline__ vector bool int __ATTRS_o_ai
2118 vec_cmple(vector signed int __a, vector signed int __b) {
2119  return vec_cmpge(__b, __a);
2120 }
2121 
2122 static __inline__ vector bool int __ATTRS_o_ai
2123 vec_cmple(vector unsigned int __a, vector unsigned int __b) {
2124  return vec_cmpge(__b, __a);
2125 }
2126 
2127 static __inline__ vector bool int __ATTRS_o_ai vec_cmple(vector float __a,
2128  vector float __b) {
2129  return vec_cmpge(__b, __a);
2130 }
2131 
2132 #ifdef __VSX__
2133 static __inline__ vector bool long long __ATTRS_o_ai
2134 vec_cmple(vector double __a, vector double __b) {
2135  return vec_cmpge(__b, __a);
2136 }
2137 #endif
2138 
2139 #ifdef __POWER8_VECTOR__
2140 static __inline__ vector bool long long __ATTRS_o_ai
2141 vec_cmple(vector signed long long __a, vector signed long long __b) {
2142  return vec_cmpge(__b, __a);
2143 }
2144 
2145 static __inline__ vector bool long long __ATTRS_o_ai
2146 vec_cmple(vector unsigned long long __a, vector unsigned long long __b) {
2147  return vec_cmpge(__b, __a);
2148 }
2149 #endif
2150 
2151 /* vec_cmplt */
2152 
2153 static __inline__ vector bool char __ATTRS_o_ai
2154 vec_cmplt(vector signed char __a, vector signed char __b) {
2155  return vec_cmpgt(__b, __a);
2156 }
2157 
2158 static __inline__ vector bool char __ATTRS_o_ai
2159 vec_cmplt(vector unsigned char __a, vector unsigned char __b) {
2160  return vec_cmpgt(__b, __a);
2161 }
2162 
2163 static __inline__ vector bool short __ATTRS_o_ai vec_cmplt(vector short __a,
2164  vector short __b) {
2165  return vec_cmpgt(__b, __a);
2166 }
2167 
2168 static __inline__ vector bool short __ATTRS_o_ai
2169 vec_cmplt(vector unsigned short __a, vector unsigned short __b) {
2170  return vec_cmpgt(__b, __a);
2171 }
2172 
2173 static __inline__ vector bool int __ATTRS_o_ai vec_cmplt(vector int __a,
2174  vector int __b) {
2175  return vec_cmpgt(__b, __a);
2176 }
2177 
2178 static __inline__ vector bool int __ATTRS_o_ai
2179 vec_cmplt(vector unsigned int __a, vector unsigned int __b) {
2180  return vec_cmpgt(__b, __a);
2181 }
2182 
2183 static __inline__ vector bool int __ATTRS_o_ai vec_cmplt(vector float __a,
2184  vector float __b) {
2185  return vec_cmpgt(__b, __a);
2186 }
2187 
2188 #ifdef __VSX__
2189 static __inline__ vector bool long long __ATTRS_o_ai
2190 vec_cmplt(vector double __a, vector double __b) {
2191  return vec_cmpgt(__b, __a);
2192 }
2193 #endif
2194 
2195 #ifdef __POWER8_VECTOR__
2196 static __inline__ vector bool long long __ATTRS_o_ai
2197 vec_cmplt(vector signed long long __a, vector signed long long __b) {
2198  return vec_cmpgt(__b, __a);
2199 }
2200 
2201 static __inline__ vector bool long long __ATTRS_o_ai
2202 vec_cmplt(vector unsigned long long __a, vector unsigned long long __b) {
2203  return vec_cmpgt(__b, __a);
2204 }
2205 
2206 /* vec_popcnt */
2207 
2208 static __inline__ vector signed char __ATTRS_o_ai
2209 vec_popcnt(vector signed char __a) {
2210  return __builtin_altivec_vpopcntb(__a);
2211 }
2212 static __inline__ vector unsigned char __ATTRS_o_ai
2213 vec_popcnt(vector unsigned char __a) {
2214  return __builtin_altivec_vpopcntb(__a);
2215 }
2216 static __inline__ vector signed short __ATTRS_o_ai
2217 vec_popcnt(vector signed short __a) {
2218  return __builtin_altivec_vpopcnth(__a);
2219 }
2220 static __inline__ vector unsigned short __ATTRS_o_ai
2221 vec_popcnt(vector unsigned short __a) {
2222  return __builtin_altivec_vpopcnth(__a);
2223 }
2224 static __inline__ vector signed int __ATTRS_o_ai
2225 vec_popcnt(vector signed int __a) {
2226  return __builtin_altivec_vpopcntw(__a);
2227 }
2228 static __inline__ vector unsigned int __ATTRS_o_ai
2229 vec_popcnt(vector unsigned int __a) {
2230  return __builtin_altivec_vpopcntw(__a);
2231 }
2232 static __inline__ vector signed long long __ATTRS_o_ai
2233 vec_popcnt(vector signed long long __a) {
2234  return __builtin_altivec_vpopcntd(__a);
2235 }
2236 static __inline__ vector unsigned long long __ATTRS_o_ai
2237 vec_popcnt(vector unsigned long long __a) {
2238  return __builtin_altivec_vpopcntd(__a);
2239 }
2240 
2241 /* vec_cntlz */
2242 
2243 static __inline__ vector signed char __ATTRS_o_ai
2244 vec_cntlz(vector signed char __a) {
2245  return __builtin_altivec_vclzb(__a);
2246 }
2247 static __inline__ vector unsigned char __ATTRS_o_ai
2248 vec_cntlz(vector unsigned char __a) {
2249  return __builtin_altivec_vclzb(__a);
2250 }
2251 static __inline__ vector signed short __ATTRS_o_ai
2252 vec_cntlz(vector signed short __a) {
2253  return __builtin_altivec_vclzh(__a);
2254 }
2255 static __inline__ vector unsigned short __ATTRS_o_ai
2256 vec_cntlz(vector unsigned short __a) {
2257  return __builtin_altivec_vclzh(__a);
2258 }
2259 static __inline__ vector signed int __ATTRS_o_ai
2260 vec_cntlz(vector signed int __a) {
2261  return __builtin_altivec_vclzw(__a);
2262 }
2263 static __inline__ vector unsigned int __ATTRS_o_ai
2264 vec_cntlz(vector unsigned int __a) {
2265  return __builtin_altivec_vclzw(__a);
2266 }
2267 static __inline__ vector signed long long __ATTRS_o_ai
2268 vec_cntlz(vector signed long long __a) {
2269  return __builtin_altivec_vclzd(__a);
2270 }
2271 static __inline__ vector unsigned long long __ATTRS_o_ai
2272 vec_cntlz(vector unsigned long long __a) {
2273  return __builtin_altivec_vclzd(__a);
2274 }
2275 #endif
2276 
2277 #ifdef __POWER9_VECTOR__
2278 
2279 /* vec_cnttz */
2280 
2281 static __inline__ vector signed char __ATTRS_o_ai
2282 vec_cnttz(vector signed char __a) {
2283  return __builtin_altivec_vctzb(__a);
2284 }
2285 static __inline__ vector unsigned char __ATTRS_o_ai
2286 vec_cnttz(vector unsigned char __a) {
2287  return __builtin_altivec_vctzb(__a);
2288 }
2289 static __inline__ vector signed short __ATTRS_o_ai
2290 vec_cnttz(vector signed short __a) {
2291  return __builtin_altivec_vctzh(__a);
2292 }
2293 static __inline__ vector unsigned short __ATTRS_o_ai
2294 vec_cnttz(vector unsigned short __a) {
2295  return __builtin_altivec_vctzh(__a);
2296 }
2297 static __inline__ vector signed int __ATTRS_o_ai
2298 vec_cnttz(vector signed int __a) {
2299  return __builtin_altivec_vctzw(__a);
2300 }
2301 static __inline__ vector unsigned int __ATTRS_o_ai
2302 vec_cnttz(vector unsigned int __a) {
2303  return __builtin_altivec_vctzw(__a);
2304 }
2305 static __inline__ vector signed long long __ATTRS_o_ai
2306 vec_cnttz(vector signed long long __a) {
2307  return __builtin_altivec_vctzd(__a);
2308 }
2309 static __inline__ vector unsigned long long __ATTRS_o_ai
2310 vec_cnttz(vector unsigned long long __a) {
2311  return __builtin_altivec_vctzd(__a);
2312 }
2313 
2314 /* vec_first_match_index */
2315 
2316 static __inline__ unsigned __ATTRS_o_ai
2317 vec_first_match_index(vector signed char __a, vector signed char __b) {
2318  vector unsigned long long __res =
2319 #ifdef __LITTLE_ENDIAN__
2320  vec_cnttz((vector unsigned long long)vec_cmpeq(__a, __b));
2321 #else
2322  vec_cntlz((vector unsigned long long)vec_cmpeq(__a, __b));
2323 #endif
2324  if (__res[0] == 64) {
2325  return (__res[1] + 64) >> 3;
2326  }
2327  return __res[0] >> 3;
2328 }
2329 
2330 static __inline__ unsigned __ATTRS_o_ai
2331 vec_first_match_index(vector unsigned char __a, vector unsigned char __b) {
2332  vector unsigned long long __res =
2333 #ifdef __LITTLE_ENDIAN__
2334  vec_cnttz((vector unsigned long long)vec_cmpeq(__a, __b));
2335 #else
2336  vec_cntlz((vector unsigned long long)vec_cmpeq(__a, __b));
2337 #endif
2338  if (__res[0] == 64) {
2339  return (__res[1] + 64) >> 3;
2340  }
2341  return __res[0] >> 3;
2342 }
2343 
2344 static __inline__ unsigned __ATTRS_o_ai
2345 vec_first_match_index(vector signed short __a, vector signed short __b) {
2346  vector unsigned long long __res =
2347 #ifdef __LITTLE_ENDIAN__
2348  vec_cnttz((vector unsigned long long)vec_cmpeq(__a, __b));
2349 #else
2350  vec_cntlz((vector unsigned long long)vec_cmpeq(__a, __b));
2351 #endif
2352  if (__res[0] == 64) {
2353  return (__res[1] + 64) >> 4;
2354  }
2355  return __res[0] >> 4;
2356 }
2357 
2358 static __inline__ unsigned __ATTRS_o_ai
2359 vec_first_match_index(vector unsigned short __a, vector unsigned short __b) {
2360  vector unsigned long long __res =
2361 #ifdef __LITTLE_ENDIAN__
2362  vec_cnttz((vector unsigned long long)vec_cmpeq(__a, __b));
2363 #else
2364  vec_cntlz((vector unsigned long long)vec_cmpeq(__a, __b));
2365 #endif
2366  if (__res[0] == 64) {
2367  return (__res[1] + 64) >> 4;
2368  }
2369  return __res[0] >> 4;
2370 }
2371 
2372 static __inline__ unsigned __ATTRS_o_ai
2373 vec_first_match_index(vector signed int __a, vector signed int __b) {
2374  vector unsigned long long __res =
2375 #ifdef __LITTLE_ENDIAN__
2376  vec_cnttz((vector unsigned long long)vec_cmpeq(__a, __b));
2377 #else
2378  vec_cntlz((vector unsigned long long)vec_cmpeq(__a, __b));
2379 #endif
2380  if (__res[0] == 64) {
2381  return (__res[1] + 64) >> 5;
2382  }
2383  return __res[0] >> 5;
2384 }
2385 
2386 static __inline__ unsigned __ATTRS_o_ai
2387 vec_first_match_index(vector unsigned int __a, vector unsigned int __b) {
2388  vector unsigned long long __res =
2389 #ifdef __LITTLE_ENDIAN__
2390  vec_cnttz((vector unsigned long long)vec_cmpeq(__a, __b));
2391 #else
2392  vec_cntlz((vector unsigned long long)vec_cmpeq(__a, __b));
2393 #endif
2394  if (__res[0] == 64) {
2395  return (__res[1] + 64) >> 5;
2396  }
2397  return __res[0] >> 5;
2398 }
2399 
2400 /* vec_first_match_or_eos_index */
2401 
2402 static __inline__ unsigned __ATTRS_o_ai
2403 vec_first_match_or_eos_index(vector signed char __a, vector signed char __b) {
2404  /* Compare the result of the comparison of two vectors with either and OR the
2405  result. Either the elements are equal or one will equal the comparison
2406  result if either is zero.
2407  */
2408  vector bool char __tmp1 = vec_cmpeq(__a, __b);
2409  vector bool char __tmp2 = __tmp1 |
2410  vec_cmpeq((vector signed char)__tmp1, __a) |
2411  vec_cmpeq((vector signed char)__tmp1, __b);
2412 
2413  vector unsigned long long __res =
2414 #ifdef __LITTLE_ENDIAN__
2415  vec_cnttz((vector unsigned long long)__tmp2);
2416 #else
2417  vec_cntlz((vector unsigned long long)__tmp2);
2418 #endif
2419  if (__res[0] == 64) {
2420  return (__res[1] + 64) >> 3;
2421  }
2422  return __res[0] >> 3;
2423 }
2424 
2425 static __inline__ unsigned __ATTRS_o_ai
2426 vec_first_match_or_eos_index(vector unsigned char __a,
2427  vector unsigned char __b) {
2428  vector bool char __tmp1 = vec_cmpeq(__a, __b);
2429  vector bool char __tmp2 = __tmp1 |
2430  vec_cmpeq((vector unsigned char)__tmp1, __a) |
2431  vec_cmpeq((vector unsigned char)__tmp1, __b);
2432 
2433  vector unsigned long long __res =
2434 #ifdef __LITTLE_ENDIAN__
2435  vec_cnttz((vector unsigned long long)__tmp2);
2436 #else
2437  vec_cntlz((vector unsigned long long)__tmp2);
2438 #endif
2439  if (__res[0] == 64) {
2440  return (__res[1] + 64) >> 3;
2441  }
2442  return __res[0] >> 3;
2443 }
2444 
2445 static __inline__ unsigned __ATTRS_o_ai
2446 vec_first_match_or_eos_index(vector signed short __a, vector signed short __b) {
2447  vector bool short __tmp1 = vec_cmpeq(__a, __b);
2448  vector bool short __tmp2 = __tmp1 |
2449  vec_cmpeq((vector signed short)__tmp1, __a) |
2450  vec_cmpeq((vector signed short)__tmp1, __b);
2451 
2452  vector unsigned long long __res =
2453 #ifdef __LITTLE_ENDIAN__
2454  vec_cnttz((vector unsigned long long)__tmp2);
2455 #else
2456  vec_cntlz((vector unsigned long long)__tmp2);
2457 #endif
2458  if (__res[0] == 64) {
2459  return (__res[1] + 64) >> 4;
2460  }
2461  return __res[0] >> 4;
2462 }
2463 
2464 static __inline__ unsigned __ATTRS_o_ai
2465 vec_first_match_or_eos_index(vector unsigned short __a,
2466  vector unsigned short __b) {
2467  vector bool short __tmp1 = vec_cmpeq(__a, __b);
2468  vector bool short __tmp2 = __tmp1 |
2469  vec_cmpeq((vector unsigned short)__tmp1, __a) |
2470  vec_cmpeq((vector unsigned short)__tmp1, __b);
2471 
2472  vector unsigned long long __res =
2473 #ifdef __LITTLE_ENDIAN__
2474  vec_cnttz((vector unsigned long long)__tmp2);
2475 #else
2476  vec_cntlz((vector unsigned long long)__tmp2);
2477 #endif
2478  if (__res[0] == 64) {
2479  return (__res[1] + 64) >> 4;
2480  }
2481  return __res[0] >> 4;
2482 }
2483 
2484 static __inline__ unsigned __ATTRS_o_ai
2485 vec_first_match_or_eos_index(vector signed int __a, vector signed int __b) {
2486  vector bool int __tmp1 = vec_cmpeq(__a, __b);
2487  vector bool int __tmp2 = __tmp1 | vec_cmpeq((vector signed int)__tmp1, __a) |
2488  vec_cmpeq((vector signed int)__tmp1, __b);
2489 
2490  vector unsigned long long __res =
2491 #ifdef __LITTLE_ENDIAN__
2492  vec_cnttz((vector unsigned long long)__tmp2);
2493 #else
2494  vec_cntlz((vector unsigned long long)__tmp2);
2495 #endif
2496  if (__res[0] == 64) {
2497  return (__res[1] + 64) >> 5;
2498  }
2499  return __res[0] >> 5;
2500 }
2501 
2502 static __inline__ unsigned __ATTRS_o_ai
2503 vec_first_match_or_eos_index(vector unsigned int __a, vector unsigned int __b) {
2504  vector bool int __tmp1 = vec_cmpeq(__a, __b);
2505  vector bool int __tmp2 = __tmp1 |
2506  vec_cmpeq((vector unsigned int)__tmp1, __a) |
2507  vec_cmpeq((vector unsigned int)__tmp1, __b);
2508 
2509  vector unsigned long long __res =
2510 #ifdef __LITTLE_ENDIAN__
2511  vec_cnttz((vector unsigned long long)__tmp2);
2512 #else
2513  vec_cntlz((vector unsigned long long)__tmp2);
2514 #endif
2515  if (__res[0] == 64) {
2516  return (__res[1] + 64) >> 5;
2517  }
2518  return __res[0] >> 5;
2519 }
2520 
2521 /* vec_first_mismatch_index */
2522 
2523 static __inline__ unsigned __ATTRS_o_ai
2524 vec_first_mismatch_index(vector signed char __a, vector signed char __b) {
2525  vector unsigned long long __res =
2526 #ifdef __LITTLE_ENDIAN__
2527  vec_cnttz((vector unsigned long long)vec_cmpne(__a, __b));
2528 #else
2529  vec_cntlz((vector unsigned long long)vec_cmpne(__a, __b));
2530 #endif
2531  if (__res[0] == 64) {
2532  return (__res[1] + 64) >> 3;
2533  }
2534  return __res[0] >> 3;
2535 }
2536 
2537 static __inline__ unsigned __ATTRS_o_ai
2538 vec_first_mismatch_index(vector unsigned char __a, vector unsigned char __b) {
2539  vector unsigned long long __res =
2540 #ifdef __LITTLE_ENDIAN__
2541  vec_cnttz((vector unsigned long long)vec_cmpne(__a, __b));
2542 #else
2543  vec_cntlz((vector unsigned long long)vec_cmpne(__a, __b));
2544 #endif
2545  if (__res[0] == 64) {
2546  return (__res[1] + 64) >> 3;
2547  }
2548  return __res[0] >> 3;
2549 }
2550 
2551 static __inline__ unsigned __ATTRS_o_ai
2552 vec_first_mismatch_index(vector signed short __a, vector signed short __b) {
2553  vector unsigned long long __res =
2554 #ifdef __LITTLE_ENDIAN__
2555  vec_cnttz((vector unsigned long long)vec_cmpne(__a, __b));
2556 #else
2557  vec_cntlz((vector unsigned long long)vec_cmpne(__a, __b));
2558 #endif
2559  if (__res[0] == 64) {
2560  return (__res[1] + 64) >> 4;
2561  }
2562  return __res[0] >> 4;
2563 }
2564 
2565 static __inline__ unsigned __ATTRS_o_ai
2566 vec_first_mismatch_index(vector unsigned short __a, vector unsigned short __b) {
2567  vector unsigned long long __res =
2568 #ifdef __LITTLE_ENDIAN__
2569  vec_cnttz((vector unsigned long long)vec_cmpne(__a, __b));
2570 #else
2571  vec_cntlz((vector unsigned long long)vec_cmpne(__a, __b));
2572 #endif
2573  if (__res[0] == 64) {
2574  return (__res[1] + 64) >> 4;
2575  }
2576  return __res[0] >> 4;
2577 }
2578 
2579 static __inline__ unsigned __ATTRS_o_ai
2580 vec_first_mismatch_index(vector signed int __a, vector signed int __b) {
2581  vector unsigned long long __res =
2582 #ifdef __LITTLE_ENDIAN__
2583  vec_cnttz((vector unsigned long long)vec_cmpne(__a, __b));
2584 #else
2585  vec_cntlz((vector unsigned long long)vec_cmpne(__a, __b));
2586 #endif
2587  if (__res[0] == 64) {
2588  return (__res[1] + 64) >> 5;
2589  }
2590  return __res[0] >> 5;
2591 }
2592 
2593 static __inline__ unsigned __ATTRS_o_ai
2594 vec_first_mismatch_index(vector unsigned int __a, vector unsigned int __b) {
2595  vector unsigned long long __res =
2596 #ifdef __LITTLE_ENDIAN__
2597  vec_cnttz((vector unsigned long long)vec_cmpne(__a, __b));
2598 #else
2599  vec_cntlz((vector unsigned long long)vec_cmpne(__a, __b));
2600 #endif
2601  if (__res[0] == 64) {
2602  return (__res[1] + 64) >> 5;
2603  }
2604  return __res[0] >> 5;
2605 }
2606 
2607 /* vec_first_mismatch_or_eos_index */
2608 
2609 static __inline__ unsigned __ATTRS_o_ai
2610 vec_first_mismatch_or_eos_index(vector signed char __a,
2611  vector signed char __b) {
2612  vector unsigned long long __res =
2613 #ifdef __LITTLE_ENDIAN__
2614  vec_cnttz((vector unsigned long long)vec_cmpnez(__a, __b));
2615 #else
2616  vec_cntlz((vector unsigned long long)vec_cmpnez(__a, __b));
2617 #endif
2618  if (__res[0] == 64) {
2619  return (__res[1] + 64) >> 3;
2620  }
2621  return __res[0] >> 3;
2622 }
2623 
2624 static __inline__ unsigned __ATTRS_o_ai
2625 vec_first_mismatch_or_eos_index(vector unsigned char __a,
2626  vector unsigned char __b) {
2627  vector unsigned long long __res =
2628 #ifdef __LITTLE_ENDIAN__
2629  vec_cnttz((vector unsigned long long)vec_cmpnez(__a, __b));
2630 #else
2631  vec_cntlz((vector unsigned long long)vec_cmpnez(__a, __b));
2632 #endif
2633  if (__res[0] == 64) {
2634  return (__res[1] + 64) >> 3;
2635  }
2636  return __res[0] >> 3;
2637 }
2638 
2639 static __inline__ unsigned __ATTRS_o_ai
2640 vec_first_mismatch_or_eos_index(vector signed short __a,
2641  vector signed short __b) {
2642  vector unsigned long long __res =
2643 #ifdef __LITTLE_ENDIAN__
2644  vec_cnttz((vector unsigned long long)vec_cmpnez(__a, __b));
2645 #else
2646  vec_cntlz((vector unsigned long long)vec_cmpnez(__a, __b));
2647 #endif
2648  if (__res[0] == 64) {
2649  return (__res[1] + 64) >> 4;
2650  }
2651  return __res[0] >> 4;
2652 }
2653 
2654 static __inline__ unsigned __ATTRS_o_ai
2655 vec_first_mismatch_or_eos_index(vector unsigned short __a,
2656  vector unsigned short __b) {
2657  vector unsigned long long __res =
2658 #ifdef __LITTLE_ENDIAN__
2659  vec_cnttz((vector unsigned long long)vec_cmpnez(__a, __b));
2660 #else
2661  vec_cntlz((vector unsigned long long)vec_cmpnez(__a, __b));
2662 #endif
2663  if (__res[0] == 64) {
2664  return (__res[1] + 64) >> 4;
2665  }
2666  return __res[0] >> 4;
2667 }
2668 
2669 static __inline__ unsigned __ATTRS_o_ai
2670 vec_first_mismatch_or_eos_index(vector signed int __a, vector signed int __b) {
2671  vector unsigned long long __res =
2672 #ifdef __LITTLE_ENDIAN__
2673  vec_cnttz((vector unsigned long long)vec_cmpnez(__a, __b));
2674 #else
2675  vec_cntlz((vector unsigned long long)vec_cmpnez(__a, __b));
2676 #endif
2677  if (__res[0] == 64) {
2678  return (__res[1] + 64) >> 5;
2679  }
2680  return __res[0] >> 5;
2681 }
2682 
2683 static __inline__ unsigned __ATTRS_o_ai
2684 vec_first_mismatch_or_eos_index(vector unsigned int __a,
2685  vector unsigned int __b) {
2686  vector unsigned long long __res =
2687 #ifdef __LITTLE_ENDIAN__
2688  vec_cnttz((vector unsigned long long)vec_cmpnez(__a, __b));
2689 #else
2690  vec_cntlz((vector unsigned long long)vec_cmpnez(__a, __b));
2691 #endif
2692  if (__res[0] == 64) {
2693  return (__res[1] + 64) >> 5;
2694  }
2695  return __res[0] >> 5;
2696 }
2697 
2698 static __inline__ vector double __ATTRS_o_ai
2699 vec_insert_exp(vector double __a, vector unsigned long long __b) {
2700  return __builtin_vsx_xviexpdp((vector unsigned long long)__a,__b);
2701 }
2702 
2703 static __inline__ vector double __ATTRS_o_ai
2704 vec_insert_exp(vector unsigned long long __a, vector unsigned long long __b) {
2705  return __builtin_vsx_xviexpdp(__a,__b);
2706 }
2707 
2708 static __inline__ vector float __ATTRS_o_ai
2709 vec_insert_exp(vector float __a, vector unsigned int __b) {
2710  return __builtin_vsx_xviexpsp((vector unsigned int)__a,__b);
2711 }
2712 
2713 static __inline__ vector float __ATTRS_o_ai
2714 vec_insert_exp(vector unsigned int __a, vector unsigned int __b) {
2715  return __builtin_vsx_xviexpsp(__a,__b);
2716 }
2717 
2718 #if defined(__powerpc64__)
2719 static __inline__ vector signed char __ATTRS_o_ai vec_xl_len(signed char *__a,
2720  size_t __b) {
2721  return (vector signed char)__builtin_vsx_lxvl(__a, (__b << 56));
2722 }
2723 
2724 static __inline__ vector unsigned char __ATTRS_o_ai
2725 vec_xl_len(unsigned char *__a, size_t __b) {
2726  return (vector unsigned char)__builtin_vsx_lxvl(__a, (__b << 56));
2727 }
2728 
2729 static __inline__ vector signed short __ATTRS_o_ai vec_xl_len(signed short *__a,
2730  size_t __b) {
2731  return (vector signed short)__builtin_vsx_lxvl(__a, (__b << 56));
2732 }
2733 
2734 static __inline__ vector unsigned short __ATTRS_o_ai
2735 vec_xl_len(unsigned short *__a, size_t __b) {
2736  return (vector unsigned short)__builtin_vsx_lxvl(__a, (__b << 56));
2737 }
2738 
2739 static __inline__ vector signed int __ATTRS_o_ai vec_xl_len(signed int *__a,
2740  size_t __b) {
2741  return (vector signed int)__builtin_vsx_lxvl(__a, (__b << 56));
2742 }
2743 
2744 static __inline__ vector unsigned int __ATTRS_o_ai vec_xl_len(unsigned int *__a,
2745  size_t __b) {
2746  return (vector unsigned int)__builtin_vsx_lxvl(__a, (__b << 56));
2747 }
2748 
2749 static __inline__ vector float __ATTRS_o_ai vec_xl_len(float *__a, size_t __b) {
2750  return (vector float)__builtin_vsx_lxvl(__a, (__b << 56));
2751 }
2752 
2753 static __inline__ vector signed __int128 __ATTRS_o_ai
2754 vec_xl_len(signed __int128 *__a, size_t __b) {
2755  return (vector signed __int128)__builtin_vsx_lxvl(__a, (__b << 56));
2756 }
2757 
2758 static __inline__ vector unsigned __int128 __ATTRS_o_ai
2759 vec_xl_len(unsigned __int128 *__a, size_t __b) {
2760  return (vector unsigned __int128)__builtin_vsx_lxvl(__a, (__b << 56));
2761 }
2762 
2763 static __inline__ vector signed long long __ATTRS_o_ai
2764 vec_xl_len(signed long long *__a, size_t __b) {
2765  return (vector signed long long)__builtin_vsx_lxvl(__a, (__b << 56));
2766 }
2767 
2768 static __inline__ vector unsigned long long __ATTRS_o_ai
2769 vec_xl_len(unsigned long long *__a, size_t __b) {
2770  return (vector unsigned long long)__builtin_vsx_lxvl(__a, (__b << 56));
2771 }
2772 
2773 static __inline__ vector double __ATTRS_o_ai vec_xl_len(double *__a,
2774  size_t __b) {
2775  return (vector double)__builtin_vsx_lxvl(__a, (__b << 56));
2776 }
2777 
2778 static __inline__ vector double __ATTRS_o_ai vec_xl_len_r(unsigned char *__a,
2779  size_t __b) {
2780  vector unsigned char __res =
2781  (vector unsigned char)__builtin_vsx_lxvll(__a, (__b << 56));
2782 #ifdef __LITTLE_ENDIAN__
2783  vector unsigned char __mask =
2784  (vector unsigned char)__builtin_altivec_lvsr(16 - __b, (int *)NULL);
2785  __res = (vector unsigned char)__builtin_altivec_vperm_4si(
2786  (vector int)__res, (vector int)__res, __mask);
2787 #endif
2788  return __res;
2789 }
2790 
2791 // vec_xst_len
2792 static __inline__ void __ATTRS_o_ai vec_xst_len(vector unsigned char __a,
2793  unsigned char *__b,
2794  size_t __c) {
2795  return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
2796 }
2797 
2798 static __inline__ void __ATTRS_o_ai vec_xst_len(vector signed char __a,
2799  signed char *__b, size_t __c) {
2800  return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
2801 }
2802 
2803 static __inline__ void __ATTRS_o_ai vec_xst_len(vector signed short __a,
2804  signed short *__b, size_t __c) {
2805  return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
2806 }
2807 
2808 static __inline__ void __ATTRS_o_ai vec_xst_len(vector unsigned short __a,
2809  unsigned short *__b,
2810  size_t __c) {
2811  return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
2812 }
2813 
2814 static __inline__ void __ATTRS_o_ai vec_xst_len(vector signed int __a,
2815  signed int *__b, size_t __c) {
2816  return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
2817 }
2818 
2819 static __inline__ void __ATTRS_o_ai vec_xst_len(vector unsigned int __a,
2820  unsigned int *__b, size_t __c) {
2821  return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
2822 }
2823 
2824 static __inline__ void __ATTRS_o_ai vec_xst_len(vector float __a, float *__b,
2825  size_t __c) {
2826  return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
2827 }
2828 
2829 static __inline__ void __ATTRS_o_ai vec_xst_len(vector signed __int128 __a,
2830  signed __int128 *__b,
2831  size_t __c) {
2832  return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
2833 }
2834 
2835 static __inline__ void __ATTRS_o_ai vec_xst_len(vector unsigned __int128 __a,
2836  unsigned __int128 *__b,
2837  size_t __c) {
2838  return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
2839 }
2840 
2841 static __inline__ void __ATTRS_o_ai vec_xst_len(vector signed long long __a,
2842  signed long long *__b,
2843  size_t __c) {
2844  return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
2845 }
2846 
2847 static __inline__ void __ATTRS_o_ai vec_xst_len(vector unsigned long long __a,
2848  unsigned long long *__b,
2849  size_t __c) {
2850  return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
2851 }
2852 
2853 static __inline__ void __ATTRS_o_ai vec_xst_len(vector double __a, double *__b,
2854  size_t __c) {
2855  return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
2856 }
2857 
2858 static __inline__ void __ATTRS_o_ai vec_xst_len_r(vector unsigned char __a,
2859  unsigned char *__b,
2860  size_t __c) {
2861 #ifdef __LITTLE_ENDIAN__
2862  vector unsigned char __mask =
2863  (vector unsigned char)__builtin_altivec_lvsl(16 - __c, (int *)NULL);
2864  vector unsigned char __res =
2865  __builtin_altivec_vperm_4si((vector int)__a, (vector int)__a, __mask);
2866  return __builtin_vsx_stxvll((vector int)__res, __b, (__c << 56));
2867 #else
2868  return __builtin_vsx_stxvll((vector int)__a, __b, (__c << 56));
2869 #endif
2870 }
2871 #endif
2872 #endif
2873 
2874 /* vec_cpsgn */
2875 
2876 #ifdef __VSX__
2877 static __inline__ vector float __ATTRS_o_ai vec_cpsgn(vector float __a,
2878  vector float __b) {
2879  return __builtin_vsx_xvcpsgnsp(__a, __b);
2880 }
2881 
2882 static __inline__ vector double __ATTRS_o_ai vec_cpsgn(vector double __a,
2883  vector double __b) {
2884  return __builtin_vsx_xvcpsgndp(__a, __b);
2885 }
2886 #endif
2887 
2888 /* vec_ctf */
2889 
2890 #ifdef __VSX__
2891 #define vec_ctf(__a, __b) \
2892  _Generic((__a), vector int \
2893  : (vector float)__builtin_altivec_vcfsx((__a), (__b)), \
2894  vector unsigned int \
2895  : (vector float)__builtin_altivec_vcfux((vector int)(__a), (__b)), \
2896  vector unsigned long long \
2897  : (__builtin_convertvector((vector unsigned long long)(__a), \
2898  vector double) * \
2899  (vector double)(vector unsigned long long)((0x3ffULL - (__b)) \
2900  << 52)), \
2901  vector signed long long \
2902  : (__builtin_convertvector((vector signed long long)(__a), \
2903  vector double) * \
2904  (vector double)(vector unsigned long long)((0x3ffULL - (__b)) \
2905  << 52)))
2906 #else
2907 #define vec_ctf(__a, __b) \
2908  _Generic((__a), vector int \
2909  : (vector float)__builtin_altivec_vcfsx((__a), (__b)), \
2910  vector unsigned int \
2911  : (vector float)__builtin_altivec_vcfux((vector int)(__a), (__b)))
2912 #endif
2913 
2914 /* vec_vcfsx */
2915 
2916 #define vec_vcfux __builtin_altivec_vcfux
2917 
2918 /* vec_vcfux */
2919 
2920 #define vec_vcfsx(__a, __b) __builtin_altivec_vcfsx((vector int)(__a), (__b))
2921 
2922 /* vec_cts */
2923 
2924 #ifdef __VSX__
2925 #define vec_cts(__a, __b) \
2926  _Generic((__a), vector float \
2927  : __builtin_altivec_vctsxs((__a), (__b)), vector double \
2928  : __extension__({ \
2929  vector double __ret = \
2930  (__a) * \
2931  (vector double)(vector unsigned long long)((0x3ffULL + (__b)) \
2932  << 52); \
2933  __builtin_convertvector(__ret, vector signed long long); \
2934  }))
2935 #else
2936 #define vec_cts __builtin_altivec_vctsxs
2937 #endif
2938 
2939 /* vec_vctsxs */
2940 
2941 #define vec_vctsxs __builtin_altivec_vctsxs
2942 
2943 /* vec_ctu */
2944 
2945 #ifdef __VSX__
2946 #define vec_ctu(__a, __b) \
2947  _Generic((__a), vector float \
2948  : __builtin_altivec_vctuxs((__a), (__b)), vector double \
2949  : __extension__({ \
2950  vector double __ret = \
2951  (__a) * \
2952  (vector double)(vector unsigned long long)((0x3ffULL + __b) \
2953  << 52); \
2954  __builtin_convertvector(__ret, vector unsigned long long); \
2955  }))
2956 #else
2957 #define vec_ctu __builtin_altivec_vctuxs
2958 #endif
2959 
2960 /* vec_vctuxs */
2961 
2962 #define vec_vctuxs __builtin_altivec_vctuxs
2963 
2964 /* vec_signed */
2965 
2966 static __inline__ vector signed int __ATTRS_o_ai
2967 vec_sld(vector signed int, vector signed int, unsigned const int __c);
2968 
2969 static __inline__ vector signed int __ATTRS_o_ai
2970 vec_signed(vector float __a) {
2971  return __builtin_convertvector(__a, vector signed int);
2972 }
2973 
2974 #ifdef __VSX__
2975 static __inline__ vector signed long long __ATTRS_o_ai
2976 vec_signed(vector double __a) {
2977  return __builtin_convertvector(__a, vector signed long long);
2978 }
2979 
2980 static __inline__ vector signed int __attribute__((__always_inline__))
2981 vec_signed2(vector double __a, vector double __b) {
2982  return (vector signed int) { __a[0], __a[1], __b[0], __b[1] };
2983 }
2984 
2985 static __inline__ vector signed int __ATTRS_o_ai
2986 vec_signede(vector double __a) {
2987 #ifdef __LITTLE_ENDIAN__
2988  vector signed int __ret = __builtin_vsx_xvcvdpsxws(__a);
2989  return vec_sld(__ret, __ret, 12);
2990 #else
2991  return __builtin_vsx_xvcvdpsxws(__a);
2992 #endif
2993 }
2994 
2995 static __inline__ vector signed int __ATTRS_o_ai
2996 vec_signedo(vector double __a) {
2997 #ifdef __LITTLE_ENDIAN__
2998  return __builtin_vsx_xvcvdpsxws(__a);
2999 #else
3000  vector signed int __ret = __builtin_vsx_xvcvdpsxws(__a);
3001  return vec_sld(__ret, __ret, 12);
3002 #endif
3003 }
3004 #endif
3005 
3006 /* vec_unsigned */
3007 
3008 static __inline__ vector unsigned int __ATTRS_o_ai
3009 vec_sld(vector unsigned int, vector unsigned int, unsigned const int __c);
3010 
3011 static __inline__ vector unsigned int __ATTRS_o_ai
3012 vec_unsigned(vector float __a) {
3013  return __builtin_convertvector(__a, vector unsigned int);
3014 }
3015 
3016 #ifdef __VSX__
3017 static __inline__ vector unsigned long long __ATTRS_o_ai
3018 vec_unsigned(vector double __a) {
3019  return __builtin_convertvector(__a, vector unsigned long long);
3020 }
3021 
3022 static __inline__ vector unsigned int __attribute__((__always_inline__))
3023 vec_unsigned2(vector double __a, vector double __b) {
3024  return (vector unsigned int) { __a[0], __a[1], __b[0], __b[1] };
3025 }
3026 
3027 static __inline__ vector unsigned int __ATTRS_o_ai
3028 vec_unsignede(vector double __a) {
3029 #ifdef __LITTLE_ENDIAN__
3030  vector unsigned int __ret = __builtin_vsx_xvcvdpuxws(__a);
3031  return vec_sld(__ret, __ret, 12);
3032 #else
3033  return __builtin_vsx_xvcvdpuxws(__a);
3034 #endif
3035 }
3036 
3037 static __inline__ vector unsigned int __ATTRS_o_ai
3038 vec_unsignedo(vector double __a) {
3039 #ifdef __LITTLE_ENDIAN__
3040  return __builtin_vsx_xvcvdpuxws(__a);
3041 #else
3042  vector unsigned int __ret = __builtin_vsx_xvcvdpuxws(__a);
3043  return vec_sld(__ret, __ret, 12);
3044 #endif
3045 }
3046 #endif
3047 
3048 /* vec_float */
3049 
3050 static __inline__ vector float __ATTRS_o_ai
3051 vec_sld(vector float, vector float, unsigned const int __c);
3052 
3053 static __inline__ vector float __ATTRS_o_ai
3054 vec_float(vector signed int __a) {
3055  return __builtin_convertvector(__a, vector float);
3056 }
3057 
3058 static __inline__ vector float __ATTRS_o_ai
3059 vec_float(vector unsigned int __a) {
3060  return __builtin_convertvector(__a, vector float);
3061 }
3062 
3063 #ifdef __VSX__
3064 static __inline__ vector float __ATTRS_o_ai
3065 vec_float2(vector signed long long __a, vector signed long long __b) {
3066  return (vector float) { __a[0], __a[1], __b[0], __b[1] };
3067 }
3068 
3069 static __inline__ vector float __ATTRS_o_ai
3070 vec_float2(vector unsigned long long __a, vector unsigned long long __b) {
3071  return (vector float) { __a[0], __a[1], __b[0], __b[1] };
3072 }
3073 
3074 static __inline__ vector float __ATTRS_o_ai
3075 vec_float2(vector double __a, vector double __b) {
3076  return (vector float) { __a[0], __a[1], __b[0], __b[1] };
3077 }
3078 
3079 static __inline__ vector float __ATTRS_o_ai
3080 vec_floate(vector signed long long __a) {
3081 #ifdef __LITTLE_ENDIAN__
3082  vector float __ret = __builtin_vsx_xvcvsxdsp(__a);
3083  return vec_sld(__ret, __ret, 12);
3084 #else
3085  return __builtin_vsx_xvcvsxdsp(__a);
3086 #endif
3087 }
3088 
3089 static __inline__ vector float __ATTRS_o_ai
3090 vec_floate(vector unsigned long long __a) {
3091 #ifdef __LITTLE_ENDIAN__
3092  vector float __ret = __builtin_vsx_xvcvuxdsp(__a);
3093  return vec_sld(__ret, __ret, 12);
3094 #else
3095  return __builtin_vsx_xvcvuxdsp(__a);
3096 #endif
3097 }
3098 
3099 static __inline__ vector float __ATTRS_o_ai
3100 vec_floate(vector double __a) {
3101 #ifdef __LITTLE_ENDIAN__
3102  vector float __ret = __builtin_vsx_xvcvdpsp(__a);
3103  return vec_sld(__ret, __ret, 12);
3104 #else
3105  return __builtin_vsx_xvcvdpsp(__a);
3106 #endif
3107 }
3108 
3109 static __inline__ vector float __ATTRS_o_ai
3110 vec_floato(vector signed long long __a) {
3111 #ifdef __LITTLE_ENDIAN__
3112  return __builtin_vsx_xvcvsxdsp(__a);
3113 #else
3114  vector float __ret = __builtin_vsx_xvcvsxdsp(__a);
3115  return vec_sld(__ret, __ret, 12);
3116 #endif
3117 }
3118 
3119 static __inline__ vector float __ATTRS_o_ai
3120 vec_floato(vector unsigned long long __a) {
3121 #ifdef __LITTLE_ENDIAN__
3122  return __builtin_vsx_xvcvuxdsp(__a);
3123 #else
3124  vector float __ret = __builtin_vsx_xvcvuxdsp(__a);
3125  return vec_sld(__ret, __ret, 12);
3126 #endif
3127 }
3128 
3129 static __inline__ vector float __ATTRS_o_ai
3130 vec_floato(vector double __a) {
3131 #ifdef __LITTLE_ENDIAN__
3132  return __builtin_vsx_xvcvdpsp(__a);
3133 #else
3134  vector float __ret = __builtin_vsx_xvcvdpsp(__a);
3135  return vec_sld(__ret, __ret, 12);
3136 #endif
3137 }
3138 #endif
3139 
3140 /* vec_double */
3141 
3142 #ifdef __VSX__
3143 static __inline__ vector double __ATTRS_o_ai
3144 vec_double(vector signed long long __a) {
3145  return __builtin_convertvector(__a, vector double);
3146 }
3147 
3148 static __inline__ vector double __ATTRS_o_ai
3149 vec_double(vector unsigned long long __a) {
3150  return __builtin_convertvector(__a, vector double);
3151 }
3152 
3153 static __inline__ vector double __ATTRS_o_ai
3154 vec_doublee(vector signed int __a) {
3155 #ifdef __LITTLE_ENDIAN__
3156  return __builtin_vsx_xvcvsxwdp(vec_sld(__a, __a, 4));
3157 #else
3158  return __builtin_vsx_xvcvsxwdp(__a);
3159 #endif
3160 }
3161 
3162 static __inline__ vector double __ATTRS_o_ai
3163 vec_doublee(vector unsigned int __a) {
3164 #ifdef __LITTLE_ENDIAN__
3165  return __builtin_vsx_xvcvuxwdp(vec_sld(__a, __a, 4));
3166 #else
3167  return __builtin_vsx_xvcvuxwdp(__a);
3168 #endif
3169 }
3170 
3171 static __inline__ vector double __ATTRS_o_ai
3172 vec_doublee(vector float __a) {
3173 #ifdef __LITTLE_ENDIAN__
3174  return __builtin_vsx_xvcvspdp(vec_sld(__a, __a, 4));
3175 #else
3176  return __builtin_vsx_xvcvspdp(__a);
3177 #endif
3178 }
3179 
3180 static __inline__ vector double __ATTRS_o_ai
3181 vec_doubleh(vector signed int __a) {
3182  vector double __ret = {__a[0], __a[1]};
3183  return __ret;
3184 }
3185 
3186 static __inline__ vector double __ATTRS_o_ai
3187 vec_doubleh(vector unsigned int __a) {
3188  vector double __ret = {__a[0], __a[1]};
3189  return __ret;
3190 }
3191 
3192 static __inline__ vector double __ATTRS_o_ai
3193 vec_doubleh(vector float __a) {
3194  vector double __ret = {__a[0], __a[1]};
3195  return __ret;
3196 }
3197 
3198 static __inline__ vector double __ATTRS_o_ai
3199 vec_doublel(vector signed int __a) {
3200  vector double __ret = {__a[2], __a[3]};
3201  return __ret;
3202 }
3203 
3204 static __inline__ vector double __ATTRS_o_ai
3205 vec_doublel(vector unsigned int __a) {
3206  vector double __ret = {__a[2], __a[3]};
3207  return __ret;
3208 }
3209 
3210 static __inline__ vector double __ATTRS_o_ai
3211 vec_doublel(vector float __a) {
3212  vector double __ret = {__a[2], __a[3]};
3213  return __ret;
3214 }
3215 
3216 static __inline__ vector double __ATTRS_o_ai
3217 vec_doubleo(vector signed int __a) {
3218 #ifdef __LITTLE_ENDIAN__
3219  return __builtin_vsx_xvcvsxwdp(__a);
3220 #else
3221  return __builtin_vsx_xvcvsxwdp(vec_sld(__a, __a, 4));
3222 #endif
3223 }
3224 
3225 static __inline__ vector double __ATTRS_o_ai
3226 vec_doubleo(vector unsigned int __a) {
3227 #ifdef __LITTLE_ENDIAN__
3228  return __builtin_vsx_xvcvuxwdp(__a);
3229 #else
3230  return __builtin_vsx_xvcvuxwdp(vec_sld(__a, __a, 4));
3231 #endif
3232 }
3233 
3234 static __inline__ vector double __ATTRS_o_ai
3235 vec_doubleo(vector float __a) {
3236 #ifdef __LITTLE_ENDIAN__
3237  return __builtin_vsx_xvcvspdp(__a);
3238 #else
3239  return __builtin_vsx_xvcvspdp(vec_sld(__a, __a, 4));
3240 #endif
3241 }
3242 #endif
3243 
3244 /* vec_div */
3245 
3246 /* Integer vector divides (vectors are scalarized, elements divided
3247  and the vectors reassembled).
3248 */
3249 static __inline__ vector signed char __ATTRS_o_ai
3250 vec_div(vector signed char __a, vector signed char __b) {
3251  return __a / __b;
3252 }
3253 
3254 static __inline__ vector unsigned char __ATTRS_o_ai
3255 vec_div(vector unsigned char __a, vector unsigned char __b) {
3256  return __a / __b;
3257 }
3258 
3259 static __inline__ vector signed short __ATTRS_o_ai
3260 vec_div(vector signed short __a, vector signed short __b) {
3261  return __a / __b;
3262 }
3263 
3264 static __inline__ vector unsigned short __ATTRS_o_ai
3265 vec_div(vector unsigned short __a, vector unsigned short __b) {
3266  return __a / __b;
3267 }
3268 
3269 static __inline__ vector signed int __ATTRS_o_ai
3270 vec_div(vector signed int __a, vector signed int __b) {
3271  return __a / __b;
3272 }
3273 
3274 static __inline__ vector unsigned int __ATTRS_o_ai
3275 vec_div(vector unsigned int __a, vector unsigned int __b) {
3276  return __a / __b;
3277 }
3278 
3279 #ifdef __VSX__
3280 static __inline__ vector signed long long __ATTRS_o_ai
3281 vec_div(vector signed long long __a, vector signed long long __b) {
3282  return __a / __b;
3283 }
3284 
3285 static __inline__ vector unsigned long long __ATTRS_o_ai
3286 vec_div(vector unsigned long long __a, vector unsigned long long __b) {
3287  return __a / __b;
3288 }
3289 
3290 static __inline__ vector float __ATTRS_o_ai vec_div(vector float __a,
3291  vector float __b) {
3292  return __a / __b;
3293 }
3294 
3295 static __inline__ vector double __ATTRS_o_ai vec_div(vector double __a,
3296  vector double __b) {
3297  return __a / __b;
3298 }
3299 #endif
3300 
3301 /* vec_dss */
3302 
3303 static __inline__ void __attribute__((__always_inline__)) vec_dss(int __a) {
3304  __builtin_altivec_dss(__a);
3305 }
3306 
3307 /* vec_dssall */
3308 
3309 static __inline__ void __attribute__((__always_inline__)) vec_dssall(void) {
3310  __builtin_altivec_dssall();
3311 }
3312 
3313 /* vec_dst */
3314 #define vec_dst(__PTR, __CW, __STR) \
3315  __extension__( \
3316  { __builtin_altivec_dst((const void *)(__PTR), (__CW), (__STR)); })
3317 
3318 /* vec_dstst */
3319 #define vec_dstst(__PTR, __CW, __STR) \
3320  __extension__( \
3321  { __builtin_altivec_dstst((const void *)(__PTR), (__CW), (__STR)); })
3322 
3323 /* vec_dststt */
3324 #define vec_dststt(__PTR, __CW, __STR) \
3325  __extension__( \
3326  { __builtin_altivec_dststt((const void *)(__PTR), (__CW), (__STR)); })
3327 
3328 /* vec_dstt */
3329 #define vec_dstt(__PTR, __CW, __STR) \
3330  __extension__( \
3331  { __builtin_altivec_dstt((const void *)(__PTR), (__CW), (__STR)); })
3332 
3333 /* vec_eqv */
3334 
3335 #ifdef __POWER8_VECTOR__
3336 static __inline__ vector signed char __ATTRS_o_ai
3337 vec_eqv(vector signed char __a, vector signed char __b) {
3338  return (vector signed char)__builtin_vsx_xxleqv((vector unsigned int)__a,
3339  (vector unsigned int)__b);
3340 }
3341 
3342 static __inline__ vector unsigned char __ATTRS_o_ai
3343 vec_eqv(vector unsigned char __a, vector unsigned char __b) {
3344  return (vector unsigned char)__builtin_vsx_xxleqv((vector unsigned int)__a,
3345  (vector unsigned int)__b);
3346 }
3347 
3348 static __inline__ vector bool char __ATTRS_o_ai vec_eqv(vector bool char __a,
3349  vector bool char __b) {
3350  return (vector bool char)__builtin_vsx_xxleqv((vector unsigned int)__a,
3351  (vector unsigned int)__b);
3352 }
3353 
3354 static __inline__ vector signed short __ATTRS_o_ai
3355 vec_eqv(vector signed short __a, vector signed short __b) {
3356  return (vector signed short)__builtin_vsx_xxleqv((vector unsigned int)__a,
3357  (vector unsigned int)__b);
3358 }
3359 
3360 static __inline__ vector unsigned short __ATTRS_o_ai
3361 vec_eqv(vector unsigned short __a, vector unsigned short __b) {
3362  return (vector unsigned short)__builtin_vsx_xxleqv((vector unsigned int)__a,
3363  (vector unsigned int)__b);
3364 }
3365 
3366 static __inline__ vector bool short __ATTRS_o_ai
3367 vec_eqv(vector bool short __a, vector bool short __b) {
3368  return (vector bool short)__builtin_vsx_xxleqv((vector unsigned int)__a,
3369  (vector unsigned int)__b);
3370 }
3371 
3372 static __inline__ vector signed int __ATTRS_o_ai
3373 vec_eqv(vector signed int __a, vector signed int __b) {
3374  return (vector signed int)__builtin_vsx_xxleqv((vector unsigned int)__a,
3375  (vector unsigned int)__b);
3376 }
3377 
3378 static __inline__ vector unsigned int __ATTRS_o_ai
3379 vec_eqv(vector unsigned int __a, vector unsigned int __b) {
3380  return __builtin_vsx_xxleqv(__a, __b);
3381 }
3382 
3383 static __inline__ vector bool int __ATTRS_o_ai vec_eqv(vector bool int __a,
3384  vector bool int __b) {
3385  return (vector bool int)__builtin_vsx_xxleqv((vector unsigned int)__a,
3386  (vector unsigned int)__b);
3387 }
3388 
3389 static __inline__ vector signed long long __ATTRS_o_ai
3390 vec_eqv(vector signed long long __a, vector signed long long __b) {
3391  return (vector signed long long)__builtin_vsx_xxleqv(
3392  (vector unsigned int)__a, (vector unsigned int)__b);
3393 }
3394 
3395 static __inline__ vector unsigned long long __ATTRS_o_ai
3396 vec_eqv(vector unsigned long long __a, vector unsigned long long __b) {
3397  return (vector unsigned long long)__builtin_vsx_xxleqv(
3398  (vector unsigned int)__a, (vector unsigned int)__b);
3399 }
3400 
3401 static __inline__ vector bool long long __ATTRS_o_ai
3402 vec_eqv(vector bool long long __a, vector bool long long __b) {
3403  return (vector bool long long)__builtin_vsx_xxleqv((vector unsigned int)__a,
3404  (vector unsigned int)__b);
3405 }
3406 
3407 static __inline__ vector float __ATTRS_o_ai vec_eqv(vector float __a,
3408  vector float __b) {
3409  return (vector float)__builtin_vsx_xxleqv((vector unsigned int)__a,
3410  (vector unsigned int)__b);
3411 }
3412 
3413 static __inline__ vector double __ATTRS_o_ai vec_eqv(vector double __a,
3414  vector double __b) {
3415  return (vector double)__builtin_vsx_xxleqv((vector unsigned int)__a,
3416  (vector unsigned int)__b);
3417 }
3418 #endif
3419 
3420 /* vec_expte */
3421 
3422 static __inline__ vector float __attribute__((__always_inline__))
3423 vec_expte(vector float __a) {
3424  return __builtin_altivec_vexptefp(__a);
3425 }
3426 
3427 /* vec_vexptefp */
3428 
3429 static __inline__ vector float __attribute__((__always_inline__))
3430 vec_vexptefp(vector float __a) {
3431  return __builtin_altivec_vexptefp(__a);
3432 }
3433 
3434 /* vec_floor */
3435 
3436 static __inline__ vector float __ATTRS_o_ai vec_floor(vector float __a) {
3437 #ifdef __VSX__
3438  return __builtin_vsx_xvrspim(__a);
3439 #else
3440  return __builtin_altivec_vrfim(__a);
3441 #endif
3442 }
3443 
3444 #ifdef __VSX__
3445 static __inline__ vector double __ATTRS_o_ai vec_floor(vector double __a) {
3446  return __builtin_vsx_xvrdpim(__a);
3447 }
3448 #endif
3449 
3450 /* vec_vrfim */
3451 
3452 static __inline__ vector float __attribute__((__always_inline__))
3453 vec_vrfim(vector float __a) {
3454  return __builtin_altivec_vrfim(__a);
3455 }
3456 
3457 /* vec_ld */
3458 
3459 static __inline__ vector signed char __ATTRS_o_ai
3460 vec_ld(int __a, const vector signed char *__b) {
3461  return (vector signed char)__builtin_altivec_lvx(__a, __b);
3462 }
3463 
3464 static __inline__ vector signed char __ATTRS_o_ai
3465 vec_ld(int __a, const signed char *__b) {
3466  return (vector signed char)__builtin_altivec_lvx(__a, __b);
3467 }
3468 
3469 static __inline__ vector unsigned char __ATTRS_o_ai
3470 vec_ld(int __a, const vector unsigned char *__b) {
3471  return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
3472 }
3473 
3474 static __inline__ vector unsigned char __ATTRS_o_ai
3475 vec_ld(int __a, const unsigned char *__b) {
3476  return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
3477 }
3478 
3479 static __inline__ vector bool char __ATTRS_o_ai
3480 vec_ld(int __a, const vector bool char *__b) {
3481  return (vector bool char)__builtin_altivec_lvx(__a, __b);
3482 }
3483 
3484 static __inline__ vector short __ATTRS_o_ai vec_ld(int __a,
3485  const vector short *__b) {
3486  return (vector short)__builtin_altivec_lvx(__a, __b);
3487 }
3488 
3489 static __inline__ vector short __ATTRS_o_ai vec_ld(int __a, const short *__b) {
3490  return (vector short)__builtin_altivec_lvx(__a, __b);
3491 }
3492 
3493 static __inline__ vector unsigned short __ATTRS_o_ai
3494 vec_ld(int __a, const vector unsigned short *__b) {
3495  return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
3496 }
3497 
3498 static __inline__ vector unsigned short __ATTRS_o_ai
3499 vec_ld(int __a, const unsigned short *__b) {
3500  return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
3501 }
3502 
3503 static __inline__ vector bool short __ATTRS_o_ai
3504 vec_ld(int __a, const vector bool short *__b) {
3505  return (vector bool short)__builtin_altivec_lvx(__a, __b);
3506 }
3507 
3508 static __inline__ vector pixel __ATTRS_o_ai vec_ld(int __a,
3509  const vector pixel *__b) {
3510  return (vector pixel)__builtin_altivec_lvx(__a, __b);
3511 }
3512 
3513 static __inline__ vector int __ATTRS_o_ai vec_ld(int __a,
3514  const vector int *__b) {
3515  return (vector int)__builtin_altivec_lvx(__a, __b);
3516 }
3517 
3518 static __inline__ vector int __ATTRS_o_ai vec_ld(int __a, const int *__b) {
3519  return (vector int)__builtin_altivec_lvx(__a, __b);
3520 }
3521 
3522 static __inline__ vector unsigned int __ATTRS_o_ai
3523 vec_ld(int __a, const vector unsigned int *__b) {
3524  return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
3525 }
3526 
3527 static __inline__ vector unsigned int __ATTRS_o_ai
3528 vec_ld(int __a, const unsigned int *__b) {
3529  return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
3530 }
3531 
3532 static __inline__ vector bool int __ATTRS_o_ai
3533 vec_ld(int __a, const vector bool int *__b) {
3534  return (vector bool int)__builtin_altivec_lvx(__a, __b);
3535 }
3536 
3537 static __inline__ vector float __ATTRS_o_ai vec_ld(int __a,
3538  const vector float *__b) {
3539  return (vector float)__builtin_altivec_lvx(__a, __b);
3540 }
3541 
3542 static __inline__ vector float __ATTRS_o_ai vec_ld(int __a, const float *__b) {
3543  return (vector float)__builtin_altivec_lvx(__a, __b);
3544 }
3545 
3546 /* vec_lvx */
3547 
3548 static __inline__ vector signed char __ATTRS_o_ai
3549 vec_lvx(int __a, const vector signed char *__b) {
3550  return (vector signed char)__builtin_altivec_lvx(__a, __b);
3551 }
3552 
3553 static __inline__ vector signed char __ATTRS_o_ai
3554 vec_lvx(int __a, const signed char *__b) {
3555  return (vector signed char)__builtin_altivec_lvx(__a, __b);
3556 }
3557 
3558 static __inline__ vector unsigned char __ATTRS_o_ai
3559 vec_lvx(int __a, const vector unsigned char *__b) {
3560  return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
3561 }
3562 
3563 static __inline__ vector unsigned char __ATTRS_o_ai
3564 vec_lvx(int __a, const unsigned char *__b) {
3565  return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
3566 }
3567 
3568 static __inline__ vector bool char __ATTRS_o_ai
3569 vec_lvx(int __a, const vector bool char *__b) {
3570  return (vector bool char)__builtin_altivec_lvx(__a, __b);
3571 }
3572 
3573 static __inline__ vector short __ATTRS_o_ai vec_lvx(int __a,
3574  const vector short *__b) {
3575  return (vector short)__builtin_altivec_lvx(__a, __b);
3576 }
3577 
3578 static __inline__ vector short __ATTRS_o_ai vec_lvx(int __a, const short *__b) {
3579  return (vector short)__builtin_altivec_lvx(__a, __b);
3580 }
3581 
3582 static __inline__ vector unsigned short __ATTRS_o_ai
3583 vec_lvx(int __a, const vector unsigned short *__b) {
3584  return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
3585 }
3586 
3587 static __inline__ vector unsigned short __ATTRS_o_ai
3588 vec_lvx(int __a, const unsigned short *__b) {
3589  return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
3590 }
3591 
3592 static __inline__ vector bool short __ATTRS_o_ai
3593 vec_lvx(int __a, const vector bool short *__b) {
3594  return (vector bool short)__builtin_altivec_lvx(__a, __b);
3595 }
3596 
3597 static __inline__ vector pixel __ATTRS_o_ai vec_lvx(int __a,
3598  const vector pixel *__b) {
3599  return (vector pixel)__builtin_altivec_lvx(__a, __b);
3600 }
3601 
3602 static __inline__ vector int __ATTRS_o_ai vec_lvx(int __a,
3603  const vector int *__b) {
3604  return (vector int)__builtin_altivec_lvx(__a, __b);
3605 }
3606 
3607 static __inline__ vector int __ATTRS_o_ai vec_lvx(int __a, const int *__b) {
3608  return (vector int)__builtin_altivec_lvx(__a, __b);
3609 }
3610 
3611 static __inline__ vector unsigned int __ATTRS_o_ai
3612 vec_lvx(int __a, const vector unsigned int *__b) {
3613  return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
3614 }
3615 
3616 static __inline__ vector unsigned int __ATTRS_o_ai
3617 vec_lvx(int __a, const unsigned int *__b) {
3618  return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
3619 }
3620 
3621 static __inline__ vector bool int __ATTRS_o_ai
3622 vec_lvx(int __a, const vector bool int *__b) {
3623  return (vector bool int)__builtin_altivec_lvx(__a, __b);
3624 }
3625 
3626 static __inline__ vector float __ATTRS_o_ai vec_lvx(int __a,
3627  const vector float *__b) {
3628  return (vector float)__builtin_altivec_lvx(__a, __b);
3629 }
3630 
3631 static __inline__ vector float __ATTRS_o_ai vec_lvx(int __a, const float *__b) {
3632  return (vector float)__builtin_altivec_lvx(__a, __b);
3633 }
3634 
3635 /* vec_lde */
3636 
3637 static __inline__ vector signed char __ATTRS_o_ai
3638 vec_lde(int __a, const signed char *__b) {
3639  return (vector signed char)__builtin_altivec_lvebx(__a, __b);
3640 }
3641 
3642 static __inline__ vector unsigned char __ATTRS_o_ai
3643 vec_lde(int __a, const unsigned char *__b) {
3644  return (vector unsigned char)__builtin_altivec_lvebx(__a, __b);
3645 }
3646 
3647 static __inline__ vector short __ATTRS_o_ai vec_lde(int __a, const short *__b) {
3648  return (vector short)__builtin_altivec_lvehx(__a, __b);
3649 }
3650 
3651 static __inline__ vector unsigned short __ATTRS_o_ai
3652 vec_lde(int __a, const unsigned short *__b) {
3653  return (vector unsigned short)__builtin_altivec_lvehx(__a, __b);
3654 }
3655 
3656 static __inline__ vector int __ATTRS_o_ai vec_lde(int __a, const int *__b) {
3657  return (vector int)__builtin_altivec_lvewx(__a, __b);
3658 }
3659 
3660 static __inline__ vector unsigned int __ATTRS_o_ai
3661 vec_lde(int __a, const unsigned int *__b) {
3662  return (vector unsigned int)__builtin_altivec_lvewx(__a, __b);
3663 }
3664 
3665 static __inline__ vector float __ATTRS_o_ai vec_lde(int __a, const float *__b) {
3666  return (vector float)__builtin_altivec_lvewx(__a, __b);
3667 }
3668 
3669 /* vec_lvebx */
3670 
3671 static __inline__ vector signed char __ATTRS_o_ai
3672 vec_lvebx(int __a, const signed char *__b) {
3673  return (vector signed char)__builtin_altivec_lvebx(__a, __b);
3674 }
3675 
3676 static __inline__ vector unsigned char __ATTRS_o_ai
3677 vec_lvebx(int __a, const unsigned char *__b) {
3678  return (vector unsigned char)__builtin_altivec_lvebx(__a, __b);
3679 }
3680 
3681 /* vec_lvehx */
3682 
3683 static __inline__ vector short __ATTRS_o_ai vec_lvehx(int __a,
3684  const short *__b) {
3685  return (vector short)__builtin_altivec_lvehx(__a, __b);
3686 }
3687 
3688 static __inline__ vector unsigned short __ATTRS_o_ai
3689 vec_lvehx(int __a, const unsigned short *__b) {
3690  return (vector unsigned short)__builtin_altivec_lvehx(__a, __b);
3691 }
3692 
3693 /* vec_lvewx */
3694 
3695 static __inline__ vector int __ATTRS_o_ai vec_lvewx(int __a, const int *__b) {
3696  return (vector int)__builtin_altivec_lvewx(__a, __b);
3697 }
3698 
3699 static __inline__ vector unsigned int __ATTRS_o_ai
3700 vec_lvewx(int __a, const unsigned int *__b) {
3701  return (vector unsigned int)__builtin_altivec_lvewx(__a, __b);
3702 }
3703 
3704 static __inline__ vector float __ATTRS_o_ai vec_lvewx(int __a,
3705  const float *__b) {
3706  return (vector float)__builtin_altivec_lvewx(__a, __b);
3707 }
3708 
3709 /* vec_ldl */
3710 
3711 static __inline__ vector signed char __ATTRS_o_ai
3712 vec_ldl(int __a, const vector signed char *__b) {
3713  return (vector signed char)__builtin_altivec_lvxl(__a, __b);
3714 }
3715 
3716 static __inline__ vector signed char __ATTRS_o_ai
3717 vec_ldl(int __a, const signed char *__b) {
3718  return (vector signed char)__builtin_altivec_lvxl(__a, __b);
3719 }
3720 
3721 static __inline__ vector unsigned char __ATTRS_o_ai
3722 vec_ldl(int __a, const vector unsigned char *__b) {
3723  return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
3724 }
3725 
3726 static __inline__ vector unsigned char __ATTRS_o_ai
3727 vec_ldl(int __a, const unsigned char *__b) {
3728  return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
3729 }
3730 
3731 static __inline__ vector bool char __ATTRS_o_ai
3732 vec_ldl(int __a, const vector bool char *__b) {
3733  return (vector bool char)__builtin_altivec_lvxl(__a, __b);
3734 }
3735 
3736 static __inline__ vector short __ATTRS_o_ai vec_ldl(int __a,
3737  const vector short *__b) {
3738  return (vector short)__builtin_altivec_lvxl(__a, __b);
3739 }
3740 
3741 static __inline__ vector short __ATTRS_o_ai vec_ldl(int __a, const short *__b) {
3742  return (vector short)__builtin_altivec_lvxl(__a, __b);
3743 }
3744 
3745 static __inline__ vector unsigned short __ATTRS_o_ai
3746 vec_ldl(int __a, const vector unsigned short *__b) {
3747  return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
3748 }
3749 
3750 static __inline__ vector unsigned short __ATTRS_o_ai
3751 vec_ldl(int __a, const unsigned short *__b) {
3752  return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
3753 }
3754 
3755 static __inline__ vector bool short __ATTRS_o_ai
3756 vec_ldl(int __a, const vector bool short *__b) {
3757  return (vector bool short)__builtin_altivec_lvxl(__a, __b);
3758 }
3759 
3760 static __inline__ vector pixel __ATTRS_o_ai vec_ldl(int __a,
3761  const vector pixel *__b) {
3762  return (vector pixel short)__builtin_altivec_lvxl(__a, __b);
3763 }
3764 
3765 static __inline__ vector int __ATTRS_o_ai vec_ldl(int __a,
3766  const vector int *__b) {
3767  return (vector int)__builtin_altivec_lvxl(__a, __b);
3768 }
3769 
3770 static __inline__ vector int __ATTRS_o_ai vec_ldl(int __a, const int *__b) {
3771  return (vector int)__builtin_altivec_lvxl(__a, __b);
3772 }
3773 
3774 static __inline__ vector unsigned int __ATTRS_o_ai
3775 vec_ldl(int __a, const vector unsigned int *__b) {
3776  return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
3777 }
3778 
3779 static __inline__ vector unsigned int __ATTRS_o_ai
3780 vec_ldl(int __a, const unsigned int *__b) {
3781  return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
3782 }
3783 
3784 static __inline__ vector bool int __ATTRS_o_ai
3785 vec_ldl(int __a, const vector bool int *__b) {
3786  return (vector bool int)__builtin_altivec_lvxl(__a, __b);
3787 }
3788 
3789 static __inline__ vector float __ATTRS_o_ai vec_ldl(int __a,
3790  const vector float *__b) {
3791  return (vector float)__builtin_altivec_lvxl(__a, __b);
3792 }
3793 
3794 static __inline__ vector float __ATTRS_o_ai vec_ldl(int __a, const float *__b) {
3795  return (vector float)__builtin_altivec_lvxl(__a, __b);
3796 }
3797 
3798 /* vec_lvxl */
3799 
3800 static __inline__ vector signed char __ATTRS_o_ai
3801 vec_lvxl(int __a, const vector signed char *__b) {
3802  return (vector signed char)__builtin_altivec_lvxl(__a, __b);
3803 }
3804 
3805 static __inline__ vector signed char __ATTRS_o_ai
3806 vec_lvxl(int __a, const signed char *__b) {
3807  return (vector signed char)__builtin_altivec_lvxl(__a, __b);
3808 }
3809 
3810 static __inline__ vector unsigned char __ATTRS_o_ai
3811 vec_lvxl(int __a, const vector unsigned char *__b) {
3812  return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
3813 }
3814 
3815 static __inline__ vector unsigned char __ATTRS_o_ai
3816 vec_lvxl(int __a, const unsigned char *__b) {
3817  return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
3818 }
3819 
3820 static __inline__ vector bool char __ATTRS_o_ai
3821 vec_lvxl(int __a, const vector bool char *__b) {
3822  return (vector bool char)__builtin_altivec_lvxl(__a, __b);
3823 }
3824 
3825 static __inline__ vector short __ATTRS_o_ai vec_lvxl(int __a,
3826  const vector short *__b) {
3827  return (vector short)__builtin_altivec_lvxl(__a, __b);
3828 }
3829 
3830 static __inline__ vector short __ATTRS_o_ai vec_lvxl(int __a,
3831  const short *__b) {
3832  return (vector short)__builtin_altivec_lvxl(__a, __b);
3833 }
3834 
3835 static __inline__ vector unsigned short __ATTRS_o_ai
3836 vec_lvxl(int __a, const vector unsigned short *__b) {
3837  return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
3838 }
3839 
3840 static __inline__ vector unsigned short __ATTRS_o_ai
3841 vec_lvxl(int __a, const unsigned short *__b) {
3842  return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
3843 }
3844 
3845 static __inline__ vector bool short __ATTRS_o_ai
3846 vec_lvxl(int __a, const vector bool short *__b) {
3847  return (vector bool short)__builtin_altivec_lvxl(__a, __b);
3848 }
3849 
3850 static __inline__ vector pixel __ATTRS_o_ai vec_lvxl(int __a,
3851  const vector pixel *__b) {
3852  return (vector pixel)__builtin_altivec_lvxl(__a, __b);
3853 }
3854 
3855 static __inline__ vector int __ATTRS_o_ai vec_lvxl(int __a,
3856  const vector int *__b) {
3857  return (vector int)__builtin_altivec_lvxl(__a, __b);
3858 }
3859 
3860 static __inline__ vector int __ATTRS_o_ai vec_lvxl(int __a, const int *__b) {
3861  return (vector int)__builtin_altivec_lvxl(__a, __b);
3862 }
3863 
3864 static __inline__ vector unsigned int __ATTRS_o_ai
3865 vec_lvxl(int __a, const vector unsigned int *__b) {
3866  return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
3867 }
3868 
3869 static __inline__ vector unsigned int __ATTRS_o_ai
3870 vec_lvxl(int __a, const unsigned int *__b) {
3871  return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
3872 }
3873 
3874 static __inline__ vector bool int __ATTRS_o_ai
3875 vec_lvxl(int __a, const vector bool int *__b) {
3876  return (vector bool int)__builtin_altivec_lvxl(__a, __b);
3877 }
3878 
3879 static __inline__ vector float __ATTRS_o_ai vec_lvxl(int __a,
3880  const vector float *__b) {
3881  return (vector float)__builtin_altivec_lvxl(__a, __b);
3882 }
3883 
3884 static __inline__ vector float __ATTRS_o_ai vec_lvxl(int __a,
3885  const float *__b) {
3886  return (vector float)__builtin_altivec_lvxl(__a, __b);
3887 }
3888 
3889 /* vec_loge */
3890 
3891 static __inline__ vector float __attribute__((__always_inline__))
3892 vec_loge(vector float __a) {
3893  return __builtin_altivec_vlogefp(__a);
3894 }
3895 
3896 /* vec_vlogefp */
3897 
3898 static __inline__ vector float __attribute__((__always_inline__))
3899 vec_vlogefp(vector float __a) {
3900  return __builtin_altivec_vlogefp(__a);
3901 }
3902 
3903 /* vec_lvsl */
3904 
3905 #ifdef __LITTLE_ENDIAN__
3906 static __inline__ vector unsigned char __ATTRS_o_ai
3907  __attribute__((__deprecated__("use assignment for unaligned little endian \
3908 loads/stores"))) vec_lvsl(int __a, const signed char *__b) {
3909  vector unsigned char mask =
3910  (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
3911  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
3912  7, 6, 5, 4, 3, 2, 1, 0};
3913  return vec_perm(mask, mask, reverse);
3914 }
3915 #else
3916 static __inline__ vector unsigned char __ATTRS_o_ai
3917 vec_lvsl(int __a, const signed char *__b) {
3918  return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
3919 }
3920 #endif
3921 
3922 #ifdef __LITTLE_ENDIAN__
3923 static __inline__ vector unsigned char __ATTRS_o_ai
3924  __attribute__((__deprecated__("use assignment for unaligned little endian \
3925 loads/stores"))) vec_lvsl(int __a, const unsigned char *__b) {
3926  vector unsigned char mask =
3927  (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
3928  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
3929  7, 6, 5, 4, 3, 2, 1, 0};
3930  return vec_perm(mask, mask, reverse);
3931 }
3932 #else
3933 static __inline__ vector unsigned char __ATTRS_o_ai
3934 vec_lvsl(int __a, const unsigned char *__b) {
3935  return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
3936 }
3937 #endif
3938 
3939 #ifdef __LITTLE_ENDIAN__
3940 static __inline__ vector unsigned char __ATTRS_o_ai
3941  __attribute__((__deprecated__("use assignment for unaligned little endian \
3942 loads/stores"))) vec_lvsl(int __a, const short *__b) {
3943  vector unsigned char mask =
3944  (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
3945  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
3946  7, 6, 5, 4, 3, 2, 1, 0};
3947  return vec_perm(mask, mask, reverse);
3948 }
3949 #else
3950 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsl(int __a,
3951  const short *__b) {
3952  return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
3953 }
3954 #endif
3955 
3956 #ifdef __LITTLE_ENDIAN__
3957 static __inline__ vector unsigned char __ATTRS_o_ai
3958  __attribute__((__deprecated__("use assignment for unaligned little endian \
3959 loads/stores"))) vec_lvsl(int __a, const unsigned short *__b) {
3960  vector unsigned char mask =
3961  (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
3962  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
3963  7, 6, 5, 4, 3, 2, 1, 0};
3964  return vec_perm(mask, mask, reverse);
3965 }
3966 #else
3967 static __inline__ vector unsigned char __ATTRS_o_ai
3968 vec_lvsl(int __a, const unsigned short *__b) {
3969  return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
3970 }
3971 #endif
3972 
3973 #ifdef __LITTLE_ENDIAN__
3974 static __inline__ vector unsigned char __ATTRS_o_ai
3975  __attribute__((__deprecated__("use assignment for unaligned little endian \
3976 loads/stores"))) vec_lvsl(int __a, const int *__b) {
3977  vector unsigned char mask =
3978  (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
3979  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
3980  7, 6, 5, 4, 3, 2, 1, 0};
3981  return vec_perm(mask, mask, reverse);
3982 }
3983 #else
3984 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsl(int __a,
3985  const int *__b) {
3986  return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
3987 }
3988 #endif
3989 
3990 #ifdef __LITTLE_ENDIAN__
3991 static __inline__ vector unsigned char __ATTRS_o_ai
3992  __attribute__((__deprecated__("use assignment for unaligned little endian \
3993 loads/stores"))) vec_lvsl(int __a, const unsigned int *__b) {
3994  vector unsigned char mask =
3995  (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
3996  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
3997  7, 6, 5, 4, 3, 2, 1, 0};
3998  return vec_perm(mask, mask, reverse);
3999 }
4000 #else
4001 static __inline__ vector unsigned char __ATTRS_o_ai
4002 vec_lvsl(int __a, const unsigned int *__b) {
4003  return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4004 }
4005 #endif
4006 
4007 #ifdef __LITTLE_ENDIAN__
4008 static __inline__ vector unsigned char __ATTRS_o_ai
4009  __attribute__((__deprecated__("use assignment for unaligned little endian \
4010 loads/stores"))) vec_lvsl(int __a, const float *__b) {
4011  vector unsigned char mask =
4012  (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4013  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4014  7, 6, 5, 4, 3, 2, 1, 0};
4015  return vec_perm(mask, mask, reverse);
4016 }
4017 #else
4018 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsl(int __a,
4019  const float *__b) {
4020  return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4021 }
4022 #endif
4023 
4024 /* vec_lvsr */
4025 
4026 #ifdef __LITTLE_ENDIAN__
4027 static __inline__ vector unsigned char __ATTRS_o_ai
4028  __attribute__((__deprecated__("use assignment for unaligned little endian \
4029 loads/stores"))) vec_lvsr(int __a, const signed char *__b) {
4030  vector unsigned char mask =
4031  (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4032  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4033  7, 6, 5, 4, 3, 2, 1, 0};
4034  return vec_perm(mask, mask, reverse);
4035 }
4036 #else
4037 static __inline__ vector unsigned char __ATTRS_o_ai
4038 vec_lvsr(int __a, const signed char *__b) {
4039  return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4040 }
4041 #endif
4042 
4043 #ifdef __LITTLE_ENDIAN__
4044 static __inline__ vector unsigned char __ATTRS_o_ai
4045  __attribute__((__deprecated__("use assignment for unaligned little endian \
4046 loads/stores"))) vec_lvsr(int __a, const unsigned char *__b) {
4047  vector unsigned char mask =
4048  (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4049  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4050  7, 6, 5, 4, 3, 2, 1, 0};
4051  return vec_perm(mask, mask, reverse);
4052 }
4053 #else
4054 static __inline__ vector unsigned char __ATTRS_o_ai
4055 vec_lvsr(int __a, const unsigned char *__b) {
4056  return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4057 }
4058 #endif
4059 
4060 #ifdef __LITTLE_ENDIAN__
4061 static __inline__ vector unsigned char __ATTRS_o_ai
4062  __attribute__((__deprecated__("use assignment for unaligned little endian \
4063 loads/stores"))) vec_lvsr(int __a, const short *__b) {
4064  vector unsigned char mask =
4065  (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4066  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4067  7, 6, 5, 4, 3, 2, 1, 0};
4068  return vec_perm(mask, mask, reverse);
4069 }
4070 #else
4071 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsr(int __a,
4072  const short *__b) {
4073  return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4074 }
4075 #endif
4076 
4077 #ifdef __LITTLE_ENDIAN__
4078 static __inline__ vector unsigned char __ATTRS_o_ai
4079  __attribute__((__deprecated__("use assignment for unaligned little endian \
4080 loads/stores"))) vec_lvsr(int __a, const unsigned short *__b) {
4081  vector unsigned char mask =
4082  (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4083  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4084  7, 6, 5, 4, 3, 2, 1, 0};
4085  return vec_perm(mask, mask, reverse);
4086 }
4087 #else
4088 static __inline__ vector unsigned char __ATTRS_o_ai
4089 vec_lvsr(int __a, const unsigned short *__b) {
4090  return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4091 }
4092 #endif
4093 
4094 #ifdef __LITTLE_ENDIAN__
4095 static __inline__ vector unsigned char __ATTRS_o_ai
4096  __attribute__((__deprecated__("use assignment for unaligned little endian \
4097 loads/stores"))) vec_lvsr(int __a, const int *__b) {
4098  vector unsigned char mask =
4099  (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4100  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4101  7, 6, 5, 4, 3, 2, 1, 0};
4102  return vec_perm(mask, mask, reverse);
4103 }
4104 #else
4105 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsr(int __a,
4106  const int *__b) {
4107  return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4108 }
4109 #endif
4110 
4111 #ifdef __LITTLE_ENDIAN__
4112 static __inline__ vector unsigned char __ATTRS_o_ai
4113  __attribute__((__deprecated__("use assignment for unaligned little endian \
4114 loads/stores"))) vec_lvsr(int __a, const unsigned int *__b) {
4115  vector unsigned char mask =
4116  (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4117  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4118  7, 6, 5, 4, 3, 2, 1, 0};
4119  return vec_perm(mask, mask, reverse);
4120 }
4121 #else
4122 static __inline__ vector unsigned char __ATTRS_o_ai
4123 vec_lvsr(int __a, const unsigned int *__b) {
4124  return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4125 }
4126 #endif
4127 
4128 #ifdef __LITTLE_ENDIAN__
4129 static __inline__ vector unsigned char __ATTRS_o_ai
4130  __attribute__((__deprecated__("use assignment for unaligned little endian \
4131 loads/stores"))) vec_lvsr(int __a, const float *__b) {
4132  vector unsigned char mask =
4133  (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4134  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4135  7, 6, 5, 4, 3, 2, 1, 0};
4136  return vec_perm(mask, mask, reverse);
4137 }
4138 #else
4139 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsr(int __a,
4140  const float *__b) {
4141  return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4142 }
4143 #endif
4144 
4145 /* vec_madd */
4146 static __inline__ vector signed short __ATTRS_o_ai
4147 vec_mladd(vector signed short, vector signed short, vector signed short);
4148 static __inline__ vector signed short __ATTRS_o_ai
4149 vec_mladd(vector signed short, vector unsigned short, vector unsigned short);
4150 static __inline__ vector signed short __ATTRS_o_ai
4151 vec_mladd(vector unsigned short, vector signed short, vector signed short);
4152 static __inline__ vector unsigned short __ATTRS_o_ai
4153 vec_mladd(vector unsigned short, vector unsigned short, vector unsigned short);
4154 
4155 static __inline__ vector signed short __ATTRS_o_ai vec_madd(
4156  vector signed short __a, vector signed short __b, vector signed short __c) {
4157  return vec_mladd(__a, __b, __c);
4158 }
4159 
4160 static __inline__ vector signed short __ATTRS_o_ai
4161 vec_madd(vector signed short __a, vector unsigned short __b,
4162  vector unsigned short __c) {
4163  return vec_mladd(__a, __b, __c);
4164 }
4165 
4166 static __inline__ vector signed short __ATTRS_o_ai
4167 vec_madd(vector unsigned short __a, vector signed short __b,
4168  vector signed short __c) {
4169  return vec_mladd(__a, __b, __c);
4170 }
4171 
4172 static __inline__ vector unsigned short __ATTRS_o_ai
4173 vec_madd(vector unsigned short __a, vector unsigned short __b,
4174  vector unsigned short __c) {
4175  return vec_mladd(__a, __b, __c);
4176 }
4177 
4178 static __inline__ vector float __ATTRS_o_ai vec_madd(vector float __a,
4179  vector float __b,
4180  vector float __c) {
4181 #ifdef __VSX__
4182  return __builtin_vsx_xvmaddasp(__a, __b, __c);
4183 #else
4184  return __builtin_altivec_vmaddfp(__a, __b, __c);
4185 #endif
4186 }
4187 
4188 #ifdef __VSX__
4189 static __inline__ vector double __ATTRS_o_ai vec_madd(vector double __a,
4190  vector double __b,
4191  vector double __c) {
4192  return __builtin_vsx_xvmaddadp(__a, __b, __c);
4193 }
4194 #endif
4195 
4196 /* vec_vmaddfp */
4197 
4198 static __inline__ vector float __attribute__((__always_inline__))
4199 vec_vmaddfp(vector float __a, vector float __b, vector float __c) {
4200  return __builtin_altivec_vmaddfp(__a, __b, __c);
4201 }
4202 
4203 /* vec_madds */
4204 
4205 static __inline__ vector signed short __attribute__((__always_inline__))
4206 vec_madds(vector signed short __a, vector signed short __b,
4207  vector signed short __c) {
4208  return __builtin_altivec_vmhaddshs(__a, __b, __c);
4209 }
4210 
4211 /* vec_vmhaddshs */
4212 static __inline__ vector signed short __attribute__((__always_inline__))
4213 vec_vmhaddshs(vector signed short __a, vector signed short __b,
4214  vector signed short __c) {
4215  return __builtin_altivec_vmhaddshs(__a, __b, __c);
4216 }
4217 
4218 /* vec_msub */
4219 
4220 #ifdef __VSX__
4221 static __inline__ vector float __ATTRS_o_ai vec_msub(vector float __a,
4222  vector float __b,
4223  vector float __c) {
4224  return __builtin_vsx_xvmsubasp(__a, __b, __c);
4225 }
4226 
4227 static __inline__ vector double __ATTRS_o_ai vec_msub(vector double __a,
4228  vector double __b,
4229  vector double __c) {
4230  return __builtin_vsx_xvmsubadp(__a, __b, __c);
4231 }
4232 #endif
4233 
4234 /* vec_max */
4235 
4236 static __inline__ vector signed char __ATTRS_o_ai
4237 vec_max(vector signed char __a, vector signed char __b) {
4238  return __builtin_altivec_vmaxsb(__a, __b);
4239 }
4240 
4241 static __inline__ vector signed char __ATTRS_o_ai
4242 vec_max(vector bool char __a, vector signed char __b) {
4243  return __builtin_altivec_vmaxsb((vector signed char)__a, __b);
4244 }
4245 
4246 static __inline__ vector signed char __ATTRS_o_ai
4247 vec_max(vector signed char __a, vector bool char __b) {
4248  return __builtin_altivec_vmaxsb(__a, (vector signed char)__b);
4249 }
4250 
4251 static __inline__ vector unsigned char __ATTRS_o_ai
4252 vec_max(vector unsigned char __a, vector unsigned char __b) {
4253  return __builtin_altivec_vmaxub(__a, __b);
4254 }
4255 
4256 static __inline__ vector unsigned char __ATTRS_o_ai
4257 vec_max(vector bool char __a, vector unsigned char __b) {
4258  return __builtin_altivec_vmaxub((vector unsigned char)__a, __b);
4259 }
4260 
4261 static __inline__ vector unsigned char __ATTRS_o_ai
4262 vec_max(vector unsigned char __a, vector bool char __b) {
4263  return __builtin_altivec_vmaxub(__a, (vector unsigned char)__b);
4264 }
4265 
4266 static __inline__ vector short __ATTRS_o_ai vec_max(vector short __a,
4267  vector short __b) {
4268  return __builtin_altivec_vmaxsh(__a, __b);
4269 }
4270 
4271 static __inline__ vector short __ATTRS_o_ai vec_max(vector bool short __a,
4272  vector short __b) {
4273  return __builtin_altivec_vmaxsh((vector short)__a, __b);
4274 }
4275 
4276 static __inline__ vector short __ATTRS_o_ai vec_max(vector short __a,
4277  vector bool short __b) {
4278  return __builtin_altivec_vmaxsh(__a, (vector short)__b);
4279 }
4280 
4281 static __inline__ vector unsigned short __ATTRS_o_ai
4282 vec_max(vector unsigned short __a, vector unsigned short __b) {
4283  return __builtin_altivec_vmaxuh(__a, __b);
4284 }
4285 
4286 static __inline__ vector unsigned short __ATTRS_o_ai
4287 vec_max(vector bool short __a, vector unsigned short __b) {
4288  return __builtin_altivec_vmaxuh((vector unsigned short)__a, __b);
4289 }
4290 
4291 static __inline__ vector unsigned short __ATTRS_o_ai
4292 vec_max(vector unsigned short __a, vector bool short __b) {
4293  return __builtin_altivec_vmaxuh(__a, (vector unsigned short)__b);
4294 }
4295 
4296 static __inline__ vector int __ATTRS_o_ai vec_max(vector int __a,
4297  vector int __b) {
4298  return __builtin_altivec_vmaxsw(__a, __b);
4299 }
4300 
4301 static __inline__ vector int __ATTRS_o_ai vec_max(vector bool int __a,
4302  vector int __b) {
4303  return __builtin_altivec_vmaxsw((vector int)__a, __b);
4304 }
4305 
4306 static __inline__ vector int __ATTRS_o_ai vec_max(vector int __a,
4307  vector bool int __b) {
4308  return __builtin_altivec_vmaxsw(__a, (vector int)__b);
4309 }
4310 
4311 static __inline__ vector unsigned int __ATTRS_o_ai
4312 vec_max(vector unsigned int __a, vector unsigned int __b) {
4313  return __builtin_altivec_vmaxuw(__a, __b);
4314 }
4315 
4316 static __inline__ vector unsigned int __ATTRS_o_ai
4317 vec_max(vector bool int __a, vector unsigned int __b) {
4318  return __builtin_altivec_vmaxuw((vector unsigned int)__a, __b);
4319 }
4320 
4321 static __inline__ vector unsigned int __ATTRS_o_ai
4322 vec_max(vector unsigned int __a, vector bool int __b) {
4323  return __builtin_altivec_vmaxuw(__a, (vector unsigned int)__b);
4324 }
4325 
4326 #ifdef __POWER8_VECTOR__
4327 static __inline__ vector signed long long __ATTRS_o_ai
4328 vec_max(vector signed long long __a, vector signed long long __b) {
4329  return __builtin_altivec_vmaxsd(__a, __b);
4330 }
4331 
4332 static __inline__ vector signed long long __ATTRS_o_ai
4333 vec_max(vector bool long long __a, vector signed long long __b) {
4334  return __builtin_altivec_vmaxsd((vector signed long long)__a, __b);
4335 }
4336 
4337 static __inline__ vector signed long long __ATTRS_o_ai
4338 vec_max(vector signed long long __a, vector bool long long __b) {
4339  return __builtin_altivec_vmaxsd(__a, (vector signed long long)__b);
4340 }
4341 
4342 static __inline__ vector unsigned long long __ATTRS_o_ai
4343 vec_max(vector unsigned long long __a, vector unsigned long long __b) {
4344  return __builtin_altivec_vmaxud(__a, __b);
4345 }
4346 
4347 static __inline__ vector unsigned long long __ATTRS_o_ai
4348 vec_max(vector bool long long __a, vector unsigned long long __b) {
4349  return __builtin_altivec_vmaxud((vector unsigned long long)__a, __b);
4350 }
4351 
4352 static __inline__ vector unsigned long long __ATTRS_o_ai
4353 vec_max(vector unsigned long long __a, vector bool long long __b) {
4354  return __builtin_altivec_vmaxud(__a, (vector unsigned long long)__b);
4355 }
4356 #endif
4357 
4358 static __inline__ vector float __ATTRS_o_ai vec_max(vector float __a,
4359  vector float __b) {
4360 #ifdef __VSX__
4361  return __builtin_vsx_xvmaxsp(__a, __b);
4362 #else
4363  return __builtin_altivec_vmaxfp(__a, __b);
4364 #endif
4365 }
4366 
4367 #ifdef __VSX__
4368 static __inline__ vector double __ATTRS_o_ai vec_max(vector double __a,
4369  vector double __b) {
4370  return __builtin_vsx_xvmaxdp(__a, __b);
4371 }
4372 #endif
4373 
4374 /* vec_vmaxsb */
4375 
4376 static __inline__ vector signed char __ATTRS_o_ai
4377 vec_vmaxsb(vector signed char __a, vector signed char __b) {
4378  return __builtin_altivec_vmaxsb(__a, __b);
4379 }
4380 
4381 static __inline__ vector signed char __ATTRS_o_ai
4382 vec_vmaxsb(vector bool char __a, vector signed char __b) {
4383  return __builtin_altivec_vmaxsb((vector signed char)__a, __b);
4384 }
4385 
4386 static __inline__ vector signed char __ATTRS_o_ai
4387 vec_vmaxsb(vector signed char __a, vector bool char __b) {
4388  return __builtin_altivec_vmaxsb(__a, (vector signed char)__b);
4389 }
4390 
4391 /* vec_vmaxub */
4392 
4393 static __inline__ vector unsigned char __ATTRS_o_ai
4394 vec_vmaxub(vector unsigned char __a, vector unsigned char __b) {
4395  return __builtin_altivec_vmaxub(__a, __b);
4396 }
4397 
4398 static __inline__ vector unsigned char __ATTRS_o_ai
4399 vec_vmaxub(vector bool char __a, vector unsigned char __b) {
4400  return __builtin_altivec_vmaxub((vector unsigned char)__a, __b);
4401 }
4402 
4403 static __inline__ vector unsigned char __ATTRS_o_ai
4404 vec_vmaxub(vector unsigned char __a, vector bool char __b) {
4405  return __builtin_altivec_vmaxub(__a, (vector unsigned char)__b);
4406 }
4407 
4408 /* vec_vmaxsh */
4409 
4410 static __inline__ vector short __ATTRS_o_ai vec_vmaxsh(vector short __a,
4411  vector short __b) {
4412  return __builtin_altivec_vmaxsh(__a, __b);
4413 }
4414 
4415 static __inline__ vector short __ATTRS_o_ai vec_vmaxsh(vector bool short __a,
4416  vector short __b) {
4417  return __builtin_altivec_vmaxsh((vector short)__a, __b);
4418 }
4419 
4420 static __inline__ vector short __ATTRS_o_ai vec_vmaxsh(vector short __a,
4421  vector bool short __b) {
4422  return __builtin_altivec_vmaxsh(__a, (vector short)__b);
4423 }
4424 
4425 /* vec_vmaxuh */
4426 
4427 static __inline__ vector unsigned short __ATTRS_o_ai
4428 vec_vmaxuh(vector unsigned short __a, vector unsigned short __b) {
4429  return __builtin_altivec_vmaxuh(__a, __b);
4430 }
4431 
4432 static __inline__ vector unsigned short __ATTRS_o_ai
4433 vec_vmaxuh(vector bool short __a, vector unsigned short __b) {
4434  return __builtin_altivec_vmaxuh((vector unsigned short)__a, __b);
4435 }
4436 
4437 static __inline__ vector unsigned short __ATTRS_o_ai
4438 vec_vmaxuh(vector unsigned short __a, vector bool short __b) {
4439  return __builtin_altivec_vmaxuh(__a, (vector unsigned short)__b);
4440 }
4441 
4442 /* vec_vmaxsw */
4443 
4444 static __inline__ vector int __ATTRS_o_ai vec_vmaxsw(vector int __a,
4445  vector int __b) {
4446  return __builtin_altivec_vmaxsw(__a, __b);
4447 }
4448 
4449 static __inline__ vector int __ATTRS_o_ai vec_vmaxsw(vector bool int __a,
4450  vector int __b) {
4451  return __builtin_altivec_vmaxsw((vector int)__a, __b);
4452 }
4453 
4454 static __inline__ vector int __ATTRS_o_ai vec_vmaxsw(vector int __a,
4455  vector bool int __b) {
4456  return __builtin_altivec_vmaxsw(__a, (vector int)__b);
4457 }
4458 
4459 /* vec_vmaxuw */
4460 
4461 static __inline__ vector unsigned int __ATTRS_o_ai
4462 vec_vmaxuw(vector unsigned int __a, vector unsigned int __b) {
4463  return __builtin_altivec_vmaxuw(__a, __b);
4464 }
4465 
4466 static __inline__ vector unsigned int __ATTRS_o_ai
4467 vec_vmaxuw(vector bool int __a, vector unsigned int __b) {
4468  return __builtin_altivec_vmaxuw((vector unsigned int)__a, __b);
4469 }
4470 
4471 static __inline__ vector unsigned int __ATTRS_o_ai
4472 vec_vmaxuw(vector unsigned int __a, vector bool int __b) {
4473  return __builtin_altivec_vmaxuw(__a, (vector unsigned int)__b);
4474 }
4475 
4476 /* vec_vmaxfp */
4477 
4478 static __inline__ vector float __attribute__((__always_inline__))
4479 vec_vmaxfp(vector float __a, vector float __b) {
4480 #ifdef __VSX__
4481  return __builtin_vsx_xvmaxsp(__a, __b);
4482 #else
4483  return __builtin_altivec_vmaxfp(__a, __b);
4484 #endif
4485 }
4486 
4487 /* vec_mergeh */
4488 
4489 static __inline__ vector signed char __ATTRS_o_ai
4490 vec_mergeh(vector signed char __a, vector signed char __b) {
4491  return vec_perm(__a, __b,
4492  (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
4493  0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
4494  0x06, 0x16, 0x07, 0x17));
4495 }
4496 
4497 static __inline__ vector unsigned char __ATTRS_o_ai
4498 vec_mergeh(vector unsigned char __a, vector unsigned char __b) {
4499  return vec_perm(__a, __b,
4500  (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
4501  0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
4502  0x06, 0x16, 0x07, 0x17));
4503 }
4504 
4505 static __inline__ vector bool char __ATTRS_o_ai
4506 vec_mergeh(vector bool char __a, vector bool char __b) {
4507  return vec_perm(__a, __b,
4508  (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
4509  0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
4510  0x06, 0x16, 0x07, 0x17));
4511 }
4512 
4513 static __inline__ vector short __ATTRS_o_ai vec_mergeh(vector short __a,
4514  vector short __b) {
4515  return vec_perm(__a, __b,
4516  (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
4517  0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
4518  0x06, 0x07, 0x16, 0x17));
4519 }
4520 
4521 static __inline__ vector unsigned short __ATTRS_o_ai
4522 vec_mergeh(vector unsigned short __a, vector unsigned short __b) {
4523  return vec_perm(__a, __b,
4524  (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
4525  0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
4526  0x06, 0x07, 0x16, 0x17));
4527 }
4528 
4529 static __inline__ vector bool short __ATTRS_o_ai
4530 vec_mergeh(vector bool short __a, vector bool short __b) {
4531  return vec_perm(__a, __b,
4532  (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
4533  0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
4534  0x06, 0x07, 0x16, 0x17));
4535 }
4536 
4537 static __inline__ vector pixel __ATTRS_o_ai vec_mergeh(vector pixel __a,
4538  vector pixel __b) {
4539  return vec_perm(__a, __b,
4540  (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
4541  0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
4542  0x06, 0x07, 0x16, 0x17));
4543 }
4544 
4545 static __inline__ vector int __ATTRS_o_ai vec_mergeh(vector int __a,
4546  vector int __b) {
4547  return vec_perm(__a, __b,
4548  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
4549  0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
4550  0x14, 0x15, 0x16, 0x17));
4551 }
4552 
4553 static __inline__ vector unsigned int __ATTRS_o_ai
4554 vec_mergeh(vector unsigned int __a, vector unsigned int __b) {
4555  return vec_perm(__a, __b,
4556  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
4557  0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
4558  0x14, 0x15, 0x16, 0x17));
4559 }
4560 
4561 static __inline__ vector bool int __ATTRS_o_ai vec_mergeh(vector bool int __a,
4562  vector bool int __b) {
4563  return vec_perm(__a, __b,
4564  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
4565  0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
4566  0x14, 0x15, 0x16, 0x17));
4567 }
4568 
4569 static __inline__ vector float __ATTRS_o_ai vec_mergeh(vector float __a,
4570  vector float __b) {
4571  return vec_perm(__a, __b,
4572  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
4573  0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
4574  0x14, 0x15, 0x16, 0x17));
4575 }
4576 
4577 #ifdef __VSX__
4578 static __inline__ vector signed long long __ATTRS_o_ai
4579 vec_mergeh(vector signed long long __a, vector signed long long __b) {
4580  return vec_perm(__a, __b,
4581  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
4582  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
4583  0x14, 0x15, 0x16, 0x17));
4584 }
4585 
4586 static __inline__ vector signed long long __ATTRS_o_ai
4587 vec_mergeh(vector signed long long __a, vector bool long long __b) {
4588  return vec_perm(__a, (vector signed long long)__b,
4589  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
4590  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
4591  0x14, 0x15, 0x16, 0x17));
4592 }
4593 
4594 static __inline__ vector signed long long __ATTRS_o_ai
4595 vec_mergeh(vector bool long long __a, vector signed long long __b) {
4596  return vec_perm((vector signed long long)__a, __b,
4597  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
4598  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
4599  0x14, 0x15, 0x16, 0x17));
4600 }
4601 
4602 static __inline__ vector unsigned long long __ATTRS_o_ai
4603 vec_mergeh(vector unsigned long long __a, vector unsigned long long __b) {
4604  return vec_perm(__a, __b,
4605  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
4606  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
4607  0x14, 0x15, 0x16, 0x17));
4608 }
4609 
4610 static __inline__ vector unsigned long long __ATTRS_o_ai
4611 vec_mergeh(vector unsigned long long __a, vector bool long long __b) {
4612  return vec_perm(__a, (vector unsigned long long)__b,
4613  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
4614  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
4615  0x14, 0x15, 0x16, 0x17));
4616 }
4617 
4618 static __inline__ vector unsigned long long __ATTRS_o_ai
4619 vec_mergeh(vector bool long long __a, vector unsigned long long __b) {
4620  return vec_perm((vector unsigned long long)__a, __b,
4621  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
4622  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
4623  0x14, 0x15, 0x16, 0x17));
4624 }
4625 
4626 static __inline__ vector bool long long __ATTRS_o_ai
4627 vec_mergeh(vector bool long long __a, vector bool long long __b) {
4628  return vec_perm(__a, __b,
4629  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
4630  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
4631  0x14, 0x15, 0x16, 0x17));
4632 }
4633 
4634 static __inline__ vector double __ATTRS_o_ai vec_mergeh(vector double __a,
4635  vector double __b) {
4636  return vec_perm(__a, __b,
4637  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
4638  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
4639  0x14, 0x15, 0x16, 0x17));
4640 }
4641 static __inline__ vector double __ATTRS_o_ai
4642 vec_mergeh(vector double __a, vector bool long long __b) {
4643  return vec_perm(__a, (vector double)__b,
4644  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
4645  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
4646  0x14, 0x15, 0x16, 0x17));
4647 }
4648 static __inline__ vector double __ATTRS_o_ai
4649 vec_mergeh(vector bool long long __a, vector double __b) {
4650  return vec_perm((vector double)__a, __b,
4651  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
4652  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
4653  0x14, 0x15, 0x16, 0x17));
4654 }
4655 #endif
4656 
4657 /* vec_vmrghb */
4658 
4659 #define __builtin_altivec_vmrghb vec_vmrghb
4660 
4661 static __inline__ vector signed char __ATTRS_o_ai
4662 vec_vmrghb(vector signed char __a, vector signed char __b) {
4663  return vec_perm(__a, __b,
4664  (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
4665  0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
4666  0x06, 0x16, 0x07, 0x17));
4667 }
4668 
4669 static __inline__ vector unsigned char __ATTRS_o_ai
4670 vec_vmrghb(vector unsigned char __a, vector unsigned char __b) {
4671  return vec_perm(__a, __b,
4672  (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
4673  0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
4674  0x06, 0x16, 0x07, 0x17));
4675 }
4676 
4677 static __inline__ vector bool char __ATTRS_o_ai
4678 vec_vmrghb(vector bool char __a, vector bool char __b) {
4679  return vec_perm(__a, __b,
4680  (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
4681  0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
4682  0x06, 0x16, 0x07, 0x17));
4683 }
4684 
4685 /* vec_vmrghh */
4686 
4687 #define __builtin_altivec_vmrghh vec_vmrghh
4688 
4689 static __inline__ vector short __ATTRS_o_ai vec_vmrghh(vector short __a,
4690  vector short __b) {
4691  return vec_perm(__a, __b,
4692  (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
4693  0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
4694  0x06, 0x07, 0x16, 0x17));
4695 }
4696 
4697 static __inline__ vector unsigned short __ATTRS_o_ai
4698 vec_vmrghh(vector unsigned short __a, vector unsigned short __b) {
4699  return vec_perm(__a, __b,
4700  (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
4701  0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
4702  0x06, 0x07, 0x16, 0x17));
4703 }
4704 
4705 static __inline__ vector bool short __ATTRS_o_ai
4706 vec_vmrghh(vector bool short __a, vector bool short __b) {
4707  return vec_perm(__a, __b,
4708  (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
4709  0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
4710  0x06, 0x07, 0x16, 0x17));
4711 }
4712 
4713 static __inline__ vector pixel __ATTRS_o_ai vec_vmrghh(vector pixel __a,
4714  vector pixel __b) {
4715  return vec_perm(__a, __b,
4716  (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
4717  0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
4718  0x06, 0x07, 0x16, 0x17));
4719 }
4720 
4721 /* vec_vmrghw */
4722 
4723 #define __builtin_altivec_vmrghw vec_vmrghw
4724 
4725 static __inline__ vector int __ATTRS_o_ai vec_vmrghw(vector int __a,
4726  vector int __b) {
4727  return vec_perm(__a, __b,
4728  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
4729  0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
4730  0x14, 0x15, 0x16, 0x17));
4731 }
4732 
4733 static __inline__ vector unsigned int __ATTRS_o_ai
4734 vec_vmrghw(vector unsigned int __a, vector unsigned int __b) {
4735  return vec_perm(__a, __b,
4736  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
4737  0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
4738  0x14, 0x15, 0x16, 0x17));
4739 }
4740 
4741 static __inline__ vector bool int __ATTRS_o_ai vec_vmrghw(vector bool int __a,
4742  vector bool int __b) {
4743  return vec_perm(__a, __b,
4744  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
4745  0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
4746  0x14, 0x15, 0x16, 0x17));
4747 }
4748 
4749 static __inline__ vector float __ATTRS_o_ai vec_vmrghw(vector float __a,
4750  vector float __b) {
4751  return vec_perm(__a, __b,
4752  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
4753  0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
4754  0x14, 0x15, 0x16, 0x17));
4755 }
4756 
4757 /* vec_mergel */
4758 
4759 static __inline__ vector signed char __ATTRS_o_ai
4760 vec_mergel(vector signed char __a, vector signed char __b) {
4761  return vec_perm(__a, __b,
4762  (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
4763  0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
4764  0x0E, 0x1E, 0x0F, 0x1F));
4765 }
4766 
4767 static __inline__ vector unsigned char __ATTRS_o_ai
4768 vec_mergel(vector unsigned char __a, vector unsigned char __b) {
4769  return vec_perm(__a, __b,
4770  (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
4771  0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
4772  0x0E, 0x1E, 0x0F, 0x1F));
4773 }
4774 
4775 static __inline__ vector bool char __ATTRS_o_ai
4776 vec_mergel(vector bool char __a, vector bool char __b) {
4777  return vec_perm(__a, __b,
4778  (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
4779  0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
4780  0x0E, 0x1E, 0x0F, 0x1F));
4781 }
4782 
4783 static __inline__ vector short __ATTRS_o_ai vec_mergel(vector short __a,
4784  vector short __b) {
4785  return vec_perm(__a, __b,
4786  (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
4787  0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
4788  0x0E, 0x0F, 0x1E, 0x1F));
4789 }
4790 
4791 static __inline__ vector unsigned short __ATTRS_o_ai
4792 vec_mergel(vector unsigned short __a, vector unsigned short __b) {
4793  return vec_perm(__a, __b,
4794  (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
4795  0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
4796  0x0E, 0x0F, 0x1E, 0x1F));
4797 }
4798 
4799 static __inline__ vector bool short __ATTRS_o_ai
4800 vec_mergel(vector bool short __a, vector bool short __b) {
4801  return vec_perm(__a, __b,
4802  (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
4803  0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
4804  0x0E, 0x0F, 0x1E, 0x1F));
4805 }
4806 
4807 static __inline__ vector pixel __ATTRS_o_ai vec_mergel(vector pixel __a,
4808  vector pixel __b) {
4809  return vec_perm(__a, __b,
4810  (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
4811  0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
4812  0x0E, 0x0F, 0x1E, 0x1F));
4813 }
4814 
4815 static __inline__ vector int __ATTRS_o_ai vec_mergel(vector int __a,
4816  vector int __b) {
4817  return vec_perm(__a, __b,
4818  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
4819  0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
4820  0x1C, 0x1D, 0x1E, 0x1F));
4821 }
4822 
4823 static __inline__ vector unsigned int __ATTRS_o_ai
4824 vec_mergel(vector unsigned int __a, vector unsigned int __b) {
4825  return vec_perm(__a, __b,
4826  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
4827  0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
4828  0x1C, 0x1D, 0x1E, 0x1F));
4829 }
4830 
4831 static __inline__ vector bool int __ATTRS_o_ai vec_mergel(vector bool int __a,
4832  vector bool int __b) {
4833  return vec_perm(__a, __b,
4834  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
4835  0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
4836  0x1C, 0x1D, 0x1E, 0x1F));
4837 }
4838 
4839 static __inline__ vector float __ATTRS_o_ai vec_mergel(vector float __a,
4840  vector float __b) {
4841  return vec_perm(__a, __b,
4842  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
4843  0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
4844  0x1C, 0x1D, 0x1E, 0x1F));
4845 }
4846 
4847 #ifdef __VSX__
4848 static __inline__ vector signed long long __ATTRS_o_ai
4849 vec_mergel(vector signed long long __a, vector signed long long __b) {
4850  return vec_perm(__a, __b,
4851  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
4852  0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
4853  0x1C, 0x1D, 0x1E, 0x1F));
4854 }
4855 static __inline__ vector signed long long __ATTRS_o_ai
4856 vec_mergel(vector signed long long __a, vector bool long long __b) {
4857  return vec_perm(__a, (vector signed long long)__b,
4858  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
4859  0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
4860  0x1C, 0x1D, 0x1E, 0x1F));
4861 }
4862 static __inline__ vector signed long long __ATTRS_o_ai
4863 vec_mergel(vector bool long long __a, vector signed long long __b) {
4864  return vec_perm((vector signed long long)__a, __b,
4865  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
4866  0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
4867  0x1C, 0x1D, 0x1E, 0x1F));
4868 }
4869 static __inline__ vector unsigned long long __ATTRS_o_ai
4870 vec_mergel(vector unsigned long long __a, vector unsigned long long __b) {
4871  return vec_perm(__a, __b,
4872  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
4873  0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
4874  0x1C, 0x1D, 0x1E, 0x1F));
4875 }
4876 static __inline__ vector unsigned long long __ATTRS_o_ai
4877 vec_mergel(vector unsigned long long __a, vector bool long long __b) {
4878  return vec_perm(__a, (vector unsigned long long)__b,
4879  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
4880  0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
4881  0x1C, 0x1D, 0x1E, 0x1F));
4882 }
4883 static __inline__ vector unsigned long long __ATTRS_o_ai
4884 vec_mergel(vector bool long long __a, vector unsigned long long __b) {
4885  return vec_perm((vector unsigned long long)__a, __b,
4886  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
4887  0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
4888  0x1C, 0x1D, 0x1E, 0x1F));
4889 }
4890 static __inline__ vector bool long long __ATTRS_o_ai
4891 vec_mergel(vector bool long long __a, vector bool long long __b) {
4892  return vec_perm(__a, __b,
4893  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
4894  0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
4895  0x1C, 0x1D, 0x1E, 0x1F));
4896 }
4897 static __inline__ vector double __ATTRS_o_ai vec_mergel(vector double __a,
4898  vector double __b) {
4899  return vec_perm(__a, __b,
4900  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
4901  0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
4902  0x1C, 0x1D, 0x1E, 0x1F));
4903 }
4904 static __inline__ vector double __ATTRS_o_ai
4905 vec_mergel(vector double __a, vector bool long long __b) {
4906  return vec_perm(__a, (vector double)__b,
4907  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
4908  0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
4909  0x1C, 0x1D, 0x1E, 0x1F));
4910 }
4911 static __inline__ vector double __ATTRS_o_ai
4912 vec_mergel(vector bool long long __a, vector double __b) {
4913  return vec_perm((vector double)__a, __b,
4914  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
4915  0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
4916  0x1C, 0x1D, 0x1E, 0x1F));
4917 }
4918 #endif
4919 
4920 /* vec_vmrglb */
4921 
4922 #define __builtin_altivec_vmrglb vec_vmrglb
4923 
4924 static __inline__ vector signed char __ATTRS_o_ai
4925 vec_vmrglb(vector signed char __a, vector signed char __b) {
4926  return vec_perm(__a, __b,
4927  (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
4928  0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
4929  0x0E, 0x1E, 0x0F, 0x1F));
4930 }
4931 
4932 static __inline__ vector unsigned char __ATTRS_o_ai
4933 vec_vmrglb(vector unsigned char __a, vector unsigned char __b) {
4934  return vec_perm(__a, __b,
4935  (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
4936  0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
4937  0x0E, 0x1E, 0x0F, 0x1F));
4938 }
4939 
4940 static __inline__ vector bool char __ATTRS_o_ai
4941 vec_vmrglb(vector bool char __a, vector bool char __b) {
4942  return vec_perm(__a, __b,
4943  (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
4944  0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
4945  0x0E, 0x1E, 0x0F, 0x1F));
4946 }
4947 
4948 /* vec_vmrglh */
4949 
4950 #define __builtin_altivec_vmrglh vec_vmrglh
4951 
4952 static __inline__ vector short __ATTRS_o_ai vec_vmrglh(vector short __a,
4953  vector short __b) {
4954  return vec_perm(__a, __b,
4955  (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
4956  0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
4957  0x0E, 0x0F, 0x1E, 0x1F));
4958 }
4959 
4960 static __inline__ vector unsigned short __ATTRS_o_ai
4961 vec_vmrglh(vector unsigned short __a, vector unsigned short __b) {
4962  return vec_perm(__a, __b,
4963  (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
4964  0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
4965  0x0E, 0x0F, 0x1E, 0x1F));
4966 }
4967 
4968 static __inline__ vector bool short __ATTRS_o_ai
4969 vec_vmrglh(vector bool short __a, vector bool short __b) {
4970  return vec_perm(__a, __b,
4971  (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
4972  0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
4973  0x0E, 0x0F, 0x1E, 0x1F));
4974 }
4975 
4976 static __inline__ vector pixel __ATTRS_o_ai vec_vmrglh(vector pixel __a,
4977  vector pixel __b) {
4978  return vec_perm(__a, __b,
4979  (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
4980  0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
4981  0x0E, 0x0F, 0x1E, 0x1F));
4982 }
4983 
4984 /* vec_vmrglw */
4985 
4986 #define __builtin_altivec_vmrglw vec_vmrglw
4987 
4988 static __inline__ vector int __ATTRS_o_ai vec_vmrglw(vector int __a,
4989  vector int __b) {
4990  return vec_perm(__a, __b,
4991  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
4992  0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
4993  0x1C, 0x1D, 0x1E, 0x1F));
4994 }
4995 
4996 static __inline__ vector unsigned int __ATTRS_o_ai
4997 vec_vmrglw(vector unsigned int __a, vector unsigned int __b) {
4998  return vec_perm(__a, __b,
4999  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
5000  0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
5001  0x1C, 0x1D, 0x1E, 0x1F));
5002 }
5003 
5004 static __inline__ vector bool int __ATTRS_o_ai vec_vmrglw(vector bool int __a,
5005  vector bool int __b) {
5006  return vec_perm(__a, __b,
5007  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
5008  0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
5009  0x1C, 0x1D, 0x1E, 0x1F));
5010 }
5011 
5012 static __inline__ vector float __ATTRS_o_ai vec_vmrglw(vector float __a,
5013  vector float __b) {
5014  return vec_perm(__a, __b,
5015  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
5016  0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
5017  0x1C, 0x1D, 0x1E, 0x1F));
5018 }
5019 
5020 #ifdef __POWER8_VECTOR__
5021 /* vec_mergee */
5022 
5023 static __inline__ vector bool int __ATTRS_o_ai vec_mergee(vector bool int __a,
5024  vector bool int __b) {
5025  return vec_perm(__a, __b,
5026  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5027  0x12, 0x13, 0x08, 0x09, 0x0A, 0x0B,
5028  0x18, 0x19, 0x1A, 0x1B));
5029 }
5030 
5031 static __inline__ vector signed int __ATTRS_o_ai
5032 vec_mergee(vector signed int __a, vector signed int __b) {
5033  return vec_perm(__a, __b,
5034  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5035  0x12, 0x13, 0x08, 0x09, 0x0A, 0x0B,
5036  0x18, 0x19, 0x1A, 0x1B));
5037 }
5038 
5039 static __inline__ vector unsigned int __ATTRS_o_ai
5040 vec_mergee(vector unsigned int __a, vector unsigned int __b) {
5041  return vec_perm(__a, __b,
5042  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5043  0x12, 0x13, 0x08, 0x09, 0x0A, 0x0B,
5044  0x18, 0x19, 0x1A, 0x1B));
5045 }
5046 
5047 static __inline__ vector bool long long __ATTRS_o_ai
5048 vec_mergee(vector bool long long __a, vector bool long long __b) {
5049  return vec_mergeh(__a, __b);
5050 }
5051 
5052 static __inline__ vector signed long long __ATTRS_o_ai
5053 vec_mergee(vector signed long long __a, vector signed long long __b) {
5054  return vec_mergeh(__a, __b);
5055 }
5056 
5057 static __inline__ vector unsigned long long __ATTRS_o_ai
5058 vec_mergee(vector unsigned long long __a, vector unsigned long long __b) {
5059  return vec_mergeh(__a, __b);
5060 }
5061 
5062 static __inline__ vector float __ATTRS_o_ai
5063 vec_mergee(vector float __a, vector float __b) {
5064  return vec_perm(__a, __b,
5065  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5066  0x12, 0x13, 0x08, 0x09, 0x0A, 0x0B,
5067  0x18, 0x19, 0x1A, 0x1B));
5068 }
5069 
5070 static __inline__ vector double __ATTRS_o_ai
5071 vec_mergee(vector double __a, vector double __b) {
5072  return vec_mergeh(__a, __b);
5073 }
5074 
5075 /* vec_mergeo */
5076 
5077 static __inline__ vector bool int __ATTRS_o_ai vec_mergeo(vector bool int __a,
5078  vector bool int __b) {
5079  return vec_perm(__a, __b,
5080  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x14, 0x15,
5081  0x16, 0x17, 0x0C, 0x0D, 0x0E, 0x0F,
5082  0x1C, 0x1D, 0x1E, 0x1F));
5083 }
5084 
5085 static __inline__ vector signed int __ATTRS_o_ai
5086 vec_mergeo(vector signed int __a, vector signed int __b) {
5087  return vec_perm(__a, __b,
5088  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x14, 0x15,
5089  0x16, 0x17, 0x0C, 0x0D, 0x0E, 0x0F,
5090  0x1C, 0x1D, 0x1E, 0x1F));
5091 }
5092 
5093 static __inline__ vector unsigned int __ATTRS_o_ai
5094 vec_mergeo(vector unsigned int __a, vector unsigned int __b) {
5095  return vec_perm(__a, __b,
5096  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x14, 0x15,
5097  0x16, 0x17, 0x0C, 0x0D, 0x0E, 0x0F,
5098  0x1C, 0x1D, 0x1E, 0x1F));
5099 }
5100 
5101 static __inline__ vector bool long long __ATTRS_o_ai
5102 vec_mergeo(vector bool long long __a, vector bool long long __b) {
5103  return vec_mergel(__a, __b);
5104 }
5105 
5106 static __inline__ vector signed long long __ATTRS_o_ai
5107 vec_mergeo(vector signed long long __a, vector signed long long __b) {
5108  return vec_mergel(__a, __b);
5109 }
5110 
5111 static __inline__ vector unsigned long long __ATTRS_o_ai
5112 vec_mergeo(vector unsigned long long __a, vector unsigned long long __b) {
5113  return vec_mergel(__a, __b);
5114 }
5115 
5116 static __inline__ vector float __ATTRS_o_ai
5117 vec_mergeo(vector float __a, vector float __b) {
5118  return vec_perm(__a, __b,
5119  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x14, 0x15,
5120  0x16, 0x17, 0x0C, 0x0D, 0x0E, 0x0F,
5121  0x1C, 0x1D, 0x1E, 0x1F));
5122 }
5123 
5124 static __inline__ vector double __ATTRS_o_ai
5125 vec_mergeo(vector double __a, vector double __b) {
5126  return vec_mergel(__a, __b);
5127 }
5128 
5129 #endif
5130 
5131 /* vec_mfvscr */
5132 
5133 static __inline__ vector unsigned short __attribute__((__always_inline__))
5134 vec_mfvscr(void) {
5135  return __builtin_altivec_mfvscr();
5136 }
5137 
5138 /* vec_min */
5139 
5140 static __inline__ vector signed char __ATTRS_o_ai
5141 vec_min(vector signed char __a, vector signed char __b) {
5142  return __builtin_altivec_vminsb(__a, __b);
5143 }
5144 
5145 static __inline__ vector signed char __ATTRS_o_ai
5146 vec_min(vector bool char __a, vector signed char __b) {
5147  return __builtin_altivec_vminsb((vector signed char)__a, __b);
5148 }
5149 
5150 static __inline__ vector signed char __ATTRS_o_ai
5151 vec_min(vector signed char __a, vector bool char __b) {
5152  return __builtin_altivec_vminsb(__a, (vector signed char)__b);
5153 }
5154 
5155 static __inline__ vector unsigned char __ATTRS_o_ai
5156 vec_min(vector unsigned char __a, vector unsigned char __b) {
5157  return __builtin_altivec_vminub(__a, __b);
5158 }
5159 
5160 static __inline__ vector unsigned char __ATTRS_o_ai
5161 vec_min(vector bool char __a, vector unsigned char __b) {
5162  return __builtin_altivec_vminub((vector unsigned char)__a, __b);
5163 }
5164 
5165 static __inline__ vector unsigned char __ATTRS_o_ai
5166 vec_min(vector unsigned char __a, vector bool char __b) {
5167  return __builtin_altivec_vminub(__a, (vector unsigned char)__b);
5168 }
5169 
5170 static __inline__ vector short __ATTRS_o_ai vec_min(vector short __a,
5171  vector short __b) {
5172  return __builtin_altivec_vminsh(__a, __b);
5173 }
5174 
5175 static __inline__ vector short __ATTRS_o_ai vec_min(vector bool short __a,
5176  vector short __b) {
5177  return __builtin_altivec_vminsh((vector short)__a, __b);
5178 }
5179 
5180 static __inline__ vector short __ATTRS_o_ai vec_min(vector short __a,
5181  vector bool short __b) {
5182  return __builtin_altivec_vminsh(__a, (vector short)__b);
5183 }
5184 
5185 static __inline__ vector unsigned short __ATTRS_o_ai
5186 vec_min(vector unsigned short __a, vector unsigned short __b) {
5187  return __builtin_altivec_vminuh(__a, __b);
5188 }
5189 
5190 static __inline__ vector unsigned short __ATTRS_o_ai
5191 vec_min(vector bool short __a, vector unsigned short __b) {
5192  return __builtin_altivec_vminuh((vector unsigned short)__a, __b);
5193 }
5194 
5195 static __inline__ vector unsigned short __ATTRS_o_ai
5196 vec_min(vector unsigned short __a, vector bool short __b) {
5197  return __builtin_altivec_vminuh(__a, (vector unsigned short)__b);
5198 }
5199 
5200 static __inline__ vector int __ATTRS_o_ai vec_min(vector int __a,
5201  vector int __b) {
5202  return __builtin_altivec_vminsw(__a, __b);
5203 }
5204 
5205 static __inline__ vector int __ATTRS_o_ai vec_min(vector bool int __a,
5206  vector int __b) {
5207  return __builtin_altivec_vminsw((vector int)__a, __b);
5208 }
5209 
5210 static __inline__ vector int __ATTRS_o_ai vec_min(vector int __a,
5211  vector bool int __b) {
5212  return __builtin_altivec_vminsw(__a, (vector int)__b);
5213 }
5214 
5215 static __inline__ vector unsigned int __ATTRS_o_ai
5216 vec_min(vector unsigned int __a, vector unsigned int __b) {
5217  return __builtin_altivec_vminuw(__a, __b);
5218 }
5219 
5220 static __inline__ vector unsigned int __ATTRS_o_ai
5221 vec_min(vector bool int __a, vector unsigned int __b) {
5222  return __builtin_altivec_vminuw((vector unsigned int)__a, __b);
5223 }
5224 
5225 static __inline__ vector unsigned int __ATTRS_o_ai
5226 vec_min(vector unsigned int __a, vector bool int __b) {
5227  return __builtin_altivec_vminuw(__a, (vector unsigned int)__b);
5228 }
5229 
5230 #ifdef __POWER8_VECTOR__
5231 static __inline__ vector signed long long __ATTRS_o_ai
5232 vec_min(vector signed long long __a, vector signed long long __b) {
5233  return __builtin_altivec_vminsd(__a, __b);
5234 }
5235 
5236 static __inline__ vector signed long long __ATTRS_o_ai
5237 vec_min(vector bool long long __a, vector signed long long __b) {
5238  return __builtin_altivec_vminsd((vector signed long long)__a, __b);
5239 }
5240 
5241 static __inline__ vector signed long long __ATTRS_o_ai
5242 vec_min(vector signed long long __a, vector bool long long __b) {
5243  return __builtin_altivec_vminsd(__a, (vector signed long long)__b);
5244 }
5245 
5246 static __inline__ vector unsigned long long __ATTRS_o_ai
5247 vec_min(vector unsigned long long __a, vector unsigned long long __b) {
5248  return __builtin_altivec_vminud(__a, __b);
5249 }
5250 
5251 static __inline__ vector unsigned long long __ATTRS_o_ai
5252 vec_min(vector bool long long __a, vector unsigned long long __b) {
5253  return __builtin_altivec_vminud((vector unsigned long long)__a, __b);
5254 }
5255 
5256 static __inline__ vector unsigned long long __ATTRS_o_ai
5257 vec_min(vector unsigned long long __a, vector bool long long __b) {
5258  return __builtin_altivec_vminud(__a, (vector unsigned long long)__b);
5259 }
5260 #endif
5261 
5262 static __inline__ vector float __ATTRS_o_ai vec_min(vector float __a,
5263  vector float __b) {
5264 #ifdef __VSX__
5265  return __builtin_vsx_xvminsp(__a, __b);
5266 #else
5267  return __builtin_altivec_vminfp(__a, __b);
5268 #endif
5269 }
5270 
5271 #ifdef __VSX__
5272 static __inline__ vector double __ATTRS_o_ai vec_min(vector double __a,
5273  vector double __b) {
5274  return __builtin_vsx_xvmindp(__a, __b);
5275 }
5276 #endif
5277 
5278 /* vec_vminsb */
5279 
5280 static __inline__ vector signed char __ATTRS_o_ai
5281 vec_vminsb(vector signed char __a, vector signed char __b) {
5282  return __builtin_altivec_vminsb(__a, __b);
5283 }
5284 
5285 static __inline__ vector signed char __ATTRS_o_ai
5286 vec_vminsb(vector bool char __a, vector signed char __b) {
5287  return __builtin_altivec_vminsb((vector signed char)__a, __b);
5288 }
5289 
5290 static __inline__ vector signed char __ATTRS_o_ai
5291 vec_vminsb(vector signed char __a, vector bool char __b) {
5292  return __builtin_altivec_vminsb(__a, (vector signed char)__b);
5293 }
5294 
5295 /* vec_vminub */
5296 
5297 static __inline__ vector unsigned char __ATTRS_o_ai
5298 vec_vminub(vector unsigned char __a, vector unsigned char __b) {
5299  return __builtin_altivec_vminub(__a, __b);
5300 }
5301 
5302 static __inline__ vector unsigned char __ATTRS_o_ai
5303 vec_vminub(vector bool char __a, vector unsigned char __b) {
5304  return __builtin_altivec_vminub((vector unsigned char)__a, __b);
5305 }
5306 
5307 static __inline__ vector unsigned char __ATTRS_o_ai
5308 vec_vminub(vector unsigned char __a, vector bool char __b) {
5309  return __builtin_altivec_vminub(__a, (vector unsigned char)__b);
5310 }
5311 
5312 /* vec_vminsh */
5313 
5314 static __inline__ vector short __ATTRS_o_ai vec_vminsh(vector short __a,
5315  vector short __b) {
5316  return __builtin_altivec_vminsh(__a, __b);
5317 }
5318 
5319 static __inline__ vector short __ATTRS_o_ai vec_vminsh(vector bool short __a,
5320  vector short __b) {
5321  return __builtin_altivec_vminsh((vector short)__a, __b);
5322 }
5323 
5324 static __inline__ vector short __ATTRS_o_ai vec_vminsh(vector short __a,
5325  vector bool short __b) {
5326  return __builtin_altivec_vminsh(__a, (vector short)__b);
5327 }
5328 
5329 /* vec_vminuh */
5330 
5331 static __inline__ vector unsigned short __ATTRS_o_ai
5332 vec_vminuh(vector unsigned short __a, vector unsigned short __b) {
5333  return __builtin_altivec_vminuh(__a, __b);
5334 }
5335 
5336 static __inline__ vector unsigned short __ATTRS_o_ai
5337 vec_vminuh(vector bool short __a, vector unsigned short __b) {
5338  return __builtin_altivec_vminuh((vector unsigned short)__a, __b);
5339 }
5340 
5341 static __inline__ vector unsigned short __ATTRS_o_ai
5342 vec_vminuh(vector unsigned short __a, vector bool short __b) {
5343  return __builtin_altivec_vminuh(__a, (vector unsigned short)__b);
5344 }
5345 
5346 /* vec_vminsw */
5347 
5348 static __inline__ vector int __ATTRS_o_ai vec_vminsw(vector int __a,
5349  vector int __b) {
5350  return __builtin_altivec_vminsw(__a, __b);
5351 }
5352 
5353 static __inline__ vector int __ATTRS_o_ai vec_vminsw(vector bool int __a,
5354  vector int __b) {
5355  return __builtin_altivec_vminsw((vector int)__a, __b);
5356 }
5357 
5358 static __inline__ vector int __ATTRS_o_ai vec_vminsw(vector int __a,
5359  vector bool int __b) {
5360  return __builtin_altivec_vminsw(__a, (vector int)__b);
5361 }
5362 
5363 /* vec_vminuw */
5364 
5365 static __inline__ vector unsigned int __ATTRS_o_ai
5366 vec_vminuw(vector unsigned int __a, vector unsigned int __b) {
5367  return __builtin_altivec_vminuw(__a, __b);
5368 }
5369 
5370 static __inline__ vector unsigned int __ATTRS_o_ai
5371 vec_vminuw(vector bool int __a, vector unsigned int __b) {
5372  return __builtin_altivec_vminuw((vector unsigned int)__a, __b);
5373 }
5374 
5375 static __inline__ vector unsigned int __ATTRS_o_ai
5376 vec_vminuw(vector unsigned int __a, vector bool int __b) {
5377  return __builtin_altivec_vminuw(__a, (vector unsigned int)__b);
5378 }
5379 
5380 /* vec_vminfp */
5381 
5382 static __inline__ vector float __attribute__((__always_inline__))
5383 vec_vminfp(vector float __a, vector float __b) {
5384 #ifdef __VSX__
5385  return __builtin_vsx_xvminsp(__a, __b);
5386 #else
5387  return __builtin_altivec_vminfp(__a, __b);
5388 #endif
5389 }
5390 
5391 /* vec_mladd */
5392 
5393 #define __builtin_altivec_vmladduhm vec_mladd
5394 
5395 static __inline__ vector short __ATTRS_o_ai vec_mladd(vector short __a,
5396  vector short __b,
5397  vector short __c) {
5398  return __a * __b + __c;
5399 }
5400 
5401 static __inline__ vector short __ATTRS_o_ai vec_mladd(
5402  vector short __a, vector unsigned short __b, vector unsigned short __c) {
5403  return __a * (vector short)__b + (vector short)__c;
5404 }
5405 
5406 static __inline__ vector short __ATTRS_o_ai vec_mladd(vector unsigned short __a,
5407  vector short __b,
5408  vector short __c) {
5409  return (vector short)__a * __b + __c;
5410 }
5411 
5412 static __inline__ vector unsigned short __ATTRS_o_ai
5413 vec_mladd(vector unsigned short __a, vector unsigned short __b,
5414  vector unsigned short __c) {
5415  return __a * __b + __c;
5416 }
5417 
5418 /* vec_vmladduhm */
5419 
5420 static __inline__ vector short __ATTRS_o_ai vec_vmladduhm(vector short __a,
5421  vector short __b,
5422  vector short __c) {
5423  return __a * __b + __c;
5424 }
5425 
5426 static __inline__ vector short __ATTRS_o_ai vec_vmladduhm(
5427  vector short __a, vector unsigned short __b, vector unsigned short __c) {
5428  return __a * (vector short)__b + (vector short)__c;
5429 }
5430 
5431 static __inline__ vector short __ATTRS_o_ai
5432 vec_vmladduhm(vector unsigned short __a, vector short __b, vector short __c) {
5433  return (vector short)__a * __b + __c;
5434 }
5435 
5436 static __inline__ vector unsigned short __ATTRS_o_ai
5437 vec_vmladduhm(vector unsigned short __a, vector unsigned short __b,
5438  vector unsigned short __c) {
5439  return __a * __b + __c;
5440 }
5441 
5442 /* vec_mradds */
5443 
5444 static __inline__ vector short __attribute__((__always_inline__))
5445 vec_mradds(vector short __a, vector short __b, vector short __c) {
5446  return __builtin_altivec_vmhraddshs(__a, __b, __c);
5447 }
5448 
5449 /* vec_vmhraddshs */
5450 
5451 static __inline__ vector short __attribute__((__always_inline__))
5452 vec_vmhraddshs(vector short __a, vector short __b, vector short __c) {
5453  return __builtin_altivec_vmhraddshs(__a, __b, __c);
5454 }
5455 
5456 /* vec_msum */
5457 
5458 static __inline__ vector int __ATTRS_o_ai vec_msum(vector signed char __a,
5459  vector unsigned char __b,
5460  vector int __c) {
5461  return __builtin_altivec_vmsummbm(__a, __b, __c);
5462 }
5463 
5464 static __inline__ vector unsigned int __ATTRS_o_ai
5465 vec_msum(vector unsigned char __a, vector unsigned char __b,
5466  vector unsigned int __c) {
5467  return __builtin_altivec_vmsumubm(__a, __b, __c);
5468 }
5469 
5470 static __inline__ vector int __ATTRS_o_ai vec_msum(vector short __a,
5471  vector short __b,
5472  vector int __c) {
5473  return __builtin_altivec_vmsumshm(__a, __b, __c);
5474 }
5475 
5476 static __inline__ vector unsigned int __ATTRS_o_ai
5477 vec_msum(vector unsigned short __a, vector unsigned short __b,
5478  vector unsigned int __c) {
5479  return __builtin_altivec_vmsumuhm(__a, __b, __c);
5480 }
5481 
5482 /* vec_vmsummbm */
5483 
5484 static __inline__ vector int __attribute__((__always_inline__))
5485 vec_vmsummbm(vector signed char __a, vector unsigned char __b, vector int __c) {
5486  return __builtin_altivec_vmsummbm(__a, __b, __c);
5487 }
5488 
5489 /* vec_vmsumubm */
5490 
5491 static __inline__ vector unsigned int __attribute__((__always_inline__))
5492 vec_vmsumubm(vector unsigned char __a, vector unsigned char __b,
5493  vector unsigned int __c) {
5494  return __builtin_altivec_vmsumubm(__a, __b, __c);
5495 }
5496 
5497 /* vec_vmsumshm */
5498 
5499 static __inline__ vector int __attribute__((__always_inline__))
5500 vec_vmsumshm(vector short __a, vector short __b, vector int __c) {
5501  return __builtin_altivec_vmsumshm(__a, __b, __c);
5502 }
5503 
5504 /* vec_vmsumuhm */
5505 
5506 static __inline__ vector unsigned int __attribute__((__always_inline__))
5507 vec_vmsumuhm(vector unsigned short __a, vector unsigned short __b,
5508  vector unsigned int __c) {
5509  return __builtin_altivec_vmsumuhm(__a, __b, __c);
5510 }
5511 
5512 /* vec_msums */
5513 
5514 static __inline__ vector int __ATTRS_o_ai vec_msums(vector short __a,
5515  vector short __b,
5516  vector int __c) {
5517  return __builtin_altivec_vmsumshs(__a, __b, __c);
5518 }
5519 
5520 static __inline__ vector unsigned int __ATTRS_o_ai
5521 vec_msums(vector unsigned short __a, vector unsigned short __b,
5522  vector unsigned int __c) {
5523  return __builtin_altivec_vmsumuhs(__a, __b, __c);
5524 }
5525 
5526 /* vec_vmsumshs */
5527 
5528 static __inline__ vector int __attribute__((__always_inline__))
5529 vec_vmsumshs(vector short __a, vector short __b, vector int __c) {
5530  return __builtin_altivec_vmsumshs(__a, __b, __c);
5531 }
5532 
5533 /* vec_vmsumuhs */
5534 
5535 static __inline__ vector unsigned int __attribute__((__always_inline__))
5536 vec_vmsumuhs(vector unsigned short __a, vector unsigned short __b,
5537  vector unsigned int __c) {
5538  return __builtin_altivec_vmsumuhs(__a, __b, __c);
5539 }
5540 
5541 /* vec_mtvscr */
5542 
5543 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector signed char __a) {
5544  __builtin_altivec_mtvscr((vector int)__a);
5545 }
5546 
5547 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector unsigned char __a) {
5548  __builtin_altivec_mtvscr((vector int)__a);
5549 }
5550 
5551 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector bool char __a) {
5552  __builtin_altivec_mtvscr((vector int)__a);
5553 }
5554 
5555 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector short __a) {
5556  __builtin_altivec_mtvscr((vector int)__a);
5557 }
5558 
5559 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector unsigned short __a) {
5560  __builtin_altivec_mtvscr((vector int)__a);
5561 }
5562 
5563 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector bool short __a) {
5564  __builtin_altivec_mtvscr((vector int)__a);
5565 }
5566 
5567 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector pixel __a) {
5568  __builtin_altivec_mtvscr((vector int)__a);
5569 }
5570 
5571 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector int __a) {
5572  __builtin_altivec_mtvscr((vector int)__a);
5573 }
5574 
5575 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector unsigned int __a) {
5576  __builtin_altivec_mtvscr((vector int)__a);
5577 }
5578 
5579 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector bool int __a) {
5580  __builtin_altivec_mtvscr((vector int)__a);
5581 }
5582 
5583 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector float __a) {
5584  __builtin_altivec_mtvscr((vector int)__a);
5585 }
5586 
5587 /* vec_mul */
5588 
5589 /* Integer vector multiplication will involve multiplication of the odd/even
5590  elements separately, then truncating the results and moving to the
5591  result vector.
5592 */
5593 static __inline__ vector signed char __ATTRS_o_ai
5594 vec_mul(vector signed char __a, vector signed char __b) {
5595  return __a * __b;
5596 }
5597 
5598 static __inline__ vector unsigned char __ATTRS_o_ai
5599 vec_mul(vector unsigned char __a, vector unsigned char __b) {
5600  return __a * __b;
5601 }
5602 
5603 static __inline__ vector signed short __ATTRS_o_ai
5604 vec_mul(vector signed short __a, vector signed short __b) {
5605  return __a * __b;
5606 }
5607 
5608 static __inline__ vector unsigned short __ATTRS_o_ai
5609 vec_mul(vector unsigned short __a, vector unsigned short __b) {
5610  return __a * __b;
5611 }
5612 
5613 static __inline__ vector signed int __ATTRS_o_ai
5614 vec_mul(vector signed int __a, vector signed int __b) {
5615  return __a * __b;
5616 }
5617 
5618 static __inline__ vector unsigned int __ATTRS_o_ai
5619 vec_mul(vector unsigned int __a, vector unsigned int __b) {
5620  return __a * __b;
5621 }
5622 
5623 #ifdef __VSX__
5624 static __inline__ vector signed long long __ATTRS_o_ai
5625 vec_mul(vector signed long long __a, vector signed long long __b) {
5626  return __a * __b;
5627 }
5628 
5629 static __inline__ vector unsigned long long __ATTRS_o_ai
5630 vec_mul(vector unsigned long long __a, vector unsigned long long __b) {
5631  return __a * __b;
5632 }
5633 #endif
5634 
5635 static __inline__ vector float __ATTRS_o_ai vec_mul(vector float __a,
5636  vector float __b) {
5637  return __a * __b;
5638 }
5639 
5640 #ifdef __VSX__
5641 static __inline__ vector double __ATTRS_o_ai vec_mul(vector double __a,
5642  vector double __b) {
5643  return __a * __b;
5644 }
5645 #endif
5646 
5647 /* The vmulos* and vmules* instructions have a big endian bias, so
5648  we must reverse the meaning of "even" and "odd" for little endian. */
5649 
5650 /* vec_mule */
5651 
5652 static __inline__ vector short __ATTRS_o_ai vec_mule(vector signed char __a,
5653  vector signed char __b) {
5654 #ifdef __LITTLE_ENDIAN__
5655  return __builtin_altivec_vmulosb(__a, __b);
5656 #else
5657  return __builtin_altivec_vmulesb(__a, __b);
5658 #endif
5659 }
5660 
5661 static __inline__ vector unsigned short __ATTRS_o_ai
5662 vec_mule(vector unsigned char __a, vector unsigned char __b) {
5663 #ifdef __LITTLE_ENDIAN__
5664  return __builtin_altivec_vmuloub(__a, __b);
5665 #else
5666  return __builtin_altivec_vmuleub(__a, __b);
5667 #endif
5668 }
5669 
5670 static __inline__ vector int __ATTRS_o_ai vec_mule(vector short __a,
5671  vector short __b) {
5672 #ifdef __LITTLE_ENDIAN__
5673  return __builtin_altivec_vmulosh(__a, __b);
5674 #else
5675  return __builtin_altivec_vmulesh(__a, __b);
5676 #endif
5677 }
5678 
5679 static __inline__ vector unsigned int __ATTRS_o_ai
5680 vec_mule(vector unsigned short __a, vector unsigned short __b) {
5681 #ifdef __LITTLE_ENDIAN__
5682  return __builtin_altivec_vmulouh(__a, __b);
5683 #else
5684  return __builtin_altivec_vmuleuh(__a, __b);
5685 #endif
5686 }
5687 
5688 #ifdef __POWER8_VECTOR__
5689 static __inline__ vector signed long long __ATTRS_o_ai
5690 vec_mule(vector signed int __a, vector signed int __b) {
5691 #ifdef __LITTLE_ENDIAN__
5692  return __builtin_altivec_vmulosw(__a, __b);
5693 #else
5694  return __builtin_altivec_vmulesw(__a, __b);
5695 #endif
5696 }
5697 
5698 static __inline__ vector unsigned long long __ATTRS_o_ai
5699 vec_mule(vector unsigned int __a, vector unsigned int __b) {
5700 #ifdef __LITTLE_ENDIAN__
5701  return __builtin_altivec_vmulouw(__a, __b);
5702 #else
5703  return __builtin_altivec_vmuleuw(__a, __b);
5704 #endif
5705 }
5706 #endif
5707 
5708 /* vec_vmulesb */
5709 
5710 static __inline__ vector short __attribute__((__always_inline__))
5711 vec_vmulesb(vector signed char __a, vector signed char __b) {
5712 #ifdef __LITTLE_ENDIAN__
5713  return __builtin_altivec_vmulosb(__a, __b);
5714 #else
5715  return __builtin_altivec_vmulesb(__a, __b);
5716 #endif
5717 }
5718 
5719 /* vec_vmuleub */
5720 
5721 static __inline__ vector unsigned short __attribute__((__always_inline__))
5722 vec_vmuleub(vector unsigned char __a, vector unsigned char __b) {
5723 #ifdef __LITTLE_ENDIAN__
5724  return __builtin_altivec_vmuloub(__a, __b);
5725 #else
5726  return __builtin_altivec_vmuleub(__a, __b);
5727 #endif
5728 }
5729 
5730 /* vec_vmulesh */
5731 
5732 static __inline__ vector int __attribute__((__always_inline__))
5733 vec_vmulesh(vector short __a, vector short __b) {
5734 #ifdef __LITTLE_ENDIAN__
5735  return __builtin_altivec_vmulosh(__a, __b);
5736 #else
5737  return __builtin_altivec_vmulesh(__a, __b);
5738 #endif
5739 }
5740 
5741 /* vec_vmuleuh */
5742 
5743 static __inline__ vector unsigned int __attribute__((__always_inline__))
5744 vec_vmuleuh(vector unsigned short __a, vector unsigned short __b) {
5745 #ifdef __LITTLE_ENDIAN__
5746  return __builtin_altivec_vmulouh(__a, __b);
5747 #else
5748  return __builtin_altivec_vmuleuh(__a, __b);
5749 #endif
5750 }
5751 
5752 /* vec_mulo */
5753 
5754 static __inline__ vector short __ATTRS_o_ai vec_mulo(vector signed char __a,
5755  vector signed char __b) {
5756 #ifdef __LITTLE_ENDIAN__
5757  return __builtin_altivec_vmulesb(__a, __b);
5758 #else
5759  return __builtin_altivec_vmulosb(__a, __b);
5760 #endif
5761 }
5762 
5763 static __inline__ vector unsigned short __ATTRS_o_ai
5764 vec_mulo(vector unsigned char __a, vector unsigned char __b) {
5765 #ifdef __LITTLE_ENDIAN__
5766  return __builtin_altivec_vmuleub(__a, __b);
5767 #else
5768  return __builtin_altivec_vmuloub(__a, __b);
5769 #endif
5770 }
5771 
5772 static __inline__ vector int __ATTRS_o_ai vec_mulo(vector short __a,
5773  vector short __b) {
5774 #ifdef __LITTLE_ENDIAN__
5775  return __builtin_altivec_vmulesh(__a, __b);
5776 #else
5777  return __builtin_altivec_vmulosh(__a, __b);
5778 #endif
5779 }
5780 
5781 static __inline__ vector unsigned int __ATTRS_o_ai
5782 vec_mulo(vector unsigned short __a, vector unsigned short __b) {
5783 #ifdef __LITTLE_ENDIAN__
5784  return __builtin_altivec_vmuleuh(__a, __b);
5785 #else
5786  return __builtin_altivec_vmulouh(__a, __b);
5787 #endif
5788 }
5789 
5790 #ifdef __POWER8_VECTOR__
5791 static __inline__ vector signed long long __ATTRS_o_ai
5792 vec_mulo(vector signed int __a, vector signed int __b) {
5793 #ifdef __LITTLE_ENDIAN__
5794  return __builtin_altivec_vmulesw(__a, __b);
5795 #else
5796  return __builtin_altivec_vmulosw(__a, __b);
5797 #endif
5798 }
5799 
5800 static __inline__ vector unsigned long long __ATTRS_o_ai
5801 vec_mulo(vector unsigned int __a, vector unsigned int __b) {
5802 #ifdef __LITTLE_ENDIAN__
5803  return __builtin_altivec_vmuleuw(__a, __b);
5804 #else
5805  return __builtin_altivec_vmulouw(__a, __b);
5806 #endif
5807 }
5808 #endif
5809 
5810 /* vec_vmulosb */
5811 
5812 static __inline__ vector short __attribute__((__always_inline__))
5813 vec_vmulosb(vector signed char __a, vector signed char __b) {
5814 #ifdef __LITTLE_ENDIAN__
5815  return __builtin_altivec_vmulesb(__a, __b);
5816 #else
5817  return __builtin_altivec_vmulosb(__a, __b);
5818 #endif
5819 }
5820 
5821 /* vec_vmuloub */
5822 
5823 static __inline__ vector unsigned short __attribute__((__always_inline__))
5824 vec_vmuloub(vector unsigned char __a, vector unsigned char __b) {
5825 #ifdef __LITTLE_ENDIAN__
5826  return __builtin_altivec_vmuleub(__a, __b);
5827 #else
5828  return __builtin_altivec_vmuloub(__a, __b);
5829 #endif
5830 }
5831 
5832 /* vec_vmulosh */
5833 
5834 static __inline__ vector int __attribute__((__always_inline__))
5835 vec_vmulosh(vector short __a, vector short __b) {
5836 #ifdef __LITTLE_ENDIAN__
5837  return __builtin_altivec_vmulesh(__a, __b);
5838 #else
5839  return __builtin_altivec_vmulosh(__a, __b);
5840 #endif
5841 }
5842 
5843 /* vec_vmulouh */
5844 
5845 static __inline__ vector unsigned int __attribute__((__always_inline__))
5846 vec_vmulouh(vector unsigned short __a, vector unsigned short __b) {
5847 #ifdef __LITTLE_ENDIAN__
5848  return __builtin_altivec_vmuleuh(__a, __b);
5849 #else
5850  return __builtin_altivec_vmulouh(__a, __b);
5851 #endif
5852 }
5853 
5854 /* vec_nand */
5855 
5856 #ifdef __POWER8_VECTOR__
5857 static __inline__ vector signed char __ATTRS_o_ai
5858 vec_nand(vector signed char __a, vector signed char __b) {
5859  return ~(__a & __b);
5860 }
5861 
5862 static __inline__ vector signed char __ATTRS_o_ai
5863 vec_nand(vector signed char __a, vector bool char __b) {
5864  return ~(__a & __b);
5865 }
5866 
5867 static __inline__ vector signed char __ATTRS_o_ai
5868 vec_nand(vector bool char __a, vector signed char __b) {
5869  return ~(__a & __b);
5870 }
5871 
5872 static __inline__ vector unsigned char __ATTRS_o_ai
5873 vec_nand(vector unsigned char __a, vector unsigned char __b) {
5874  return ~(__a & __b);
5875 }
5876 
5877 static __inline__ vector unsigned char __ATTRS_o_ai
5878 vec_nand(vector unsigned char __a, vector bool char __b) {
5879  return ~(__a & __b);
5880 }
5881 
5882 static __inline__ vector unsigned char __ATTRS_o_ai
5883 vec_nand(vector bool char __a, vector unsigned char __b) {
5884  return ~(__a & __b);
5885 }
5886 
5887 static __inline__ vector bool char __ATTRS_o_ai vec_nand(vector bool char __a,
5888  vector bool char __b) {
5889  return ~(__a & __b);
5890 }
5891 
5892 static __inline__ vector signed short __ATTRS_o_ai
5893 vec_nand(vector signed short __a, vector signed short __b) {
5894  return ~(__a & __b);
5895 }
5896 
5897 static __inline__ vector signed short __ATTRS_o_ai
5898 vec_nand(vector signed short __a, vector bool short __b) {
5899  return ~(__a & __b);
5900 }
5901 
5902 static __inline__ vector signed short __ATTRS_o_ai
5903 vec_nand(vector bool short __a, vector signed short __b) {
5904  return ~(__a & __b);
5905 }
5906 
5907 static __inline__ vector unsigned short __ATTRS_o_ai
5908 vec_nand(vector unsigned short __a, vector unsigned short __b) {
5909  return ~(__a & __b);
5910 }
5911 
5912 static __inline__ vector unsigned short __ATTRS_o_ai
5913 vec_nand(vector unsigned short __a, vector bool short __b) {
5914  return ~(__a & __b);
5915 }
5916 
5917 static __inline__ vector bool short __ATTRS_o_ai
5918 vec_nand(vector bool short __a, vector bool short __b) {
5919  return ~(__a & __b);
5920 }
5921 
5922 static __inline__ vector signed int __ATTRS_o_ai
5923 vec_nand(vector signed int __a, vector signed int __b) {
5924  return ~(__a & __b);
5925 }
5926 
5927 static __inline__ vector signed int __ATTRS_o_ai vec_nand(vector signed int __a,
5928  vector bool int __b) {
5929  return ~(__a & __b);
5930 }
5931 
5932 static __inline__ vector signed int __ATTRS_o_ai
5933 vec_nand(vector bool int __a, vector signed int __b) {
5934  return ~(__a & __b);
5935 }
5936 
5937 static __inline__ vector unsigned int __ATTRS_o_ai
5938 vec_nand(vector unsigned int __a, vector unsigned int __b) {
5939  return ~(__a & __b);
5940 }
5941 
5942 static __inline__ vector unsigned int __ATTRS_o_ai
5943 vec_nand(vector unsigned int __a, vector bool int __b) {
5944  return ~(__a & __b);
5945 }
5946 
5947 static __inline__ vector unsigned int __ATTRS_o_ai
5948 vec_nand(vector bool int __a, vector unsigned int __b) {
5949  return ~(__a & __b);
5950 }
5951 
5952 static __inline__ vector bool int __ATTRS_o_ai vec_nand(vector bool int __a,
5953  vector bool int __b) {
5954  return ~(__a & __b);
5955 }
5956 
5957 static __inline__ vector float __ATTRS_o_ai
5958 vec_nand(vector float __a, vector float __b) {
5959  return (vector float)(~((vector unsigned int)__a &
5960  (vector unsigned int)__b));
5961 }
5962 
5963 static __inline__ vector signed long long __ATTRS_o_ai
5964 vec_nand(vector signed long long __a, vector signed long long __b) {
5965  return ~(__a & __b);
5966 }
5967 
5968 static __inline__ vector signed long long __ATTRS_o_ai
5969 vec_nand(vector signed long long __a, vector bool long long __b) {
5970  return ~(__a & __b);
5971 }
5972 
5973 static __inline__ vector signed long long __ATTRS_o_ai
5974 vec_nand(vector bool long long __a, vector signed long long __b) {
5975  return ~(__a & __b);
5976 }
5977 
5978 static __inline__ vector unsigned long long __ATTRS_o_ai
5979 vec_nand(vector unsigned long long __a, vector unsigned long long __b) {
5980  return ~(__a & __b);
5981 }
5982 
5983 static __inline__ vector unsigned long long __ATTRS_o_ai
5984 vec_nand(vector unsigned long long __a, vector bool long long __b) {
5985  return ~(__a & __b);
5986 }
5987 
5988 static __inline__ vector unsigned long long __ATTRS_o_ai
5989 vec_nand(vector bool long long __a, vector unsigned long long __b) {
5990  return ~(__a & __b);
5991 }
5992 
5993 static __inline__ vector bool long long __ATTRS_o_ai
5994 vec_nand(vector bool long long __a, vector bool long long __b) {
5995  return ~(__a & __b);
5996 }
5997 
5998 static __inline__ vector double __ATTRS_o_ai
5999 vec_nand(vector double __a, vector double __b) {
6000  return (vector double)(~((vector unsigned long long)__a &
6001  (vector unsigned long long)__b));
6002 }
6003 
6004 #endif
6005 
6006 /* vec_nmadd */
6007 
6008 #ifdef __VSX__
6009 static __inline__ vector float __ATTRS_o_ai vec_nmadd(vector float __a,
6010  vector float __b,
6011  vector float __c) {
6012  return __builtin_vsx_xvnmaddasp(__a, __b, __c);
6013 }
6014 
6015 static __inline__ vector double __ATTRS_o_ai vec_nmadd(vector double __a,
6016  vector double __b,
6017  vector double __c) {
6018  return __builtin_vsx_xvnmaddadp(__a, __b, __c);
6019 }
6020 #endif
6021 
6022 /* vec_nmsub */
6023 
6024 static __inline__ vector float __ATTRS_o_ai vec_nmsub(vector float __a,
6025  vector float __b,
6026  vector float __c) {
6027 #ifdef __VSX__
6028  return __builtin_vsx_xvnmsubasp(__a, __b, __c);
6029 #else
6030  return __builtin_altivec_vnmsubfp(__a, __b, __c);
6031 #endif
6032 }
6033 
6034 #ifdef __VSX__
6035 static __inline__ vector double __ATTRS_o_ai vec_nmsub(vector double __a,
6036  vector double __b,
6037  vector double __c) {
6038  return __builtin_vsx_xvnmsubadp(__a, __b, __c);
6039 }
6040 #endif
6041 
6042 /* vec_vnmsubfp */
6043 
6044 static __inline__ vector float __attribute__((__always_inline__))
6045 vec_vnmsubfp(vector float __a, vector float __b, vector float __c) {
6046  return __builtin_altivec_vnmsubfp(__a, __b, __c);
6047 }
6048 
6049 /* vec_nor */
6050 
6051 #define __builtin_altivec_vnor vec_nor
6052 
6053 static __inline__ vector signed char __ATTRS_o_ai
6054 vec_nor(vector signed char __a, vector signed char __b) {
6055  return ~(__a | __b);
6056 }
6057 
6058 static __inline__ vector unsigned char __ATTRS_o_ai
6059 vec_nor(vector unsigned char __a, vector unsigned char __b) {
6060  return ~(__a | __b);
6061 }
6062 
6063 static __inline__ vector bool char __ATTRS_o_ai vec_nor(vector bool char __a,
6064  vector bool char __b) {
6065  return ~(__a | __b);
6066 }
6067 
6068 static __inline__ vector short __ATTRS_o_ai vec_nor(vector short __a,
6069  vector short __b) {
6070  return ~(__a | __b);
6071 }
6072 
6073 static __inline__ vector unsigned short __ATTRS_o_ai
6074 vec_nor(vector unsigned short __a, vector unsigned short __b) {
6075  return ~(__a | __b);
6076 }
6077 
6078 static __inline__ vector bool short __ATTRS_o_ai
6079 vec_nor(vector bool short __a, vector bool short __b) {
6080  return ~(__a | __b);
6081 }
6082 
6083 static __inline__ vector int __ATTRS_o_ai vec_nor(vector int __a,
6084  vector int __b) {
6085  return ~(__a | __b);
6086 }
6087 
6088 static __inline__ vector unsigned int __ATTRS_o_ai
6089 vec_nor(vector unsigned int __a, vector unsigned int __b) {
6090  return ~(__a | __b);
6091 }
6092 
6093 static __inline__ vector bool int __ATTRS_o_ai vec_nor(vector bool int __a,
6094  vector bool int __b) {
6095  return ~(__a | __b);
6096 }
6097 
6098 static __inline__ vector float __ATTRS_o_ai vec_nor(vector float __a,
6099  vector float __b) {
6100  vector unsigned int __res =
6101  ~((vector unsigned int)__a | (vector unsigned int)__b);
6102  return (vector float)__res;
6103 }
6104 
6105 #ifdef __VSX__
6106 static __inline__ vector double __ATTRS_o_ai vec_nor(vector double __a,
6107  vector double __b) {
6108  vector unsigned long long __res =
6109  ~((vector unsigned long long)__a | (vector unsigned long long)__b);
6110  return (vector double)__res;
6111 }
6112 #endif
6113 
6114 /* vec_vnor */
6115 
6116 static __inline__ vector signed char __ATTRS_o_ai
6117 vec_vnor(vector signed char __a, vector signed char __b) {
6118  return ~(__a | __b);
6119 }
6120 
6121 static __inline__ vector unsigned char __ATTRS_o_ai
6122 vec_vnor(vector unsigned char __a, vector unsigned char __b) {
6123  return ~(__a | __b);
6124 }
6125 
6126 static __inline__ vector bool char __ATTRS_o_ai vec_vnor(vector bool char __a,
6127  vector bool char __b) {
6128  return ~(__a | __b);
6129 }
6130 
6131 static __inline__ vector short __ATTRS_o_ai vec_vnor(vector short __a,
6132  vector short __b) {
6133  return ~(__a | __b);
6134 }
6135 
6136 static __inline__ vector unsigned short __ATTRS_o_ai
6137 vec_vnor(vector unsigned short __a, vector unsigned short __b) {
6138  return ~(__a | __b);
6139 }
6140 
6141 static __inline__ vector bool short __ATTRS_o_ai
6142 vec_vnor(vector bool short __a, vector bool short __b) {
6143  return ~(__a | __b);
6144 }
6145 
6146 static __inline__ vector int __ATTRS_o_ai vec_vnor(vector int __a,
6147  vector int __b) {
6148  return ~(__a | __b);
6149 }
6150 
6151 static __inline__ vector unsigned int __ATTRS_o_ai
6152 vec_vnor(vector unsigned int __a, vector unsigned int __b) {
6153  return ~(__a | __b);
6154 }
6155 
6156 static __inline__ vector bool int __ATTRS_o_ai vec_vnor(vector bool int __a,
6157  vector bool int __b) {
6158  return ~(__a | __b);
6159 }
6160 
6161 static __inline__ vector float __ATTRS_o_ai vec_vnor(vector float __a,
6162  vector float __b) {
6163  vector unsigned int __res =
6164  ~((vector unsigned int)__a | (vector unsigned int)__b);
6165  return (vector float)__res;
6166 }
6167 
6168 #ifdef __VSX__
6169 static __inline__ vector signed long long __ATTRS_o_ai
6170 vec_nor(vector signed long long __a, vector signed long long __b) {
6171  return ~(__a | __b);
6172 }
6173 
6174 static __inline__ vector unsigned long long __ATTRS_o_ai
6175 vec_nor(vector unsigned long long __a, vector unsigned long long __b) {
6176  return ~(__a | __b);
6177 }
6178 
6179 static __inline__ vector bool long long __ATTRS_o_ai
6180 vec_nor(vector bool long long __a, vector bool long long __b) {
6181  return ~(__a | __b);
6182 }
6183 #endif
6184 
6185 /* vec_or */
6186 
6187 #define __builtin_altivec_vor vec_or
6188 
6189 static __inline__ vector signed char __ATTRS_o_ai
6190 vec_or(vector signed char __a, vector signed char __b) {
6191  return __a | __b;
6192 }
6193 
6194 static __inline__ vector signed char __ATTRS_o_ai
6195 vec_or(vector bool char __a, vector signed char __b) {
6196  return (vector signed char)__a | __b;
6197 }
6198 
6199 static __inline__ vector signed char __ATTRS_o_ai vec_or(vector signed char __a,
6200  vector bool char __b) {
6201  return __a | (vector signed char)__b;
6202 }
6203 
6204 static __inline__ vector unsigned char __ATTRS_o_ai
6205 vec_or(vector unsigned char __a, vector unsigned char __b) {
6206  return __a | __b;
6207 }
6208 
6209 static __inline__ vector unsigned char __ATTRS_o_ai
6210 vec_or(vector bool char __a, vector unsigned char __b) {
6211  return (vector unsigned char)__a | __b;
6212 }
6213 
6214 static __inline__ vector unsigned char __ATTRS_o_ai
6215 vec_or(vector unsigned char __a, vector bool char __b) {
6216  return __a | (vector unsigned char)__b;
6217 }
6218 
6219 static __inline__ vector bool char __ATTRS_o_ai vec_or(vector bool char __a,
6220  vector bool char __b) {
6221  return __a | __b;
6222 }
6223 
6224 static __inline__ vector short __ATTRS_o_ai vec_or(vector short __a,
6225  vector short __b) {
6226  return __a | __b;
6227 }
6228 
6229 static __inline__ vector short __ATTRS_o_ai vec_or(vector bool short __a,
6230  vector short __b) {
6231  return (vector short)__a | __b;
6232 }
6233 
6234 static __inline__ vector short __ATTRS_o_ai vec_or(vector short __a,
6235  vector bool short __b) {
6236  return __a | (vector short)__b;
6237 }
6238 
6239 static __inline__ vector unsigned short __ATTRS_o_ai
6240 vec_or(vector unsigned short __a, vector unsigned short __b) {
6241  return __a | __b;
6242 }
6243 
6244 static __inline__ vector unsigned short __ATTRS_o_ai
6245 vec_or(vector bool short __a, vector unsigned short __b) {
6246  return (vector unsigned short)__a | __b;
6247 }
6248 
6249 static __inline__ vector unsigned short __ATTRS_o_ai
6250 vec_or(vector unsigned short __a, vector bool short __b) {
6251  return __a | (vector unsigned short)__b;
6252 }
6253 
6254 static __inline__ vector bool short __ATTRS_o_ai vec_or(vector bool short __a,
6255  vector bool short __b) {
6256  return __a | __b;
6257 }
6258 
6259 static __inline__ vector int __ATTRS_o_ai vec_or(vector int __a,
6260  vector int __b) {
6261  return __a | __b;
6262 }
6263 
6264 static __inline__ vector int __ATTRS_o_ai vec_or(vector bool int __a,
6265  vector int __b) {
6266  return (vector int)__a | __b;
6267 }
6268 
6269 static __inline__ vector int __ATTRS_o_ai vec_or(vector int __a,
6270  vector bool int __b) {
6271  return __a | (vector int)__b;
6272 }
6273 
6274 static __inline__ vector unsigned int __ATTRS_o_ai
6275 vec_or(vector unsigned int __a, vector unsigned int __b) {
6276  return __a | __b;
6277 }
6278 
6279 static __inline__ vector unsigned int __ATTRS_o_ai
6280 vec_or(vector bool int __a, vector unsigned int __b) {
6281  return (vector unsigned int)__a | __b;
6282 }
6283 
6284 static __inline__ vector unsigned int __ATTRS_o_ai
6285 vec_or(vector unsigned int __a, vector bool int __b) {
6286  return __a | (vector unsigned int)__b;
6287 }
6288 
6289 static __inline__ vector bool int __ATTRS_o_ai vec_or(vector bool int __a,
6290  vector bool int __b) {
6291  return __a | __b;
6292 }
6293 
6294 static __inline__ vector float __ATTRS_o_ai vec_or(vector float __a,
6295  vector float __b) {
6296  vector unsigned int __res =
6297  (vector unsigned int)__a | (vector unsigned int)__b;
6298  return (vector float)__res;
6299 }
6300 
6301 static __inline__ vector float __ATTRS_o_ai vec_or(vector bool int __a,
6302  vector float __b) {
6303  vector unsigned int __res =
6304  (vector unsigned int)__a | (vector unsigned int)__b;
6305  return (vector float)__res;
6306 }
6307 
6308 static __inline__ vector float __ATTRS_o_ai vec_or(vector float __a,
6309  vector bool int __b) {
6310  vector unsigned int __res =
6311  (vector unsigned int)__a | (vector unsigned int)__b;
6312  return (vector float)__res;
6313 }
6314 
6315 #ifdef __VSX__
6316 static __inline__ vector double __ATTRS_o_ai vec_or(vector bool long long __a,
6317  vector double __b) {
6318  return (vector unsigned long long)__a | (vector unsigned long long)__b;
6319 }
6320 
6321 static __inline__ vector double __ATTRS_o_ai vec_or(vector double __a,
6322  vector bool long long __b) {
6323  return (vector unsigned long long)__a | (vector unsigned long long)__b;
6324 }
6325 
6326 static __inline__ vector double __ATTRS_o_ai vec_or(vector double __a,
6327  vector double __b) {
6328  vector unsigned long long __res =
6329  (vector unsigned long long)__a | (vector unsigned long long)__b;
6330  return (vector double)__res;
6331 }
6332 
6333 static __inline__ vector signed long long __ATTRS_o_ai
6334 vec_or(vector signed long long __a, vector signed long long __b) {
6335  return __a | __b;
6336 }
6337 
6338 static __inline__ vector signed long long __ATTRS_o_ai
6339 vec_or(vector bool long long __a, vector signed long long __b) {
6340  return (vector signed long long)__a | __b;
6341 }
6342 
6343 static __inline__ vector signed long long __ATTRS_o_ai
6344 vec_or(vector signed long long __a, vector bool long long __b) {
6345  return __a | (vector signed long long)__b;
6346 }
6347 
6348 static __inline__ vector unsigned long long __ATTRS_o_ai
6349 vec_or(vector unsigned long long __a, vector unsigned long long __b) {
6350  return __a | __b;
6351 }
6352 
6353 static __inline__ vector unsigned long long __ATTRS_o_ai
6354 vec_or(vector bool long long __a, vector unsigned long long __b) {
6355  return (vector unsigned long long)__a | __b;
6356 }
6357 
6358 static __inline__ vector unsigned long long __ATTRS_o_ai
6359 vec_or(vector unsigned long long __a, vector bool long long __b) {
6360  return __a | (vector unsigned long long)__b;
6361 }
6362 
6363 static __inline__ vector bool long long __ATTRS_o_ai
6364 vec_or(vector bool long long __a, vector bool long long __b) {
6365  return __a | __b;
6366 }
6367 #endif
6368 
6369 #ifdef __POWER8_VECTOR__
6370 static __inline__ vector signed char __ATTRS_o_ai
6371 vec_orc(vector signed char __a, vector signed char __b) {
6372  return __a | ~__b;
6373 }
6374 
6375 static __inline__ vector signed char __ATTRS_o_ai
6376 vec_orc(vector signed char __a, vector bool char __b) {
6377  return __a | ~__b;
6378 }
6379 
6380 static __inline__ vector signed char __ATTRS_o_ai
6381 vec_orc(vector bool char __a, vector signed char __b) {
6382  return __a | ~__b;
6383 }
6384 
6385 static __inline__ vector unsigned char __ATTRS_o_ai
6386 vec_orc(vector unsigned char __a, vector unsigned char __b) {
6387  return __a | ~__b;
6388 }
6389 
6390 static __inline__ vector unsigned char __ATTRS_o_ai
6391 vec_orc(vector unsigned char __a, vector bool char __b) {
6392  return __a | ~__b;
6393 }
6394 
6395 static __inline__ vector unsigned char __ATTRS_o_ai
6396 vec_orc(vector bool char __a, vector unsigned char __b) {
6397  return __a | ~__b;
6398 }
6399 
6400 static __inline__ vector bool char __ATTRS_o_ai vec_orc(vector bool char __a,
6401  vector bool char __b) {
6402  return __a | ~__b;
6403 }
6404 
6405 static __inline__ vector signed short __ATTRS_o_ai
6406 vec_orc(vector signed short __a, vector signed short __b) {
6407  return __a | ~__b;
6408 }
6409 
6410 static __inline__ vector signed short __ATTRS_o_ai
6411 vec_orc(vector signed short __a, vector bool short __b) {
6412  return __a | ~__b;
6413 }
6414 
6415 static __inline__ vector signed short __ATTRS_o_ai
6416 vec_orc(vector bool short __a, vector signed short __b) {
6417  return __a | ~__b;
6418 }
6419 
6420 static __inline__ vector unsigned short __ATTRS_o_ai
6421 vec_orc(vector unsigned short __a, vector unsigned short __b) {
6422  return __a | ~__b;
6423 }
6424 
6425 static __inline__ vector unsigned short __ATTRS_o_ai
6426 vec_orc(vector unsigned short __a, vector bool short __b) {
6427  return __a | ~__b;
6428 }
6429 
6430 static __inline__ vector unsigned short __ATTRS_o_ai
6431 vec_orc(vector bool short __a, vector unsigned short __b) {
6432  return __a | ~__b;
6433 }
6434 
6435 static __inline__ vector bool short __ATTRS_o_ai
6436 vec_orc(vector bool short __a, vector bool short __b) {
6437  return __a | ~__b;
6438 }
6439 
6440 static __inline__ vector signed int __ATTRS_o_ai
6441 vec_orc(vector signed int __a, vector signed int __b) {
6442  return __a | ~__b;
6443 }
6444 
6445 static __inline__ vector signed int __ATTRS_o_ai vec_orc(vector signed int __a,
6446  vector bool int __b) {
6447  return __a | ~__b;
6448 }
6449 
6450 static __inline__ vector signed int __ATTRS_o_ai
6451 vec_orc(vector bool int __a, vector signed int __b) {
6452  return __a | ~__b;
6453 }
6454 
6455 static __inline__ vector unsigned int __ATTRS_o_ai
6456 vec_orc(vector unsigned int __a, vector unsigned int __b) {
6457  return __a | ~__b;
6458 }
6459 
6460 static __inline__ vector unsigned int __ATTRS_o_ai
6461 vec_orc(vector unsigned int __a, vector bool int __b) {
6462  return __a | ~__b;
6463 }
6464 
6465 static __inline__ vector unsigned int __ATTRS_o_ai
6466 vec_orc(vector bool int __a, vector unsigned int __b) {
6467  return __a | ~__b;
6468 }
6469 
6470 static __inline__ vector bool int __ATTRS_o_ai vec_orc(vector bool int __a,
6471  vector bool int __b) {
6472  return __a | ~__b;
6473 }
6474 
6475 static __inline__ vector float __ATTRS_o_ai
6476 vec_orc(vector bool int __a, vector float __b) {
6477  return (vector float)(__a | ~(vector unsigned int)__b);
6478 }
6479 
6480 static __inline__ vector float __ATTRS_o_ai
6481 vec_orc(vector float __a, vector bool int __b) {
6482  return (vector float)((vector unsigned int)__a | ~__b);
6483 }
6484 
6485 static __inline__ vector signed long long __ATTRS_o_ai
6486 vec_orc(vector signed long long __a, vector signed long long __b) {
6487  return __a | ~__b;
6488 }
6489 
6490 static __inline__ vector signed long long __ATTRS_o_ai
6491 vec_orc(vector signed long long __a, vector bool long long __b) {
6492  return __a | ~__b;
6493 }
6494 
6495 static __inline__ vector signed long long __ATTRS_o_ai
6496 vec_orc(vector bool long long __a, vector signed long long __b) {
6497  return __a | ~__b;
6498 }
6499 
6500 static __inline__ vector unsigned long long __ATTRS_o_ai
6501 vec_orc(vector unsigned long long __a, vector unsigned long long __b) {
6502  return __a | ~__b;
6503 }
6504 
6505 static __inline__ vector unsigned long long __ATTRS_o_ai
6506 vec_orc(vector unsigned long long __a, vector bool long long __b) {
6507  return __a | ~__b;
6508 }
6509 
6510 static __inline__ vector unsigned long long __ATTRS_o_ai
6511 vec_orc(vector bool long long __a, vector unsigned long long __b) {
6512  return __a | ~__b;
6513 }
6514 
6515 static __inline__ vector bool long long __ATTRS_o_ai
6516 vec_orc(vector bool long long __a, vector bool long long __b) {
6517  return __a | ~__b;
6518 }
6519 
6520 static __inline__ vector double __ATTRS_o_ai
6521 vec_orc(vector double __a, vector bool long long __b) {
6522  return (vector double)((vector unsigned long long)__a | ~__b);
6523 }
6524 
6525 static __inline__ vector double __ATTRS_o_ai
6526 vec_orc(vector bool long long __a, vector double __b) {
6527  return (vector double)(__a | ~(vector unsigned long long)__b);
6528 }
6529 #endif
6530 
6531 /* vec_vor */
6532 
6533 static __inline__ vector signed char __ATTRS_o_ai
6534 vec_vor(vector signed char __a, vector signed char __b) {
6535  return __a | __b;
6536 }
6537 
6538 static __inline__ vector signed char __ATTRS_o_ai
6539 vec_vor(vector bool char __a, vector signed char __b) {
6540  return (vector signed char)__a | __b;
6541 }
6542 
6543 static __inline__ vector signed char __ATTRS_o_ai
6544 vec_vor(vector signed char __a, vector bool char __b) {
6545  return __a | (vector signed char)__b;
6546 }
6547 
6548 static __inline__ vector unsigned char __ATTRS_o_ai
6549 vec_vor(vector unsigned char __a, vector unsigned char __b) {
6550  return __a | __b;
6551 }
6552 
6553 static __inline__ vector unsigned char __ATTRS_o_ai
6554 vec_vor(vector bool char __a, vector unsigned char __b) {
6555  return (vector unsigned char)__a | __b;
6556 }
6557 
6558 static __inline__ vector unsigned char __ATTRS_o_ai
6559 vec_vor(vector unsigned char __a, vector bool char __b) {
6560  return __a | (vector unsigned char)__b;
6561 }
6562 
6563 static __inline__ vector bool char __ATTRS_o_ai vec_vor(vector bool char __a,
6564  vector bool char __b) {
6565  return __a | __b;
6566 }
6567 
6568 static __inline__ vector short __ATTRS_o_ai vec_vor(vector short __a,
6569  vector short __b) {
6570  return __a | __b;
6571 }
6572 
6573 static __inline__ vector short __ATTRS_o_ai vec_vor(vector bool short __a,
6574  vector short __b) {
6575  return (vector short)__a | __b;
6576 }
6577 
6578 static __inline__ vector short __ATTRS_o_ai vec_vor(vector short __a,
6579  vector bool short __b) {
6580  return __a | (vector short)__b;
6581 }
6582 
6583 static __inline__ vector unsigned short __ATTRS_o_ai
6584 vec_vor(vector unsigned short __a, vector unsigned short __b) {
6585  return __a | __b;
6586 }
6587 
6588 static __inline__ vector unsigned short __ATTRS_o_ai
6589 vec_vor(vector bool short __a, vector unsigned short __b) {
6590  return (vector unsigned short)__a | __b;
6591 }
6592 
6593 static __inline__ vector unsigned short __ATTRS_o_ai
6594 vec_vor(vector unsigned short __a, vector bool short __b) {
6595  return __a | (vector unsigned short)__b;
6596 }
6597 
6598 static __inline__ vector bool short __ATTRS_o_ai
6599 vec_vor(vector bool short __a, vector bool short __b) {
6600  return __a | __b;
6601 }
6602 
6603 static __inline__ vector int __ATTRS_o_ai vec_vor(vector int __a,
6604  vector int __b) {
6605  return __a | __b;
6606 }
6607 
6608 static __inline__ vector int __ATTRS_o_ai vec_vor(vector bool int __a,
6609  vector int __b) {
6610  return (vector int)__a | __b;
6611 }
6612 
6613 static __inline__ vector int __ATTRS_o_ai vec_vor(vector int __a,
6614  vector bool int __b) {
6615  return __a | (vector int)__b;
6616 }
6617 
6618 static __inline__ vector unsigned int __ATTRS_o_ai
6619 vec_vor(vector unsigned int __a, vector unsigned int __b) {
6620  return __a | __b;
6621 }
6622 
6623 static __inline__ vector unsigned int __ATTRS_o_ai
6624 vec_vor(vector bool int __a, vector unsigned int __b) {
6625  return (vector unsigned int)__a | __b;
6626 }
6627 
6628 static __inline__ vector unsigned int __ATTRS_o_ai
6629 vec_vor(vector unsigned int __a, vector bool int __b) {
6630  return __a | (vector unsigned int)__b;
6631 }
6632 
6633 static __inline__ vector bool int __ATTRS_o_ai vec_vor(vector bool int __a,
6634  vector bool int __b) {
6635  return __a | __b;
6636 }
6637 
6638 static __inline__ vector float __ATTRS_o_ai vec_vor(vector float __a,
6639  vector float __b) {
6640  vector unsigned int __res =
6641  (vector unsigned int)__a | (vector unsigned int)__b;
6642  return (vector float)__res;
6643 }
6644 
6645 static __inline__ vector float __ATTRS_o_ai vec_vor(vector bool int __a,
6646  vector float __b) {
6647  vector unsigned int __res =
6648  (vector unsigned int)__a | (vector unsigned int)__b;
6649  return (vector float)__res;
6650 }
6651 
6652 static __inline__ vector float __ATTRS_o_ai vec_vor(vector float __a,
6653  vector bool int __b) {
6654  vector unsigned int __res =
6655  (vector unsigned int)__a | (vector unsigned int)__b;
6656  return (vector float)__res;
6657 }
6658 
6659 #ifdef __VSX__
6660 static __inline__ vector signed long long __ATTRS_o_ai
6661 vec_vor(vector signed long long __a, vector signed long long __b) {
6662  return __a | __b;
6663 }
6664 
6665 static __inline__ vector signed long long __ATTRS_o_ai
6666 vec_vor(vector bool long long __a, vector signed long long __b) {
6667  return (vector signed long long)__a | __b;
6668 }
6669 
6670 static __inline__ vector signed long long __ATTRS_o_ai
6671 vec_vor(vector signed long long __a, vector bool long long __b) {
6672  return __a | (vector signed long long)__b;
6673 }
6674 
6675 static __inline__ vector unsigned long long __ATTRS_o_ai
6676 vec_vor(vector unsigned long long __a, vector unsigned long long __b) {
6677  return __a | __b;
6678 }
6679 
6680 static __inline__ vector unsigned long long __ATTRS_o_ai
6681 vec_vor(vector bool long long __a, vector unsigned long long __b) {
6682  return (vector unsigned long long)__a | __b;
6683 }
6684 
6685 static __inline__ vector unsigned long long __ATTRS_o_ai
6686 vec_vor(vector unsigned long long __a, vector bool long long __b) {
6687  return __a | (vector unsigned long long)__b;
6688 }
6689 
6690 static __inline__ vector bool long long __ATTRS_o_ai
6691 vec_vor(vector bool long long __a, vector bool long long __b) {
6692  return __a | __b;
6693 }
6694 #endif
6695 
6696 /* vec_pack */
6697 
6698 /* The various vector pack instructions have a big-endian bias, so for
6699  little endian we must handle reversed element numbering. */
6700 
6701 static __inline__ vector signed char __ATTRS_o_ai
6702 vec_pack(vector signed short __a, vector signed short __b) {
6703 #ifdef __LITTLE_ENDIAN__
6704  return (vector signed char)vec_perm(
6705  __a, __b,
6706  (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
6707  0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
6708 #else
6709  return (vector signed char)vec_perm(
6710  __a, __b,
6711  (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
6712  0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
6713 #endif
6714 }
6715 
6716 static __inline__ vector unsigned char __ATTRS_o_ai
6717 vec_pack(vector unsigned short __a, vector unsigned short __b) {
6718 #ifdef __LITTLE_ENDIAN__
6719  return (vector unsigned char)vec_perm(
6720  __a, __b,
6721  (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
6722  0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
6723 #else
6724  return (vector unsigned char)vec_perm(
6725  __a, __b,
6726  (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
6727  0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
6728 #endif
6729 }
6730 
6731 static __inline__ vector bool char __ATTRS_o_ai
6732 vec_pack(vector bool short __a, vector bool short __b) {
6733 #ifdef __LITTLE_ENDIAN__
6734  return (vector bool char)vec_perm(
6735  __a, __b,
6736  (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
6737  0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
6738 #else
6739  return (vector bool char)vec_perm(
6740  __a, __b,
6741  (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
6742  0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
6743 #endif
6744 }
6745 
6746 static __inline__ vector short __ATTRS_o_ai vec_pack(vector int __a,
6747  vector int __b) {
6748 #ifdef __LITTLE_ENDIAN__
6749  return (vector short)vec_perm(
6750  __a, __b,
6751  (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
6752  0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
6753 #else
6754  return (vector short)vec_perm(
6755  __a, __b,
6756  (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
6757  0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
6758 #endif
6759 }
6760 
6761 static __inline__ vector unsigned short __ATTRS_o_ai
6762 vec_pack(vector unsigned int __a, vector unsigned int __b) {
6763 #ifdef __LITTLE_ENDIAN__
6764  return (vector unsigned short)vec_perm(
6765  __a, __b,
6766  (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
6767  0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
6768 #else
6769  return (vector unsigned short)vec_perm(
6770  __a, __b,
6771  (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
6772  0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
6773 #endif
6774 }
6775 
6776 static __inline__ vector bool short __ATTRS_o_ai vec_pack(vector bool int __a,
6777  vector bool int __b) {
6778 #ifdef __LITTLE_ENDIAN__
6779  return (vector bool short)vec_perm(
6780  __a, __b,
6781  (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
6782  0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
6783 #else
6784  return (vector bool short)vec_perm(
6785  __a, __b,
6786  (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
6787  0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
6788 #endif
6789 }
6790 
6791 #ifdef __VSX__
6792 static __inline__ vector signed int __ATTRS_o_ai
6793 vec_pack(vector signed long long __a, vector signed long long __b) {
6794 #ifdef __LITTLE_ENDIAN__
6795  return (vector signed int)vec_perm(
6796  __a, __b,
6797  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
6798  0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
6799 #else
6800  return (vector signed int)vec_perm(
6801  __a, __b,
6802  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
6803  0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
6804 #endif
6805 }
6806 static __inline__ vector unsigned int __ATTRS_o_ai
6807 vec_pack(vector unsigned long long __a, vector unsigned long long __b) {
6808 #ifdef __LITTLE_ENDIAN__
6809  return (vector unsigned int)vec_perm(
6810  __a, __b,
6811  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
6812  0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
6813 #else
6814  return (vector unsigned int)vec_perm(
6815  __a, __b,
6816  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
6817  0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
6818 #endif
6819 }
6820 
6821 static __inline__ vector bool int __ATTRS_o_ai
6822 vec_pack(vector bool long long __a, vector bool long long __b) {
6823 #ifdef __LITTLE_ENDIAN__
6824  return (vector bool int)vec_perm(
6825  __a, __b,
6826  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
6827  0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
6828 #else
6829  return (vector bool int)vec_perm(
6830  __a, __b,
6831  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
6832  0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
6833 #endif
6834 }
6835 
6836 static __inline__ vector float __ATTRS_o_ai
6837 vec_pack(vector double __a, vector double __b) {
6838  return (vector float) (__a[0], __a[1], __b[0], __b[1]);
6839 }
6840 #endif
6841 
6842 #ifdef __POWER9_VECTOR__
6843 static __inline__ vector unsigned short __ATTRS_o_ai
6844 vec_pack_to_short_fp32(vector float __a, vector float __b) {
6845  vector float __resa = __builtin_vsx_xvcvsphp(__a);
6846  vector float __resb = __builtin_vsx_xvcvsphp(__b);
6847 #ifdef __LITTLE_ENDIAN__
6848  return (vector unsigned short)vec_mergee(__resa, __resb);
6849 #else
6850  return (vector unsigned short)vec_mergeo(__resa, __resb);
6851 #endif
6852 }
6853 
6854 #endif
6855 /* vec_vpkuhum */
6856 
6857 #define __builtin_altivec_vpkuhum vec_vpkuhum
6858 
6859 static __inline__ vector signed char __ATTRS_o_ai
6860 vec_vpkuhum(vector signed short __a, vector signed short __b) {
6861 #ifdef __LITTLE_ENDIAN__
6862  return (vector signed char)vec_perm(
6863  __a, __b,
6864  (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
6865  0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
6866 #else
6867  return (vector signed char)vec_perm(
6868  __a, __b,
6869  (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
6870  0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
6871 #endif
6872 }
6873 
6874 static __inline__ vector unsigned char __ATTRS_o_ai
6875 vec_vpkuhum(vector unsigned short __a, vector unsigned short __b) {
6876 #ifdef __LITTLE_ENDIAN__
6877  return (vector unsigned char)vec_perm(
6878  __a, __b,
6879  (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
6880  0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
6881 #else
6882  return (vector unsigned char)vec_perm(
6883  __a, __b,
6884  (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
6885  0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
6886 #endif
6887 }
6888 
6889 static __inline__ vector bool char __ATTRS_o_ai
6890 vec_vpkuhum(vector bool short __a, vector bool short __b) {
6891 #ifdef __LITTLE_ENDIAN__
6892  return (vector bool char)vec_perm(
6893  __a, __b,
6894  (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
6895  0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
6896 #else
6897  return (vector bool char)vec_perm(
6898  __a, __b,
6899  (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
6900  0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
6901 #endif
6902 }
6903 
6904 /* vec_vpkuwum */
6905 
6906 #define __builtin_altivec_vpkuwum vec_vpkuwum
6907 
6908 static __inline__ vector short __ATTRS_o_ai vec_vpkuwum(vector int __a,
6909  vector int __b) {
6910 #ifdef __LITTLE_ENDIAN__
6911  return (vector short)vec_perm(
6912  __a, __b,
6913  (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
6914  0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
6915 #else
6916  return (vector short)vec_perm(
6917  __a, __b,
6918  (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
6919  0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
6920 #endif
6921 }
6922 
6923 static __inline__ vector unsigned short __ATTRS_o_ai
6924 vec_vpkuwum(vector unsigned int __a, vector unsigned int __b) {
6925 #ifdef __LITTLE_ENDIAN__
6926  return (vector unsigned short)vec_perm(
6927  __a, __b,
6928  (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
6929  0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
6930 #else
6931  return (vector unsigned short)vec_perm(
6932  __a, __b,
6933  (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
6934  0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
6935 #endif
6936 }
6937 
6938 static __inline__ vector bool short __ATTRS_o_ai
6939 vec_vpkuwum(vector bool int __a, vector bool int __b) {
6940 #ifdef __LITTLE_ENDIAN__
6941  return (vector bool short)vec_perm(
6942  __a, __b,
6943  (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
6944  0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
6945 #else
6946  return (vector bool short)vec_perm(
6947  __a, __b,
6948  (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
6949  0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
6950 #endif
6951 }
6952 
6953 /* vec_vpkudum */
6954 
6955 #ifdef __POWER8_VECTOR__
6956 #define __builtin_altivec_vpkudum vec_vpkudum
6957 
6958 static __inline__ vector int __ATTRS_o_ai vec_vpkudum(vector long long __a,
6959  vector long long __b) {
6960 #ifdef __LITTLE_ENDIAN__
6961  return (vector int)vec_perm(
6962  __a, __b,
6963  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
6964  0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
6965 #else
6966  return (vector int)vec_perm(
6967  __a, __b,
6968  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
6969  0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
6970 #endif
6971 }
6972 
6973 static __inline__ vector unsigned int __ATTRS_o_ai
6974 vec_vpkudum(vector unsigned long long __a, vector unsigned long long __b) {
6975 #ifdef __LITTLE_ENDIAN__
6976  return (vector unsigned int)vec_perm(
6977  __a, __b,
6978  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
6979  0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
6980 #else
6981  return (vector unsigned int)vec_perm(
6982  __a, __b,
6983  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
6984  0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
6985 #endif
6986 }
6987 
6988 static __inline__ vector bool int __ATTRS_o_ai
6989 vec_vpkudum(vector bool long long __a, vector bool long long __b) {
6990 #ifdef __LITTLE_ENDIAN__
6991  return (vector bool int)vec_perm(
6992  (vector long long)__a, (vector long long)__b,
6993  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
6994  0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
6995 #else
6996  return (vector bool int)vec_perm(
6997  (vector long long)__a, (vector long long)__b,
6998  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
6999  0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
7000 #endif
7001 }
7002 #endif
7003 
7004 /* vec_packpx */
7005 
7006 static __inline__ vector pixel __attribute__((__always_inline__))
7007 vec_packpx(vector unsigned int __a, vector unsigned int __b) {
7008 #ifdef __LITTLE_ENDIAN__
7009  return (vector pixel)__builtin_altivec_vpkpx(__b, __a);
7010 #else
7011  return (vector pixel)__builtin_altivec_vpkpx(__a, __b);
7012 #endif
7013 }
7014 
7015 /* vec_vpkpx */
7016 
7017 static __inline__ vector pixel __attribute__((__always_inline__))
7018 vec_vpkpx(vector unsigned int __a, vector unsigned int __b) {
7019 #ifdef __LITTLE_ENDIAN__
7020  return (vector pixel)__builtin_altivec_vpkpx(__b, __a);
7021 #else
7022  return (vector pixel)__builtin_altivec_vpkpx(__a, __b);
7023 #endif
7024 }
7025 
7026 /* vec_packs */
7027 
7028 static __inline__ vector signed char __ATTRS_o_ai vec_packs(vector short __a,
7029  vector short __b) {
7030 #ifdef __LITTLE_ENDIAN__
7031  return __builtin_altivec_vpkshss(__b, __a);
7032 #else
7033  return __builtin_altivec_vpkshss(__a, __b);
7034 #endif
7035 }
7036 
7037 static __inline__ vector unsigned char __ATTRS_o_ai
7038 vec_packs(vector unsigned short __a, vector unsigned short __b) {
7039 #ifdef __LITTLE_ENDIAN__
7040  return __builtin_altivec_vpkuhus(__b, __a);
7041 #else
7042  return __builtin_altivec_vpkuhus(__a, __b);
7043 #endif
7044 }
7045 
7046 static __inline__ vector signed short __ATTRS_o_ai vec_packs(vector int __a,
7047  vector int __b) {
7048 #ifdef __LITTLE_ENDIAN__
7049  return __builtin_altivec_vpkswss(__b, __a);
7050 #else
7051  return __builtin_altivec_vpkswss(__a, __b);
7052 #endif
7053 }
7054 
7055 static __inline__ vector unsigned short __ATTRS_o_ai
7056 vec_packs(vector unsigned int __a, vector unsigned int __b) {
7057 #ifdef __LITTLE_ENDIAN__
7058  return __builtin_altivec_vpkuwus(__b, __a);
7059 #else
7060  return __builtin_altivec_vpkuwus(__a, __b);
7061 #endif
7062 }
7063 
7064 #ifdef __POWER8_VECTOR__
7065 static __inline__ vector int __ATTRS_o_ai vec_packs(vector long long __a,
7066  vector long long __b) {
7067 #ifdef __LITTLE_ENDIAN__
7068  return __builtin_altivec_vpksdss(__b, __a);
7069 #else
7070  return __builtin_altivec_vpksdss(__a, __b);
7071 #endif
7072 }
7073 
7074 static __inline__ vector unsigned int __ATTRS_o_ai
7075 vec_packs(vector unsigned long long __a, vector unsigned long long __b) {
7076 #ifdef __LITTLE_ENDIAN__
7077  return __builtin_altivec_vpkudus(__b, __a);
7078 #else
7079  return __builtin_altivec_vpkudus(__a, __b);
7080 #endif
7081 }
7082 #endif
7083 
7084 /* vec_vpkshss */
7085 
7086 static __inline__ vector signed char __attribute__((__always_inline__))
7087 vec_vpkshss(vector short __a, vector short __b) {
7088 #ifdef __LITTLE_ENDIAN__
7089  return __builtin_altivec_vpkshss(__b, __a);
7090 #else
7091  return __builtin_altivec_vpkshss(__a, __b);
7092 #endif
7093 }
7094 
7095 /* vec_vpksdss */
7096 
7097 #ifdef __POWER8_VECTOR__
7098 static __inline__ vector int __ATTRS_o_ai vec_vpksdss(vector long long __a,
7099  vector long long __b) {
7100 #ifdef __LITTLE_ENDIAN__
7101  return __builtin_altivec_vpksdss(__b, __a);
7102 #else
7103  return __builtin_altivec_vpksdss(__a, __b);
7104 #endif
7105 }
7106 #endif
7107 
7108 /* vec_vpkuhus */
7109 
7110 static __inline__ vector unsigned char __attribute__((__always_inline__))
7111 vec_vpkuhus(vector unsigned short __a, vector unsigned short __b) {
7112 #ifdef __LITTLE_ENDIAN__
7113  return __builtin_altivec_vpkuhus(__b, __a);
7114 #else
7115  return __builtin_altivec_vpkuhus(__a, __b);
7116 #endif
7117 }
7118 
7119 /* vec_vpkudus */
7120 
7121 #ifdef __POWER8_VECTOR__
7122 static __inline__ vector unsigned int __attribute__((__always_inline__))
7123 vec_vpkudus(vector unsigned long long __a, vector unsigned long long __b) {
7124 #ifdef __LITTLE_ENDIAN__
7125  return __builtin_altivec_vpkudus(__b, __a);
7126 #else
7127  return __builtin_altivec_vpkudus(__a, __b);
7128 #endif
7129 }
7130 #endif
7131 
7132 /* vec_vpkswss */
7133 
7134 static __inline__ vector signed short __attribute__((__always_inline__))
7135 vec_vpkswss(vector int __a, vector int __b) {
7136 #ifdef __LITTLE_ENDIAN__
7137  return __builtin_altivec_vpkswss(__b, __a);
7138 #else
7139  return __builtin_altivec_vpkswss(__a, __b);
7140 #endif
7141 }
7142 
7143 /* vec_vpkuwus */
7144 
7145 static __inline__ vector unsigned short __attribute__((__always_inline__))
7146 vec_vpkuwus(vector unsigned int __a, vector unsigned int __b) {
7147 #ifdef __LITTLE_ENDIAN__
7148  return __builtin_altivec_vpkuwus(__b, __a);
7149 #else
7150  return __builtin_altivec_vpkuwus(__a, __b);
7151 #endif
7152 }
7153 
7154 /* vec_packsu */
7155 
7156 static __inline__ vector unsigned char __ATTRS_o_ai
7157 vec_packsu(vector short __a, vector short __b) {
7158 #ifdef __LITTLE_ENDIAN__
7159  return __builtin_altivec_vpkshus(__b, __a);
7160 #else
7161  return __builtin_altivec_vpkshus(__a, __b);
7162 #endif
7163 }
7164 
7165 static __inline__ vector unsigned char __ATTRS_o_ai
7166 vec_packsu(vector unsigned short __a, vector unsigned short __b) {
7167 #ifdef __LITTLE_ENDIAN__
7168  return __builtin_altivec_vpkuhus(__b, __a);
7169 #else
7170  return __builtin_altivec_vpkuhus(__a, __b);
7171 #endif
7172 }
7173 
7174 static __inline__ vector unsigned short __ATTRS_o_ai
7175 vec_packsu(vector int __a, vector int __b) {
7176 #ifdef __LITTLE_ENDIAN__
7177  return __builtin_altivec_vpkswus(__b, __a);
7178 #else
7179  return __builtin_altivec_vpkswus(__a, __b);
7180 #endif
7181 }
7182 
7183 static __inline__ vector unsigned short __ATTRS_o_ai
7184 vec_packsu(vector unsigned int __a, vector unsigned int __b) {
7185 #ifdef __LITTLE_ENDIAN__
7186  return __builtin_altivec_vpkuwus(__b, __a);
7187 #else
7188  return __builtin_altivec_vpkuwus(__a, __b);
7189 #endif
7190 }
7191 
7192 #ifdef __POWER8_VECTOR__
7193 static __inline__ vector unsigned int __ATTRS_o_ai
7194 vec_packsu(vector long long __a, vector long long __b) {
7195 #ifdef __LITTLE_ENDIAN__
7196  return __builtin_altivec_vpksdus(__b, __a);
7197 #else
7198  return __builtin_altivec_vpksdus(__a, __b);
7199 #endif
7200 }
7201 
7202 static __inline__ vector unsigned int __ATTRS_o_ai
7203 vec_packsu(vector unsigned long long __a, vector unsigned long long __b) {
7204 #ifdef __LITTLE_ENDIAN__
7205  return __builtin_altivec_vpkudus(__b, __a);
7206 #else
7207  return __builtin_altivec_vpkudus(__a, __b);
7208 #endif
7209 }
7210 #endif
7211 
7212 /* vec_vpkshus */
7213 
7214 static __inline__ vector unsigned char __ATTRS_o_ai
7215 vec_vpkshus(vector short __a, vector short __b) {
7216 #ifdef __LITTLE_ENDIAN__
7217  return __builtin_altivec_vpkshus(__b, __a);
7218 #else
7219  return __builtin_altivec_vpkshus(__a, __b);
7220 #endif
7221 }
7222 
7223 static __inline__ vector unsigned char __ATTRS_o_ai
7224 vec_vpkshus(vector unsigned short __a, vector unsigned short __b) {
7225 #ifdef __LITTLE_ENDIAN__
7226  return __builtin_altivec_vpkuhus(__b, __a);
7227 #else
7228  return __builtin_altivec_vpkuhus(__a, __b);
7229 #endif
7230 }
7231 
7232 /* vec_vpkswus */
7233 
7234 static __inline__ vector unsigned short __ATTRS_o_ai
7235 vec_vpkswus(vector int __a, vector int __b) {
7236 #ifdef __LITTLE_ENDIAN__
7237  return __builtin_altivec_vpkswus(__b, __a);
7238 #else
7239  return __builtin_altivec_vpkswus(__a, __b);
7240 #endif
7241 }
7242 
7243 static __inline__ vector unsigned short __ATTRS_o_ai
7244 vec_vpkswus(vector unsigned int __a, vector unsigned int __b) {
7245 #ifdef __LITTLE_ENDIAN__
7246  return __builtin_altivec_vpkuwus(__b, __a);
7247 #else
7248  return __builtin_altivec_vpkuwus(__a, __b);
7249 #endif
7250 }
7251 
7252 /* vec_vpksdus */
7253 
7254 #ifdef __POWER8_VECTOR__
7255 static __inline__ vector unsigned int __ATTRS_o_ai
7256 vec_vpksdus(vector long long __a, vector long long __b) {
7257 #ifdef __LITTLE_ENDIAN__
7258  return __builtin_altivec_vpksdus(__b, __a);
7259 #else
7260  return __builtin_altivec_vpksdus(__a, __b);
7261 #endif
7262 }
7263 #endif
7264 
7265 /* vec_perm */
7266 
7267 // The vperm instruction is defined architecturally with a big-endian bias.
7268 // For little endian, we swap the input operands and invert the permute
7269 // control vector. Only the rightmost 5 bits matter, so we could use
7270 // a vector of all 31s instead of all 255s to perform the inversion.
7271 // However, when the PCV is not a constant, using 255 has an advantage
7272 // in that the vec_xor can be recognized as a vec_nor (and for P8 and
7273 // later, possibly a vec_nand).
7274 
7275 static __inline__ vector signed char __ATTRS_o_ai vec_perm(
7276  vector signed char __a, vector signed char __b, vector unsigned char __c) {
7277 #ifdef __LITTLE_ENDIAN__
7278  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7279  255, 255, 255, 255, 255, 255, 255, 255};
7280  __d = vec_xor(__c, __d);
7281  return (vector signed char)__builtin_altivec_vperm_4si((vector int)__b,
7282  (vector int)__a, __d);
7283 #else
7284  return (vector signed char)__builtin_altivec_vperm_4si((vector int)__a,
7285  (vector int)__b, __c);
7286 #endif
7287 }
7288 
7289 static __inline__ vector unsigned char __ATTRS_o_ai
7290 vec_perm(vector unsigned char __a, vector unsigned char __b,
7291  vector unsigned char __c) {
7292 #ifdef __LITTLE_ENDIAN__
7293  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7294  255, 255, 255, 255, 255, 255, 255, 255};
7295  __d = vec_xor(__c, __d);
7296  return (vector unsigned char)__builtin_altivec_vperm_4si(
7297  (vector int)__b, (vector int)__a, __d);
7298 #else
7299  return (vector unsigned char)__builtin_altivec_vperm_4si(
7300  (vector int)__a, (vector int)__b, __c);
7301 #endif
7302 }
7303 
7304 static __inline__ vector bool char __ATTRS_o_ai
7305 vec_perm(vector bool char __a, vector bool char __b, vector unsigned char __c) {
7306 #ifdef __LITTLE_ENDIAN__
7307  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7308  255, 255, 255, 255, 255, 255, 255, 255};
7309  __d = vec_xor(__c, __d);
7310  return (vector bool char)__builtin_altivec_vperm_4si((vector int)__b,
7311  (vector int)__a, __d);
7312 #else
7313  return (vector bool char)__builtin_altivec_vperm_4si((vector int)__a,
7314  (vector int)__b, __c);
7315 #endif
7316 }
7317 
7318 static __inline__ vector short __ATTRS_o_ai vec_perm(vector signed short __a,
7319  vector signed short __b,
7320  vector unsigned char __c) {
7321 #ifdef __LITTLE_ENDIAN__
7322  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7323  255, 255, 255, 255, 255, 255, 255, 255};
7324  __d = vec_xor(__c, __d);
7325  return (vector signed short)__builtin_altivec_vperm_4si((vector int)__b,
7326  (vector int)__a, __d);
7327 #else
7328  return (vector signed short)__builtin_altivec_vperm_4si((vector int)__a,
7329  (vector int)__b, __c);
7330 #endif
7331 }
7332 
7333 static __inline__ vector unsigned short __ATTRS_o_ai
7334 vec_perm(vector unsigned short __a, vector unsigned short __b,
7335  vector unsigned char __c) {
7336 #ifdef __LITTLE_ENDIAN__
7337  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7338  255, 255, 255, 255, 255, 255, 255, 255};
7339  __d = vec_xor(__c, __d);
7340  return (vector unsigned short)__builtin_altivec_vperm_4si(
7341  (vector int)__b, (vector int)__a, __d);
7342 #else
7343  return (vector unsigned short)__builtin_altivec_vperm_4si(
7344  (vector int)__a, (vector int)__b, __c);
7345 #endif
7346 }
7347 
7348 static __inline__ vector bool short __ATTRS_o_ai vec_perm(
7349  vector bool short __a, vector bool short __b, vector unsigned char __c) {
7350 #ifdef __LITTLE_ENDIAN__
7351  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7352  255, 255, 255, 255, 255, 255, 255, 255};
7353  __d = vec_xor(__c, __d);
7354  return (vector bool short)__builtin_altivec_vperm_4si((vector int)__b,
7355  (vector int)__a, __d);
7356 #else
7357  return (vector bool short)__builtin_altivec_vperm_4si((vector int)__a,
7358  (vector int)__b, __c);
7359 #endif
7360 }
7361 
7362 static __inline__ vector pixel __ATTRS_o_ai vec_perm(vector pixel __a,
7363  vector pixel __b,
7364  vector unsigned char __c) {
7365 #ifdef __LITTLE_ENDIAN__
7366  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7367  255, 255, 255, 255, 255, 255, 255, 255};
7368  __d = vec_xor(__c, __d);
7369  return (vector pixel)__builtin_altivec_vperm_4si((vector int)__b,
7370  (vector int)__a, __d);
7371 #else
7372  return (vector pixel)__builtin_altivec_vperm_4si((vector int)__a,
7373  (vector int)__b, __c);
7374 #endif
7375 }
7376 
7377 static __inline__ vector int __ATTRS_o_ai vec_perm(vector signed int __a,
7378  vector signed int __b,
7379  vector unsigned char __c) {
7380 #ifdef __LITTLE_ENDIAN__
7381  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7382  255, 255, 255, 255, 255, 255, 255, 255};
7383  __d = vec_xor(__c, __d);
7384  return (vector signed int)__builtin_altivec_vperm_4si(__b, __a, __d);
7385 #else
7386  return (vector signed int)__builtin_altivec_vperm_4si(__a, __b, __c);
7387 #endif
7388 }
7389 
7390 static __inline__ vector unsigned int __ATTRS_o_ai
7391 vec_perm(vector unsigned int __a, vector unsigned int __b,
7392  vector unsigned char __c) {
7393 #ifdef __LITTLE_ENDIAN__
7394  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7395  255, 255, 255, 255, 255, 255, 255, 255};
7396  __d = vec_xor(__c, __d);
7397  return (vector unsigned int)__builtin_altivec_vperm_4si((vector int)__b,
7398  (vector int)__a, __d);
7399 #else
7400  return (vector unsigned int)__builtin_altivec_vperm_4si((vector int)__a,
7401  (vector int)__b, __c);
7402 #endif
7403 }
7404 
7405 static __inline__ vector bool int __ATTRS_o_ai
7406 vec_perm(vector bool int __a, vector bool int __b, vector unsigned char __c) {
7407 #ifdef __LITTLE_ENDIAN__
7408  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7409  255, 255, 255, 255, 255, 255, 255, 255};
7410  __d = vec_xor(__c, __d);
7411  return (vector bool int)__builtin_altivec_vperm_4si((vector int)__b,
7412  (vector int)__a, __d);
7413 #else
7414  return (vector bool int)__builtin_altivec_vperm_4si((vector int)__a,
7415  (vector int)__b, __c);
7416 #endif
7417 }
7418 
7419 static __inline__ vector float __ATTRS_o_ai vec_perm(vector float __a,
7420  vector float __b,
7421  vector unsigned char __c) {
7422 #ifdef __LITTLE_ENDIAN__
7423  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7424  255, 255, 255, 255, 255, 255, 255, 255};
7425  __d = vec_xor(__c, __d);
7426  return (vector float)__builtin_altivec_vperm_4si((vector int)__b,
7427  (vector int)__a, __d);
7428 #else
7429  return (vector float)__builtin_altivec_vperm_4si((vector int)__a,
7430  (vector int)__b, __c);
7431 #endif
7432 }
7433 
7434 #ifdef __VSX__
7435 static __inline__ vector long long __ATTRS_o_ai
7436 vec_perm(vector signed long long __a, vector signed long long __b,
7437  vector unsigned char __c) {
7438 #ifdef __LITTLE_ENDIAN__
7439  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7440  255, 255, 255, 255, 255, 255, 255, 255};
7441  __d = vec_xor(__c, __d);
7442  return (vector signed long long)__builtin_altivec_vperm_4si(
7443  (vector int)__b, (vector int)__a, __d);
7444 #else
7445  return (vector signed long long)__builtin_altivec_vperm_4si(
7446  (vector int)__a, (vector int)__b, __c);
7447 #endif
7448 }
7449 
7450 static __inline__ vector unsigned long long __ATTRS_o_ai
7451 vec_perm(vector unsigned long long __a, vector unsigned long long __b,
7452  vector unsigned char __c) {
7453 #ifdef __LITTLE_ENDIAN__
7454  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7455  255, 255, 255, 255, 255, 255, 255, 255};
7456  __d = vec_xor(__c, __d);
7457  return (vector unsigned long long)__builtin_altivec_vperm_4si(
7458  (vector int)__b, (vector int)__a, __d);
7459 #else
7460  return (vector unsigned long long)__builtin_altivec_vperm_4si(
7461  (vector int)__a, (vector int)__b, __c);
7462 #endif
7463 }
7464 
7465 static __inline__ vector bool long long __ATTRS_o_ai
7466 vec_perm(vector bool long long __a, vector bool long long __b,
7467  vector unsigned char __c) {
7468 #ifdef __LITTLE_ENDIAN__
7469  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7470  255, 255, 255, 255, 255, 255, 255, 255};
7471  __d = vec_xor(__c, __d);
7472  return (vector bool long long)__builtin_altivec_vperm_4si(
7473  (vector int)__b, (vector int)__a, __d);
7474 #else
7475  return (vector bool long long)__builtin_altivec_vperm_4si(
7476  (vector int)__a, (vector int)__b, __c);
7477 #endif
7478 }
7479 
7480 static __inline__ vector double __ATTRS_o_ai
7481 vec_perm(vector double __a, vector double __b, vector unsigned char __c) {
7482 #ifdef __LITTLE_ENDIAN__
7483  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7484  255, 255, 255, 255, 255, 255, 255, 255};
7485  __d = vec_xor(__c, __d);
7486  return (vector double)__builtin_altivec_vperm_4si((vector int)__b,
7487  (vector int)__a, __d);
7488 #else
7489  return (vector double)__builtin_altivec_vperm_4si((vector int)__a,
7490  (vector int)__b, __c);
7491 #endif
7492 }
7493 #endif
7494 
7495 /* vec_vperm */
7496 
7497 static __inline__ vector signed char __ATTRS_o_ai vec_vperm(
7498  vector signed char __a, vector signed char __b, vector unsigned char __c) {
7499  return vec_perm(__a, __b, __c);
7500 }
7501 
7502 static __inline__ vector unsigned char __ATTRS_o_ai
7503 vec_vperm(vector unsigned char __a, vector unsigned char __b,
7504  vector unsigned char __c) {
7505  return vec_perm(__a, __b, __c);
7506 }
7507 
7508 static __inline__ vector bool char __ATTRS_o_ai vec_vperm(
7509  vector bool char __a, vector bool char __b, vector unsigned char __c) {
7510  return vec_perm(__a, __b, __c);
7511 }
7512 
7513 static __inline__ vector short __ATTRS_o_ai
7514 vec_vperm(vector short __a, vector short __b, vector unsigned char __c) {
7515  return vec_perm(__a, __b, __c);
7516 }
7517 
7518 static __inline__ vector unsigned short __ATTRS_o_ai
7519 vec_vperm(vector unsigned short __a, vector unsigned short __b,
7520  vector unsigned char __c) {
7521  return vec_perm(__a, __b, __c);
7522 }
7523 
7524 static __inline__ vector bool short __ATTRS_o_ai vec_vperm(
7525  vector bool short __a, vector bool short __b, vector unsigned char __c) {
7526  return vec_perm(__a, __b, __c);
7527 }
7528 
7529 static __inline__ vector pixel __ATTRS_o_ai
7530 vec_vperm(vector pixel __a, vector pixel __b, vector unsigned char __c) {
7531  return vec_perm(__a, __b, __c);
7532 }
7533 
7534 static __inline__ vector int __ATTRS_o_ai vec_vperm(vector int __a,
7535  vector int __b,
7536  vector unsigned char __c) {
7537  return vec_perm(__a, __b, __c);
7538 }
7539 
7540 static __inline__ vector unsigned int __ATTRS_o_ai
7541 vec_vperm(vector unsigned int __a, vector unsigned int __b,
7542  vector unsigned char __c) {
7543  return vec_perm(__a, __b, __c);
7544 }
7545 
7546 static __inline__ vector bool int __ATTRS_o_ai
7547 vec_vperm(vector bool int __a, vector bool int __b, vector unsigned char __c) {
7548  return vec_perm(__a, __b, __c);
7549 }
7550 
7551 static __inline__ vector float __ATTRS_o_ai
7552 vec_vperm(vector float __a, vector float __b, vector unsigned char __c) {
7553  return vec_perm(__a, __b, __c);
7554 }
7555 
7556 #ifdef __VSX__
7557 static __inline__ vector long long __ATTRS_o_ai vec_vperm(
7558  vector long long __a, vector long long __b, vector unsigned char __c) {
7559  return vec_perm(__a, __b, __c);
7560 }
7561 
7562 static __inline__ vector unsigned long long __ATTRS_o_ai
7563 vec_vperm(vector unsigned long long __a, vector unsigned long long __b,
7564  vector unsigned char __c) {
7565  return vec_perm(__a, __b, __c);
7566 }
7567 
7568 static __inline__ vector double __ATTRS_o_ai
7569 vec_vperm(vector double __a, vector double __b, vector unsigned char __c) {
7570  return vec_perm(__a, __b, __c);
7571 }
7572 #endif
7573 
7574 /* vec_re */
7575 
7576 static __inline__ vector float __ATTRS_o_ai vec_re(vector float __a) {
7577 #ifdef __VSX__
7578  return __builtin_vsx_xvresp(__a);
7579 #else
7580  return __builtin_altivec_vrefp(__a);
7581 #endif
7582 }
7583 
7584 #ifdef __VSX__
7585 static __inline__ vector double __ATTRS_o_ai vec_re(vector double __a) {
7586  return __builtin_vsx_xvredp(__a);
7587 }
7588 #endif
7589 
7590 /* vec_vrefp */
7591 
7592 static __inline__ vector float __attribute__((__always_inline__))
7593 vec_vrefp(vector float __a) {
7594  return __builtin_altivec_vrefp(__a);
7595 }
7596 
7597 /* vec_rl */
7598 
7599 static __inline__ vector signed char __ATTRS_o_ai
7600 vec_rl(vector signed char __a, vector unsigned char __b) {
7601  return (vector signed char)__builtin_altivec_vrlb((vector char)__a, __b);
7602 }
7603 
7604 static __inline__ vector unsigned char __ATTRS_o_ai
7605 vec_rl(vector unsigned char __a, vector unsigned char __b) {
7606  return (vector unsigned char)__builtin_altivec_vrlb((vector char)__a, __b);
7607 }
7608 
7609 static __inline__ vector short __ATTRS_o_ai vec_rl(vector short __a,
7610  vector unsigned short __b) {
7611  return __builtin_altivec_vrlh(__a, __b);
7612 }
7613 
7614 static __inline__ vector unsigned short __ATTRS_o_ai
7615 vec_rl(vector unsigned short __a, vector unsigned short __b) {
7616  return (vector unsigned short)__builtin_altivec_vrlh((vector short)__a, __b);
7617 }
7618 
7619 static __inline__ vector int __ATTRS_o_ai vec_rl(vector int __a,
7620  vector unsigned int __b) {
7621  return __builtin_altivec_vrlw(__a, __b);
7622 }
7623 
7624 static __inline__ vector unsigned int __ATTRS_o_ai
7625 vec_rl(vector unsigned int __a, vector unsigned int __b) {
7626  return (vector unsigned int)__builtin_altivec_vrlw((vector int)__a, __b);
7627 }
7628 
7629 #ifdef __POWER8_VECTOR__
7630 static __inline__ vector signed long long __ATTRS_o_ai
7631 vec_rl(vector signed long long __a, vector unsigned long long __b) {
7632  return __builtin_altivec_vrld(__a, __b);
7633 }
7634 
7635 static __inline__ vector unsigned long long __ATTRS_o_ai
7636 vec_rl(vector unsigned long long __a, vector unsigned long long __b) {
7637  return __builtin_altivec_vrld(__a, __b);
7638 }
7639 #endif
7640 
7641 /* vec_rlmi */
7642 #ifdef __POWER9_VECTOR__
7643 static __inline__ vector unsigned int __ATTRS_o_ai
7644 vec_rlmi(vector unsigned int __a, vector unsigned int __b,
7645  vector unsigned int __c) {
7646  return __builtin_altivec_vrlwmi(__a, __c, __b);
7647 }
7648 
7649 static __inline__ vector unsigned long long __ATTRS_o_ai
7650 vec_rlmi(vector unsigned long long __a, vector unsigned long long __b,
7651  vector unsigned long long __c) {
7652  return __builtin_altivec_vrldmi(__a, __c, __b);
7653 }
7654 
7655 /* vec_rlnm */
7656 static __inline__ vector unsigned int __ATTRS_o_ai
7657 vec_rlnm(vector unsigned int __a, vector unsigned int __b,
7658  vector unsigned int __c) {
7659  vector unsigned int OneByte = { 0x8, 0x8, 0x8, 0x8 };
7660  return __builtin_altivec_vrlwnm(__a, ((__c << OneByte) | __b));
7661 }
7662 
7663 static __inline__ vector unsigned long long __ATTRS_o_ai
7664 vec_rlnm(vector unsigned long long __a, vector unsigned long long __b,
7665  vector unsigned long long __c) {
7666  vector unsigned long long OneByte = { 0x8, 0x8 };
7667  return __builtin_altivec_vrldnm(__a, ((__c << OneByte) | __b));
7668 }
7669 #endif
7670 
7671 /* vec_vrlb */
7672 
7673 static __inline__ vector signed char __ATTRS_o_ai
7674 vec_vrlb(vector signed char __a, vector unsigned char __b) {
7675  return (vector signed char)__builtin_altivec_vrlb((vector char)__a, __b);
7676 }
7677 
7678 static __inline__ vector unsigned char __ATTRS_o_ai
7679 vec_vrlb(vector unsigned char __a, vector unsigned char __b) {
7680  return (vector unsigned char)__builtin_altivec_vrlb((vector char)__a, __b);
7681 }
7682 
7683 /* vec_vrlh */
7684 
7685 static __inline__ vector short __ATTRS_o_ai
7686 vec_vrlh(vector short __a, vector unsigned short __b) {
7687  return __builtin_altivec_vrlh(__a, __b);
7688 }
7689 
7690 static __inline__ vector unsigned short __ATTRS_o_ai
7691 vec_vrlh(vector unsigned short __a, vector unsigned short __b) {
7692  return (vector unsigned short)__builtin_altivec_vrlh((vector short)__a, __b);
7693 }
7694 
7695 /* vec_vrlw */
7696 
7697 static __inline__ vector int __ATTRS_o_ai vec_vrlw(vector int __a,
7698  vector unsigned int __b) {
7699  return __builtin_altivec_vrlw(__a, __b);
7700 }
7701 
7702 static __inline__ vector unsigned int __ATTRS_o_ai
7703 vec_vrlw(vector unsigned int __a, vector unsigned int __b) {
7704  return (vector unsigned int)__builtin_altivec_vrlw((vector int)__a, __b);
7705 }
7706 
7707 /* vec_round */
7708 
7709 static __inline__ vector float __ATTRS_o_ai vec_round(vector float __a) {
7710 #ifdef __VSX__
7711  return __builtin_vsx_xvrspi(__a);
7712 #else
7713  return __builtin_altivec_vrfin(__a);
7714 #endif
7715 }
7716 
7717 #ifdef __VSX__
7718 static __inline__ vector double __ATTRS_o_ai vec_round(vector double __a) {
7719  return __builtin_vsx_xvrdpi(__a);
7720 }
7721 
7722 /* vec_rint */
7723 
7724 static __inline__ vector float __ATTRS_o_ai vec_rint(vector float __a) {
7725  return __builtin_vsx_xvrspic(__a);
7726 }
7727 
7728 static __inline__ vector double __ATTRS_o_ai vec_rint(vector double __a) {
7729  return __builtin_vsx_xvrdpic(__a);
7730 }
7731 
7732 /* vec_nearbyint */
7733 
7734 static __inline__ vector float __ATTRS_o_ai vec_nearbyint(vector float __a) {
7735  return __builtin_vsx_xvrspi(__a);
7736 }
7737 
7738 static __inline__ vector double __ATTRS_o_ai vec_nearbyint(vector double __a) {
7739  return __builtin_vsx_xvrdpi(__a);
7740 }
7741 #endif
7742 
7743 /* vec_vrfin */
7744 
7745 static __inline__ vector float __attribute__((__always_inline__))
7746 vec_vrfin(vector float __a) {
7747  return __builtin_altivec_vrfin(__a);
7748 }
7749 
7750 /* vec_sqrt */
7751 
7752 #ifdef __VSX__
7753 static __inline__ vector float __ATTRS_o_ai vec_sqrt(vector float __a) {
7754  return __builtin_vsx_xvsqrtsp(__a);
7755 }
7756 
7757 static __inline__ vector double __ATTRS_o_ai vec_sqrt(vector double __a) {
7758  return __builtin_vsx_xvsqrtdp(__a);
7759 }
7760 #endif
7761 
7762 /* vec_rsqrte */
7763 
7764 static __inline__ vector float __ATTRS_o_ai vec_rsqrte(vector float __a) {
7765 #ifdef __VSX__
7766  return __builtin_vsx_xvrsqrtesp(__a);
7767 #else
7768  return __builtin_altivec_vrsqrtefp(__a);
7769 #endif
7770 }
7771 
7772 #ifdef __VSX__
7773 static __inline__ vector double __ATTRS_o_ai vec_rsqrte(vector double __a) {
7774  return __builtin_vsx_xvrsqrtedp(__a);
7775 }
7776 #endif
7777 
7778 /* vec_vrsqrtefp */
7779 
7780 static __inline__ __vector float __attribute__((__always_inline__))
7781 vec_vrsqrtefp(vector float __a) {
7782  return __builtin_altivec_vrsqrtefp(__a);
7783 }
7784 
7785 /* vec_sel */
7786 
7787 #define __builtin_altivec_vsel_4si vec_sel
7788 
7789 static __inline__ vector signed char __ATTRS_o_ai vec_sel(
7790  vector signed char __a, vector signed char __b, vector unsigned char __c) {
7791  return (__a & ~(vector signed char)__c) | (__b & (vector signed char)__c);
7792 }
7793 
7794 static __inline__ vector signed char __ATTRS_o_ai
7795 vec_sel(vector signed char __a, vector signed char __b, vector bool char __c) {
7796  return (__a & ~(vector signed char)__c) | (__b & (vector signed char)__c);
7797 }
7798 
7799 static __inline__ vector unsigned char __ATTRS_o_ai
7800 vec_sel(vector unsigned char __a, vector unsigned char __b,
7801  vector unsigned char __c) {
7802  return (__a & ~__c) | (__b & __c);
7803 }
7804 
7805 static __inline__ vector unsigned char __ATTRS_o_ai vec_sel(
7806  vector unsigned char __a, vector unsigned char __b, vector bool char __c) {
7807  return (__a & ~(vector unsigned char)__c) | (__b & (vector unsigned char)__c);
7808 }
7809 
7810 static __inline__ vector bool char __ATTRS_o_ai
7811 vec_sel(vector bool char __a, vector bool char __b, vector unsigned char __c) {
7812  return (__a & ~(vector bool char)__c) | (__b & (vector bool char)__c);
7813 }
7814 
7815 static __inline__ vector bool char __ATTRS_o_ai vec_sel(vector bool char __a,
7816  vector bool char __b,
7817  vector bool char __c) {
7818  return (__a & ~__c) | (__b & __c);
7819 }
7820 
7821 static __inline__ vector short __ATTRS_o_ai vec_sel(vector short __a,
7822  vector short __b,
7823  vector unsigned short __c) {
7824  return (__a & ~(vector short)__c) | (__b & (vector short)__c);
7825 }
7826 
7827 static __inline__ vector short __ATTRS_o_ai vec_sel(vector short __a,
7828  vector short __b,
7829  vector bool short __c) {
7830  return (__a & ~(vector short)__c) | (__b & (vector short)__c);
7831 }
7832 
7833 static __inline__ vector unsigned short __ATTRS_o_ai
7834 vec_sel(vector unsigned short __a, vector unsigned short __b,
7835  vector unsigned short __c) {
7836  return (__a & ~__c) | (__b & __c);
7837 }
7838 
7839 static __inline__ vector unsigned short __ATTRS_o_ai
7840 vec_sel(vector unsigned short __a, vector unsigned short __b,
7841  vector bool short __c) {
7842  return (__a & ~(vector unsigned short)__c) |
7843  (__b & (vector unsigned short)__c);
7844 }
7845 
7846 static __inline__ vector bool short __ATTRS_o_ai vec_sel(
7847  vector bool short __a, vector bool short __b, vector unsigned short __c) {
7848  return (__a & ~(vector bool short)__c) | (__b & (vector bool short)__c);
7849 }
7850 
7851 static __inline__ vector bool short __ATTRS_o_ai
7852 vec_sel(vector bool short __a, vector bool short __b, vector bool short __c) {
7853  return (__a & ~__c) | (__b & __c);
7854 }
7855 
7856 static __inline__ vector int __ATTRS_o_ai vec_sel(vector int __a,
7857  vector int __b,
7858  vector unsigned int __c) {
7859  return (__a & ~(vector int)__c) | (__b & (vector int)__c);
7860 }
7861 
7862 static __inline__ vector int __ATTRS_o_ai vec_sel(vector int __a,
7863  vector int __b,
7864  vector bool int __c) {
7865  return (__a & ~(vector int)__c) | (__b & (vector int)__c);
7866 }
7867 
7868 static __inline__ vector unsigned int __ATTRS_o_ai vec_sel(
7869  vector unsigned int __a, vector unsigned int __b, vector unsigned int __c) {
7870  return (__a & ~__c) | (__b & __c);
7871 }
7872 
7873 static __inline__ vector unsigned int __ATTRS_o_ai
7874 vec_sel(vector unsigned int __a, vector unsigned int __b, vector bool int __c) {
7875  return (__a & ~(vector unsigned int)__c) | (__b & (vector unsigned int)__c);
7876 }
7877 
7878 static __inline__ vector bool int __ATTRS_o_ai
7879 vec_sel(vector bool int __a, vector bool int __b, vector unsigned int __c) {
7880  return (__a & ~(vector bool int)__c) | (__b & (vector bool int)__c);
7881 }
7882 
7883 static __inline__ vector bool int __ATTRS_o_ai vec_sel(vector bool int __a,
7884  vector bool int __b,
7885  vector bool int __c) {
7886  return (__a & ~__c) | (__b & __c);
7887 }
7888 
7889 static __inline__ vector float __ATTRS_o_ai vec_sel(vector float __a,
7890  vector float __b,
7891  vector unsigned int __c) {
7892  vector int __res = ((vector int)__a & ~(vector int)__c) |
7893  ((vector int)__b & (vector int)__c);
7894  return (vector float)__res;
7895 }
7896 
7897 static __inline__ vector float __ATTRS_o_ai vec_sel(vector float __a,
7898  vector float __b,
7899  vector bool int __c) {
7900  vector int __res = ((vector int)__a & ~(vector int)__c) |
7901  ((vector int)__b & (vector int)__c);
7902  return (vector float)__res;
7903 }
7904 
7905 #ifdef __VSX__
7906 static __inline__ vector double __ATTRS_o_ai
7907 vec_sel(vector double __a, vector double __b, vector bool long long __c) {
7908  vector long long __res = ((vector long long)__a & ~(vector long long)__c) |
7909  ((vector long long)__b & (vector long long)__c);
7910  return (vector double)__res;
7911 }
7912 
7913 static __inline__ vector double __ATTRS_o_ai
7914 vec_sel(vector double __a, vector double __b, vector unsigned long long __c) {
7915  vector long long __res = ((vector long long)__a & ~(vector long long)__c) |
7916  ((vector long long)__b & (vector long long)__c);
7917  return (vector double)__res;
7918 }
7919 #endif
7920 
7921 /* vec_vsel */
7922 
7923 static __inline__ vector signed char __ATTRS_o_ai vec_vsel(
7924  vector signed char __a, vector signed char __b, vector unsigned char __c) {
7925  return (__a & ~(vector signed char)__c) | (__b & (vector signed char)__c);
7926 }
7927 
7928 static __inline__ vector signed char __ATTRS_o_ai
7929 vec_vsel(vector signed char __a, vector signed char __b, vector bool char __c) {
7930  return (__a & ~(vector signed char)__c) | (__b & (vector signed char)__c);
7931 }
7932 
7933 static __inline__ vector unsigned char __ATTRS_o_ai
7934 vec_vsel(vector unsigned char __a, vector unsigned char __b,
7935  vector unsigned char __c) {
7936  return (__a & ~__c) | (__b & __c);
7937 }
7938 
7939 static __inline__ vector unsigned char __ATTRS_o_ai vec_vsel(
7940  vector unsigned char __a, vector unsigned char __b, vector bool char __c) {
7941  return (__a & ~(vector unsigned char)__c) | (__b & (vector unsigned char)__c);
7942 }
7943 
7944 static __inline__ vector bool char __ATTRS_o_ai
7945 vec_vsel(vector bool char __a, vector bool char __b, vector unsigned char __c) {
7946  return (__a & ~(vector bool char)__c) | (__b & (vector bool char)__c);
7947 }
7948 
7949 static __inline__ vector bool char __ATTRS_o_ai vec_vsel(vector bool char __a,
7950  vector bool char __b,
7951  vector bool char __c) {
7952  return (__a & ~__c) | (__b & __c);
7953 }
7954 
7955 static __inline__ vector short __ATTRS_o_ai
7956 vec_vsel(vector short __a, vector short __b, vector unsigned short __c) {
7957  return (__a & ~(vector short)__c) | (__b & (vector short)__c);
7958 }
7959 
7960 static __inline__ vector short __ATTRS_o_ai vec_vsel(vector short __a,
7961  vector short __b,
7962  vector bool short __c) {
7963  return (__a & ~(vector short)__c) | (__b & (vector short)__c);
7964 }
7965 
7966 static __inline__ vector unsigned short __ATTRS_o_ai
7967 vec_vsel(vector unsigned short __a, vector unsigned short __b,
7968  vector unsigned short __c) {
7969  return (__a & ~__c) | (__b & __c);
7970 }
7971 
7972 static __inline__ vector unsigned short __ATTRS_o_ai
7973 vec_vsel(vector unsigned short __a, vector unsigned short __b,
7974  vector bool short __c) {
7975  return (__a & ~(vector unsigned short)__c) |
7976  (__b & (vector unsigned short)__c);
7977 }
7978 
7979 static __inline__ vector bool short __ATTRS_o_ai vec_vsel(
7980  vector bool short __a, vector bool short __b, vector unsigned short __c) {
7981  return (__a & ~(vector bool short)__c) | (__b & (vector bool short)__c);
7982 }
7983 
7984 static __inline__ vector bool short __ATTRS_o_ai
7985 vec_vsel(vector bool short __a, vector bool short __b, vector bool short __c) {
7986  return (__a & ~__c) | (__b & __c);
7987 }
7988 
7989 static __inline__ vector int __ATTRS_o_ai vec_vsel(vector int __a,
7990  vector int __b,
7991  vector unsigned int __c) {
7992  return (__a & ~(vector int)__c) | (__b & (vector int)__c);
7993 }
7994 
7995 static __inline__ vector int __ATTRS_o_ai vec_vsel(vector int __a,
7996  vector int __b,
7997  vector bool int __c) {
7998  return (__a & ~(vector int)__c) | (__b & (vector int)__c);
7999 }
8000 
8001 static __inline__ vector unsigned int __ATTRS_o_ai vec_vsel(
8002  vector unsigned int __a, vector unsigned int __b, vector unsigned int __c) {
8003  return (__a & ~__c) | (__b & __c);
8004 }
8005 
8006 static __inline__ vector unsigned int __ATTRS_o_ai vec_vsel(
8007  vector unsigned int __a, vector unsigned int __b, vector bool int __c) {
8008  return (__a & ~(vector unsigned int)__c) | (__b & (vector unsigned int)__c);
8009 }
8010 
8011 static __inline__ vector bool int __ATTRS_o_ai
8012 vec_vsel(vector bool int __a, vector bool int __b, vector unsigned int __c) {
8013  return (__a & ~(vector bool int)__c) | (__b & (vector bool int)__c);
8014 }
8015 
8016 static __inline__ vector bool int __ATTRS_o_ai vec_vsel(vector bool int __a,
8017  vector bool int __b,
8018  vector bool int __c) {
8019  return (__a & ~__c) | (__b & __c);
8020 }
8021 
8022 static __inline__ vector float __ATTRS_o_ai vec_vsel(vector float __a,
8023  vector float __b,
8024  vector unsigned int __c) {
8025  vector int __res = ((vector int)__a & ~(vector int)__c) |
8026  ((vector int)__b & (vector int)__c);
8027  return (vector float)__res;
8028 }
8029 
8030 static __inline__ vector float __ATTRS_o_ai vec_vsel(vector float __a,
8031  vector float __b,
8032  vector bool int __c) {
8033  vector int __res = ((vector int)__a & ~(vector int)__c) |
8034  ((vector int)__b & (vector int)__c);
8035  return (vector float)__res;
8036 }
8037 
8038 /* vec_sl */
8039 
8040 // vec_sl does modulo arithmetic on __b first, so __b is allowed to be more
8041 // than the length of __a.
8042 static __inline__ vector unsigned char __ATTRS_o_ai
8043 vec_sl(vector unsigned char __a, vector unsigned char __b) {
8044  return __a << (__b %
8045  (vector unsigned char)(sizeof(unsigned char) * __CHAR_BIT__));
8046 }
8047 
8048 static __inline__ vector signed char __ATTRS_o_ai
8049 vec_sl(vector signed char __a, vector unsigned char __b) {
8050  return (vector signed char)vec_sl((vector unsigned char)__a, __b);
8051 }
8052 
8053 static __inline__ vector unsigned short __ATTRS_o_ai
8054 vec_sl(vector unsigned short __a, vector unsigned short __b) {
8055  return __a << (__b % (vector unsigned short)(sizeof(unsigned short) *
8056  __CHAR_BIT__));
8057 }
8058 
8059 static __inline__ vector short __ATTRS_o_ai vec_sl(vector short __a,
8060  vector unsigned short __b) {
8061  return (vector short)vec_sl((vector unsigned short)__a, __b);
8062 }
8063 
8064 static __inline__ vector unsigned int __ATTRS_o_ai
8065 vec_sl(vector unsigned int __a, vector unsigned int __b) {
8066  return __a << (__b %
8067  (vector unsigned int)(sizeof(unsigned int) * __CHAR_BIT__));
8068 }
8069 
8070 static __inline__ vector int __ATTRS_o_ai vec_sl(vector int __a,
8071  vector unsigned int __b) {
8072  return (vector int)vec_sl((vector unsigned int)__a, __b);
8073 }
8074 
8075 #ifdef __POWER8_VECTOR__
8076 static __inline__ vector unsigned long long __ATTRS_o_ai
8077 vec_sl(vector unsigned long long __a, vector unsigned long long __b) {
8078  return __a << (__b % (vector unsigned long long)(sizeof(unsigned long long) *
8079  __CHAR_BIT__));
8080 }
8081 
8082 static __inline__ vector long long __ATTRS_o_ai
8083 vec_sl(vector long long __a, vector unsigned long long __b) {
8084  return (vector long long)vec_sl((vector unsigned long long)__a, __b);
8085 }
8086 #endif
8087 
8088 /* vec_vslb */
8089 
8090 #define __builtin_altivec_vslb vec_vslb
8091 
8092 static __inline__ vector signed char __ATTRS_o_ai
8093 vec_vslb(vector signed char __a, vector unsigned char __b) {
8094  return vec_sl(__a, __b);
8095 }
8096 
8097 static __inline__ vector unsigned char __ATTRS_o_ai
8098 vec_vslb(vector unsigned char __a, vector unsigned char __b) {
8099  return vec_sl(__a, __b);
8100 }
8101 
8102 /* vec_vslh */
8103 
8104 #define __builtin_altivec_vslh vec_vslh
8105 
8106 static __inline__ vector short __ATTRS_o_ai
8107 vec_vslh(vector short __a, vector unsigned short __b) {
8108  return vec_sl(__a, __b);
8109 }
8110 
8111 static __inline__ vector unsigned short __ATTRS_o_ai
8112 vec_vslh(vector unsigned short __a, vector unsigned short __b) {
8113  return vec_sl(__a, __b);
8114 }
8115 
8116 /* vec_vslw */
8117 
8118 #define __builtin_altivec_vslw vec_vslw
8119 
8120 static __inline__ vector int __ATTRS_o_ai vec_vslw(vector int __a,
8121  vector unsigned int __b) {
8122  return vec_sl(__a, __b);
8123 }
8124 
8125 static __inline__ vector unsigned int __ATTRS_o_ai
8126 vec_vslw(vector unsigned int __a, vector unsigned int __b) {
8127  return vec_sl(__a, __b);
8128 }
8129 
8130 /* vec_sld */
8131 
8132 #define __builtin_altivec_vsldoi_4si vec_sld
8133 
8134 static __inline__ vector signed char __ATTRS_o_ai vec_sld(
8135  vector signed char __a, vector signed char __b, unsigned const int __c) {
8136  unsigned char __d = __c & 0x0F;
8137 #ifdef __LITTLE_ENDIAN__
8138  return vec_perm(
8139  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8140  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8141  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8142  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8143 #else
8144  return vec_perm(
8145  __a, __b,
8146  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8147  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8148  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8149 #endif
8150 }
8151 
8152 static __inline__ vector unsigned char __ATTRS_o_ai
8153 vec_sld(vector unsigned char __a, vector unsigned char __b,
8154  unsigned const int __c) {
8155  unsigned char __d = __c & 0x0F;
8156 #ifdef __LITTLE_ENDIAN__
8157  return vec_perm(
8158  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8159  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8160  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8161  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8162 #else
8163  return vec_perm(
8164  __a, __b,
8165  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8166  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8167  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8168 #endif
8169 }
8170 
8171 static __inline__ vector bool char __ATTRS_o_ai
8172 vec_sld(vector bool char __a, vector bool char __b, unsigned const int __c) {
8173  unsigned char __d = __c & 0x0F;
8174 #ifdef __LITTLE_ENDIAN__
8175  return vec_perm(
8176  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8177  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8178  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8179  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8180 #else
8181  return vec_perm(
8182  __a, __b,
8183  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8184  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8185  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8186 #endif
8187 }
8188 
8189 static __inline__ vector signed short __ATTRS_o_ai vec_sld(
8190  vector signed short __a, vector signed short __b, unsigned const int __c) {
8191  unsigned char __d = __c & 0x0F;
8192 #ifdef __LITTLE_ENDIAN__
8193  return vec_perm(
8194  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8195  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8196  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8197  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8198 #else
8199  return vec_perm(
8200  __a, __b,
8201  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8202  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8203  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8204 #endif
8205 }
8206 
8207 static __inline__ vector unsigned short __ATTRS_o_ai
8208 vec_sld(vector unsigned short __a, vector unsigned short __b,
8209  unsigned const int __c) {
8210  unsigned char __d = __c & 0x0F;
8211 #ifdef __LITTLE_ENDIAN__
8212  return vec_perm(
8213  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8214  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8215  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8216  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8217 #else
8218  return vec_perm(
8219  __a, __b,
8220  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8221  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8222  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8223 #endif
8224 }
8225 
8226 static __inline__ vector bool short __ATTRS_o_ai
8227 vec_sld(vector bool short __a, vector bool short __b, unsigned const int __c) {
8228  unsigned char __d = __c & 0x0F;
8229 #ifdef __LITTLE_ENDIAN__
8230  return vec_perm(
8231  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8232  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8233  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8234  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8235 #else
8236  return vec_perm(
8237  __a, __b,
8238  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8239  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8240  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8241 #endif
8242 }
8243 
8244 static __inline__ vector pixel __ATTRS_o_ai vec_sld(vector pixel __a,
8245  vector pixel __b,
8246  unsigned const int __c) {
8247  unsigned char __d = __c & 0x0F;
8248 #ifdef __LITTLE_ENDIAN__
8249  return vec_perm(
8250  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8251  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8252  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8253  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8254 #else
8255  return vec_perm(
8256  __a, __b,
8257  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8258  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8259  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8260 #endif
8261 }
8262 
8263 static __inline__ vector signed int __ATTRS_o_ai
8264 vec_sld(vector signed int __a, vector signed int __b, unsigned const int __c) {
8265  unsigned char __d = __c & 0x0F;
8266 #ifdef __LITTLE_ENDIAN__
8267  return vec_perm(
8268  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8269  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8270  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8271  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8272 #else
8273  return vec_perm(
8274  __a, __b,
8275  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8276  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8277  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8278 #endif
8279 }
8280 
8281 static __inline__ vector unsigned int __ATTRS_o_ai vec_sld(
8282  vector unsigned int __a, vector unsigned int __b, unsigned const int __c) {
8283  unsigned char __d = __c & 0x0F;
8284 #ifdef __LITTLE_ENDIAN__
8285  return vec_perm(
8286  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8287  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8288  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8289  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8290 #else
8291  return vec_perm(
8292  __a, __b,
8293  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8294  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8295  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8296 #endif
8297 }
8298 
8299 static __inline__ vector bool int __ATTRS_o_ai vec_sld(vector bool int __a,
8300  vector bool int __b,
8301  unsigned const int __c) {
8302  unsigned char __d = __c & 0x0F;
8303 #ifdef __LITTLE_ENDIAN__
8304  return vec_perm(
8305  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8306  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8307  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8308  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8309 #else
8310  return vec_perm(
8311  __a, __b,
8312  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8313  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8314  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8315 #endif
8316 }
8317 
8318 static __inline__ vector float __ATTRS_o_ai vec_sld(vector float __a,
8319  vector float __b,
8320  unsigned const int __c) {
8321  unsigned char __d = __c & 0x0F;
8322 #ifdef __LITTLE_ENDIAN__
8323  return vec_perm(
8324  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8325  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8326  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8327  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8328 #else
8329  return vec_perm(
8330  __a, __b,
8331  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8332  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8333  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8334 #endif
8335 }
8336 
8337 #ifdef __VSX__
8338 static __inline__ vector bool long long __ATTRS_o_ai
8339 vec_sld(vector bool long long __a, vector bool long long __b,
8340  unsigned const int __c) {
8341  unsigned char __d = __c & 0x0F;
8342 #ifdef __LITTLE_ENDIAN__
8343  return vec_perm(
8344  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8345  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8346  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8347  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8348 #else
8349  return vec_perm(
8350  __a, __b,
8351  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8352  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8353  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8354 #endif
8355 }
8356 
8357 static __inline__ vector signed long long __ATTRS_o_ai
8358 vec_sld(vector signed long long __a, vector signed long long __b,
8359  unsigned const int __c) {
8360  unsigned char __d = __c & 0x0F;
8361 #ifdef __LITTLE_ENDIAN__
8362  return vec_perm(
8363  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8364  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8365  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8366  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8367 #else
8368  return vec_perm(
8369  __a, __b,
8370  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8371  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8372  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8373 #endif
8374 }
8375 
8376 static __inline__ vector unsigned long long __ATTRS_o_ai
8377 vec_sld(vector unsigned long long __a, vector unsigned long long __b,
8378  unsigned const int __c) {
8379  unsigned char __d = __c & 0x0F;
8380 #ifdef __LITTLE_ENDIAN__
8381  return vec_perm(
8382  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8383  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8384  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8385  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8386 #else
8387  return vec_perm(
8388  __a, __b,
8389  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8390  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8391  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8392 #endif
8393 }
8394 
8395 static __inline__ vector double __ATTRS_o_ai vec_sld(vector double __a,
8396  vector double __b,
8397  unsigned const int __c) {
8398  unsigned char __d = __c & 0x0F;
8399 #ifdef __LITTLE_ENDIAN__
8400  return vec_perm(
8401  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8402  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8403  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8404  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8405 #else
8406  return vec_perm(
8407  __a, __b,
8408  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8409  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8410  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8411 #endif
8412 }
8413 #endif
8414 
8415 /* vec_sldw */
8416 static __inline__ vector signed char __ATTRS_o_ai vec_sldw(
8417  vector signed char __a, vector signed char __b, unsigned const int __c) {
8418  return vec_sld(__a, __b, ((__c << 2) & 0x0F));
8419 }
8420 
8421 static __inline__ vector unsigned char __ATTRS_o_ai
8422 vec_sldw(vector unsigned char __a, vector unsigned char __b,
8423  unsigned const int __c) {
8424  return vec_sld(__a, __b, ((__c << 2) & 0x0F));
8425 }
8426 
8427 static __inline__ vector signed short __ATTRS_o_ai vec_sldw(
8428  vector signed short __a, vector signed short __b, unsigned const int __c) {
8429  return vec_sld(__a, __b, ((__c << 2) & 0x0F));
8430 }
8431 
8432 static __inline__ vector unsigned short __ATTRS_o_ai
8433 vec_sldw(vector unsigned short __a, vector unsigned short __b,
8434  unsigned const int __c) {
8435  return vec_sld(__a, __b, ((__c << 2) & 0x0F));
8436 }
8437 
8438 static __inline__ vector signed int __ATTRS_o_ai
8439 vec_sldw(vector signed int __a, vector signed int __b, unsigned const int __c) {
8440  return vec_sld(__a, __b, ((__c << 2) & 0x0F));
8441 }
8442 
8443 static __inline__ vector unsigned int __ATTRS_o_ai vec_sldw(
8444  vector unsigned int __a, vector unsigned int __b, unsigned const int __c) {
8445  return vec_sld(__a, __b, ((__c << 2) & 0x0F));
8446 }
8447 
8448 #ifdef __VSX__
8449 static __inline__ vector signed long long __ATTRS_o_ai
8450 vec_sldw(vector signed long long __a, vector signed long long __b,
8451  unsigned const int __c) {
8452  return vec_sld(__a, __b, ((__c << 2) & 0x0F));
8453 }
8454 
8455 static __inline__ vector unsigned long long __ATTRS_o_ai
8456 vec_sldw(vector unsigned long long __a, vector unsigned long long __b,
8457  unsigned const int __c) {
8458  return vec_sld(__a, __b, ((__c << 2) & 0x0F));
8459 }
8460 #endif
8461 
8462 #ifdef __POWER9_VECTOR__
8463 /* vec_slv */
8464 static __inline__ vector unsigned char __ATTRS_o_ai
8465 vec_slv(vector unsigned char __a, vector unsigned char __b) {
8466  return __builtin_altivec_vslv(__a, __b);
8467 }
8468 
8469 /* vec_srv */
8470 static __inline__ vector unsigned char __ATTRS_o_ai
8471 vec_srv(vector unsigned char __a, vector unsigned char __b) {
8472  return __builtin_altivec_vsrv(__a, __b);
8473 }
8474 #endif
8475 
8476 /* vec_vsldoi */
8477 
8478 static __inline__ vector signed char __ATTRS_o_ai
8479 vec_vsldoi(vector signed char __a, vector signed char __b, unsigned char __c) {
8480  unsigned char __d = __c & 0x0F;
8481 #ifdef __LITTLE_ENDIAN__
8482  return vec_perm(
8483  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8484  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8485  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8486  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8487 #else
8488  return vec_perm(
8489  __a, __b,
8490  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8491  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8492  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8493 #endif
8494 }
8495 
8496 static __inline__ vector unsigned char __ATTRS_o_ai vec_vsldoi(
8497  vector unsigned char __a, vector unsigned char __b, unsigned char __c) {
8498  unsigned char __d = __c & 0x0F;
8499 #ifdef __LITTLE_ENDIAN__
8500  return vec_perm(
8501  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8502  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8503  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8504  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8505 #else
8506  return vec_perm(
8507  __a, __b,
8508  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8509  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8510  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8511 #endif
8512 }
8513 
8514 static __inline__ vector short __ATTRS_o_ai vec_vsldoi(vector short __a,
8515  vector short __b,
8516  unsigned char __c) {
8517  unsigned char __d = __c & 0x0F;
8518 #ifdef __LITTLE_ENDIAN__
8519  return vec_perm(
8520  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8521  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8522  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8523  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8524 #else
8525  return vec_perm(
8526  __a, __b,
8527  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8528  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8529  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8530 #endif
8531 }
8532 
8533 static __inline__ vector unsigned short __ATTRS_o_ai vec_vsldoi(
8534  vector unsigned short __a, vector unsigned short __b, unsigned char __c) {
8535  unsigned char __d = __c & 0x0F;
8536 #ifdef __LITTLE_ENDIAN__
8537  return vec_perm(
8538  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8539  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8540  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8541  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8542 #else
8543  return vec_perm(
8544  __a, __b,
8545  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8546  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8547  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8548 #endif
8549 }
8550 
8551 static __inline__ vector pixel __ATTRS_o_ai vec_vsldoi(vector pixel __a,
8552  vector pixel __b,
8553  unsigned char __c) {
8554  unsigned char __d = __c & 0x0F;
8555 #ifdef __LITTLE_ENDIAN__
8556  return vec_perm(
8557  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8558  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8559  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8560  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8561 #else
8562  return vec_perm(
8563  __a, __b,
8564  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8565  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8566  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8567 #endif
8568 }
8569 
8570 static __inline__ vector int __ATTRS_o_ai vec_vsldoi(vector int __a,
8571  vector int __b,
8572  unsigned char __c) {
8573  unsigned char __d = __c & 0x0F;
8574 #ifdef __LITTLE_ENDIAN__
8575  return vec_perm(
8576  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8577  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8578  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8579  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8580 #else
8581  return vec_perm(
8582  __a, __b,
8583  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8584  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8585  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8586 #endif
8587 }
8588 
8589 static __inline__ vector unsigned int __ATTRS_o_ai vec_vsldoi(
8590  vector unsigned int __a, vector unsigned int __b, unsigned char __c) {
8591  unsigned char __d = __c & 0x0F;
8592 #ifdef __LITTLE_ENDIAN__
8593  return vec_perm(
8594  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8595  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8596  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8597  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8598 #else
8599  return vec_perm(
8600  __a, __b,
8601  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8602  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8603  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8604 #endif
8605 }
8606 
8607 static __inline__ vector float __ATTRS_o_ai vec_vsldoi(vector float __a,
8608  vector float __b,
8609  unsigned char __c) {
8610  unsigned char __d = __c & 0x0F;
8611 #ifdef __LITTLE_ENDIAN__
8612  return vec_perm(
8613  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8614  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8615  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8616  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8617 #else
8618  return vec_perm(
8619  __a, __b,
8620  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8621  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8622  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8623 #endif
8624 }
8625 
8626 /* vec_sll */
8627 
8628 static __inline__ vector signed char __ATTRS_o_ai
8629 vec_sll(vector signed char __a, vector unsigned char __b) {
8630  return (vector signed char)__builtin_altivec_vsl((vector int)__a,
8631  (vector int)__b);
8632 }
8633 
8634 static __inline__ vector signed char __ATTRS_o_ai
8635 vec_sll(vector signed char __a, vector unsigned short __b) {
8636  return (vector signed char)__builtin_altivec_vsl((vector int)__a,
8637  (vector int)__b);
8638 }
8639 
8640 static __inline__ vector signed char __ATTRS_o_ai
8641 vec_sll(vector signed char __a, vector unsigned int __b) {
8642  return (vector signed char)__builtin_altivec_vsl((vector int)__a,
8643  (vector int)__b);
8644 }
8645 
8646 static __inline__ vector unsigned char __ATTRS_o_ai
8647 vec_sll(vector unsigned char __a, vector unsigned char __b) {
8648  return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
8649  (vector int)__b);
8650 }
8651 
8652 static __inline__ vector unsigned char __ATTRS_o_ai
8653 vec_sll(vector unsigned char __a, vector unsigned short __b) {
8654  return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
8655  (vector int)__b);
8656 }
8657 
8658 static __inline__ vector unsigned char __ATTRS_o_ai
8659 vec_sll(vector unsigned char __a, vector unsigned int __b) {
8660  return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
8661  (vector int)__b);
8662 }
8663 
8664 static __inline__ vector bool char __ATTRS_o_ai
8665 vec_sll(vector bool char __a, vector unsigned char __b) {
8666  return (vector bool char)__builtin_altivec_vsl((vector int)__a,
8667  (vector int)__b);
8668 }
8669 
8670 static __inline__ vector bool char __ATTRS_o_ai
8671 vec_sll(vector bool char __a, vector unsigned short __b) {
8672  return (vector bool char)__builtin_altivec_vsl((vector int)__a,
8673  (vector int)__b);
8674 }
8675 
8676 static __inline__ vector bool char __ATTRS_o_ai
8677 vec_sll(vector bool char __a, vector unsigned int __b) {
8678  return (vector bool char)__builtin_altivec_vsl((vector int)__a,
8679  (vector int)__b);
8680 }
8681 
8682 static __inline__ vector short __ATTRS_o_ai vec_sll(vector short __a,
8683  vector unsigned char __b) {
8684  return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
8685 }
8686 
8687 static __inline__ vector short __ATTRS_o_ai vec_sll(vector short __a,
8688  vector unsigned short __b) {
8689  return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
8690 }
8691 
8692 static __inline__ vector short __ATTRS_o_ai vec_sll(vector short __a,
8693  vector unsigned int __b) {
8694  return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
8695 }
8696 
8697 static __inline__ vector unsigned short __ATTRS_o_ai
8698 vec_sll(vector unsigned short __a, vector unsigned char __b) {
8699  return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
8700  (vector int)__b);
8701 }
8702 
8703 static __inline__ vector unsigned short __ATTRS_o_ai
8704 vec_sll(vector unsigned short __a, vector unsigned short __b) {
8705  return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
8706  (vector int)__b);
8707 }
8708 
8709 static __inline__ vector unsigned short __ATTRS_o_ai
8710 vec_sll(vector unsigned short __a, vector unsigned int __b) {
8711  return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
8712  (vector int)__b);
8713 }
8714 
8715 static __inline__ vector bool short __ATTRS_o_ai
8716 vec_sll(vector bool short __a, vector unsigned char __b) {
8717  return (vector bool short)__builtin_altivec_vsl((vector int)__a,
8718  (vector int)__b);
8719 }
8720 
8721 static __inline__ vector bool short __ATTRS_o_ai
8722 vec_sll(vector bool short __a, vector unsigned short __b) {
8723  return (vector bool short)__builtin_altivec_vsl((vector int)__a,
8724  (vector int)__b);
8725 }
8726 
8727 static __inline__ vector bool short __ATTRS_o_ai
8728 vec_sll(vector bool short __a, vector unsigned int __b) {
8729  return (vector bool short)__builtin_altivec_vsl((vector int)__a,
8730  (vector int)__b);
8731 }
8732 
8733 static __inline__ vector pixel __ATTRS_o_ai vec_sll(vector pixel __a,
8734  vector unsigned char __b) {
8735  return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
8736 }
8737 
8738 static __inline__ vector pixel __ATTRS_o_ai vec_sll(vector pixel __a,
8739  vector unsigned short __b) {
8740  return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
8741 }
8742 
8743 static __inline__ vector pixel __ATTRS_o_ai vec_sll(vector pixel __a,
8744  vector unsigned int __b) {
8745  return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
8746 }
8747 
8748 static __inline__ vector int __ATTRS_o_ai vec_sll(vector int __a,
8749  vector unsigned char __b) {
8750  return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
8751 }
8752 
8753 static __inline__ vector int __ATTRS_o_ai vec_sll(vector int __a,
8754  vector unsigned short __b) {
8755  return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
8756 }
8757 
8758 static __inline__ vector int __ATTRS_o_ai vec_sll(vector int __a,
8759  vector unsigned int __b) {
8760  return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
8761 }
8762 
8763 static __inline__ vector unsigned int __ATTRS_o_ai
8764 vec_sll(vector unsigned int __a, vector unsigned char __b) {
8765  return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
8766  (vector int)__b);
8767 }
8768 
8769 static __inline__ vector unsigned int __ATTRS_o_ai
8770 vec_sll(vector unsigned int __a, vector unsigned short __b) {
8771  return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
8772  (vector int)__b);
8773 }
8774 
8775 static __inline__ vector unsigned int __ATTRS_o_ai
8776 vec_sll(vector unsigned int __a, vector unsigned int __b) {
8777  return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
8778  (vector int)__b);
8779 }
8780 
8781 static __inline__ vector bool int __ATTRS_o_ai
8782 vec_sll(vector bool int __a, vector unsigned char __b) {
8783  return (vector bool int)__builtin_altivec_vsl((vector int)__a,
8784  (vector int)__b);
8785 }
8786 
8787 static __inline__ vector bool int __ATTRS_o_ai
8788 vec_sll(vector bool int __a, vector unsigned short __b) {
8789  return (vector bool int)__builtin_altivec_vsl((vector int)__a,
8790  (vector int)__b);
8791 }
8792 
8793 static __inline__ vector bool int __ATTRS_o_ai
8794 vec_sll(vector bool int __a, vector unsigned int __b) {
8795  return (vector bool int)__builtin_altivec_vsl((vector int)__a,
8796  (vector int)__b);
8797 }
8798 
8799 #ifdef __VSX__
8800 static __inline__ vector signed long long __ATTRS_o_ai
8801 vec_sll(vector signed long long __a, vector unsigned char __b) {
8802  return (vector signed long long)__builtin_altivec_vsl((vector int)__a,
8803  (vector int)__b);
8804 }
8805 
8806 static __inline__ vector unsigned long long __ATTRS_o_ai
8807 vec_sll(vector unsigned long long __a, vector unsigned char __b) {
8808  return (vector unsigned long long)__builtin_altivec_vsl((vector int)__a,
8809  (vector int)__b);
8810 }
8811 #endif
8812 
8813 /* vec_vsl */
8814 
8815 static __inline__ vector signed char __ATTRS_o_ai
8816 vec_vsl(vector signed char __a, vector unsigned char __b) {
8817  return (vector signed char)__builtin_altivec_vsl((vector int)__a,
8818  (vector int)__b);
8819 }
8820 
8821 static __inline__ vector signed char __ATTRS_o_ai
8822 vec_vsl(vector signed char __a, vector unsigned short __b) {
8823  return (vector signed char)__builtin_altivec_vsl((vector int)__a,
8824  (vector int)__b);
8825 }
8826 
8827 static __inline__ vector signed char __ATTRS_o_ai
8828 vec_vsl(vector signed char __a, vector unsigned int __b) {
8829  return (vector signed char)__builtin_altivec_vsl((vector int)__a,
8830  (vector int)__b);
8831 }
8832 
8833 static __inline__ vector unsigned char __ATTRS_o_ai
8834 vec_vsl(vector unsigned char __a, vector unsigned char __b) {
8835  return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
8836  (vector int)__b);
8837 }
8838 
8839 static __inline__ vector unsigned char __ATTRS_o_ai
8840 vec_vsl(vector unsigned char __a, vector unsigned short __b) {
8841  return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
8842  (vector int)__b);
8843 }
8844 
8845 static __inline__ vector unsigned char __ATTRS_o_ai
8846 vec_vsl(vector unsigned char __a, vector unsigned int __b) {
8847  return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
8848  (vector int)__b);
8849 }
8850 
8851 static __inline__ vector bool char __ATTRS_o_ai
8852 vec_vsl(vector bool char __a, vector unsigned char __b) {
8853  return (vector bool char)__builtin_altivec_vsl((vector int)__a,
8854  (vector int)__b);
8855 }
8856 
8857 static __inline__ vector bool char __ATTRS_o_ai
8858 vec_vsl(vector bool char __a, vector unsigned short __b) {
8859  return (vector bool char)__builtin_altivec_vsl((vector int)__a,
8860  (vector int)__b);
8861 }
8862 
8863 static __inline__ vector bool char __ATTRS_o_ai
8864 vec_vsl(vector bool char __a, vector unsigned int __b) {
8865  return (vector bool char)__builtin_altivec_vsl((vector int)__a,
8866  (vector int)__b);
8867 }
8868 
8869 static __inline__ vector short __ATTRS_o_ai vec_vsl(vector short __a,
8870  vector unsigned char __b) {
8871  return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
8872 }
8873 
8874 static __inline__ vector short __ATTRS_o_ai vec_vsl(vector short __a,
8875  vector unsigned short __b) {
8876  return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
8877 }
8878 
8879 static __inline__ vector short __ATTRS_o_ai vec_vsl(vector short __a,
8880  vector unsigned int __b) {
8881  return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
8882 }
8883 
8884 static __inline__ vector unsigned short __ATTRS_o_ai
8885 vec_vsl(vector unsigned short __a, vector unsigned char __b) {
8886  return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
8887  (vector int)__b);
8888 }
8889 
8890 static __inline__ vector unsigned short __ATTRS_o_ai
8891 vec_vsl(vector unsigned short __a, vector unsigned short __b) {
8892  return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
8893  (vector int)__b);
8894 }
8895 
8896 static __inline__ vector unsigned short __ATTRS_o_ai
8897 vec_vsl(vector unsigned short __a, vector unsigned int __b) {
8898  return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
8899  (vector int)__b);
8900 }
8901 
8902 static __inline__ vector bool short __ATTRS_o_ai
8903 vec_vsl(vector bool short __a, vector unsigned char __b) {
8904  return (vector bool short)__builtin_altivec_vsl((vector int)__a,
8905  (vector int)__b);
8906 }
8907 
8908 static __inline__ vector bool short __ATTRS_o_ai
8909 vec_vsl(vector bool short __a, vector unsigned short __b) {
8910  return (vector bool short)__builtin_altivec_vsl((vector int)__a,
8911  (vector int)__b);
8912 }
8913 
8914 static __inline__ vector bool short __ATTRS_o_ai
8915 vec_vsl(vector bool short __a, vector unsigned int __b) {
8916  return (vector bool short)__builtin_altivec_vsl((vector int)__a,
8917  (vector int)__b);
8918 }
8919 
8920 static __inline__ vector pixel __ATTRS_o_ai vec_vsl(vector pixel __a,
8921  vector unsigned char __b) {
8922  return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
8923 }
8924 
8925 static __inline__ vector pixel __ATTRS_o_ai vec_vsl(vector pixel __a,
8926  vector unsigned short __b) {
8927  return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
8928 }
8929 
8930 static __inline__ vector pixel __ATTRS_o_ai vec_vsl(vector pixel __a,
8931  vector unsigned int __b) {
8932  return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
8933 }
8934 
8935 static __inline__ vector int __ATTRS_o_ai vec_vsl(vector int __a,
8936  vector unsigned char __b) {
8937  return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
8938 }
8939 
8940 static __inline__ vector int __ATTRS_o_ai vec_vsl(vector int __a,
8941  vector unsigned short __b) {
8942  return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
8943 }
8944 
8945 static __inline__ vector int __ATTRS_o_ai vec_vsl(vector int __a,
8946  vector unsigned int __b) {
8947  return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
8948 }
8949 
8950 static __inline__ vector unsigned int __ATTRS_o_ai
8951 vec_vsl(vector unsigned int __a, vector unsigned char __b) {
8952  return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
8953  (vector int)__b);
8954 }
8955 
8956 static __inline__ vector unsigned int __ATTRS_o_ai
8957 vec_vsl(vector unsigned int __a, vector unsigned short __b) {
8958  return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
8959  (vector int)__b);
8960 }
8961 
8962 static __inline__ vector unsigned int __ATTRS_o_ai
8963 vec_vsl(vector unsigned int __a, vector unsigned int __b) {
8964  return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
8965  (vector int)__b);
8966 }
8967 
8968 static __inline__ vector bool int __ATTRS_o_ai
8969 vec_vsl(vector bool int __a, vector unsigned char __b) {
8970  return (vector bool int)__builtin_altivec_vsl((vector int)__a,
8971  (vector int)__b);
8972 }
8973 
8974 static __inline__ vector bool int __ATTRS_o_ai
8975 vec_vsl(vector bool int __a, vector unsigned short __b) {
8976  return (vector bool int)__builtin_altivec_vsl((vector int)__a,
8977  (vector int)__b);
8978 }
8979 
8980 static __inline__ vector bool int __ATTRS_o_ai
8981 vec_vsl(vector bool int __a, vector unsigned int __b) {
8982  return (vector bool int)__builtin_altivec_vsl((vector int)__a,
8983  (vector int)__b);
8984 }
8985 
8986 /* vec_slo */
8987 
8988 static __inline__ vector signed char __ATTRS_o_ai
8989 vec_slo(vector signed char __a, vector signed char __b) {
8990  return (vector signed char)__builtin_altivec_vslo((vector int)__a,
8991  (vector int)__b);
8992 }
8993 
8994 static __inline__ vector signed char __ATTRS_o_ai
8995 vec_slo(vector signed char __a, vector unsigned char __b) {
8996  return (vector signed char)__builtin_altivec_vslo((vector int)__a,
8997  (vector int)__b);
8998 }
8999 
9000 static __inline__ vector unsigned char __ATTRS_o_ai
9001 vec_slo(vector unsigned char __a, vector signed char __b) {
9002  return (vector unsigned char)__builtin_altivec_vslo((vector int)__a,
9003  (vector int)__b);
9004 }
9005 
9006 static __inline__ vector unsigned char __ATTRS_o_ai
9007 vec_slo(vector unsigned char __a, vector unsigned char __b) {
9008  return (vector unsigned char)__builtin_altivec_vslo((vector int)__a,
9009  (vector int)__b);
9010 }
9011 
9012 static __inline__ vector short __ATTRS_o_ai vec_slo(vector short __a,
9013  vector signed char __b) {
9014  return (vector short)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9015 }
9016 
9017 static __inline__ vector short __ATTRS_o_ai vec_slo(vector short __a,
9018  vector unsigned char __b) {
9019  return (vector short)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9020 }
9021 
9022 static __inline__ vector unsigned short __ATTRS_o_ai
9023 vec_slo(vector unsigned short __a, vector signed char __b) {
9024  return (vector unsigned short)__builtin_altivec_vslo((vector int)__a,
9025  (vector int)__b);
9026 }
9027 
9028 static __inline__ vector unsigned short __ATTRS_o_ai
9029 vec_slo(vector unsigned short __a, vector unsigned char __b) {
9030  return (vector unsigned short)__builtin_altivec_vslo((vector int)__a,
9031  (vector int)__b);
9032 }
9033 
9034 static __inline__ vector pixel __ATTRS_o_ai vec_slo(vector pixel __a,
9035  vector signed char __b) {
9036  return (vector pixel)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9037 }
9038 
9039 static __inline__ vector pixel __ATTRS_o_ai vec_slo(vector pixel __a,
9040  vector unsigned char __b) {
9041  return (vector pixel)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9042 }
9043 
9044 static __inline__ vector int __ATTRS_o_ai vec_slo(vector int __a,
9045  vector signed char __b) {
9046  return (vector int)__builtin_altivec_vslo(__a, (vector int)__b);
9047 }
9048 
9049 static __inline__ vector int __ATTRS_o_ai vec_slo(vector int __a,
9050  vector unsigned char __b) {
9051  return (vector int)__builtin_altivec_vslo(__a, (vector int)__b);
9052 }
9053 
9054 static __inline__ vector unsigned int __ATTRS_o_ai
9055 vec_slo(vector unsigned int __a, vector signed char __b) {
9056  return (vector unsigned int)__builtin_altivec_vslo((vector int)__a,
9057  (vector int)__b);
9058 }
9059 
9060 static __inline__ vector unsigned int __ATTRS_o_ai
9061 vec_slo(vector unsigned int __a, vector unsigned char __b) {
9062  return (vector unsigned int)__builtin_altivec_vslo((vector int)__a,
9063  (vector int)__b);
9064 }
9065 
9066 static __inline__ vector float __ATTRS_o_ai vec_slo(vector float __a,
9067  vector signed char __b) {
9068  return (vector float)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9069 }
9070 
9071 static __inline__ vector float __ATTRS_o_ai vec_slo(vector float __a,
9072  vector unsigned char __b) {
9073  return (vector float)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9074 }
9075 
9076 #ifdef __VSX__
9077 static __inline__ vector signed long long __ATTRS_o_ai
9078 vec_slo(vector signed long long __a, vector signed char __b) {
9079  return (vector signed long long)__builtin_altivec_vslo((vector int)__a,
9080  (vector int)__b);
9081 }
9082 
9083 static __inline__ vector signed long long __ATTRS_o_ai
9084 vec_slo(vector signed long long __a, vector unsigned char __b) {
9085  return (vector signed long long)__builtin_altivec_vslo((vector int)__a,
9086  (vector int)__b);
9087 }
9088 
9089 static __inline__ vector unsigned long long __ATTRS_o_ai
9090 vec_slo(vector unsigned long long __a, vector signed char __b) {
9091  return (vector unsigned long long)__builtin_altivec_vslo((vector int)__a,
9092  (vector int)__b);
9093 }
9094 
9095 static __inline__ vector unsigned long long __ATTRS_o_ai
9096 vec_slo(vector unsigned long long __a, vector unsigned char __b) {
9097  return (vector unsigned long long)__builtin_altivec_vslo((vector int)__a,
9098  (vector int)__b);
9099 }
9100 #endif
9101 
9102 /* vec_vslo */
9103 
9104 static __inline__ vector signed char __ATTRS_o_ai
9105 vec_vslo(vector signed char __a, vector signed char __b) {
9106  return (vector signed char)__builtin_altivec_vslo((vector int)__a,
9107  (vector int)__b);
9108 }
9109 
9110 static __inline__ vector signed char __ATTRS_o_ai
9111 vec_vslo(vector signed char __a, vector unsigned char __b) {
9112  return (vector signed char)__builtin_altivec_vslo((vector int)__a,
9113  (vector int)__b);
9114 }
9115 
9116 static __inline__ vector unsigned char __ATTRS_o_ai
9117 vec_vslo(vector unsigned char __a, vector signed char __b) {
9118  return (vector unsigned char)__builtin_altivec_vslo((vector int)__a,
9119  (vector int)__b);
9120 }
9121 
9122 static __inline__ vector unsigned char __ATTRS_o_ai
9123 vec_vslo(vector unsigned char __a, vector unsigned char __b) {
9124  return (vector unsigned char)__builtin_altivec_vslo((vector int)__a,
9125  (vector int)__b);
9126 }
9127 
9128 static __inline__ vector short __ATTRS_o_ai vec_vslo(vector short __a,
9129  vector signed char __b) {
9130  return (vector short)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9131 }
9132 
9133 static __inline__ vector short __ATTRS_o_ai vec_vslo(vector short __a,
9134  vector unsigned char __b) {
9135  return (vector short)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9136 }
9137 
9138 static __inline__ vector unsigned short __ATTRS_o_ai
9139 vec_vslo(vector unsigned short __a, vector signed char __b) {
9140  return (vector unsigned short)__builtin_altivec_vslo((vector int)__a,
9141  (vector int)__b);
9142 }
9143 
9144 static __inline__ vector unsigned short __ATTRS_o_ai
9145 vec_vslo(vector unsigned short __a, vector unsigned char __b) {
9146  return (vector unsigned short)__builtin_altivec_vslo((vector int)__a,
9147  (vector int)__b);
9148 }
9149 
9150 static __inline__ vector pixel __ATTRS_o_ai vec_vslo(vector pixel __a,
9151  vector signed char __b) {
9152  return (vector pixel)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9153 }
9154 
9155 static __inline__ vector pixel __ATTRS_o_ai vec_vslo(vector pixel __a,
9156  vector unsigned char __b) {
9157  return (vector pixel)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9158 }
9159 
9160 static __inline__ vector int __ATTRS_o_ai vec_vslo(vector int __a,
9161  vector signed char __b) {
9162  return (vector int)__builtin_altivec_vslo(__a, (vector int)__b);
9163 }
9164 
9165 static __inline__ vector int __ATTRS_o_ai vec_vslo(vector int __a,
9166  vector unsigned char __b) {
9167  return (vector int)__builtin_altivec_vslo(__a, (vector int)__b);
9168 }
9169 
9170 static __inline__ vector unsigned int __ATTRS_o_ai
9171 vec_vslo(vector unsigned int __a, vector signed char __b) {
9172  return (vector unsigned int)__builtin_altivec_vslo((vector int)__a,
9173  (vector int)__b);
9174 }
9175 
9176 static __inline__ vector unsigned int __ATTRS_o_ai
9177 vec_vslo(vector unsigned int __a, vector unsigned char __b) {
9178  return (vector unsigned int)__builtin_altivec_vslo((vector int)__a,
9179  (vector int)__b);
9180 }
9181 
9182 static __inline__ vector float __ATTRS_o_ai vec_vslo(vector float __a,
9183  vector signed char __b) {
9184  return (vector float)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9185 }
9186 
9187 static __inline__ vector float __ATTRS_o_ai vec_vslo(vector float __a,
9188  vector unsigned char __b) {
9189  return (vector float)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9190 }
9191 
9192 /* vec_splat */
9193 
9194 static __inline__ vector signed char __ATTRS_o_ai
9195 vec_splat(vector signed char __a, unsigned const int __b) {
9196  return vec_perm(__a, __a, (vector unsigned char)(__b & 0x0F));
9197 }
9198 
9199 static __inline__ vector unsigned char __ATTRS_o_ai
9200 vec_splat(vector unsigned char __a, unsigned const int __b) {
9201  return vec_perm(__a, __a, (vector unsigned char)(__b & 0x0F));
9202 }
9203 
9204 static __inline__ vector bool char __ATTRS_o_ai
9205 vec_splat(vector bool char __a, unsigned const int __b) {
9206  return vec_perm(__a, __a, (vector unsigned char)(__b & 0x0F));
9207 }
9208 
9209 static __inline__ vector signed short __ATTRS_o_ai
9210 vec_splat(vector signed short __a, unsigned const int __b) {
9211  unsigned char b0 = (__b & 0x07) * 2;
9212  unsigned char b1 = b0 + 1;
9213  return vec_perm(__a, __a,
9214  (vector unsigned char)(b0, b1, b0, b1, b0, b1, b0, b1, b0, b1,
9215  b0, b1, b0, b1, b0, b1));
9216 }
9217 
9218 static __inline__ vector unsigned short __ATTRS_o_ai
9219 vec_splat(vector unsigned short __a, unsigned const int __b) {
9220  unsigned char b0 = (__b & 0x07) * 2;
9221  unsigned char b1 = b0 + 1;
9222  return vec_perm(__a, __a,
9223  (vector unsigned char)(b0, b1, b0, b1, b0, b1, b0, b1, b0, b1,
9224  b0, b1, b0, b1, b0, b1));
9225 }
9226 
9227 static __inline__ vector bool short __ATTRS_o_ai
9228 vec_splat(vector bool short __a, unsigned const int __b) {
9229  unsigned char b0 = (__b & 0x07) * 2;
9230  unsigned char b1 = b0 + 1;
9231  return vec_perm(__a, __a,
9232  (vector unsigned char)(b0, b1, b0, b1, b0, b1, b0, b1, b0, b1,
9233  b0, b1, b0, b1, b0, b1));
9234 }
9235 
9236 static __inline__ vector pixel __ATTRS_o_ai vec_splat(vector pixel __a,
9237  unsigned const int __b) {
9238  unsigned char b0 = (__b & 0x07) * 2;
9239  unsigned char b1 = b0 + 1;
9240  return vec_perm(__a, __a,
9241  (vector unsigned char)(b0, b1, b0, b1, b0, b1, b0, b1, b0, b1,
9242  b0, b1, b0, b1, b0, b1));
9243 }
9244 
9245 static __inline__ vector signed int __ATTRS_o_ai
9246 vec_splat(vector signed int __a, unsigned const int __b) {
9247  unsigned char b0 = (__b & 0x03) * 4;
9248  unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3;
9249  return vec_perm(__a, __a,
9250  (vector unsigned char)(b0, b1, b2, b3, b0, b1, b2, b3, b0, b1,
9251  b2, b3, b0, b1, b2, b3));
9252 }
9253 
9254 static __inline__ vector unsigned int __ATTRS_o_ai
9255 vec_splat(vector unsigned int __a, unsigned const int __b) {
9256  unsigned char b0 = (__b & 0x03) * 4;
9257  unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3;
9258  return vec_perm(__a, __a,
9259  (vector unsigned char)(b0, b1, b2, b3, b0, b1, b2, b3, b0, b1,
9260  b2, b3, b0, b1, b2, b3));
9261 }
9262 
9263 static __inline__ vector bool int __ATTRS_o_ai
9264 vec_splat(vector bool int __a, unsigned const int __b) {
9265  unsigned char b0 = (__b & 0x03) * 4;
9266  unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3;
9267  return vec_perm(__a, __a,
9268  (vector unsigned char)(b0, b1, b2, b3, b0, b1, b2, b3, b0, b1,
9269  b2, b3, b0, b1, b2, b3));
9270 }
9271 
9272 static __inline__ vector float __ATTRS_o_ai vec_splat(vector float __a,
9273  unsigned const int __b) {
9274  unsigned char b0 = (__b & 0x03) * 4;
9275  unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3;
9276  return vec_perm(__a, __a,
9277  (vector unsigned char)(b0, b1, b2, b3, b0, b1, b2, b3, b0, b1,
9278  b2, b3, b0, b1, b2, b3));
9279 }
9280 
9281 #ifdef __VSX__
9282 static __inline__ vector double __ATTRS_o_ai vec_splat(vector double __a,
9283  unsigned const int __b) {
9284  unsigned char b0 = (__b & 0x01) * 8;
9285  unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3, b4 = b0 + 4, b5 = b0 + 5,
9286  b6 = b0 + 6, b7 = b0 + 7;
9287  return vec_perm(__a, __a,
9288  (vector unsigned char)(b0, b1, b2, b3, b4, b5, b6, b7, b0, b1,
9289  b2, b3, b4, b5, b6, b7));
9290 }
9291 static __inline__ vector bool long long __ATTRS_o_ai
9292 vec_splat(vector bool long long __a, unsigned const int __b) {
9293  unsigned char b0 = (__b & 0x01) * 8;
9294  unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3, b4 = b0 + 4, b5 = b0 + 5,
9295  b6 = b0 + 6, b7 = b0 + 7;
9296  return vec_perm(__a, __a,
9297  (vector unsigned char)(b0, b1, b2, b3, b4, b5, b6, b7, b0, b1,
9298  b2, b3, b4, b5, b6, b7));
9299 }
9300 static __inline__ vector signed long long __ATTRS_o_ai
9301 vec_splat(vector signed long long __a, unsigned const int __b) {
9302  unsigned char b0 = (__b & 0x01) * 8;
9303  unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3, b4 = b0 + 4, b5 = b0 + 5,
9304  b6 = b0 + 6, b7 = b0 + 7;
9305  return vec_perm(__a, __a,
9306  (vector unsigned char)(b0, b1, b2, b3, b4, b5, b6, b7, b0, b1,
9307  b2, b3, b4, b5, b6, b7));
9308 }
9309 static __inline__ vector unsigned long long __ATTRS_o_ai
9310 vec_splat(vector unsigned long long __a, unsigned const int __b) {
9311  unsigned char b0 = (__b & 0x01) * 8;
9312  unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3, b4 = b0 + 4, b5 = b0 + 5,
9313  b6 = b0 + 6, b7 = b0 + 7;
9314  return vec_perm(__a, __a,
9315  (vector unsigned char)(b0, b1, b2, b3, b4, b5, b6, b7, b0, b1,
9316  b2, b3, b4, b5, b6, b7));
9317 }
9318 #endif
9319 
9320 /* vec_vspltb */
9321 
9322 #define __builtin_altivec_vspltb vec_vspltb
9323 
9324 static __inline__ vector signed char __ATTRS_o_ai
9325 vec_vspltb(vector signed char __a, unsigned char __b) {
9326  return vec_perm(__a, __a, (vector unsigned char)(__b));
9327 }
9328 
9329 static __inline__ vector unsigned char __ATTRS_o_ai
9330 vec_vspltb(vector unsigned char __a, unsigned char __b) {
9331  return vec_perm(__a, __a, (vector unsigned char)(__b));
9332 }
9333 
9334 static __inline__ vector bool char __ATTRS_o_ai vec_vspltb(vector bool char __a,
9335  unsigned char __b) {
9336  return vec_perm(__a, __a, (vector unsigned char)(__b));
9337 }
9338 
9339 /* vec_vsplth */
9340 
9341 #define __builtin_altivec_vsplth vec_vsplth
9342 
9343 static __inline__ vector short __ATTRS_o_ai vec_vsplth(vector short __a,
9344  unsigned char __b) {
9345  __b *= 2;
9346  unsigned char b1 = __b + 1;
9347  return vec_perm(__a, __a,
9348  (vector unsigned char)(__b, b1, __b, b1, __b, b1, __b, b1,
9349  __b, b1, __b, b1, __b, b1, __b, b1));
9350 }
9351 
9352 static __inline__ vector unsigned short __ATTRS_o_ai
9353 vec_vsplth(vector unsigned short __a, unsigned char __b) {
9354  __b *= 2;
9355  unsigned char b1 = __b + 1;
9356  return vec_perm(__a, __a,
9357  (vector unsigned char)(__b, b1, __b, b1, __b, b1, __b, b1,
9358  __b, b1, __b, b1, __b, b1, __b, b1));
9359 }
9360 
9361 static __inline__ vector bool short __ATTRS_o_ai
9362 vec_vsplth(vector bool short __a, unsigned char __b) {
9363  __b *= 2;
9364  unsigned char b1 = __b + 1;
9365  return vec_perm(__a, __a,
9366  (vector unsigned char)(__b, b1, __b, b1, __b, b1, __b, b1,
9367  __b, b1, __b, b1, __b, b1, __b, b1));
9368 }
9369 
9370 static __inline__ vector pixel __ATTRS_o_ai vec_vsplth(vector pixel __a,
9371  unsigned char __b) {
9372  __b *= 2;
9373  unsigned char b1 = __b + 1;
9374  return vec_perm(__a, __a,
9375  (vector unsigned char)(__b, b1, __b, b1, __b, b1, __b, b1,
9376  __b, b1, __b, b1, __b, b1, __b, b1));
9377 }
9378 
9379 /* vec_vspltw */
9380 
9381 #define __builtin_altivec_vspltw vec_vspltw
9382 
9383 static __inline__ vector int __ATTRS_o_ai vec_vspltw(vector int __a,
9384  unsigned char __b) {
9385  __b *= 4;
9386  unsigned char b1 = __b + 1, b2 = __b + 2, b3 = __b + 3;
9387  return vec_perm(__a, __a,
9388  (vector unsigned char)(__b, b1, b2, b3, __b, b1, b2, b3, __b,
9389  b1, b2, b3, __b, b1, b2, b3));
9390 }
9391 
9392 static __inline__ vector unsigned int __ATTRS_o_ai
9393 vec_vspltw(vector unsigned int __a, unsigned char __b) {
9394  __b *= 4;
9395  unsigned char b1 = __b + 1, b2 = __b + 2, b3 = __b + 3;
9396  return vec_perm(__a, __a,
9397  (vector unsigned char)(__b, b1, b2, b3, __b, b1, b2, b3, __b,
9398  b1, b2, b3, __b, b1, b2, b3));
9399 }
9400 
9401 static __inline__ vector bool int __ATTRS_o_ai vec_vspltw(vector bool int __a,
9402  unsigned char __b) {
9403  __b *= 4;
9404  unsigned char b1 = __b + 1, b2 = __b + 2, b3 = __b + 3;
9405  return vec_perm(__a, __a,
9406  (vector unsigned char)(__b, b1, b2, b3, __b, b1, b2, b3, __b,
9407  b1, b2, b3, __b, b1, b2, b3));
9408 }
9409 
9410 static __inline__ vector float __ATTRS_o_ai vec_vspltw(vector float __a,
9411  unsigned char __b) {
9412  __b *= 4;
9413  unsigned char b1 = __b + 1, b2 = __b + 2, b3 = __b + 3;
9414  return vec_perm(__a, __a,
9415  (vector unsigned char)(__b, b1, b2, b3, __b, b1, b2, b3, __b,
9416  b1, b2, b3, __b, b1, b2, b3));
9417 }
9418 
9419 /* vec_splat_s8 */
9420 
9421 #define __builtin_altivec_vspltisb vec_splat_s8
9422 
9423 // FIXME: parameter should be treated as 5-bit signed literal
9424 static __inline__ vector signed char __ATTRS_o_ai
9425 vec_splat_s8(signed char __a) {
9426  return (vector signed char)(__a);
9427 }
9428 
9429 /* vec_vspltisb */
9430 
9431 // FIXME: parameter should be treated as 5-bit signed literal
9432 static __inline__ vector signed char __ATTRS_o_ai
9433 vec_vspltisb(signed char __a) {
9434  return (vector signed char)(__a);
9435 }
9436 
9437 /* vec_splat_s16 */
9438 
9439 #define __builtin_altivec_vspltish vec_splat_s16
9440 
9441 // FIXME: parameter should be treated as 5-bit signed literal
9442 static __inline__ vector short __ATTRS_o_ai vec_splat_s16(signed char __a) {
9443  return (vector short)(__a);
9444 }
9445 
9446 /* vec_vspltish */
9447 
9448 // FIXME: parameter should be treated as 5-bit signed literal
9449 static __inline__ vector short __ATTRS_o_ai vec_vspltish(signed char __a) {
9450  return (vector short)(__a);
9451 }
9452 
9453 /* vec_splat_s32 */
9454 
9455 #define __builtin_altivec_vspltisw vec_splat_s32
9456 
9457 // FIXME: parameter should be treated as 5-bit signed literal
9458 static __inline__ vector int __ATTRS_o_ai vec_splat_s32(signed char __a) {
9459  return (vector int)(__a);
9460 }
9461 
9462 /* vec_vspltisw */
9463 
9464 // FIXME: parameter should be treated as 5-bit signed literal
9465 static __inline__ vector int __ATTRS_o_ai vec_vspltisw(signed char __a) {
9466  return (vector int)(__a);
9467 }
9468 
9469 /* vec_splat_u8 */
9470 
9471 // FIXME: parameter should be treated as 5-bit signed literal
9472 static __inline__ vector unsigned char __ATTRS_o_ai
9473 vec_splat_u8(unsigned char __a) {
9474  return (vector unsigned char)(__a);
9475 }
9476 
9477 /* vec_splat_u16 */
9478 
9479 // FIXME: parameter should be treated as 5-bit signed literal
9480 static __inline__ vector unsigned short __ATTRS_o_ai
9481 vec_splat_u16(signed char __a) {
9482  return (vector unsigned short)(__a);
9483 }
9484 
9485 /* vec_splat_u32 */
9486 
9487 // FIXME: parameter should be treated as 5-bit signed literal
9488 static __inline__ vector unsigned int __ATTRS_o_ai
9489 vec_splat_u32(signed char __a) {
9490  return (vector unsigned int)(__a);
9491 }
9492 
9493 /* vec_sr */
9494 
9495 // vec_sr does modulo arithmetic on __b first, so __b is allowed to be more
9496 // than the length of __a.
9497 static __inline__ vector unsigned char __ATTRS_o_ai
9498 vec_sr(vector unsigned char __a, vector unsigned char __b) {
9499  return __a >>
9500  (__b % (vector unsigned char)(sizeof(unsigned char) * __CHAR_BIT__));
9501 }
9502 
9503 static __inline__ vector signed char __ATTRS_o_ai
9504 vec_sr(vector signed char __a, vector unsigned char __b) {
9505  return (vector signed char)vec_sr((vector unsigned char)__a, __b);
9506 }
9507 
9508 static __inline__ vector unsigned short __ATTRS_o_ai
9509 vec_sr(vector unsigned short __a, vector unsigned short __b) {
9510  return __a >>
9511  (__b % (vector unsigned short)(sizeof(unsigned short) * __CHAR_BIT__));
9512 }
9513 
9514 static __inline__ vector short __ATTRS_o_ai vec_sr(vector short __a,
9515  vector unsigned short __b) {
9516  return (vector short)vec_sr((vector unsigned short)__a, __b);
9517 }
9518 
9519 static __inline__ vector unsigned int __ATTRS_o_ai
9520 vec_sr(vector unsigned int __a, vector unsigned int __b) {
9521  return __a >>
9522  (__b % (vector unsigned int)(sizeof(unsigned int) * __CHAR_BIT__));
9523 }
9524 
9525 static __inline__ vector int __ATTRS_o_ai vec_sr(vector int __a,
9526  vector unsigned int __b) {
9527  return (vector int)vec_sr((vector unsigned int)__a, __b);
9528 }
9529 
9530 #ifdef __POWER8_VECTOR__
9531 static __inline__ vector unsigned long long __ATTRS_o_ai
9532 vec_sr(vector unsigned long long __a, vector unsigned long long __b) {
9533  return __a >> (__b % (vector unsigned long long)(sizeof(unsigned long long) *
9534  __CHAR_BIT__));
9535 }
9536 
9537 static __inline__ vector long long __ATTRS_o_ai
9538 vec_sr(vector long long __a, vector unsigned long long __b) {
9539  return (vector long long)vec_sr((vector unsigned long long)__a, __b);
9540 }
9541 #endif
9542 
9543 /* vec_vsrb */
9544 
9545 #define __builtin_altivec_vsrb vec_vsrb
9546 
9547 static __inline__ vector signed char __ATTRS_o_ai
9548 vec_vsrb(vector signed char __a, vector unsigned char __b) {
9549  return vec_sr(__a, __b);
9550 }
9551 
9552 static __inline__ vector unsigned char __ATTRS_o_ai
9553 vec_vsrb(vector unsigned char __a, vector unsigned char __b) {
9554  return vec_sr(__a, __b);
9555 }
9556 
9557 /* vec_vsrh */
9558 
9559 #define __builtin_altivec_vsrh vec_vsrh
9560 
9561 static __inline__ vector short __ATTRS_o_ai
9562 vec_vsrh(vector short __a, vector unsigned short __b) {
9563  return vec_sr(__a, __b);
9564 }
9565 
9566 static __inline__ vector unsigned short __ATTRS_o_ai
9567 vec_vsrh(vector unsigned short __a, vector unsigned short __b) {
9568  return vec_sr(__a, __b);
9569 }
9570 
9571 /* vec_vsrw */
9572 
9573 #define __builtin_altivec_vsrw vec_vsrw
9574 
9575 static __inline__ vector int __ATTRS_o_ai vec_vsrw(vector int __a,
9576  vector unsigned int __b) {
9577  return vec_sr(__a, __b);
9578 }
9579 
9580 static __inline__ vector unsigned int __ATTRS_o_ai
9581 vec_vsrw(vector unsigned int __a, vector unsigned int __b) {
9582  return vec_sr(__a, __b);
9583 }
9584 
9585 /* vec_sra */
9586 
9587 static __inline__ vector signed char __ATTRS_o_ai
9588 vec_sra(vector signed char __a, vector unsigned char __b) {
9589  return (vector signed char)__builtin_altivec_vsrab((vector char)__a, __b);
9590 }
9591 
9592 static __inline__ vector unsigned char __ATTRS_o_ai
9593 vec_sra(vector unsigned char __a, vector unsigned char __b) {
9594  return (vector unsigned char)__builtin_altivec_vsrab((vector char)__a, __b);
9595 }
9596 
9597 static __inline__ vector short __ATTRS_o_ai vec_sra(vector short __a,
9598  vector unsigned short __b) {
9599  return __builtin_altivec_vsrah(__a, (vector unsigned short)__b);
9600 }
9601 
9602 static __inline__ vector unsigned short __ATTRS_o_ai
9603 vec_sra(vector unsigned short __a, vector unsigned short __b) {
9604  return (vector unsigned short)__builtin_altivec_vsrah((vector short)__a, __b);
9605 }
9606 
9607 static __inline__ vector int __ATTRS_o_ai vec_sra(vector int __a,
9608  vector unsigned int __b) {
9609  return __builtin_altivec_vsraw(__a, __b);
9610 }
9611 
9612 static __inline__ vector unsigned int __ATTRS_o_ai
9613 vec_sra(vector unsigned int __a, vector unsigned int __b) {
9614  return (vector unsigned int)__builtin_altivec_vsraw((vector int)__a, __b);
9615 }
9616 
9617 #ifdef __POWER8_VECTOR__
9618 static __inline__ vector signed long long __ATTRS_o_ai
9619 vec_sra(vector signed long long __a, vector unsigned long long __b) {
9620  return __a >> __b;
9621 }
9622 
9623 static __inline__ vector unsigned long long __ATTRS_o_ai
9624 vec_sra(vector unsigned long long __a, vector unsigned long long __b) {
9625  return (vector unsigned long long)((vector signed long long)__a >> __b);
9626 }
9627 #endif
9628 
9629 /* vec_vsrab */
9630 
9631 static __inline__ vector signed char __ATTRS_o_ai
9632 vec_vsrab(vector signed char __a, vector unsigned char __b) {
9633  return (vector signed char)__builtin_altivec_vsrab((vector char)__a, __b);
9634 }
9635 
9636 static __inline__ vector unsigned char __ATTRS_o_ai
9637 vec_vsrab(vector unsigned char __a, vector unsigned char __b) {
9638  return (vector unsigned char)__builtin_altivec_vsrab((vector char)__a, __b);
9639 }
9640 
9641 /* vec_vsrah */
9642 
9643 static __inline__ vector short __ATTRS_o_ai
9644 vec_vsrah(vector short __a, vector unsigned short __b) {
9645  return __builtin_altivec_vsrah(__a, (vector unsigned short)__b);
9646 }
9647 
9648 static __inline__ vector unsigned short __ATTRS_o_ai
9649 vec_vsrah(vector unsigned short __a, vector unsigned short __b) {
9650  return (vector unsigned short)__builtin_altivec_vsrah((vector short)__a, __b);
9651 }
9652 
9653 /* vec_vsraw */
9654 
9655 static __inline__ vector int __ATTRS_o_ai vec_vsraw(vector int __a,
9656  vector unsigned int __b) {
9657  return __builtin_altivec_vsraw(__a, __b);
9658 }
9659 
9660 static __inline__ vector unsigned int __ATTRS_o_ai
9661 vec_vsraw(vector unsigned int __a, vector unsigned int __b) {
9662  return (vector unsigned int)__builtin_altivec_vsraw((vector int)__a, __b);
9663 }
9664 
9665 /* vec_srl */
9666 
9667 static __inline__ vector signed char __ATTRS_o_ai
9668 vec_srl(vector signed char __a, vector unsigned char __b) {
9669  return (vector signed char)__builtin_altivec_vsr((vector int)__a,
9670  (vector int)__b);
9671 }
9672 
9673 static __inline__ vector signed char __ATTRS_o_ai
9674 vec_srl(vector signed char __a, vector unsigned short __b) {
9675  return (vector signed char)__builtin_altivec_vsr((vector int)__a,
9676  (vector int)__b);
9677 }
9678 
9679 static __inline__ vector signed char __ATTRS_o_ai
9680 vec_srl(vector signed char __a, vector unsigned int __b) {
9681  return (vector signed char)__builtin_altivec_vsr((vector int)__a,
9682  (vector int)__b);
9683 }
9684 
9685 static __inline__ vector unsigned char __ATTRS_o_ai
9686 vec_srl(vector unsigned char __a, vector unsigned char __b) {
9687  return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
9688  (vector int)__b);
9689 }
9690 
9691 static __inline__ vector unsigned char __ATTRS_o_ai
9692 vec_srl(vector unsigned char __a, vector unsigned short __b) {
9693  return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
9694  (vector int)__b);
9695 }
9696 
9697 static __inline__ vector unsigned char __ATTRS_o_ai
9698 vec_srl(vector unsigned char __a, vector unsigned int __b) {
9699  return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
9700  (vector int)__b);
9701 }
9702 
9703 static __inline__ vector bool char __ATTRS_o_ai
9704 vec_srl(vector bool char __a, vector unsigned char __b) {
9705  return (vector bool char)__builtin_altivec_vsr((vector int)__a,
9706  (vector int)__b);
9707 }
9708 
9709 static __inline__ vector bool char __ATTRS_o_ai
9710 vec_srl(vector bool char __a, vector unsigned short __b) {
9711  return (vector bool char)__builtin_altivec_vsr((vector int)__a,
9712  (vector int)__b);
9713 }
9714 
9715 static __inline__ vector bool char __ATTRS_o_ai
9716 vec_srl(vector bool char __a, vector unsigned int __b) {
9717  return (vector bool char)__builtin_altivec_vsr((vector int)__a,
9718  (vector int)__b);
9719 }
9720 
9721 static __inline__ vector short __ATTRS_o_ai vec_srl(vector short __a,
9722  vector unsigned char __b) {
9723  return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9724 }
9725 
9726 static __inline__ vector short __ATTRS_o_ai vec_srl(vector short __a,
9727  vector unsigned short __b) {
9728  return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9729 }
9730 
9731 static __inline__ vector short __ATTRS_o_ai vec_srl(vector short __a,
9732  vector unsigned int __b) {
9733  return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9734 }
9735 
9736 static __inline__ vector unsigned short __ATTRS_o_ai
9737 vec_srl(vector unsigned short __a, vector unsigned char __b) {
9738  return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
9739  (vector int)__b);
9740 }
9741 
9742 static __inline__ vector unsigned short __ATTRS_o_ai
9743 vec_srl(vector unsigned short __a, vector unsigned short __b) {
9744  return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
9745  (vector int)__b);
9746 }
9747 
9748 static __inline__ vector unsigned short __ATTRS_o_ai
9749 vec_srl(vector unsigned short __a, vector unsigned int __b) {
9750  return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
9751  (vector int)__b);
9752 }
9753 
9754 static __inline__ vector bool short __ATTRS_o_ai
9755 vec_srl(vector bool short __a, vector unsigned char __b) {
9756  return (vector bool short)__builtin_altivec_vsr((vector int)__a,
9757  (vector int)__b);
9758 }
9759 
9760 static __inline__ vector bool short __ATTRS_o_ai
9761 vec_srl(vector bool short __a, vector unsigned short __b) {
9762  return (vector bool short)__builtin_altivec_vsr((vector int)__a,
9763  (vector int)__b);
9764 }
9765 
9766 static __inline__ vector bool short __ATTRS_o_ai
9767 vec_srl(vector bool short __a, vector unsigned int __b) {
9768  return (vector bool short)__builtin_altivec_vsr((vector int)__a,
9769  (vector int)__b);
9770 }
9771 
9772 static __inline__ vector pixel __ATTRS_o_ai vec_srl(vector pixel __a,
9773  vector unsigned char __b) {
9774  return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9775 }
9776 
9777 static __inline__ vector pixel __ATTRS_o_ai vec_srl(vector pixel __a,
9778  vector unsigned short __b) {
9779  return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9780 }
9781 
9782 static __inline__ vector pixel __ATTRS_o_ai vec_srl(vector pixel __a,
9783  vector unsigned int __b) {
9784  return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9785 }
9786 
9787 static __inline__ vector int __ATTRS_o_ai vec_srl(vector int __a,
9788  vector unsigned char __b) {
9789  return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
9790 }
9791 
9792 static __inline__ vector int __ATTRS_o_ai vec_srl(vector int __a,
9793  vector unsigned short __b) {
9794  return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
9795 }
9796 
9797 static __inline__ vector int __ATTRS_o_ai vec_srl(vector int __a,
9798  vector unsigned int __b) {
9799  return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
9800 }
9801 
9802 static __inline__ vector unsigned int __ATTRS_o_ai
9803 vec_srl(vector unsigned int __a, vector unsigned char __b) {
9804  return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
9805  (vector int)__b);
9806 }
9807 
9808 static __inline__ vector unsigned int __ATTRS_o_ai
9809 vec_srl(vector unsigned int __a, vector unsigned short __b) {
9810  return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
9811  (vector int)__b);
9812 }
9813 
9814 static __inline__ vector unsigned int __ATTRS_o_ai
9815 vec_srl(vector unsigned int __a, vector unsigned int __b) {
9816  return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
9817  (vector int)__b);
9818 }
9819 
9820 static __inline__ vector bool int __ATTRS_o_ai
9821 vec_srl(vector bool int __a, vector unsigned char __b) {
9822  return (vector bool int)__builtin_altivec_vsr((vector int)__a,
9823  (vector int)__b);
9824 }
9825 
9826 static __inline__ vector bool int __ATTRS_o_ai
9827 vec_srl(vector bool int __a, vector unsigned short __b) {
9828  return (vector bool int)__builtin_altivec_vsr((vector int)__a,
9829  (vector int)__b);
9830 }
9831 
9832 static __inline__ vector bool int __ATTRS_o_ai
9833 vec_srl(vector bool int __a, vector unsigned int __b) {
9834  return (vector bool int)__builtin_altivec_vsr((vector int)__a,
9835  (vector int)__b);
9836 }
9837 
9838 #ifdef __VSX__
9839 static __inline__ vector signed long long __ATTRS_o_ai
9840 vec_srl(vector signed long long __a, vector unsigned char __b) {
9841  return (vector signed long long)__builtin_altivec_vsr((vector int)__a,
9842  (vector int)__b);
9843 }
9844 
9845 static __inline__ vector unsigned long long __ATTRS_o_ai
9846 vec_srl(vector unsigned long long __a, vector unsigned char __b) {
9847  return (vector unsigned long long)__builtin_altivec_vsr((vector int)__a,
9848  (vector int)__b);
9849 }
9850 #endif
9851 
9852 /* vec_vsr */
9853 
9854 static __inline__ vector signed char __ATTRS_o_ai
9855 vec_vsr(vector signed char __a, vector unsigned char __b) {
9856  return (vector signed char)__builtin_altivec_vsr((vector int)__a,
9857  (vector int)__b);
9858 }
9859 
9860 static __inline__ vector signed char __ATTRS_o_ai
9861 vec_vsr(vector signed char __a, vector unsigned short __b) {
9862  return (vector signed char)__builtin_altivec_vsr((vector int)__a,
9863  (vector int)__b);
9864 }
9865 
9866 static __inline__ vector signed char __ATTRS_o_ai
9867 vec_vsr(vector signed char __a, vector unsigned int __b) {
9868  return (vector signed char)__builtin_altivec_vsr((vector int)__a,
9869  (vector int)__b);
9870 }
9871 
9872 static __inline__ vector unsigned char __ATTRS_o_ai
9873 vec_vsr(vector unsigned char __a, vector unsigned char __b) {
9874  return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
9875  (vector int)__b);
9876 }
9877 
9878 static __inline__ vector unsigned char __ATTRS_o_ai
9879 vec_vsr(vector unsigned char __a, vector unsigned short __b) {
9880  return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
9881  (vector int)__b);
9882 }
9883 
9884 static __inline__ vector unsigned char __ATTRS_o_ai
9885 vec_vsr(vector unsigned char __a, vector unsigned int __b) {
9886  return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
9887  (vector int)__b);
9888 }
9889 
9890 static __inline__ vector bool char __ATTRS_o_ai
9891 vec_vsr(vector bool char __a, vector unsigned char __b) {
9892  return (vector bool char)__builtin_altivec_vsr((vector int)__a,
9893  (vector int)__b);
9894 }
9895 
9896 static __inline__ vector bool char __ATTRS_o_ai
9897 vec_vsr(vector bool char __a, vector unsigned short __b) {
9898  return (vector bool char)__builtin_altivec_vsr((vector int)__a,
9899  (vector int)__b);
9900 }
9901 
9902 static __inline__ vector bool char __ATTRS_o_ai
9903 vec_vsr(vector bool char __a, vector unsigned int __b) {
9904  return (vector bool char)__builtin_altivec_vsr((vector int)__a,
9905  (vector int)__b);
9906 }
9907 
9908 static __inline__ vector short __ATTRS_o_ai vec_vsr(vector short __a,
9909  vector unsigned char __b) {
9910  return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9911 }
9912 
9913 static __inline__ vector short __ATTRS_o_ai vec_vsr(vector short __a,
9914  vector unsigned short __b) {
9915  return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9916 }
9917 
9918 static __inline__ vector short __ATTRS_o_ai vec_vsr(vector short __a,
9919  vector unsigned int __b) {
9920  return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9921 }
9922 
9923 static __inline__ vector unsigned short __ATTRS_o_ai
9924 vec_vsr(vector unsigned short __a, vector unsigned char __b) {
9925  return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
9926  (vector int)__b);
9927 }
9928 
9929 static __inline__ vector unsigned short __ATTRS_o_ai
9930 vec_vsr(vector unsigned short __a, vector unsigned short __b) {
9931  return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
9932  (vector int)__b);
9933 }
9934 
9935 static __inline__ vector unsigned short __ATTRS_o_ai
9936 vec_vsr(vector unsigned short __a, vector unsigned int __b) {
9937  return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
9938  (vector int)__b);
9939 }
9940 
9941 static __inline__ vector bool short __ATTRS_o_ai
9942 vec_vsr(vector bool short __a, vector unsigned char __b) {
9943  return (vector bool short)__builtin_altivec_vsr((vector int)__a,
9944  (vector int)__b);
9945 }
9946 
9947 static __inline__ vector bool short __ATTRS_o_ai
9948 vec_vsr(vector bool short __a, vector unsigned short __b) {
9949  return (vector bool short)__builtin_altivec_vsr((vector int)__a,
9950  (vector int)__b);
9951 }
9952 
9953 static __inline__ vector bool short __ATTRS_o_ai
9954 vec_vsr(vector bool short __a, vector unsigned int __b) {
9955  return (vector bool short)__builtin_altivec_vsr((vector int)__a,
9956  (vector int)__b);
9957 }
9958 
9959 static __inline__ vector pixel __ATTRS_o_ai vec_vsr(vector pixel __a,
9960  vector unsigned char __b) {
9961  return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9962 }
9963 
9964 static __inline__ vector pixel __ATTRS_o_ai vec_vsr(vector pixel __a,
9965  vector unsigned short __b) {
9966  return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9967 }
9968 
9969 static __inline__ vector pixel __ATTRS_o_ai vec_vsr(vector pixel __a,
9970  vector unsigned int __b) {
9971  return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9972 }
9973 
9974 static __inline__ vector int __ATTRS_o_ai vec_vsr(vector int __a,
9975  vector unsigned char __b) {
9976  return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
9977 }
9978 
9979 static __inline__ vector int __ATTRS_o_ai vec_vsr(vector int __a,
9980  vector unsigned short __b) {
9981  return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
9982 }
9983 
9984 static __inline__ vector int __ATTRS_o_ai vec_vsr(vector int __a,
9985  vector unsigned int __b) {
9986  return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
9987 }
9988 
9989 static __inline__ vector unsigned int __ATTRS_o_ai
9990 vec_vsr(vector unsigned int __a, vector unsigned char __b) {
9991  return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
9992  (vector int)__b);
9993 }
9994 
9995 static __inline__ vector unsigned int __ATTRS_o_ai
9996 vec_vsr(vector unsigned int __a, vector unsigned short __b) {
9997  return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
9998  (vector int)__b);
9999 }
10000 
10001 static __inline__ vector unsigned int __ATTRS_o_ai
10002 vec_vsr(vector unsigned int __a, vector unsigned int __b) {
10003  return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
10004  (vector int)__b);
10005 }
10006 
10007 static __inline__ vector bool int __ATTRS_o_ai
10008 vec_vsr(vector bool int __a, vector unsigned char __b) {
10009  return (vector bool int)__builtin_altivec_vsr((vector int)__a,
10010  (vector int)__b);
10011 }
10012 
10013 static __inline__ vector bool int __ATTRS_o_ai
10014 vec_vsr(vector bool int __a, vector unsigned short __b) {
10015  return (vector bool int)__builtin_altivec_vsr((vector int)__a,
10016  (vector int)__b);
10017 }
10018 
10019 static __inline__ vector bool int __ATTRS_o_ai
10020 vec_vsr(vector bool int __a, vector unsigned int __b) {
10021  return (vector bool int)__builtin_altivec_vsr((vector int)__a,
10022  (vector int)__b);
10023 }
10024 
10025 /* vec_sro */
10026 
10027 static __inline__ vector signed char __ATTRS_o_ai
10028 vec_sro(vector signed char __a, vector signed char __b) {
10029  return (vector signed char)__builtin_altivec_vsro((vector int)__a,
10030  (vector int)__b);
10031 }
10032 
10033 static __inline__ vector signed char __ATTRS_o_ai
10034 vec_sro(vector signed char __a, vector unsigned char __b) {
10035  return (vector signed char)__builtin_altivec_vsro((vector int)__a,
10036  (vector int)__b);
10037 }
10038 
10039 static __inline__ vector unsigned char __ATTRS_o_ai
10040 vec_sro(vector unsigned char __a, vector signed char __b) {
10041  return (vector unsigned char)__builtin_altivec_vsro((vector int)__a,
10042  (vector int)__b);
10043 }
10044 
10045 static __inline__ vector unsigned char __ATTRS_o_ai
10046 vec_sro(vector unsigned char __a, vector unsigned char __b) {
10047  return (vector unsigned char)__builtin_altivec_vsro((vector int)__a,
10048  (vector int)__b);
10049 }
10050 
10051 static __inline__ vector short __ATTRS_o_ai vec_sro(vector short __a,
10052  vector signed char __b) {
10053  return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10054 }
10055 
10056 static __inline__ vector short __ATTRS_o_ai vec_sro(vector short __a,
10057  vector unsigned char __b) {
10058  return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10059 }
10060 
10061 static __inline__ vector unsigned short __ATTRS_o_ai
10062 vec_sro(vector unsigned short __a, vector signed char __b) {
10063  return (vector unsigned short)__builtin_altivec_vsro((vector int)__a,
10064  (vector int)__b);
10065 }
10066 
10067 static __inline__ vector unsigned short __ATTRS_o_ai
10068 vec_sro(vector unsigned short __a, vector unsigned char __b) {
10069  return (vector unsigned short)__builtin_altivec_vsro((vector int)__a,
10070  (vector int)__b);
10071 }
10072 
10073 static __inline__ vector pixel __ATTRS_o_ai vec_sro(vector pixel __a,
10074  vector signed char __b) {
10075  return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10076 }
10077 
10078 static __inline__ vector pixel __ATTRS_o_ai vec_sro(vector pixel __a,
10079  vector unsigned char __b) {
10080  return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10081 }
10082 
10083 static __inline__ vector int __ATTRS_o_ai vec_sro(vector int __a,
10084  vector signed char __b) {
10085  return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
10086 }
10087 
10088 static __inline__ vector int __ATTRS_o_ai vec_sro(vector int __a,
10089  vector unsigned char __b) {
10090  return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
10091 }
10092 
10093 static __inline__ vector unsigned int __ATTRS_o_ai
10094 vec_sro(vector unsigned int __a, vector signed char __b) {
10095  return (vector unsigned int)__builtin_altivec_vsro((vector int)__a,
10096  (vector int)__b);
10097 }
10098 
10099 static __inline__ vector unsigned int __ATTRS_o_ai
10100 vec_sro(vector unsigned int __a, vector unsigned char __b) {
10101  return (vector unsigned int)__builtin_altivec_vsro((vector int)__a,
10102  (vector int)__b);
10103 }
10104 
10105 static __inline__ vector float __ATTRS_o_ai vec_sro(vector float __a,
10106  vector signed char __b) {
10107  return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10108 }
10109 
10110 static __inline__ vector float __ATTRS_o_ai vec_sro(vector float __a,
10111  vector unsigned char __b) {
10112  return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10113 }
10114 
10115 #ifdef __VSX__
10116 static __inline__ vector signed long long __ATTRS_o_ai
10117 vec_sro(vector signed long long __a, vector signed char __b) {
10118  return (vector signed long long)__builtin_altivec_vsro((vector int)__a,
10119  (vector int)__b);
10120 }
10121 
10122 static __inline__ vector signed long long __ATTRS_o_ai
10123 vec_sro(vector signed long long __a, vector unsigned char __b) {
10124  return (vector signed long long)__builtin_altivec_vsro((vector int)__a,
10125  (vector int)__b);
10126 }
10127 
10128 static __inline__ vector unsigned long long __ATTRS_o_ai
10129 vec_sro(vector unsigned long long __a, vector signed char __b) {
10130  return (vector unsigned long long)__builtin_altivec_vsro((vector int)__a,
10131  (vector int)__b);
10132 }
10133 
10134 static __inline__ vector unsigned long long __ATTRS_o_ai
10135 vec_sro(vector unsigned long long __a, vector unsigned char __b) {
10136  return (vector unsigned long long)__builtin_altivec_vsro((vector int)__a,
10137  (vector int)__b);
10138 }
10139 #endif
10140 
10141 /* vec_vsro */
10142 
10143 static __inline__ vector signed char __ATTRS_o_ai
10144 vec_vsro(vector signed char __a, vector signed char __b) {
10145  return (vector signed char)__builtin_altivec_vsro((vector int)__a,
10146  (vector int)__b);
10147 }
10148 
10149 static __inline__ vector signed char __ATTRS_o_ai
10150 vec_vsro(vector signed char __a, vector unsigned char __b) {
10151  return (vector signed char)__builtin_altivec_vsro((vector int)__a,
10152  (vector int)__b);
10153 }
10154 
10155 static __inline__ vector unsigned char __ATTRS_o_ai
10156 vec_vsro(vector unsigned char __a, vector signed char __b) {
10157  return (vector unsigned char)__builtin_altivec_vsro((vector int)__a,
10158  (vector int)__b);
10159 }
10160 
10161 static __inline__ vector unsigned char __ATTRS_o_ai
10162 vec_vsro(vector unsigned char __a, vector unsigned char __b) {
10163  return (vector unsigned char)__builtin_altivec_vsro((vector int)__a,
10164  (vector int)__b);
10165 }
10166 
10167 static __inline__ vector short __ATTRS_o_ai vec_vsro(vector short __a,
10168  vector signed char __b) {
10169  return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10170 }
10171 
10172 static __inline__ vector short __ATTRS_o_ai vec_vsro(vector short __a,
10173  vector unsigned char __b) {
10174  return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10175 }
10176 
10177 static __inline__ vector unsigned short __ATTRS_o_ai
10178 vec_vsro(vector unsigned short __a, vector signed char __b) {
10179  return (vector unsigned short)__builtin_altivec_vsro((vector int)__a,
10180  (vector int)__b);
10181 }
10182 
10183 static __inline__ vector unsigned short __ATTRS_o_ai
10184 vec_vsro(vector unsigned short __a, vector unsigned char __b) {
10185  return (vector unsigned short)__builtin_altivec_vsro((vector int)__a,
10186  (vector int)__b);
10187 }
10188 
10189 static __inline__ vector pixel __ATTRS_o_ai vec_vsro(vector pixel __a,
10190  vector signed char __b) {
10191  return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10192 }
10193 
10194 static __inline__ vector pixel __ATTRS_o_ai vec_vsro(vector pixel __a,
10195  vector unsigned char __b) {
10196  return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10197 }
10198 
10199 static __inline__ vector int __ATTRS_o_ai vec_vsro(vector int __a,
10200  vector signed char __b) {
10201  return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
10202 }
10203 
10204 static __inline__ vector int __ATTRS_o_ai vec_vsro(vector int __a,
10205  vector unsigned char __b) {
10206  return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
10207 }
10208 
10209 static __inline__ vector unsigned int __ATTRS_o_ai
10210 vec_vsro(vector unsigned int __a, vector signed char __b) {
10211  return (vector unsigned int)__builtin_altivec_vsro((vector int)__a,
10212  (vector int)__b);
10213 }
10214 
10215 static __inline__ vector unsigned int __ATTRS_o_ai
10216 vec_vsro(vector unsigned int __a, vector unsigned char __b) {
10217  return (vector unsigned int)__builtin_altivec_vsro((vector int)__a,
10218  (vector int)__b);
10219 }
10220 
10221 static __inline__ vector float __ATTRS_o_ai vec_vsro(vector float __a,
10222  vector signed char __b) {
10223  return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10224 }
10225 
10226 static __inline__ vector float __ATTRS_o_ai vec_vsro(vector float __a,
10227  vector unsigned char __b) {
10228  return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10229 }
10230 
10231 /* vec_st */
10232 
10233 static __inline__ void __ATTRS_o_ai vec_st(vector signed char __a, int __b,
10234  vector signed char *__c) {
10235  __builtin_altivec_stvx((vector int)__a, __b, __c);
10236 }
10237 
10238 static __inline__ void __ATTRS_o_ai vec_st(vector signed char __a, int __b,
10239  signed char *__c) {
10240  __builtin_altivec_stvx((vector int)__a, __b, __c);
10241 }
10242 
10243 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned char __a, int __b,
10244  vector unsigned char *__c) {
10245  __builtin_altivec_stvx((vector int)__a, __b, __c);
10246 }
10247 
10248 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned char __a, int __b,
10249  unsigned char *__c) {
10250  __builtin_altivec_stvx((vector int)__a, __b, __c);
10251 }
10252 
10253 static __inline__ void __ATTRS_o_ai vec_st(vector bool char __a, int __b,
10254  signed char *__c) {
10255  __builtin_altivec_stvx((vector int)__a, __b, __c);
10256 }
10257 
10258 static __inline__ void __ATTRS_o_ai vec_st(vector bool char __a, int __b,
10259  unsigned char *__c) {
10260  __builtin_altivec_stvx((vector int)__a, __b, __c);
10261 }
10262 
10263 static __inline__ void __ATTRS_o_ai vec_st(vector bool char __a, int __b,
10264  vector bool char *__c) {
10265  __builtin_altivec_stvx((vector int)__a, __b, __c);
10266 }
10267 
10268 static __inline__ void __ATTRS_o_ai vec_st(vector short __a, int __b,
10269  vector short *__c) {
10270  __builtin_altivec_stvx((vector int)__a, __b, __c);
10271 }
10272 
10273 static __inline__ void __ATTRS_o_ai vec_st(vector short __a, int __b,
10274  short *__c) {
10275  __builtin_altivec_stvx((vector int)__a, __b, __c);
10276 }
10277 
10278 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned short __a, int __b,
10279  vector unsigned short *__c) {
10280  __builtin_altivec_stvx((vector int)__a, __b, __c);
10281 }
10282 
10283 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned short __a, int __b,
10284  unsigned short *__c) {
10285  __builtin_altivec_stvx((vector int)__a, __b, __c);
10286 }
10287 
10288 static __inline__ void __ATTRS_o_ai vec_st(vector bool short __a, int __b,
10289  short *__c) {
10290  __builtin_altivec_stvx((vector int)__a, __b, __c);
10291 }
10292 
10293 static __inline__ void __ATTRS_o_ai vec_st(vector bool short __a, int __b,
10294  unsigned short *__c) {
10295  __builtin_altivec_stvx((vector int)__a, __b, __c);
10296 }
10297 
10298 static __inline__ void __ATTRS_o_ai vec_st(vector bool short __a, int __b,
10299  vector bool short *__c) {
10300  __builtin_altivec_stvx((vector int)__a, __b, __c);
10301 }
10302 
10303 static __inline__ void __ATTRS_o_ai vec_st(vector pixel __a, int __b,
10304  short *__c) {
10305  __builtin_altivec_stvx((vector int)__a, __b, __c);
10306 }
10307 
10308 static __inline__ void __ATTRS_o_ai vec_st(vector pixel __a, int __b,
10309  unsigned short *__c) {
10310  __builtin_altivec_stvx((vector int)__a, __b, __c);
10311 }
10312 
10313 static __inline__ void __ATTRS_o_ai vec_st(vector pixel __a, int __b,
10314  vector pixel *__c) {
10315  __builtin_altivec_stvx((vector int)__a, __b, __c);
10316 }
10317 
10318 static __inline__ void __ATTRS_o_ai vec_st(vector int __a, int __b,
10319  vector int *__c) {
10320  __builtin_altivec_stvx(__a, __b, __c);
10321 }
10322 
10323 static __inline__ void __ATTRS_o_ai vec_st(vector int __a, int __b, int *__c) {
10324  __builtin_altivec_stvx(__a, __b, __c);
10325 }
10326 
10327 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned int __a, int __b,
10328  vector unsigned int *__c) {
10329  __builtin_altivec_stvx((vector int)__a, __b, __c);
10330 }
10331 
10332 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned int __a, int __b,
10333  unsigned int *__c) {
10334  __builtin_altivec_stvx((vector int)__a, __b, __c);
10335 }
10336 
10337 static __inline__ void __ATTRS_o_ai vec_st(vector bool int __a, int __b,
10338  int *__c) {
10339  __builtin_altivec_stvx((vector int)__a, __b, __c);
10340 }
10341 
10342 static __inline__ void __ATTRS_o_ai vec_st(vector bool int __a, int __b,
10343  unsigned int *__c) {
10344  __builtin_altivec_stvx((vector int)__a, __b, __c);
10345 }
10346 
10347 static __inline__ void __ATTRS_o_ai vec_st(vector bool int __a, int __b,
10348  vector bool int *__c) {
10349  __builtin_altivec_stvx((vector int)__a, __b, __c);
10350 }
10351 
10352 static __inline__ void __ATTRS_o_ai vec_st(vector float __a, int __b,
10353  vector float *__c) {
10354  __builtin_altivec_stvx((vector int)__a, __b, __c);
10355 }
10356 
10357 static __inline__ void __ATTRS_o_ai vec_st(vector float __a, int __b,
10358  float *__c) {
10359  __builtin_altivec_stvx((vector int)__a, __b, __c);
10360 }
10361 
10362 /* vec_stvx */
10363 
10364 static __inline__ void __ATTRS_o_ai vec_stvx(vector signed char __a, int __b,
10365  vector signed char *__c) {
10366  __builtin_altivec_stvx((vector int)__a, __b, __c);
10367 }
10368 
10369 static __inline__ void __ATTRS_o_ai vec_stvx(vector signed char __a, int __b,
10370  signed char *__c) {
10371  __builtin_altivec_stvx((vector int)__a, __b, __c);
10372 }
10373 
10374 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned char __a, int __b,
10375  vector unsigned char *__c) {
10376  __builtin_altivec_stvx((vector int)__a, __b, __c);
10377 }
10378 
10379 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned char __a, int __b,
10380  unsigned char *__c) {
10381  __builtin_altivec_stvx((vector int)__a, __b, __c);
10382 }
10383 
10384 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool char __a, int __b,
10385  signed char *__c) {
10386  __builtin_altivec_stvx((vector int)__a, __b, __c);
10387 }
10388 
10389 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool char __a, int __b,
10390  unsigned char *__c) {
10391  __builtin_altivec_stvx((vector int)__a, __b, __c);
10392 }
10393 
10394 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool char __a, int __b,
10395  vector bool char *__c) {
10396  __builtin_altivec_stvx((vector int)__a, __b, __c);
10397 }
10398 
10399 static __inline__ void __ATTRS_o_ai vec_stvx(vector short __a, int __b,
10400  vector short *__c) {
10401  __builtin_altivec_stvx((vector int)__a, __b, __c);
10402 }
10403 
10404 static __inline__ void __ATTRS_o_ai vec_stvx(vector short __a, int __b,
10405  short *__c) {
10406  __builtin_altivec_stvx((vector int)__a, __b, __c);
10407 }
10408 
10409 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned short __a, int __b,
10410  vector unsigned short *__c) {
10411  __builtin_altivec_stvx((vector int)__a, __b, __c);
10412 }
10413 
10414 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned short __a, int __b,
10415  unsigned short *__c) {
10416  __builtin_altivec_stvx((vector int)__a, __b, __c);
10417 }
10418 
10419 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool short __a, int __b,
10420  short *__c) {
10421  __builtin_altivec_stvx((vector int)__a, __b, __c);
10422 }
10423 
10424 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool short __a, int __b,
10425  unsigned short *__c) {
10426  __builtin_altivec_stvx((vector int)__a, __b, __c);
10427 }
10428 
10429 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool short __a, int __b,
10430  vector bool short *__c) {
10431  __builtin_altivec_stvx((vector int)__a, __b, __c);
10432 }
10433 
10434 static __inline__ void __ATTRS_o_ai vec_stvx(vector pixel __a, int __b,
10435  short *__c) {
10436  __builtin_altivec_stvx((vector int)__a, __b, __c);
10437 }
10438 
10439 static __inline__ void __ATTRS_o_ai vec_stvx(vector pixel __a, int __b,
10440  unsigned short *__c) {
10441  __builtin_altivec_stvx((vector int)__a, __b, __c);
10442 }
10443 
10444 static __inline__ void __ATTRS_o_ai vec_stvx(vector pixel __a, int __b,
10445  vector pixel *__c) {
10446  __builtin_altivec_stvx((vector int)__a, __b, __c);
10447 }
10448 
10449 static __inline__ void __ATTRS_o_ai vec_stvx(vector int __a, int __b,
10450  vector int *__c) {
10451  __builtin_altivec_stvx(__a, __b, __c);
10452 }
10453 
10454 static __inline__ void __ATTRS_o_ai vec_stvx(vector int __a, int __b,
10455  int *__c) {
10456  __builtin_altivec_stvx(__a, __b, __c);
10457 }
10458 
10459 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned int __a, int __b,
10460  vector unsigned int *__c) {
10461  __builtin_altivec_stvx((vector int)__a, __b, __c);
10462 }
10463 
10464 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned int __a, int __b,
10465  unsigned int *__c) {
10466  __builtin_altivec_stvx((vector int)__a, __b, __c);
10467 }
10468 
10469 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool int __a, int __b,
10470  int *__c) {
10471  __builtin_altivec_stvx((vector int)__a, __b, __c);
10472 }
10473 
10474 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool int __a, int __b,
10475  unsigned int *__c) {
10476  __builtin_altivec_stvx((vector int)__a, __b, __c);
10477 }
10478 
10479 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool int __a, int __b,
10480  vector bool int *__c) {
10481  __builtin_altivec_stvx((vector int)__a, __b, __c);
10482 }
10483 
10484 static __inline__ void __ATTRS_o_ai vec_stvx(vector float __a, int __b,
10485  vector float *__c) {
10486  __builtin_altivec_stvx((vector int)__a, __b, __c);
10487 }
10488 
10489 static __inline__ void __ATTRS_o_ai vec_stvx(vector float __a, int __b,
10490  float *__c) {
10491  __builtin_altivec_stvx((vector int)__a, __b, __c);
10492 }
10493 
10494 /* vec_ste */
10495 
10496 static __inline__ void __ATTRS_o_ai vec_ste(vector signed char __a, int __b,
10497  signed char *__c) {
10498  __builtin_altivec_stvebx((vector char)__a, __b, __c);
10499 }
10500 
10501 static __inline__ void __ATTRS_o_ai vec_ste(vector unsigned char __a, int __b,
10502  unsigned char *__c) {
10503  __builtin_altivec_stvebx((vector char)__a, __b, __c);
10504 }
10505 
10506 static __inline__ void __ATTRS_o_ai vec_ste(vector bool char __a, int __b,
10507  signed char *__c) {
10508  __builtin_altivec_stvebx((vector char)__a, __b, __c);
10509 }
10510 
10511 static __inline__ void __ATTRS_o_ai vec_ste(vector bool char __a, int __b,
10512  unsigned char *__c) {
10513  __builtin_altivec_stvebx((vector char)__a, __b, __c);
10514 }
10515 
10516 static __inline__ void __ATTRS_o_ai vec_ste(vector short __a, int __b,
10517  short *__c) {
10518  __builtin_altivec_stvehx(__a, __b, __c);
10519 }
10520 
10521 static __inline__ void __ATTRS_o_ai vec_ste(vector unsigned short __a, int __b,
10522  unsigned short *__c) {
10523  __builtin_altivec_stvehx((vector short)__a, __b, __c);
10524 }
10525 
10526 static __inline__ void __ATTRS_o_ai vec_ste(vector bool short __a, int __b,
10527  short *__c) {
10528  __builtin_altivec_stvehx((vector short)__a, __b, __c);
10529 }
10530 
10531 static __inline__ void __ATTRS_o_ai vec_ste(vector bool short __a, int __b,
10532  unsigned short *__c) {
10533  __builtin_altivec_stvehx((vector short)__a, __b, __c);
10534 }
10535 
10536 static __inline__ void __ATTRS_o_ai vec_ste(vector pixel __a, int __b,
10537  short *__c) {
10538  __builtin_altivec_stvehx((vector short)__a, __b, __c);
10539 }
10540 
10541 static __inline__ void __ATTRS_o_ai vec_ste(vector pixel __a, int __b,
10542  unsigned short *__c) {
10543  __builtin_altivec_stvehx((vector short)__a, __b, __c);
10544 }
10545 
10546 static __inline__ void __ATTRS_o_ai vec_ste(vector int __a, int __b, int *__c) {
10547  __builtin_altivec_stvewx(__a, __b, __c);
10548 }
10549 
10550 static __inline__ void __ATTRS_o_ai vec_ste(vector unsigned int __a, int __b,
10551  unsigned int *__c) {
10552  __builtin_altivec_stvewx((vector int)__a, __b, __c);
10553 }
10554 
10555 static __inline__ void __ATTRS_o_ai vec_ste(vector bool int __a, int __b,
10556  int *__c) {
10557  __builtin_altivec_stvewx((vector int)__a, __b, __c);
10558 }
10559 
10560 static __inline__ void __ATTRS_o_ai vec_ste(vector bool int __a, int __b,
10561  unsigned int *__c) {
10562  __builtin_altivec_stvewx((vector int)__a, __b, __c);
10563 }
10564 
10565 static __inline__ void __ATTRS_o_ai vec_ste(vector float __a, int __b,
10566  float *__c) {
10567  __builtin_altivec_stvewx((vector int)__a, __b, __c);
10568 }
10569 
10570 /* vec_stvebx */
10571 
10572 static __inline__ void __ATTRS_o_ai vec_stvebx(vector signed char __a, int __b,
10573  signed char *__c) {
10574  __builtin_altivec_stvebx((vector char)__a, __b, __c);
10575 }
10576 
10577 static __inline__ void __ATTRS_o_ai vec_stvebx(vector unsigned char __a,
10578  int __b, unsigned char *__c) {
10579  __builtin_altivec_stvebx((vector char)__a, __b, __c);
10580 }
10581 
10582 static __inline__ void __ATTRS_o_ai vec_stvebx(vector bool char __a, int __b,
10583  signed char *__c) {
10584  __builtin_altivec_stvebx((vector char)__a, __b, __c);
10585 }
10586 
10587 static __inline__ void __ATTRS_o_ai vec_stvebx(vector bool char __a, int __b,
10588  unsigned char *__c) {
10589  __builtin_altivec_stvebx((vector char)__a, __b, __c);
10590 }
10591 
10592 /* vec_stvehx */
10593 
10594 static __inline__ void __ATTRS_o_ai vec_stvehx(vector short __a, int __b,
10595  short *__c) {
10596  __builtin_altivec_stvehx(__a, __b, __c);
10597 }
10598 
10599 static __inline__ void __ATTRS_o_ai vec_stvehx(vector unsigned short __a,
10600  int __b, unsigned short *__c) {
10601  __builtin_altivec_stvehx((vector short)__a, __b, __c);
10602 }
10603 
10604 static __inline__ void __ATTRS_o_ai vec_stvehx(vector bool short __a, int __b,
10605  short *__c) {
10606  __builtin_altivec_stvehx((vector short)__a, __b, __c);
10607 }
10608 
10609 static __inline__ void __ATTRS_o_ai vec_stvehx(vector bool short __a, int __b,
10610  unsigned short *__c) {
10611  __builtin_altivec_stvehx((vector short)__a, __b, __c);
10612 }
10613 
10614 static __inline__ void __ATTRS_o_ai vec_stvehx(vector pixel __a, int __b,
10615  short *__c) {
10616  __builtin_altivec_stvehx((vector short)__a, __b, __c);
10617 }
10618 
10619 static __inline__ void __ATTRS_o_ai vec_stvehx(vector pixel __a, int __b,
10620  unsigned short *__c) {
10621  __builtin_altivec_stvehx((vector short)__a, __b, __c);
10622 }
10623 
10624 /* vec_stvewx */
10625 
10626 static __inline__ void __ATTRS_o_ai vec_stvewx(vector int __a, int __b,
10627  int *__c) {
10628  __builtin_altivec_stvewx(__a, __b, __c);
10629 }
10630 
10631 static __inline__ void __ATTRS_o_ai vec_stvewx(vector unsigned int __a, int __b,
10632  unsigned int *__c) {
10633  __builtin_altivec_stvewx((vector int)__a, __b, __c);
10634 }
10635 
10636 static __inline__ void __ATTRS_o_ai vec_stvewx(vector bool int __a, int __b,
10637  int *__c) {
10638  __builtin_altivec_stvewx((vector int)__a, __b, __c);
10639 }
10640 
10641 static __inline__ void __ATTRS_o_ai vec_stvewx(vector bool int __a, int __b,
10642  unsigned int *__c) {
10643  __builtin_altivec_stvewx((vector int)__a, __b, __c);
10644 }
10645 
10646 static __inline__ void __ATTRS_o_ai vec_stvewx(vector float __a, int __b,
10647  float *__c) {
10648  __builtin_altivec_stvewx((vector int)__a, __b, __c);
10649 }
10650 
10651 /* vec_stl */
10652 
10653 static __inline__ void __ATTRS_o_ai vec_stl(vector signed char __a, int __b,
10654  vector signed char *__c) {
10655  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10656 }
10657 
10658 static __inline__ void __ATTRS_o_ai vec_stl(vector signed char __a, int __b,
10659  signed char *__c) {
10660  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10661 }
10662 
10663 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned char __a, int __b,
10664  vector unsigned char *__c) {
10665  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10666 }
10667 
10668 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned char __a, int __b,
10669  unsigned char *__c) {
10670  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10671 }
10672 
10673 static __inline__ void __ATTRS_o_ai vec_stl(vector bool char __a, int __b,
10674  signed char *__c) {
10675  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10676 }
10677 
10678 static __inline__ void __ATTRS_o_ai vec_stl(vector bool char __a, int __b,
10679  unsigned char *__c) {
10680  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10681 }
10682 
10683 static __inline__ void __ATTRS_o_ai vec_stl(vector bool char __a, int __b,
10684  vector bool char *__c) {
10685  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10686 }
10687 
10688 static __inline__ void __ATTRS_o_ai vec_stl(vector short __a, int __b,
10689  vector short *__c) {
10690  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10691 }
10692 
10693 static __inline__ void __ATTRS_o_ai vec_stl(vector short __a, int __b,
10694  short *__c) {
10695  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10696 }
10697 
10698 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned short __a, int __b,
10699  vector unsigned short *__c) {
10700  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10701 }
10702 
10703 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned short __a, int __b,
10704  unsigned short *__c) {
10705  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10706 }
10707 
10708 static __inline__ void __ATTRS_o_ai vec_stl(vector bool short __a, int __b,
10709  short *__c) {
10710  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10711 }
10712 
10713 static __inline__ void __ATTRS_o_ai vec_stl(vector bool short __a, int __b,
10714  unsigned short *__c) {
10715  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10716 }
10717 
10718 static __inline__ void __ATTRS_o_ai vec_stl(vector bool short __a, int __b,
10719  vector bool short *__c) {
10720  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10721 }
10722 
10723 static __inline__ void __ATTRS_o_ai vec_stl(vector pixel __a, int __b,
10724  short *__c) {
10725  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10726 }
10727 
10728 static __inline__ void __ATTRS_o_ai vec_stl(vector pixel __a, int __b,
10729  unsigned short *__c) {
10730  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10731 }
10732 
10733 static __inline__ void __ATTRS_o_ai vec_stl(vector pixel __a, int __b,
10734  vector pixel *__c) {
10735  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10736 }
10737 
10738 static __inline__ void __ATTRS_o_ai vec_stl(vector int __a, int __b,
10739  vector int *__c) {
10740  __builtin_altivec_stvxl(__a, __b, __c);
10741 }
10742 
10743 static __inline__ void __ATTRS_o_ai vec_stl(vector int __a, int __b, int *__c) {
10744  __builtin_altivec_stvxl(__a, __b, __c);
10745 }
10746 
10747 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned int __a, int __b,
10748  vector unsigned int *__c) {
10749  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10750 }
10751 
10752 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned int __a, int __b,
10753  unsigned int *__c) {
10754  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10755 }
10756 
10757 static __inline__ void __ATTRS_o_ai vec_stl(vector bool int __a, int __b,
10758  int *__c) {
10759  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10760 }
10761 
10762 static __inline__ void __ATTRS_o_ai vec_stl(vector bool int __a, int __b,
10763  unsigned int *__c) {
10764  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10765 }
10766 
10767 static __inline__ void __ATTRS_o_ai vec_stl(vector bool int __a, int __b,
10768  vector bool int *__c) {
10769  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10770 }
10771 
10772 static __inline__ void __ATTRS_o_ai vec_stl(vector float __a, int __b,
10773  vector float *__c) {
10774  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10775 }
10776 
10777 static __inline__ void __ATTRS_o_ai vec_stl(vector float __a, int __b,
10778  float *__c) {
10779  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10780 }
10781 
10782 /* vec_stvxl */
10783 
10784 static __inline__ void __ATTRS_o_ai vec_stvxl(vector signed char __a, int __b,
10785  vector signed char *__c) {
10786  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10787 }
10788 
10789 static __inline__ void __ATTRS_o_ai vec_stvxl(vector signed char __a, int __b,
10790  signed char *__c) {
10791  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10792 }
10793 
10794 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned char __a, int __b,
10795  vector unsigned char *__c) {
10796  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10797 }
10798 
10799 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned char __a, int __b,
10800  unsigned char *__c) {
10801  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10802 }
10803 
10804 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool char __a, int __b,
10805  signed char *__c) {
10806  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10807 }
10808 
10809 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool char __a, int __b,
10810  unsigned char *__c) {
10811  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10812 }
10813 
10814 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool char __a, int __b,
10815  vector bool char *__c) {
10816  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10817 }
10818 
10819 static __inline__ void __ATTRS_o_ai vec_stvxl(vector short __a, int __b,
10820  vector short *__c) {
10821  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10822 }
10823 
10824 static __inline__ void __ATTRS_o_ai vec_stvxl(vector short __a, int __b,
10825  short *__c) {
10826  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10827 }
10828 
10829 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned short __a,
10830  int __b,
10831  vector unsigned short *__c) {
10832  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10833 }
10834 
10835 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned short __a,
10836  int __b, unsigned short *__c) {
10837  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10838 }
10839 
10840 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool short __a, int __b,
10841  short *__c) {
10842  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10843 }
10844 
10845 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool short __a, int __b,
10846  unsigned short *__c) {
10847  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10848 }
10849 
10850 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool short __a, int __b,
10851  vector bool short *__c) {
10852  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10853 }
10854 
10855 static __inline__ void __ATTRS_o_ai vec_stvxl(vector pixel __a, int __b,
10856  short *__c) {
10857  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10858 }
10859 
10860 static __inline__ void __ATTRS_o_ai vec_stvxl(vector pixel __a, int __b,
10861  unsigned short *__c) {
10862  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10863 }
10864 
10865 static __inline__ void __ATTRS_o_ai vec_stvxl(vector pixel __a, int __b,
10866  vector pixel *__c) {
10867  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10868 }
10869 
10870 static __inline__ void __ATTRS_o_ai vec_stvxl(vector int __a, int __b,
10871  vector int *__c) {
10872  __builtin_altivec_stvxl(__a, __b, __c);
10873 }
10874 
10875 static __inline__ void __ATTRS_o_ai vec_stvxl(vector int __a, int __b,
10876  int *__c) {
10877  __builtin_altivec_stvxl(__a, __b, __c);
10878 }
10879 
10880 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned int __a, int __b,
10881  vector unsigned int *__c) {
10882  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10883 }
10884 
10885 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned int __a, int __b,
10886  unsigned int *__c) {
10887  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10888 }
10889 
10890 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool int __a, int __b,
10891  int *__c) {
10892  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10893 }
10894 
10895 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool int __a, int __b,
10896  unsigned int *__c) {
10897  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10898 }
10899 
10900 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool int __a, int __b,
10901  vector bool int *__c) {
10902  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10903 }
10904 
10905 static __inline__ void __ATTRS_o_ai vec_stvxl(vector float __a, int __b,
10906  vector float *__c) {
10907  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10908 }
10909 
10910 static __inline__ void __ATTRS_o_ai vec_stvxl(vector float __a, int __b,
10911  float *__c) {
10912  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10913 }
10914 
10915 /* vec_sub */
10916 
10917 static __inline__ vector signed char __ATTRS_o_ai
10918 vec_sub(vector signed char __a, vector signed char __b) {
10919  return __a - __b;
10920 }
10921 
10922 static __inline__ vector signed char __ATTRS_o_ai
10923 vec_sub(vector bool char __a, vector signed char __b) {
10924  return (vector signed char)__a - __b;
10925 }
10926 
10927 static __inline__ vector signed char __ATTRS_o_ai
10928 vec_sub(vector signed char __a, vector bool char __b) {
10929  return __a - (vector signed char)__b;
10930 }
10931 
10932 static __inline__ vector unsigned char __ATTRS_o_ai
10933 vec_sub(vector unsigned char __a, vector unsigned char __b) {
10934  return __a - __b;
10935 }
10936 
10937 static __inline__ vector unsigned char __ATTRS_o_ai
10938 vec_sub(vector bool char __a, vector unsigned char __b) {
10939  return (vector unsigned char)__a - __b;
10940 }
10941 
10942 static __inline__ vector unsigned char __ATTRS_o_ai
10943 vec_sub(vector unsigned char __a, vector bool char __b) {
10944  return __a - (vector unsigned char)__b;
10945 }
10946 
10947 static __inline__ vector short __ATTRS_o_ai vec_sub(vector short __a,
10948  vector short __b) {
10949  return __a - __b;
10950 }
10951 
10952 static __inline__ vector short __ATTRS_o_ai vec_sub(vector bool short __a,
10953  vector short __b) {
10954  return (vector short)__a - __b;
10955 }
10956 
10957 static __inline__ vector short __ATTRS_o_ai vec_sub(vector short __a,
10958  vector bool short __b) {
10959  return __a - (vector short)__b;
10960 }
10961 
10962 static __inline__ vector unsigned short __ATTRS_o_ai
10963 vec_sub(vector unsigned short __a, vector unsigned short __b) {
10964  return __a - __b;
10965 }
10966 
10967 static __inline__ vector unsigned short __ATTRS_o_ai
10968 vec_sub(vector bool short __a, vector unsigned short __b) {
10969  return (vector unsigned short)__a - __b;
10970 }
10971 
10972 static __inline__ vector unsigned short __ATTRS_o_ai
10973 vec_sub(vector unsigned short __a, vector bool short __b) {
10974  return __a - (vector unsigned short)__b;
10975 }
10976 
10977 static __inline__ vector int __ATTRS_o_ai vec_sub(vector int __a,
10978  vector int __b) {
10979  return __a - __b;
10980 }
10981 
10982 static __inline__ vector int __ATTRS_o_ai vec_sub(vector bool int __a,
10983  vector int __b) {
10984  return (vector int)__a - __b;
10985 }
10986 
10987 static __inline__ vector int __ATTRS_o_ai vec_sub(vector int __a,
10988  vector bool int __b) {
10989  return __a - (vector int)__b;
10990 }
10991 
10992 static __inline__ vector unsigned int __ATTRS_o_ai
10993 vec_sub(vector unsigned int __a, vector unsigned int __b) {
10994  return __a - __b;
10995 }
10996 
10997 static __inline__ vector unsigned int __ATTRS_o_ai
10998 vec_sub(vector bool int __a, vector unsigned int __b) {
10999  return (vector unsigned int)__a - __b;
11000 }
11001 
11002 static __inline__ vector unsigned int __ATTRS_o_ai
11003 vec_sub(vector unsigned int __a, vector bool int __b) {
11004  return __a - (vector unsigned int)__b;
11005 }
11006 
11007 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
11008 static __inline__ vector signed __int128 __ATTRS_o_ai
11009 vec_sub(vector signed __int128 __a, vector signed __int128 __b) {
11010  return __a - __b;
11011 }
11012 
11013 static __inline__ vector unsigned __int128 __ATTRS_o_ai
11014 vec_sub(vector unsigned __int128 __a, vector unsigned __int128 __b) {
11015  return __a - __b;
11016 }
11017 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
11018 
11019 #ifdef __VSX__
11020 static __inline__ vector signed long long __ATTRS_o_ai
11021 vec_sub(vector signed long long __a, vector signed long long __b) {
11022  return __a - __b;
11023 }
11024 
11025 static __inline__ vector unsigned long long __ATTRS_o_ai
11026 vec_sub(vector unsigned long long __a, vector unsigned long long __b) {
11027  return __a - __b;
11028 }
11029 
11030 static __inline__ vector double __ATTRS_o_ai vec_sub(vector double __a,
11031  vector double __b) {
11032  return __a - __b;
11033 }
11034 #endif
11035 
11036 static __inline__ vector float __ATTRS_o_ai vec_sub(vector float __a,
11037  vector float __b) {
11038  return __a - __b;
11039 }
11040 
11041 /* vec_vsububm */
11042 
11043 #define __builtin_altivec_vsububm vec_vsububm
11044 
11045 static __inline__ vector signed char __ATTRS_o_ai
11046 vec_vsububm(vector signed char __a, vector signed char __b) {
11047  return __a - __b;
11048 }
11049 
11050 static __inline__ vector signed char __ATTRS_o_ai
11051 vec_vsububm(vector bool char __a, vector signed char __b) {
11052  return (vector signed char)__a - __b;
11053 }
11054 
11055 static __inline__ vector signed char __ATTRS_o_ai
11056 vec_vsububm(vector signed char __a, vector bool char __b) {
11057  return __a - (vector signed char)__b;
11058 }
11059 
11060 static __inline__ vector unsigned char __ATTRS_o_ai
11061 vec_vsububm(vector unsigned char __a, vector unsigned char __b) {
11062  return __a - __b;
11063 }
11064 
11065 static __inline__ vector unsigned char __ATTRS_o_ai
11066 vec_vsububm(vector bool char __a, vector unsigned char __b) {
11067  return (vector unsigned char)__a - __b;
11068 }
11069 
11070 static __inline__ vector unsigned char __ATTRS_o_ai
11071 vec_vsububm(vector unsigned char __a, vector bool char __b) {
11072  return __a - (vector unsigned char)__b;
11073 }
11074 
11075 /* vec_vsubuhm */
11076 
11077 #define __builtin_altivec_vsubuhm vec_vsubuhm
11078 
11079 static __inline__ vector short __ATTRS_o_ai vec_vsubuhm(vector short __a,
11080  vector short __b) {
11081  return __a - __b;
11082 }
11083 
11084 static __inline__ vector short __ATTRS_o_ai vec_vsubuhm(vector bool short __a,
11085  vector short __b) {
11086  return (vector short)__a - __b;
11087 }
11088 
11089 static __inline__ vector short __ATTRS_o_ai vec_vsubuhm(vector short __a,
11090  vector bool short __b) {
11091  return __a - (vector short)__b;
11092 }
11093 
11094 static __inline__ vector unsigned short __ATTRS_o_ai
11095 vec_vsubuhm(vector unsigned short __a, vector unsigned short __b) {
11096  return __a - __b;
11097 }
11098 
11099 static __inline__ vector unsigned short __ATTRS_o_ai
11100 vec_vsubuhm(vector bool short __a, vector unsigned short __b) {
11101  return (vector unsigned short)__a - __b;
11102 }
11103 
11104 static __inline__ vector unsigned short __ATTRS_o_ai
11105 vec_vsubuhm(vector unsigned short __a, vector bool short __b) {
11106  return __a - (vector unsigned short)__b;
11107 }
11108 
11109 /* vec_vsubuwm */
11110 
11111 #define __builtin_altivec_vsubuwm vec_vsubuwm
11112 
11113 static __inline__ vector int __ATTRS_o_ai vec_vsubuwm(vector int __a,
11114  vector int __b) {
11115  return __a - __b;
11116 }
11117 
11118 static __inline__ vector int __ATTRS_o_ai vec_vsubuwm(vector bool int __a,
11119  vector int __b) {
11120  return (vector int)__a - __b;
11121 }
11122 
11123 static __inline__ vector int __ATTRS_o_ai vec_vsubuwm(vector int __a,
11124  vector bool int __b) {
11125  return __a - (vector int)__b;
11126 }
11127 
11128 static __inline__ vector unsigned int __ATTRS_o_ai
11129 vec_vsubuwm(vector unsigned int __a, vector unsigned int __b) {
11130  return __a - __b;
11131 }
11132 
11133 static __inline__ vector unsigned int __ATTRS_o_ai
11134 vec_vsubuwm(vector bool int __a, vector unsigned int __b) {
11135  return (vector unsigned int)__a - __b;
11136 }
11137 
11138 static __inline__ vector unsigned int __ATTRS_o_ai
11139 vec_vsubuwm(vector unsigned int __a, vector bool int __b) {
11140  return __a - (vector unsigned int)__b;
11141 }
11142 
11143 /* vec_vsubfp */
11144 
11145 #define __builtin_altivec_vsubfp vec_vsubfp
11146 
11147 static __inline__ vector float __attribute__((__always_inline__))
11148 vec_vsubfp(vector float __a, vector float __b) {
11149  return __a - __b;
11150 }
11151 
11152 /* vec_subc */
11153 
11154 static __inline__ vector signed int __ATTRS_o_ai
11155 vec_subc(vector signed int __a, vector signed int __b) {
11156  return (vector signed int)__builtin_altivec_vsubcuw((vector unsigned int)__a,
11157  (vector unsigned int) __b);
11158 }
11159 
11160 static __inline__ vector unsigned int __ATTRS_o_ai
11161 vec_subc(vector unsigned int __a, vector unsigned int __b) {
11162  return __builtin_altivec_vsubcuw(__a, __b);
11163 }
11164 
11165 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
11166 static __inline__ vector unsigned __int128 __ATTRS_o_ai
11167 vec_subc(vector unsigned __int128 __a, vector unsigned __int128 __b) {
11168  return __builtin_altivec_vsubcuq(__a, __b);
11169 }
11170 
11171 static __inline__ vector signed __int128 __ATTRS_o_ai
11172 vec_subc(vector signed __int128 __a, vector signed __int128 __b) {
11173  return __builtin_altivec_vsubcuq(__a, __b);
11174 }
11175 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
11176 
11177 /* vec_vsubcuw */
11178 
11179 static __inline__ vector unsigned int __attribute__((__always_inline__))
11180 vec_vsubcuw(vector unsigned int __a, vector unsigned int __b) {
11181  return __builtin_altivec_vsubcuw(__a, __b);
11182 }
11183 
11184 /* vec_subs */
11185 
11186 static __inline__ vector signed char __ATTRS_o_ai
11187 vec_subs(vector signed char __a, vector signed char __b) {
11188  return __builtin_altivec_vsubsbs(__a, __b);
11189 }
11190 
11191 static __inline__ vector signed char __ATTRS_o_ai
11192 vec_subs(vector bool char __a, vector signed char __b) {
11193  return __builtin_altivec_vsubsbs((vector signed char)__a, __b);
11194 }
11195 
11196 static __inline__ vector signed char __ATTRS_o_ai
11197 vec_subs(vector signed char __a, vector bool char __b) {
11198  return __builtin_altivec_vsubsbs(__a, (vector signed char)__b);
11199 }
11200 
11201 static __inline__ vector unsigned char __ATTRS_o_ai
11202 vec_subs(vector unsigned char __a, vector unsigned char __b) {
11203  return __builtin_altivec_vsububs(__a, __b);
11204 }
11205 
11206 static __inline__ vector unsigned char __ATTRS_o_ai
11207 vec_subs(vector bool char __a, vector unsigned char __b) {
11208  return __builtin_altivec_vsububs((vector unsigned char)__a, __b);
11209 }
11210 
11211 static __inline__ vector unsigned char __ATTRS_o_ai
11212 vec_subs(vector unsigned char __a, vector bool char __b) {
11213  return __builtin_altivec_vsububs(__a, (vector unsigned char)__b);
11214 }
11215 
11216 static __inline__ vector short __ATTRS_o_ai vec_subs(vector short __a,
11217  vector short __b) {
11218  return __builtin_altivec_vsubshs(__a, __b);
11219 }
11220 
11221 static __inline__ vector short __ATTRS_o_ai vec_subs(vector bool short __a,
11222  vector short __b) {
11223  return __builtin_altivec_vsubshs((vector short)__a, __b);
11224 }
11225 
11226 static __inline__ vector short __ATTRS_o_ai vec_subs(vector short __a,
11227  vector bool short __b) {
11228  return __builtin_altivec_vsubshs(__a, (vector short)__b);
11229 }
11230 
11231 static __inline__ vector unsigned short __ATTRS_o_ai
11232 vec_subs(vector unsigned short __a, vector unsigned short __b) {
11233  return __builtin_altivec_vsubuhs(__a, __b);
11234 }
11235 
11236 static __inline__ vector unsigned short __ATTRS_o_ai
11237 vec_subs(vector bool short __a, vector unsigned short __b) {
11238  return __builtin_altivec_vsubuhs((vector unsigned short)__a, __b);
11239 }
11240 
11241 static __inline__ vector unsigned short __ATTRS_o_ai
11242 vec_subs(vector unsigned short __a, vector bool short __b) {
11243  return __builtin_altivec_vsubuhs(__a, (vector unsigned short)__b);
11244 }
11245 
11246 static __inline__ vector int __ATTRS_o_ai vec_subs(vector int __a,
11247  vector int __b) {
11248  return __builtin_altivec_vsubsws(__a, __b);
11249 }
11250 
11251 static __inline__ vector int __ATTRS_o_ai vec_subs(vector bool int __a,
11252  vector int __b) {
11253  return __builtin_altivec_vsubsws((vector int)__a, __b);
11254 }
11255 
11256 static __inline__ vector int __ATTRS_o_ai vec_subs(vector int __a,
11257  vector bool int __b) {
11258  return __builtin_altivec_vsubsws(__a, (vector int)__b);
11259 }
11260 
11261 static __inline__ vector unsigned int __ATTRS_o_ai
11262 vec_subs(vector unsigned int __a, vector unsigned int __b) {
11263  return __builtin_altivec_vsubuws(__a, __b);
11264 }
11265 
11266 static __inline__ vector unsigned int __ATTRS_o_ai
11267 vec_subs(vector bool int __a, vector unsigned int __b) {
11268  return __builtin_altivec_vsubuws((vector unsigned int)__a, __b);
11269 }
11270 
11271 static __inline__ vector unsigned int __ATTRS_o_ai
11272 vec_subs(vector unsigned int __a, vector bool int __b) {
11273  return __builtin_altivec_vsubuws(__a, (vector unsigned int)__b);
11274 }
11275 
11276 /* vec_vsubsbs */
11277 
11278 static __inline__ vector signed char __ATTRS_o_ai
11279 vec_vsubsbs(vector signed char __a, vector signed char __b) {
11280  return __builtin_altivec_vsubsbs(__a, __b);
11281 }
11282 
11283 static __inline__ vector signed char __ATTRS_o_ai
11284 vec_vsubsbs(vector bool char __a, vector signed char __b) {
11285  return __builtin_altivec_vsubsbs((vector signed char)__a, __b);
11286 }
11287 
11288 static __inline__ vector signed char __ATTRS_o_ai
11289 vec_vsubsbs(vector signed char __a, vector bool char __b) {
11290  return __builtin_altivec_vsubsbs(__a, (vector signed char)__b);
11291 }
11292 
11293 /* vec_vsububs */
11294 
11295 static __inline__ vector unsigned char __ATTRS_o_ai
11296 vec_vsububs(vector unsigned char __a, vector unsigned char __b) {
11297  return __builtin_altivec_vsububs(__a, __b);
11298 }
11299 
11300 static __inline__ vector unsigned char __ATTRS_o_ai
11301 vec_vsububs(vector bool char __a, vector unsigned char __b) {
11302  return __builtin_altivec_vsububs((vector unsigned char)__a, __b);
11303 }
11304 
11305 static __inline__ vector unsigned char __ATTRS_o_ai
11306 vec_vsububs(vector unsigned char __a, vector bool char __b) {
11307  return __builtin_altivec_vsububs(__a, (vector unsigned char)__b);
11308 }
11309 
11310 /* vec_vsubshs */
11311 
11312 static __inline__ vector short __ATTRS_o_ai vec_vsubshs(vector short __a,
11313  vector short __b) {
11314  return __builtin_altivec_vsubshs(__a, __b);
11315 }
11316 
11317 static __inline__ vector short __ATTRS_o_ai vec_vsubshs(vector bool short __a,
11318  vector short __b) {
11319  return __builtin_altivec_vsubshs((vector short)__a, __b);
11320 }
11321 
11322 static __inline__ vector short __ATTRS_o_ai vec_vsubshs(vector short __a,
11323  vector bool short __b) {
11324  return __builtin_altivec_vsubshs(__a, (vector short)__b);
11325 }
11326 
11327 /* vec_vsubuhs */
11328 
11329 static __inline__ vector unsigned short __ATTRS_o_ai
11330 vec_vsubuhs(vector unsigned short __a, vector unsigned short __b) {
11331  return __builtin_altivec_vsubuhs(__a, __b);
11332 }
11333 
11334 static __inline__ vector unsigned short __ATTRS_o_ai
11335 vec_vsubuhs(vector bool short __a, vector unsigned short __b) {
11336  return __builtin_altivec_vsubuhs((vector unsigned short)__a, __b);
11337 }
11338 
11339 static __inline__ vector unsigned short __ATTRS_o_ai
11340 vec_vsubuhs(vector unsigned short __a, vector bool short __b) {
11341  return __builtin_altivec_vsubuhs(__a, (vector unsigned short)__b);
11342 }
11343 
11344 /* vec_vsubsws */
11345 
11346 static __inline__ vector int __ATTRS_o_ai vec_vsubsws(vector int __a,
11347  vector int __b) {
11348  return __builtin_altivec_vsubsws(__a, __b);
11349 }
11350 
11351 static __inline__ vector int __ATTRS_o_ai vec_vsubsws(vector bool int __a,
11352  vector int __b) {
11353  return __builtin_altivec_vsubsws((vector int)__a, __b);
11354 }
11355 
11356 static __inline__ vector int __ATTRS_o_ai vec_vsubsws(vector int __a,
11357  vector bool int __b) {
11358  return __builtin_altivec_vsubsws(__a, (vector int)__b);
11359 }
11360 
11361 /* vec_vsubuws */
11362 
11363 static __inline__ vector unsigned int __ATTRS_o_ai
11364 vec_vsubuws(vector unsigned int __a, vector unsigned int __b) {
11365  return __builtin_altivec_vsubuws(__a, __b);
11366 }
11367 
11368 static __inline__ vector unsigned int __ATTRS_o_ai
11369 vec_vsubuws(vector bool int __a, vector unsigned int __b) {
11370  return __builtin_altivec_vsubuws((vector unsigned int)__a, __b);
11371 }
11372 
11373 static __inline__ vector unsigned int __ATTRS_o_ai
11374 vec_vsubuws(vector unsigned int __a, vector bool int __b) {
11375  return __builtin_altivec_vsubuws(__a, (vector unsigned int)__b);
11376 }
11377 
11378 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
11379 /* vec_vsubuqm */
11380 
11381 static __inline__ vector signed __int128 __ATTRS_o_ai
11382 vec_vsubuqm(vector signed __int128 __a, vector signed __int128 __b) {
11383  return __a - __b;
11384 }
11385 
11386 static __inline__ vector unsigned __int128 __ATTRS_o_ai
11387 vec_vsubuqm(vector unsigned __int128 __a, vector unsigned __int128 __b) {
11388  return __a - __b;
11389 }
11390 
11391 /* vec_vsubeuqm */
11392 
11393 
11394 static __inline__ vector signed __int128 __ATTRS_o_ai
11395 vec_vsubeuqm(vector signed __int128 __a, vector signed __int128 __b,
11396  vector signed __int128 __c) {
11397  return __builtin_altivec_vsubeuqm(__a, __b, __c);
11398 }
11399 
11400 static __inline__ vector unsigned __int128 __ATTRS_o_ai
11401 vec_vsubeuqm(vector unsigned __int128 __a, vector unsigned __int128 __b,
11402  vector unsigned __int128 __c) {
11403  return __builtin_altivec_vsubeuqm(__a, __b, __c);
11404 }
11405 
11406 static __inline__ vector signed __int128 __ATTRS_o_ai
11407 vec_sube(vector signed __int128 __a, vector signed __int128 __b,
11408  vector signed __int128 __c) {
11409  return __builtin_altivec_vsubeuqm(__a, __b, __c);
11410 }
11411 
11412 static __inline__ vector unsigned __int128 __ATTRS_o_ai
11413 vec_sube(vector unsigned __int128 __a, vector unsigned __int128 __b,
11414  vector unsigned __int128 __c) {
11415  return __builtin_altivec_vsubeuqm(__a, __b, __c);
11416 }
11417 
11418 /* vec_vsubcuq */
11419 
11420 static __inline__ vector signed __int128 __ATTRS_o_ai
11421 vec_vsubcuq(vector signed __int128 __a, vector signed __int128 __b) {
11422  return __builtin_altivec_vsubcuq(__a, __b);
11423 }
11424 
11425 static __inline__ vector unsigned __int128 __ATTRS_o_ai
11426 vec_vsubcuq(vector unsigned __int128 __a, vector unsigned __int128 __b) {
11427  return __builtin_altivec_vsubcuq(__a, __b);
11428 }
11429 
11430 /* vec_vsubecuq */
11431 
11432 static __inline__ vector signed __int128 __ATTRS_o_ai
11433 vec_vsubecuq(vector signed __int128 __a, vector signed __int128 __b,
11434  vector signed __int128 __c) {
11435  return __builtin_altivec_vsubecuq(__a, __b, __c);
11436 }
11437 
11438 static __inline__ vector unsigned __int128 __ATTRS_o_ai
11439 vec_vsubecuq(vector unsigned __int128 __a, vector unsigned __int128 __b,
11440  vector unsigned __int128 __c) {
11441  return __builtin_altivec_vsubecuq(__a, __b, __c);
11442 }
11443 
11444 static __inline__ vector signed int __ATTRS_o_ai
11445 vec_subec(vector signed int __a, vector signed int __b,
11446  vector signed int __c) {
11447  return vec_addec(__a, ~__b, __c);
11448 }
11449 
11450 static __inline__ vector unsigned int __ATTRS_o_ai
11451 vec_subec(vector unsigned int __a, vector unsigned int __b,
11452  vector unsigned int __c) {
11453  return vec_addec(__a, ~__b, __c);
11454 }
11455 
11456 static __inline__ vector signed __int128 __ATTRS_o_ai
11457 vec_subec(vector signed __int128 __a, vector signed __int128 __b,
11458  vector signed __int128 __c) {
11459  return __builtin_altivec_vsubecuq(__a, __b, __c);
11460 }
11461 
11462 static __inline__ vector unsigned __int128 __ATTRS_o_ai
11463 vec_subec(vector unsigned __int128 __a, vector unsigned __int128 __b,
11464  vector unsigned __int128 __c) {
11465  return __builtin_altivec_vsubecuq(__a, __b, __c);
11466 }
11467 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
11468 
11469 static __inline__ vector signed int __ATTRS_o_ai
11470 vec_sube(vector signed int __a, vector signed int __b,
11471  vector signed int __c) {
11472  vector signed int __mask = {1, 1, 1, 1};
11473  vector signed int __carry = __c & __mask;
11474  return vec_adde(__a, ~__b, __carry);
11475 }
11476 
11477 static __inline__ vector unsigned int __ATTRS_o_ai
11478 vec_sube(vector unsigned int __a, vector unsigned int __b,
11479  vector unsigned int __c) {
11480  vector unsigned int __mask = {1, 1, 1, 1};
11481  vector unsigned int __carry = __c & __mask;
11482  return vec_adde(__a, ~__b, __carry);
11483 }
11484 /* vec_sum4s */
11485 
11486 static __inline__ vector int __ATTRS_o_ai vec_sum4s(vector signed char __a,
11487  vector int __b) {
11488  return __builtin_altivec_vsum4sbs(__a, __b);
11489 }
11490 
11491 static __inline__ vector unsigned int __ATTRS_o_ai
11492 vec_sum4s(vector unsigned char __a, vector unsigned int __b) {
11493  return __builtin_altivec_vsum4ubs(__a, __b);
11494 }
11495 
11496 static __inline__ vector int __ATTRS_o_ai vec_sum4s(vector signed short __a,
11497  vector int __b) {
11498  return __builtin_altivec_vsum4shs(__a, __b);
11499 }
11500 
11501 /* vec_vsum4sbs */
11502 
11503 static __inline__ vector int __attribute__((__always_inline__))
11504 vec_vsum4sbs(vector signed char __a, vector int __b) {
11505  return __builtin_altivec_vsum4sbs(__a, __b);
11506 }
11507 
11508 /* vec_vsum4ubs */
11509 
11510 static __inline__ vector unsigned int __attribute__((__always_inline__))
11511 vec_vsum4ubs(vector unsigned char __a, vector unsigned int __b) {
11512  return __builtin_altivec_vsum4ubs(__a, __b);
11513 }
11514 
11515 /* vec_vsum4shs */
11516 
11517 static __inline__ vector int __attribute__((__always_inline__))
11518 vec_vsum4shs(vector signed short __a, vector int __b) {
11519  return __builtin_altivec_vsum4shs(__a, __b);
11520 }
11521 
11522 /* vec_sum2s */
11523 
11524 /* The vsum2sws instruction has a big-endian bias, so that the second
11525  input vector and the result always reference big-endian elements
11526  1 and 3 (little-endian element 0 and 2). For ease of porting the
11527  programmer wants elements 1 and 3 in both cases, so for little
11528  endian we must perform some permutes. */
11529 
11530 static __inline__ vector signed int __attribute__((__always_inline__))
11531 vec_sum2s(vector int __a, vector int __b) {
11532 #ifdef __LITTLE_ENDIAN__
11533  vector int __c = (vector signed int)vec_perm(
11534  __b, __b, (vector unsigned char)(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15,
11535  8, 9, 10, 11));
11536  __c = __builtin_altivec_vsum2sws(__a, __c);
11537  return (vector signed int)vec_perm(
11538  __c, __c, (vector unsigned char)(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15,
11539  8, 9, 10, 11));
11540 #else
11541  return __builtin_altivec_vsum2sws(__a, __b);
11542 #endif
11543 }
11544 
11545 /* vec_vsum2sws */
11546 
11547 static __inline__ vector signed int __attribute__((__always_inline__))
11548 vec_vsum2sws(vector int __a, vector int __b) {
11549 #ifdef __LITTLE_ENDIAN__
11550  vector int __c = (vector signed int)vec_perm(
11551  __b, __b, (vector unsigned char)(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15,
11552  8, 9, 10, 11));
11553  __c = __builtin_altivec_vsum2sws(__a, __c);
11554  return (vector signed int)vec_perm(
11555  __c, __c, (vector unsigned char)(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15,
11556  8, 9, 10, 11));
11557 #else
11558  return __builtin_altivec_vsum2sws(__a, __b);
11559 #endif
11560 }
11561 
11562 /* vec_sums */
11563 
11564 /* The vsumsws instruction has a big-endian bias, so that the second
11565  input vector and the result always reference big-endian element 3
11566  (little-endian element 0). For ease of porting the programmer
11567  wants element 3 in both cases, so for little endian we must perform
11568  some permutes. */
11569 
11570 static __inline__ vector signed int __attribute__((__always_inline__))
11571 vec_sums(vector signed int __a, vector signed int __b) {
11572 #ifdef __LITTLE_ENDIAN__
11573  __b = (vector signed int)vec_splat(__b, 3);
11574  __b = __builtin_altivec_vsumsws(__a, __b);
11575  return (vector signed int)(0, 0, 0, __b[0]);
11576 #else
11577  return __builtin_altivec_vsumsws(__a, __b);
11578 #endif
11579 }
11580 
11581 /* vec_vsumsws */
11582 
11583 static __inline__ vector signed int __attribute__((__always_inline__))
11584 vec_vsumsws(vector signed int __a, vector signed int __b) {
11585 #ifdef __LITTLE_ENDIAN__
11586  __b = (vector signed int)vec_splat(__b, 3);
11587  __b = __builtin_altivec_vsumsws(__a, __b);
11588  return (vector signed int)(0, 0, 0, __b[0]);
11589 #else
11590  return __builtin_altivec_vsumsws(__a, __b);
11591 #endif
11592 }
11593 
11594 /* vec_trunc */
11595 
11596 static __inline__ vector float __ATTRS_o_ai vec_trunc(vector float __a) {
11597 #ifdef __VSX__
11598  return __builtin_vsx_xvrspiz(__a);
11599 #else
11600  return __builtin_altivec_vrfiz(__a);
11601 #endif
11602 }
11603 
11604 #ifdef __VSX__
11605 static __inline__ vector double __ATTRS_o_ai vec_trunc(vector double __a) {
11606  return __builtin_vsx_xvrdpiz(__a);
11607 }
11608 #endif
11609 
11610 /* vec_vrfiz */
11611 
11612 static __inline__ vector float __attribute__((__always_inline__))
11613 vec_vrfiz(vector float __a) {
11614  return __builtin_altivec_vrfiz(__a);
11615 }
11616 
11617 /* vec_unpackh */
11618 
11619 /* The vector unpack instructions all have a big-endian bias, so for
11620  little endian we must reverse the meanings of "high" and "low." */
11621 
11622 static __inline__ vector short __ATTRS_o_ai
11623 vec_unpackh(vector signed char __a) {
11624 #ifdef __LITTLE_ENDIAN__
11625  return __builtin_altivec_vupklsb((vector char)__a);
11626 #else
11627  return __builtin_altivec_vupkhsb((vector char)__a);
11628 #endif
11629 }
11630 
11631 static __inline__ vector bool short __ATTRS_o_ai
11632 vec_unpackh(vector bool char __a) {
11633 #ifdef __LITTLE_ENDIAN__
11634  return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
11635 #else
11636  return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
11637 #endif
11638 }
11639 
11640 static __inline__ vector int __ATTRS_o_ai vec_unpackh(vector short __a) {
11641 #ifdef __LITTLE_ENDIAN__
11642  return __builtin_altivec_vupklsh(__a);
11643 #else
11644  return __builtin_altivec_vupkhsh(__a);
11645 #endif
11646 }
11647 
11648 static __inline__ vector bool int __ATTRS_o_ai
11649 vec_unpackh(vector bool short __a) {
11650 #ifdef __LITTLE_ENDIAN__
11651  return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
11652 #else
11653  return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
11654 #endif
11655 }
11656 
11657 static __inline__ vector unsigned int __ATTRS_o_ai
11658 vec_unpackh(vector pixel __a) {
11659 #ifdef __LITTLE_ENDIAN__
11660  return (vector unsigned int)__builtin_altivec_vupklpx((vector short)__a);
11661 #else
11662  return (vector unsigned int)__builtin_altivec_vupkhpx((vector short)__a);
11663 #endif
11664 }
11665 
11666 #ifdef __POWER8_VECTOR__
11667 static __inline__ vector long long __ATTRS_o_ai vec_unpackh(vector int __a) {
11668 #ifdef __LITTLE_ENDIAN__
11669  return __builtin_altivec_vupklsw(__a);
11670 #else
11671  return __builtin_altivec_vupkhsw(__a);
11672 #endif
11673 }
11674 
11675 static __inline__ vector bool long long __ATTRS_o_ai
11676 vec_unpackh(vector bool int __a) {
11677 #ifdef __LITTLE_ENDIAN__
11678  return (vector bool long long)__builtin_altivec_vupklsw((vector int)__a);
11679 #else
11680  return (vector bool long long)__builtin_altivec_vupkhsw((vector int)__a);
11681 #endif
11682 }
11683 
11684 static __inline__ vector double __ATTRS_o_ai
11685 vec_unpackh(vector float __a) {
11686  return (vector double)(__a[0], __a[1]);
11687 }
11688 #endif
11689 
11690 /* vec_vupkhsb */
11691 
11692 static __inline__ vector short __ATTRS_o_ai
11693 vec_vupkhsb(vector signed char __a) {
11694 #ifdef __LITTLE_ENDIAN__
11695  return __builtin_altivec_vupklsb((vector char)__a);
11696 #else
11697  return __builtin_altivec_vupkhsb((vector char)__a);
11698 #endif
11699 }
11700 
11701 static __inline__ vector bool short __ATTRS_o_ai
11702 vec_vupkhsb(vector bool char __a) {
11703 #ifdef __LITTLE_ENDIAN__
11704  return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
11705 #else
11706  return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
11707 #endif
11708 }
11709 
11710 /* vec_vupkhsh */
11711 
11712 static __inline__ vector int __ATTRS_o_ai vec_vupkhsh(vector short __a) {
11713 #ifdef __LITTLE_ENDIAN__
11714  return __builtin_altivec_vupklsh(__a);
11715 #else
11716  return __builtin_altivec_vupkhsh(__a);
11717 #endif
11718 }
11719 
11720 static __inline__ vector bool int __ATTRS_o_ai
11721 vec_vupkhsh(vector bool short __a) {
11722 #ifdef __LITTLE_ENDIAN__
11723  return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
11724 #else
11725  return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
11726 #endif
11727 }
11728 
11729 static __inline__ vector unsigned int __ATTRS_o_ai
11730 vec_vupkhsh(vector pixel __a) {
11731 #ifdef __LITTLE_ENDIAN__
11732  return (vector unsigned int)__builtin_altivec_vupklpx((vector short)__a);
11733 #else
11734  return (vector unsigned int)__builtin_altivec_vupkhpx((vector short)__a);
11735 #endif
11736 }
11737 
11738 /* vec_vupkhsw */
11739 
11740 #ifdef __POWER8_VECTOR__
11741 static __inline__ vector long long __ATTRS_o_ai vec_vupkhsw(vector int __a) {
11742 #ifdef __LITTLE_ENDIAN__
11743  return __builtin_altivec_vupklsw(__a);
11744 #else
11745  return __builtin_altivec_vupkhsw(__a);
11746 #endif
11747 }
11748 
11749 static __inline__ vector bool long long __ATTRS_o_ai
11750 vec_vupkhsw(vector bool int __a) {
11751 #ifdef __LITTLE_ENDIAN__
11752  return (vector bool long long)__builtin_altivec_vupklsw((vector int)__a);
11753 #else
11754  return (vector bool long long)__builtin_altivec_vupkhsw((vector int)__a);
11755 #endif
11756 }
11757 #endif
11758 
11759 /* vec_unpackl */
11760 
11761 static __inline__ vector short __ATTRS_o_ai
11762 vec_unpackl(vector signed char __a) {
11763 #ifdef __LITTLE_ENDIAN__
11764  return __builtin_altivec_vupkhsb((vector char)__a);
11765 #else
11766  return __builtin_altivec_vupklsb((vector char)__a);
11767 #endif
11768 }
11769 
11770 static __inline__ vector bool short __ATTRS_o_ai
11771 vec_unpackl(vector bool char __a) {
11772 #ifdef __LITTLE_ENDIAN__
11773  return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
11774 #else
11775  return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
11776 #endif
11777 }
11778 
11779 static __inline__ vector int __ATTRS_o_ai vec_unpackl(vector short __a) {
11780 #ifdef __LITTLE_ENDIAN__
11781  return __builtin_altivec_vupkhsh(__a);
11782 #else
11783  return __builtin_altivec_vupklsh(__a);
11784 #endif
11785 }
11786 
11787 static __inline__ vector bool int __ATTRS_o_ai
11788 vec_unpackl(vector bool short __a) {
11789 #ifdef __LITTLE_ENDIAN__
11790  return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
11791 #else
11792  return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
11793 #endif
11794 }
11795 
11796 static __inline__ vector unsigned int __ATTRS_o_ai
11797 vec_unpackl(vector pixel __a) {
11798 #ifdef __LITTLE_ENDIAN__
11799  return (vector unsigned int)__builtin_altivec_vupkhpx((vector short)__a);
11800 #else
11801  return (vector unsigned int)__builtin_altivec_vupklpx((vector short)__a);
11802 #endif
11803 }
11804 
11805 #ifdef __POWER8_VECTOR__
11806 static __inline__ vector long long __ATTRS_o_ai vec_unpackl(vector int __a) {
11807 #ifdef __LITTLE_ENDIAN__
11808  return __builtin_altivec_vupkhsw(__a);
11809 #else
11810  return __builtin_altivec_vupklsw(__a);
11811 #endif
11812 }
11813 
11814 static __inline__ vector bool long long __ATTRS_o_ai
11815 vec_unpackl(vector bool int __a) {
11816 #ifdef __LITTLE_ENDIAN__
11817  return (vector bool long long)__builtin_altivec_vupkhsw((vector int)__a);
11818 #else
11819  return (vector bool long long)__builtin_altivec_vupklsw((vector int)__a);
11820 #endif
11821 }
11822 
11823 static __inline__ vector double __ATTRS_o_ai
11824 vec_unpackl(vector float __a) {
11825  return (vector double)(__a[2], __a[3]);
11826 }
11827 #endif
11828 
11829 /* vec_vupklsb */
11830 
11831 static __inline__ vector short __ATTRS_o_ai
11832 vec_vupklsb(vector signed char __a) {
11833 #ifdef __LITTLE_ENDIAN__
11834  return __builtin_altivec_vupkhsb((vector char)__a);
11835 #else
11836  return __builtin_altivec_vupklsb((vector char)__a);
11837 #endif
11838 }
11839 
11840 static __inline__ vector bool short __ATTRS_o_ai
11841 vec_vupklsb(vector bool char __a) {
11842 #ifdef __LITTLE_ENDIAN__
11843  return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
11844 #else
11845  return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
11846 #endif
11847 }
11848 
11849 /* vec_vupklsh */
11850 
11851 static __inline__ vector int __ATTRS_o_ai vec_vupklsh(vector short __a) {
11852 #ifdef __LITTLE_ENDIAN__
11853  return __builtin_altivec_vupkhsh(__a);
11854 #else
11855  return __builtin_altivec_vupklsh(__a);
11856 #endif
11857 }
11858 
11859 static __inline__ vector bool int __ATTRS_o_ai
11860 vec_vupklsh(vector bool short __a) {
11861 #ifdef __LITTLE_ENDIAN__
11862  return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
11863 #else
11864  return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
11865 #endif
11866 }
11867 
11868 static __inline__ vector unsigned int __ATTRS_o_ai
11869 vec_vupklsh(vector pixel __a) {
11870 #ifdef __LITTLE_ENDIAN__
11871  return (vector unsigned int)__builtin_altivec_vupkhpx((vector short)__a);
11872 #else
11873  return (vector unsigned int)__builtin_altivec_vupklpx((vector short)__a);
11874 #endif
11875 }
11876 
11877 /* vec_vupklsw */
11878 
11879 #ifdef __POWER8_VECTOR__
11880 static __inline__ vector long long __ATTRS_o_ai vec_vupklsw(vector int __a) {
11881 #ifdef __LITTLE_ENDIAN__
11882  return __builtin_altivec_vupkhsw(__a);
11883 #else
11884  return __builtin_altivec_vupklsw(__a);
11885 #endif
11886 }
11887 
11888 static __inline__ vector bool long long __ATTRS_o_ai
11889 vec_vupklsw(vector bool int __a) {
11890 #ifdef __LITTLE_ENDIAN__
11891  return (vector bool long long)__builtin_altivec_vupkhsw((vector int)__a);
11892 #else
11893  return (vector bool long long)__builtin_altivec_vupklsw((vector int)__a);
11894 #endif
11895 }
11896 #endif
11897 
11898 /* vec_vsx_ld */
11899 
11900 #ifdef __VSX__
11901 
11902 static __inline__ vector bool int __ATTRS_o_ai
11903 vec_vsx_ld(int __a, const vector bool int *__b) {
11904  return (vector bool int)__builtin_vsx_lxvw4x(__a, __b);
11905 }
11906 
11907 static __inline__ vector signed int __ATTRS_o_ai
11908 vec_vsx_ld(int __a, const vector signed int *__b) {
11909  return (vector signed int)__builtin_vsx_lxvw4x(__a, __b);
11910 }
11911 
11912 static __inline__ vector signed int __ATTRS_o_ai
11913 vec_vsx_ld(int __a, const signed int *__b) {
11914  return (vector signed int)__builtin_vsx_lxvw4x(__a, __b);
11915 }
11916 
11917 static __inline__ vector unsigned int __ATTRS_o_ai
11918 vec_vsx_ld(int __a, const vector unsigned int *__b) {
11919  return (vector unsigned int)__builtin_vsx_lxvw4x(__a, __b);
11920 }
11921 
11922 static __inline__ vector unsigned int __ATTRS_o_ai
11923 vec_vsx_ld(int __a, const unsigned int *__b) {
11924  return (vector unsigned int)__builtin_vsx_lxvw4x(__a, __b);
11925 }
11926 
11927 static __inline__ vector float __ATTRS_o_ai
11928 vec_vsx_ld(int __a, const vector float *__b) {
11929  return (vector float)__builtin_vsx_lxvw4x(__a, __b);
11930 }
11931 
11932 static __inline__ vector float __ATTRS_o_ai vec_vsx_ld(int __a,
11933  const float *__b) {
11934  return (vector float)__builtin_vsx_lxvw4x(__a, __b);
11935 }
11936 
11937 static __inline__ vector signed long long __ATTRS_o_ai
11938 vec_vsx_ld(int __a, const vector signed long long *__b) {
11939  return (vector signed long long)__builtin_vsx_lxvd2x(__a, __b);
11940 }
11941 
11942 static __inline__ vector unsigned long long __ATTRS_o_ai
11943 vec_vsx_ld(int __a, const vector unsigned long long *__b) {
11944  return (vector unsigned long long)__builtin_vsx_lxvd2x(__a, __b);
11945 }
11946 
11947 static __inline__ vector double __ATTRS_o_ai
11948 vec_vsx_ld(int __a, const vector double *__b) {
11949  return (vector double)__builtin_vsx_lxvd2x(__a, __b);
11950 }
11951 
11952 static __inline__ vector double __ATTRS_o_ai
11953 vec_vsx_ld(int __a, const double *__b) {
11954  return (vector double)__builtin_vsx_lxvd2x(__a, __b);
11955 }
11956 
11957 static __inline__ vector bool short __ATTRS_o_ai
11958 vec_vsx_ld(int __a, const vector bool short *__b) {
11959  return (vector bool short)__builtin_vsx_lxvw4x(__a, __b);
11960 }
11961 
11962 static __inline__ vector signed short __ATTRS_o_ai
11963 vec_vsx_ld(int __a, const vector signed short *__b) {
11964  return (vector signed short)__builtin_vsx_lxvw4x(__a, __b);
11965 }
11966 
11967 static __inline__ vector signed short __ATTRS_o_ai
11968 vec_vsx_ld(int __a, const signed short *__b) {
11969  return (vector signed short)__builtin_vsx_lxvw4x(__a, __b);
11970 }
11971 
11972 static __inline__ vector unsigned short __ATTRS_o_ai
11973 vec_vsx_ld(int __a, const vector unsigned short *__b) {
11974  return (vector unsigned short)__builtin_vsx_lxvw4x(__a, __b);
11975 }
11976 
11977 static __inline__ vector unsigned short __ATTRS_o_ai
11978 vec_vsx_ld(int __a, const unsigned short *__b) {
11979  return (vector unsigned short)__builtin_vsx_lxvw4x(__a, __b);
11980 }
11981 
11982 static __inline__ vector bool char __ATTRS_o_ai
11983 vec_vsx_ld(int __a, const vector bool char *__b) {
11984  return (vector bool char)__builtin_vsx_lxvw4x(__a, __b);
11985 }
11986 
11987 static __inline__ vector signed char __ATTRS_o_ai
11988 vec_vsx_ld(int __a, const vector signed char *__b) {
11989  return (vector signed char)__builtin_vsx_lxvw4x(__a, __b);
11990 }
11991 
11992 static __inline__ vector signed char __ATTRS_o_ai
11993 vec_vsx_ld(int __a, const signed char *__b) {
11994  return (vector signed char)__builtin_vsx_lxvw4x(__a, __b);
11995 }
11996 
11997 static __inline__ vector unsigned char __ATTRS_o_ai
11998 vec_vsx_ld(int __a, const vector unsigned char *__b) {
11999  return (vector unsigned char)__builtin_vsx_lxvw4x(__a, __b);
12000 }
12001 
12002 static __inline__ vector unsigned char __ATTRS_o_ai
12003 vec_vsx_ld(int __a, const unsigned char *__b) {
12004  return (vector unsigned char)__builtin_vsx_lxvw4x(__a, __b);
12005 }
12006 
12007 #endif
12008 
12009 /* vec_vsx_st */
12010 
12011 #ifdef __VSX__
12012 
12013 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool int __a, int __b,
12014  vector bool int *__c) {
12015  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12016 }
12017 
12018 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool int __a, int __b,
12019  signed int *__c) {
12020  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12021 }
12022 
12023 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool int __a, int __b,
12024  unsigned int *__c) {
12025  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12026 }
12027 
12028 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed int __a, int __b,
12029  vector signed int *__c) {
12030  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12031 }
12032 
12033 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed int __a, int __b,
12034  signed int *__c) {
12035  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12036 }
12037 
12038 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned int __a, int __b,
12039  vector unsigned int *__c) {
12040  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12041 }
12042 
12043 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned int __a, int __b,
12044  unsigned int *__c) {
12045  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12046 }
12047 
12048 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector float __a, int __b,
12049  vector float *__c) {
12050  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12051 }
12052 
12053 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector float __a, int __b,
12054  float *__c) {
12055  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12056 }
12057 
12058 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed long long __a,
12059  int __b,
12060  vector signed long long *__c) {
12061  __builtin_vsx_stxvd2x((vector double)__a, __b, __c);
12062 }
12063 
12064 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned long long __a,
12065  int __b,
12066  vector unsigned long long *__c) {
12067  __builtin_vsx_stxvd2x((vector double)__a, __b, __c);
12068 }
12069 
12070 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector double __a, int __b,
12071  vector double *__c) {
12072  __builtin_vsx_stxvd2x((vector double)__a, __b, __c);
12073 }
12074 
12075 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector double __a, int __b,
12076  double *__c) {
12077  __builtin_vsx_stxvd2x((vector double)__a, __b, __c);
12078 }
12079 
12080 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool short __a, int __b,
12081  vector bool short *__c) {
12082  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12083 }
12084 
12085 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool short __a, int __b,
12086  signed short *__c) {
12087  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12088 }
12089 
12090 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool short __a, int __b,
12091  unsigned short *__c) {
12092  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12093 }
12094 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed short __a, int __b,
12095  vector signed short *__c) {
12096  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12097 }
12098 
12099 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed short __a, int __b,
12100  signed short *__c) {
12101  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12102 }
12103 
12104 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned short __a,
12105  int __b,
12106  vector unsigned short *__c) {
12107  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12108 }
12109 
12110 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned short __a,
12111  int __b, unsigned short *__c) {
12112  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12113 }
12114 
12115 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool char __a, int __b,
12116  vector bool char *__c) {
12117  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12118 }
12119 
12120 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool char __a, int __b,
12121  signed char *__c) {
12122  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12123 }
12124 
12125 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool char __a, int __b,
12126  unsigned char *__c) {
12127  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12128 }
12129 
12130 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed char __a, int __b,
12131  vector signed char *__c) {
12132  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12133 }
12134 
12135 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed char __a, int __b,
12136  signed char *__c) {
12137  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12138 }
12139 
12140 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned char __a,
12141  int __b,
12142  vector unsigned char *__c) {
12143  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12144 }
12145 
12146 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned char __a,
12147  int __b, unsigned char *__c) {
12148  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12149 }
12150 
12151 #endif
12152 
12153 #ifdef __VSX__
12154 #define vec_xxpermdi __builtin_vsx_xxpermdi
12155 #define vec_xxsldwi __builtin_vsx_xxsldwi
12156 #endif
12157 
12158 /* vec_xor */
12159 
12160 #define __builtin_altivec_vxor vec_xor
12161 
12162 static __inline__ vector signed char __ATTRS_o_ai
12163 vec_xor(vector signed char __a, vector signed char __b) {
12164  return __a ^ __b;
12165 }
12166 
12167 static __inline__ vector signed char __ATTRS_o_ai
12168 vec_xor(vector bool char __a, vector signed char __b) {
12169  return (vector signed char)__a ^ __b;
12170 }
12171 
12172 static __inline__ vector signed char __ATTRS_o_ai
12173 vec_xor(vector signed char __a, vector bool char __b) {
12174  return __a ^ (vector signed char)__b;
12175 }
12176 
12177 static __inline__ vector unsigned char __ATTRS_o_ai
12178 vec_xor(vector unsigned char __a, vector unsigned char __b) {
12179  return __a ^ __b;
12180 }
12181 
12182 static __inline__ vector unsigned char __ATTRS_o_ai
12183 vec_xor(vector bool char __a, vector unsigned char __b) {
12184  return (vector unsigned char)__a ^ __b;
12185 }
12186 
12187 static __inline__ vector unsigned char __ATTRS_o_ai
12188 vec_xor(vector unsigned char __a, vector bool char __b) {
12189  return __a ^ (vector unsigned char)__b;
12190 }
12191 
12192 static __inline__ vector bool char __ATTRS_o_ai vec_xor(vector bool char __a,
12193  vector bool char __b) {
12194  return __a ^ __b;
12195 }
12196 
12197 static __inline__ vector short __ATTRS_o_ai vec_xor(vector short __a,
12198  vector short __b) {
12199  return __a ^ __b;
12200 }
12201 
12202 static __inline__ vector short __ATTRS_o_ai vec_xor(vector bool short __a,
12203  vector short __b) {
12204  return (vector short)__a ^ __b;
12205 }
12206 
12207 static __inline__ vector short __ATTRS_o_ai vec_xor(vector short __a,
12208  vector bool short __b) {
12209  return __a ^ (vector short)__b;
12210 }
12211 
12212 static __inline__ vector unsigned short __ATTRS_o_ai
12213 vec_xor(vector unsigned short __a, vector unsigned short __b) {
12214  return __a ^ __b;
12215 }
12216 
12217 static __inline__ vector unsigned short __ATTRS_o_ai
12218 vec_xor(vector bool short __a, vector unsigned short __b) {
12219  return (vector unsigned short)__a ^ __b;
12220 }
12221 
12222 static __inline__ vector unsigned short __ATTRS_o_ai
12223 vec_xor(vector unsigned short __a, vector bool short __b) {
12224  return __a ^ (vector unsigned short)__b;
12225 }
12226 
12227 static __inline__ vector bool short __ATTRS_o_ai
12228 vec_xor(vector bool short __a, vector bool short __b) {
12229  return __a ^ __b;
12230 }
12231 
12232 static __inline__ vector int __ATTRS_o_ai vec_xor(vector int __a,
12233  vector int __b) {
12234  return __a ^ __b;
12235 }
12236 
12237 static __inline__ vector int __ATTRS_o_ai vec_xor(vector bool int __a,
12238  vector int __b) {
12239  return (vector int)__a ^ __b;
12240 }
12241 
12242 static __inline__ vector int __ATTRS_o_ai vec_xor(vector int __a,
12243  vector bool int __b) {
12244  return __a ^ (vector int)__b;
12245 }
12246 
12247 static __inline__ vector unsigned int __ATTRS_o_ai
12248 vec_xor(vector unsigned int __a, vector unsigned int __b) {
12249  return __a ^ __b;
12250 }
12251 
12252 static __inline__ vector unsigned int __ATTRS_o_ai
12253 vec_xor(vector bool int __a, vector unsigned int __b) {
12254  return (vector unsigned int)__a ^ __b;
12255 }
12256 
12257 static __inline__ vector unsigned int __ATTRS_o_ai
12258 vec_xor(vector unsigned int __a, vector bool int __b) {
12259  return __a ^ (vector unsigned int)__b;
12260 }
12261 
12262 static __inline__ vector bool int __ATTRS_o_ai vec_xor(vector bool int __a,
12263  vector bool int __b) {
12264  return __a ^ __b;
12265 }
12266 
12267 static __inline__ vector float __ATTRS_o_ai vec_xor(vector float __a,
12268  vector float __b) {
12269  vector unsigned int __res =
12270  (vector unsigned int)__a ^ (vector unsigned int)__b;
12271  return (vector float)__res;
12272 }
12273 
12274 static __inline__ vector float __ATTRS_o_ai vec_xor(vector bool int __a,
12275  vector float __b) {
12276  vector unsigned int __res =
12277  (vector unsigned int)__a ^ (vector unsigned int)__b;
12278  return (vector float)__res;
12279 }
12280 
12281 static __inline__ vector float __ATTRS_o_ai vec_xor(vector float __a,
12282  vector bool int __b) {
12283  vector unsigned int __res =
12284  (vector unsigned int)__a ^ (vector unsigned int)__b;
12285  return (vector float)__res;
12286 }
12287 
12288 #ifdef __VSX__
12289 static __inline__ vector signed long long __ATTRS_o_ai
12290 vec_xor(vector signed long long __a, vector signed long long __b) {
12291  return __a ^ __b;
12292 }
12293 
12294 static __inline__ vector signed long long __ATTRS_o_ai
12295 vec_xor(vector bool long long __a, vector signed long long __b) {
12296  return (vector signed long long)__a ^ __b;
12297 }
12298 
12299 static __inline__ vector signed long long __ATTRS_o_ai
12300 vec_xor(vector signed long long __a, vector bool long long __b) {
12301  return __a ^ (vector signed long long)__b;
12302 }
12303 
12304 static __inline__ vector unsigned long long __ATTRS_o_ai
12305 vec_xor(vector unsigned long long __a, vector unsigned long long __b) {
12306  return __a ^ __b;
12307 }
12308 
12309 static __inline__ vector unsigned long long __ATTRS_o_ai
12310 vec_xor(vector bool long long __a, vector unsigned long long __b) {
12311  return (vector unsigned long long)__a ^ __b;
12312 }
12313 
12314 static __inline__ vector unsigned long long __ATTRS_o_ai
12315 vec_xor(vector unsigned long long __a, vector bool long long __b) {
12316  return __a ^ (vector unsigned long long)__b;
12317 }
12318 
12319 static __inline__ vector bool long long __ATTRS_o_ai
12320 vec_xor(vector bool long long __a, vector bool long long __b) {
12321  return __a ^ __b;
12322 }
12323 
12324 static __inline__ vector double __ATTRS_o_ai vec_xor(vector double __a,
12325  vector double __b) {
12326  return (vector double)((vector unsigned long long)__a ^
12327  (vector unsigned long long)__b);
12328 }
12329 
12330 static __inline__ vector double __ATTRS_o_ai
12331 vec_xor(vector double __a, vector bool long long __b) {
12332  return (vector double)((vector unsigned long long)__a ^
12333  (vector unsigned long long)__b);
12334 }
12335 
12336 static __inline__ vector double __ATTRS_o_ai vec_xor(vector bool long long __a,
12337  vector double __b) {
12338  return (vector double)((vector unsigned long long)__a ^
12339  (vector unsigned long long)__b);
12340 }
12341 #endif
12342 
12343 /* vec_vxor */
12344 
12345 static __inline__ vector signed char __ATTRS_o_ai
12346 vec_vxor(vector signed char __a, vector signed char __b) {
12347  return __a ^ __b;
12348 }
12349 
12350 static __inline__ vector signed char __ATTRS_o_ai
12351 vec_vxor(vector bool char __a, vector signed char __b) {
12352  return (vector signed char)__a ^ __b;
12353 }
12354 
12355 static __inline__ vector signed char __ATTRS_o_ai
12356 vec_vxor(vector signed char __a, vector bool char __b) {
12357  return __a ^ (vector signed char)__b;
12358 }
12359 
12360 static __inline__ vector unsigned char __ATTRS_o_ai
12361 vec_vxor(vector unsigned char __a, vector unsigned char __b) {
12362  return __a ^ __b;
12363 }
12364 
12365 static __inline__ vector unsigned char __ATTRS_o_ai
12366 vec_vxor(vector bool char __a, vector unsigned char __b) {
12367  return (vector unsigned char)__a ^ __b;
12368 }
12369 
12370 static __inline__ vector unsigned char __ATTRS_o_ai
12371 vec_vxor(vector unsigned char __a, vector bool char __b) {
12372  return __a ^ (vector unsigned char)__b;
12373 }
12374 
12375 static __inline__ vector bool char __ATTRS_o_ai vec_vxor(vector bool char __a,
12376  vector bool char __b) {
12377  return __a ^ __b;
12378 }
12379 
12380 static __inline__ vector short __ATTRS_o_ai vec_vxor(vector short __a,
12381  vector short __b) {
12382  return __a ^ __b;
12383 }
12384 
12385 static __inline__ vector short __ATTRS_o_ai vec_vxor(vector bool short __a,
12386  vector short __b) {
12387  return (vector short)__a ^ __b;
12388 }
12389 
12390 static __inline__ vector short __ATTRS_o_ai vec_vxor(vector short __a,
12391  vector bool short __b) {
12392  return __a ^ (vector short)__b;
12393 }
12394 
12395 static __inline__ vector unsigned short __ATTRS_o_ai
12396 vec_vxor(vector unsigned short __a, vector unsigned short __b) {
12397  return __a ^ __b;
12398 }
12399 
12400 static __inline__ vector unsigned short __ATTRS_o_ai
12401 vec_vxor(vector bool short __a, vector unsigned short __b) {
12402  return (vector unsigned short)__a ^ __b;
12403 }
12404 
12405 static __inline__ vector unsigned short __ATTRS_o_ai
12406 vec_vxor(vector unsigned short __a, vector bool short __b) {
12407  return __a ^ (vector unsigned short)__b;
12408 }
12409 
12410 static __inline__ vector bool short __ATTRS_o_ai
12411 vec_vxor(vector bool short __a, vector bool short __b) {
12412  return __a ^ __b;
12413 }
12414 
12415 static __inline__ vector int __ATTRS_o_ai vec_vxor(vector int __a,
12416  vector int __b) {
12417  return __a ^ __b;
12418 }
12419 
12420 static __inline__ vector int __ATTRS_o_ai vec_vxor(vector bool int __a,
12421  vector int __b) {
12422  return (vector int)__a ^ __b;
12423 }
12424 
12425 static __inline__ vector int __ATTRS_o_ai vec_vxor(vector int __a,
12426  vector bool int __b) {
12427  return __a ^ (vector int)__b;
12428 }
12429 
12430 static __inline__ vector unsigned int __ATTRS_o_ai
12431 vec_vxor(vector unsigned int __a, vector unsigned int __b) {
12432  return __a ^ __b;
12433 }
12434 
12435 static __inline__ vector unsigned int __ATTRS_o_ai
12436 vec_vxor(vector bool int __a, vector unsigned int __b) {
12437  return (vector unsigned int)__a ^ __b;
12438 }
12439 
12440 static __inline__ vector unsigned int __ATTRS_o_ai
12441 vec_vxor(vector unsigned int __a, vector bool int __b) {
12442  return __a ^ (vector unsigned int)__b;
12443 }
12444 
12445 static __inline__ vector bool int __ATTRS_o_ai vec_vxor(vector bool int __a,
12446  vector bool int __b) {
12447  return __a ^ __b;
12448 }
12449 
12450 static __inline__ vector float __ATTRS_o_ai vec_vxor(vector float __a,
12451  vector float __b) {
12452  vector unsigned int __res =
12453  (vector unsigned int)__a ^ (vector unsigned int)__b;
12454  return (vector float)__res;
12455 }
12456 
12457 static __inline__ vector float __ATTRS_o_ai vec_vxor(vector bool int __a,
12458  vector float __b) {
12459  vector unsigned int __res =
12460  (vector unsigned int)__a ^ (vector unsigned int)__b;
12461  return (vector float)__res;
12462 }
12463 
12464 static __inline__ vector float __ATTRS_o_ai vec_vxor(vector float __a,
12465  vector bool int __b) {
12466  vector unsigned int __res =
12467  (vector unsigned int)__a ^ (vector unsigned int)__b;
12468  return (vector float)__res;
12469 }
12470 
12471 #ifdef __VSX__
12472 static __inline__ vector signed long long __ATTRS_o_ai
12473 vec_vxor(vector signed long long __a, vector signed long long __b) {
12474  return __a ^ __b;
12475 }
12476 
12477 static __inline__ vector signed long long __ATTRS_o_ai
12478 vec_vxor(vector bool long long __a, vector signed long long __b) {
12479  return (vector signed long long)__a ^ __b;
12480 }
12481 
12482 static __inline__ vector signed long long __ATTRS_o_ai
12483 vec_vxor(vector signed long long __a, vector bool long long __b) {
12484  return __a ^ (vector signed long long)__b;
12485 }
12486 
12487 static __inline__ vector unsigned long long __ATTRS_o_ai
12488 vec_vxor(vector unsigned long long __a, vector unsigned long long __b) {
12489  return __a ^ __b;
12490 }
12491 
12492 static __inline__ vector unsigned long long __ATTRS_o_ai
12493 vec_vxor(vector bool long long __a, vector unsigned long long __b) {
12494  return (vector unsigned long long)__a ^ __b;
12495 }
12496 
12497 static __inline__ vector unsigned long long __ATTRS_o_ai
12498 vec_vxor(vector unsigned long long __a, vector bool long long __b) {
12499  return __a ^ (vector unsigned long long)__b;
12500 }
12501 
12502 static __inline__ vector bool long long __ATTRS_o_ai
12503 vec_vxor(vector bool long long __a, vector bool long long __b) {
12504  return __a ^ __b;
12505 }
12506 #endif
12507 
12508 /* ------------------------ extensions for CBEA ----------------------------- */
12509 
12510 /* vec_extract */
12511 
12512 static __inline__ signed char __ATTRS_o_ai vec_extract(vector signed char __a,
12513  int __b) {
12514  return __a[__b];
12515 }
12516 
12517 static __inline__ unsigned char __ATTRS_o_ai
12518 vec_extract(vector unsigned char __a, int __b) {
12519  return __a[__b];
12520 }
12521 
12522 static __inline__ unsigned char __ATTRS_o_ai vec_extract(vector bool char __a,
12523  int __b) {
12524  return __a[__b];
12525 }
12526 
12527 static __inline__ signed short __ATTRS_o_ai vec_extract(vector signed short __a,
12528  int __b) {
12529  return __a[__b];
12530 }
12531 
12532 static __inline__ unsigned short __ATTRS_o_ai
12533 vec_extract(vector unsigned short __a, int __b) {
12534  return __a[__b];
12535 }
12536 
12537 static __inline__ unsigned short __ATTRS_o_ai vec_extract(vector bool short __a,
12538  int __b) {
12539  return __a[__b];
12540 }
12541 
12542 static __inline__ signed int __ATTRS_o_ai vec_extract(vector signed int __a,
12543  int __b) {
12544  return __a[__b];
12545 }
12546 
12547 static __inline__ unsigned int __ATTRS_o_ai vec_extract(vector unsigned int __a,
12548  int __b) {
12549  return __a[__b];
12550 }
12551 
12552 static __inline__ unsigned int __ATTRS_o_ai vec_extract(vector bool int __a,
12553  int __b) {
12554  return __a[__b];
12555 }
12556 
12557 #ifdef __VSX__
12558 static __inline__ signed long long __ATTRS_o_ai
12559 vec_extract(vector signed long long __a, int __b) {
12560  return __a[__b];
12561 }
12562 
12563 static __inline__ unsigned long long __ATTRS_o_ai
12564 vec_extract(vector unsigned long long __a, int __b) {
12565  return __a[__b];
12566 }
12567 
12568 static __inline__ unsigned long long __ATTRS_o_ai
12569 vec_extract(vector bool long long __a, int __b) {
12570  return __a[__b];
12571 }
12572 
12573 static __inline__ double __ATTRS_o_ai vec_extract(vector double __a, int __b) {
12574  return __a[__b];
12575 }
12576 #endif
12577 
12578 static __inline__ float __ATTRS_o_ai vec_extract(vector float __a, int __b) {
12579  return __a[__b];
12580 }
12581 
12582 #ifdef __POWER9_VECTOR__
12583 
12584 #define vec_insert4b __builtin_vsx_insertword
12585 #define vec_extract4b __builtin_vsx_extractuword
12586 
12587 /* vec_extract_exp */
12588 
12589 static __inline__ vector unsigned int __ATTRS_o_ai
12590 vec_extract_exp(vector float __a) {
12591  return __builtin_vsx_xvxexpsp(__a);
12592 }
12593 
12594 static __inline__ vector unsigned long long __ATTRS_o_ai
12595 vec_extract_exp(vector double __a) {
12596  return __builtin_vsx_xvxexpdp(__a);
12597 }
12598 
12599 /* vec_extract_sig */
12600 
12601 static __inline__ vector unsigned int __ATTRS_o_ai
12602 vec_extract_sig(vector float __a) {
12603  return __builtin_vsx_xvxsigsp(__a);
12604 }
12605 
12606 static __inline__ vector unsigned long long __ATTRS_o_ai
12607 vec_extract_sig (vector double __a) {
12608  return __builtin_vsx_xvxsigdp(__a);
12609 }
12610 
12611 static __inline__ vector float __ATTRS_o_ai
12612 vec_extract_fp32_from_shorth(vector unsigned short __a) {
12613  vector unsigned short __b =
12614 #ifdef __LITTLE_ENDIAN__
12615  __builtin_shufflevector(__a, __a, 0, -1, 1, -1, 2, -1, 3, -1);
12616 #else
12617  __builtin_shufflevector(__a, __a, -1, 0, -1, 1, -1, 2, -1, 3);
12618 #endif
12619  return __builtin_vsx_xvcvhpsp(__b);
12620 }
12621 
12622 static __inline__ vector float __ATTRS_o_ai
12623 vec_extract_fp32_from_shortl(vector unsigned short __a) {
12624  vector unsigned short __b =
12625 #ifdef __LITTLE_ENDIAN__
12626  __builtin_shufflevector(__a, __a, 4, -1, 5, -1, 6, -1, 7, -1);
12627 #else
12628  __builtin_shufflevector(__a, __a, -1, 4, -1, 5, -1, 6, -1, 7);
12629 #endif
12630  return __builtin_vsx_xvcvhpsp(__b);
12631 }
12632 #endif /* __POWER9_VECTOR__ */
12633 
12634 /* vec_insert */
12635 
12636 static __inline__ vector signed char __ATTRS_o_ai
12637 vec_insert(signed char __a, vector signed char __b, int __c) {
12638  __b[__c] = __a;
12639  return __b;
12640 }
12641 
12642 static __inline__ vector unsigned char __ATTRS_o_ai
12643 vec_insert(unsigned char __a, vector unsigned char __b, int __c) {
12644  __b[__c] = __a;
12645  return __b;
12646 }
12647 
12648 static __inline__ vector bool char __ATTRS_o_ai vec_insert(unsigned char __a,
12649  vector bool char __b,
12650  int __c) {
12651  __b[__c] = __a;
12652  return __b;
12653 }
12654 
12655 static __inline__ vector signed short __ATTRS_o_ai
12656 vec_insert(signed short __a, vector signed short __b, int __c) {
12657  __b[__c] = __a;
12658  return __b;
12659 }
12660 
12661 static __inline__ vector unsigned short __ATTRS_o_ai
12662 vec_insert(unsigned short __a, vector unsigned short __b, int __c) {
12663  __b[__c] = __a;
12664  return __b;
12665 }
12666 
12667 static __inline__ vector bool short __ATTRS_o_ai
12668 vec_insert(unsigned short __a, vector bool short __b, int __c) {
12669  __b[__c] = __a;
12670  return __b;
12671 }
12672 
12673 static __inline__ vector signed int __ATTRS_o_ai
12674 vec_insert(signed int __a, vector signed int __b, int __c) {
12675  __b[__c] = __a;
12676  return __b;
12677 }
12678 
12679 static __inline__ vector unsigned int __ATTRS_o_ai
12680 vec_insert(unsigned int __a, vector unsigned int __b, int __c) {
12681  __b[__c] = __a;
12682  return __b;
12683 }
12684 
12685 static __inline__ vector bool int __ATTRS_o_ai vec_insert(unsigned int __a,
12686  vector bool int __b,
12687  int __c) {
12688  __b[__c] = __a;
12689  return __b;
12690 }
12691 
12692 #ifdef __VSX__
12693 static __inline__ vector signed long long __ATTRS_o_ai
12694 vec_insert(signed long long __a, vector signed long long __b, int __c) {
12695  __b[__c] = __a;
12696  return __b;
12697 }
12698 
12699 static __inline__ vector unsigned long long __ATTRS_o_ai
12700 vec_insert(unsigned long long __a, vector unsigned long long __b, int __c) {
12701  __b[__c] = __a;
12702  return __b;
12703 }
12704 
12705 static __inline__ vector bool long long __ATTRS_o_ai
12706 vec_insert(unsigned long long __a, vector bool long long __b, int __c) {
12707  __b[__c] = __a;
12708  return __b;
12709 }
12710 static __inline__ vector double __ATTRS_o_ai vec_insert(double __a,
12711  vector double __b,
12712  int __c) {
12713  __b[__c] = __a;
12714  return __b;
12715 }
12716 #endif
12717 
12718 static __inline__ vector float __ATTRS_o_ai vec_insert(float __a,
12719  vector float __b,
12720  int __c) {
12721  __b[__c] = __a;
12722  return __b;
12723 }
12724 
12725 /* vec_lvlx */
12726 
12727 static __inline__ vector signed char __ATTRS_o_ai
12728 vec_lvlx(int __a, const signed char *__b) {
12729  return vec_perm(vec_ld(__a, __b), (vector signed char)(0),
12730  vec_lvsl(__a, __b));
12731 }
12732 
12733 static __inline__ vector signed char __ATTRS_o_ai
12734 vec_lvlx(int __a, const vector signed char *__b) {
12735  return vec_perm(vec_ld(__a, __b), (vector signed char)(0),
12736  vec_lvsl(__a, (unsigned char *)__b));
12737 }
12738 
12739 static __inline__ vector unsigned char __ATTRS_o_ai
12740 vec_lvlx(int __a, const unsigned char *__b) {
12741  return vec_perm(vec_ld(__a, __b), (vector unsigned char)(0),
12742  vec_lvsl(__a, __b));
12743 }
12744 
12745 static __inline__ vector unsigned char __ATTRS_o_ai
12746 vec_lvlx(int __a, const vector unsigned char *__b) {
12747  return vec_perm(vec_ld(__a, __b), (vector unsigned char)(0),
12748  vec_lvsl(__a, (unsigned char *)__b));
12749 }
12750 
12751 static __inline__ vector bool char __ATTRS_o_ai
12752 vec_lvlx(int __a, const vector bool char *__b) {
12753  return vec_perm(vec_ld(__a, __b), (vector bool char)(0),
12754  vec_lvsl(__a, (unsigned char *)__b));
12755 }
12756 
12757 static __inline__ vector short __ATTRS_o_ai vec_lvlx(int __a,
12758  const short *__b) {
12759  return vec_perm(vec_ld(__a, __b), (vector short)(0), vec_lvsl(__a, __b));
12760 }
12761 
12762 static __inline__ vector short __ATTRS_o_ai vec_lvlx(int __a,
12763  const vector short *__b) {
12764  return vec_perm(vec_ld(__a, __b), (vector short)(0),
12765  vec_lvsl(__a, (unsigned char *)__b));
12766 }
12767 
12768 static __inline__ vector unsigned short __ATTRS_o_ai
12769 vec_lvlx(int __a, const unsigned short *__b) {
12770  return vec_perm(vec_ld(__a, __b), (vector unsigned short)(0),
12771  vec_lvsl(__a, __b));
12772 }
12773 
12774 static __inline__ vector unsigned short __ATTRS_o_ai
12775 vec_lvlx(int __a, const vector unsigned short *__b) {
12776  return vec_perm(vec_ld(__a, __b), (vector unsigned short)(0),
12777  vec_lvsl(__a, (unsigned char *)__b));
12778 }
12779 
12780 static __inline__ vector bool short __ATTRS_o_ai
12781 vec_lvlx(int __a, const vector bool short *__b) {
12782  return vec_perm(vec_ld(__a, __b), (vector bool short)(0),
12783  vec_lvsl(__a, (unsigned char *)__b));
12784 }
12785 
12786 static __inline__ vector pixel __ATTRS_o_ai vec_lvlx(int __a,
12787  const vector pixel *__b) {
12788  return vec_perm(vec_ld(__a, __b), (vector pixel)(0),
12789  vec_lvsl(__a, (unsigned char *)__b));
12790 }
12791 
12792 static __inline__ vector int __ATTRS_o_ai vec_lvlx(int __a, const int *__b) {
12793  return vec_perm(vec_ld(__a, __b), (vector int)(0), vec_lvsl(__a, __b));
12794 }
12795 
12796 static __inline__ vector int __ATTRS_o_ai vec_lvlx(int __a,
12797  const vector int *__b) {
12798  return vec_perm(vec_ld(__a, __b), (vector int)(0),
12799  vec_lvsl(__a, (unsigned char *)__b));
12800 }
12801 
12802 static __inline__ vector unsigned int __ATTRS_o_ai
12803 vec_lvlx(int __a, const unsigned int *__b) {
12804  return vec_perm(vec_ld(__a, __b), (vector unsigned int)(0),
12805  vec_lvsl(__a, __b));
12806 }
12807 
12808 static __inline__ vector unsigned int __ATTRS_o_ai
12809 vec_lvlx(int __a, const vector unsigned int *__b) {
12810  return vec_perm(vec_ld(__a, __b), (vector unsigned int)(0),
12811  vec_lvsl(__a, (unsigned char *)__b));
12812 }
12813 
12814 static __inline__ vector bool int __ATTRS_o_ai
12815 vec_lvlx(int __a, const vector bool int *__b) {
12816  return vec_perm(vec_ld(__a, __b), (vector bool int)(0),
12817  vec_lvsl(__a, (unsigned char *)__b));
12818 }
12819 
12820 static __inline__ vector float __ATTRS_o_ai vec_lvlx(int __a,
12821  const float *__b) {
12822  return vec_perm(vec_ld(__a, __b), (vector float)(0), vec_lvsl(__a, __b));
12823 }
12824 
12825 static __inline__ vector float __ATTRS_o_ai vec_lvlx(int __a,
12826  const vector float *__b) {
12827  return vec_perm(vec_ld(__a, __b), (vector float)(0),
12828  vec_lvsl(__a, (unsigned char *)__b));
12829 }
12830 
12831 /* vec_lvlxl */
12832 
12833 static __inline__ vector signed char __ATTRS_o_ai
12834 vec_lvlxl(int __a, const signed char *__b) {
12835  return vec_perm(vec_ldl(__a, __b), (vector signed char)(0),
12836  vec_lvsl(__a, __b));
12837 }
12838 
12839 static __inline__ vector signed char __ATTRS_o_ai
12840 vec_lvlxl(int __a, const vector signed char *__b) {
12841  return vec_perm(vec_ldl(__a, __b), (vector signed char)(0),
12842  vec_lvsl(__a, (unsigned char *)__b));
12843 }
12844 
12845 static __inline__ vector unsigned char __ATTRS_o_ai
12846 vec_lvlxl(int __a, const unsigned char *__b) {
12847  return vec_perm(vec_ldl(__a, __b), (vector unsigned char)(0),
12848  vec_lvsl(__a, __b));
12849 }
12850 
12851 static __inline__ vector unsigned char __ATTRS_o_ai
12852 vec_lvlxl(int __a, const vector unsigned char *__b) {
12853  return vec_perm(vec_ldl(__a, __b), (vector unsigned char)(0),
12854  vec_lvsl(__a, (unsigned char *)__b));
12855 }
12856 
12857 static __inline__ vector bool char __ATTRS_o_ai
12858 vec_lvlxl(int __a, const vector bool char *__b) {
12859  return vec_perm(vec_ldl(__a, __b), (vector bool char)(0),
12860  vec_lvsl(__a, (unsigned char *)__b));
12861 }
12862 
12863 static __inline__ vector short __ATTRS_o_ai vec_lvlxl(int __a,
12864  const short *__b) {
12865  return vec_perm(vec_ldl(__a, __b), (vector short)(0), vec_lvsl(__a, __b));
12866 }
12867 
12868 static __inline__ vector short __ATTRS_o_ai vec_lvlxl(int __a,
12869  const vector short *__b) {
12870  return vec_perm(vec_ldl(__a, __b), (vector short)(0),
12871  vec_lvsl(__a, (unsigned char *)__b));
12872 }
12873 
12874 static __inline__ vector unsigned short __ATTRS_o_ai
12875 vec_lvlxl(int __a, const unsigned short *__b) {
12876  return vec_perm(vec_ldl(__a, __b), (vector unsigned short)(0),
12877  vec_lvsl(__a, __b));
12878 }
12879 
12880 static __inline__ vector unsigned short __ATTRS_o_ai
12881 vec_lvlxl(int __a, const vector unsigned short *__b) {
12882  return vec_perm(vec_ldl(__a, __b), (vector unsigned short)(0),
12883  vec_lvsl(__a, (unsigned char *)__b));
12884 }
12885 
12886 static __inline__ vector bool short __ATTRS_o_ai
12887 vec_lvlxl(int __a, const vector bool short *__b) {
12888  return vec_perm(vec_ldl(__a, __b), (vector bool short)(0),
12889  vec_lvsl(__a, (unsigned char *)__b));
12890 }
12891 
12892 static __inline__ vector pixel __ATTRS_o_ai vec_lvlxl(int __a,
12893  const vector pixel *__b) {
12894  return vec_perm(vec_ldl(__a, __b), (vector pixel)(0),
12895  vec_lvsl(__a, (unsigned char *)__b));
12896 }
12897 
12898 static __inline__ vector int __ATTRS_o_ai vec_lvlxl(int __a, const int *__b) {
12899  return vec_perm(vec_ldl(__a, __b), (vector int)(0), vec_lvsl(__a, __b));
12900 }
12901 
12902 static __inline__ vector int __ATTRS_o_ai vec_lvlxl(int __a,
12903  const vector int *__b) {
12904  return vec_perm(vec_ldl(__a, __b), (vector int)(0),
12905  vec_lvsl(__a, (unsigned char *)__b));
12906 }
12907 
12908 static __inline__ vector unsigned int __ATTRS_o_ai
12909 vec_lvlxl(int __a, const unsigned int *__b) {
12910  return vec_perm(vec_ldl(__a, __b), (vector unsigned int)(0),
12911  vec_lvsl(__a, __b));
12912 }
12913 
12914 static __inline__ vector unsigned int __ATTRS_o_ai
12915 vec_lvlxl(int __a, const vector unsigned int *__b) {
12916  return vec_perm(vec_ldl(__a, __b), (vector unsigned int)(0),
12917  vec_lvsl(__a, (unsigned char *)__b));
12918 }
12919 
12920 static __inline__ vector bool int __ATTRS_o_ai
12921 vec_lvlxl(int __a, const vector bool int *__b) {
12922  return vec_perm(vec_ldl(__a, __b), (vector bool int)(0),
12923  vec_lvsl(__a, (unsigned char *)__b));
12924 }
12925 
12926 static __inline__ vector float __ATTRS_o_ai vec_lvlxl(int __a,
12927  const float *__b) {
12928  return vec_perm(vec_ldl(__a, __b), (vector float)(0), vec_lvsl(__a, __b));
12929 }
12930 
12931 static __inline__ vector float __ATTRS_o_ai vec_lvlxl(int __a,
12932  vector float *__b) {
12933  return vec_perm(vec_ldl(__a, __b), (vector float)(0),
12934  vec_lvsl(__a, (unsigned char *)__b));
12935 }
12936 
12937 /* vec_lvrx */
12938 
12939 static __inline__ vector signed char __ATTRS_o_ai
12940 vec_lvrx(int __a, const signed char *__b) {
12941  return vec_perm((vector signed char)(0), vec_ld(__a, __b),
12942  vec_lvsl(__a, __b));
12943 }
12944 
12945 static __inline__ vector signed char __ATTRS_o_ai
12946 vec_lvrx(int __a, const vector signed char *__b) {
12947  return vec_perm((vector signed char)(0), vec_ld(__a, __b),
12948  vec_lvsl(__a, (unsigned char *)__b));
12949 }
12950 
12951 static __inline__ vector unsigned char __ATTRS_o_ai
12952 vec_lvrx(int __a, const unsigned char *__b) {
12953  return vec_perm((vector unsigned char)(0), vec_ld(__a, __b),
12954  vec_lvsl(__a, __b));
12955 }
12956 
12957 static __inline__ vector unsigned char __ATTRS_o_ai
12958 vec_lvrx(int __a, const vector unsigned char *__b) {
12959  return vec_perm((vector unsigned char)(0), vec_ld(__a, __b),
12960  vec_lvsl(__a, (unsigned char *)__b));
12961 }
12962 
12963 static __inline__ vector bool char __ATTRS_o_ai
12964 vec_lvrx(int __a, const vector bool char *__b) {
12965  return vec_perm((vector bool char)(0), vec_ld(__a, __b),
12966  vec_lvsl(__a, (unsigned char *)__b));
12967 }
12968 
12969 static __inline__ vector short __ATTRS_o_ai vec_lvrx(int __a,
12970  const short *__b) {
12971  return vec_perm((vector short)(0), vec_ld(__a, __b), vec_lvsl(__a, __b));
12972 }
12973 
12974 static __inline__ vector short __ATTRS_o_ai vec_lvrx(int __a,
12975  const vector short *__b) {
12976  return vec_perm((vector short)(0), vec_ld(__a, __b),
12977  vec_lvsl(__a, (unsigned char *)__b));
12978 }
12979 
12980 static __inline__ vector unsigned short __ATTRS_o_ai
12981 vec_lvrx(int __a, const unsigned short *__b) {
12982  return vec_perm((vector unsigned short)(0), vec_ld(__a, __b),
12983  vec_lvsl(__a, __b));
12984 }
12985 
12986 static __inline__ vector unsigned short __ATTRS_o_ai
12987 vec_lvrx(int __a, const vector unsigned short *__b) {
12988  return vec_perm((vector unsigned short)(0), vec_ld(__a, __b),
12989  vec_lvsl(__a, (unsigned char *)__b));
12990 }
12991 
12992 static __inline__ vector bool short __ATTRS_o_ai
12993 vec_lvrx(int __a, const vector bool short *__b) {
12994  return vec_perm((vector bool short)(0), vec_ld(__a, __b),
12995  vec_lvsl(__a, (unsigned char *)__b));
12996 }
12997 
12998 static __inline__ vector pixel __ATTRS_o_ai vec_lvrx(int __a,
12999  const vector pixel *__b) {
13000  return vec_perm((vector pixel)(0), vec_ld(__a, __b),
13001  vec_lvsl(__a, (unsigned char *)__b));
13002 }
13003 
13004 static __inline__ vector int __ATTRS_o_ai vec_lvrx(int __a, const int *__b) {
13005  return vec_perm((vector int)(0), vec_ld(__a, __b), vec_lvsl(__a, __b));
13006 }
13007 
13008 static __inline__ vector int __ATTRS_o_ai vec_lvrx(int __a,
13009  const vector int *__b) {
13010  return vec_perm((vector int)(0), vec_ld(__a, __b),
13011  vec_lvsl(__a, (unsigned char *)__b));
13012 }
13013 
13014 static __inline__ vector unsigned int __ATTRS_o_ai
13015 vec_lvrx(int __a, const unsigned int *__b) {
13016  return vec_perm((vector unsigned int)(0), vec_ld(__a, __b),
13017  vec_lvsl(__a, __b));
13018 }
13019 
13020 static __inline__ vector unsigned int __ATTRS_o_ai
13021 vec_lvrx(int __a, const vector unsigned int *__b) {
13022  return vec_perm((vector unsigned int)(0), vec_ld(__a, __b),
13023  vec_lvsl(__a, (unsigned char *)__b));
13024 }
13025 
13026 static __inline__ vector bool int __ATTRS_o_ai
13027 vec_lvrx(int __a, const vector bool int *__b) {
13028  return vec_perm((vector bool int)(0), vec_ld(__a, __b),
13029  vec_lvsl(__a, (unsigned char *)__b));
13030 }
13031 
13032 static __inline__ vector float __ATTRS_o_ai vec_lvrx(int __a,
13033  const float *__b) {
13034  return vec_perm((vector float)(0), vec_ld(__a, __b), vec_lvsl(__a, __b));
13035 }
13036 
13037 static __inline__ vector float __ATTRS_o_ai vec_lvrx(int __a,
13038  const vector float *__b) {
13039  return vec_perm((vector float)(0), vec_ld(__a, __b),
13040  vec_lvsl(__a, (unsigned char *)__b));
13041 }
13042 
13043 /* vec_lvrxl */
13044 
13045 static __inline__ vector signed char __ATTRS_o_ai
13046 vec_lvrxl(int __a, const signed char *__b) {
13047  return vec_perm((vector signed char)(0), vec_ldl(__a, __b),
13048  vec_lvsl(__a, __b));
13049 }
13050 
13051 static __inline__ vector signed char __ATTRS_o_ai
13052 vec_lvrxl(int __a, const vector signed char *__b) {
13053  return vec_perm((vector signed char)(0), vec_ldl(__a, __b),
13054  vec_lvsl(__a, (unsigned char *)__b));
13055 }
13056 
13057 static __inline__ vector unsigned char __ATTRS_o_ai
13058 vec_lvrxl(int __a, const unsigned char *__b) {
13059  return vec_perm((vector unsigned char)(0), vec_ldl(__a, __b),
13060  vec_lvsl(__a, __b));
13061 }
13062 
13063 static __inline__ vector unsigned char __ATTRS_o_ai
13064 vec_lvrxl(int __a, const vector unsigned char *__b) {
13065  return vec_perm((vector unsigned char)(0), vec_ldl(__a, __b),
13066  vec_lvsl(__a, (unsigned char *)__b));
13067 }
13068 
13069 static __inline__ vector bool char __ATTRS_o_ai
13070 vec_lvrxl(int __a, const vector bool char *__b) {
13071  return vec_perm((vector bool char)(0), vec_ldl(__a, __b),
13072  vec_lvsl(__a, (unsigned char *)__b));
13073 }
13074 
13075 static __inline__ vector short __ATTRS_o_ai vec_lvrxl(int __a,
13076  const short *__b) {
13077  return vec_perm((vector short)(0), vec_ldl(__a, __b), vec_lvsl(__a, __b));
13078 }
13079 
13080 static __inline__ vector short __ATTRS_o_ai vec_lvrxl(int __a,
13081  const vector short *__b) {
13082  return vec_perm((vector short)(0), vec_ldl(__a, __b),
13083  vec_lvsl(__a, (unsigned char *)__b));
13084 }
13085 
13086 static __inline__ vector unsigned short __ATTRS_o_ai
13087 vec_lvrxl(int __a, const unsigned short *__b) {
13088  return vec_perm((vector unsigned short)(0), vec_ldl(__a, __b),
13089  vec_lvsl(__a, __b));
13090 }
13091 
13092 static __inline__ vector unsigned short __ATTRS_o_ai
13093 vec_lvrxl(int __a, const vector unsigned short *__b) {
13094  return vec_perm((vector unsigned short)(0), vec_ldl(__a, __b),
13095  vec_lvsl(__a, (unsigned char *)__b));
13096 }
13097 
13098 static __inline__ vector bool short __ATTRS_o_ai
13099 vec_lvrxl(int __a, const vector bool short *__b) {
13100  return vec_perm((vector bool short)(0), vec_ldl(__a, __b),
13101  vec_lvsl(__a, (unsigned char *)__b));
13102 }
13103 
13104 static __inline__ vector pixel __ATTRS_o_ai vec_lvrxl(int __a,
13105  const vector pixel *__b) {
13106  return vec_perm((vector pixel)(0), vec_ldl(__a, __b),
13107  vec_lvsl(__a, (unsigned char *)__b));
13108 }
13109 
13110 static __inline__ vector int __ATTRS_o_ai vec_lvrxl(int __a, const int *__b) {
13111  return vec_perm((vector int)(0), vec_ldl(__a, __b), vec_lvsl(__a, __b));
13112 }
13113 
13114 static __inline__ vector int __ATTRS_o_ai vec_lvrxl(int __a,
13115  const vector int *__b) {
13116  return vec_perm((vector int)(0), vec_ldl(__a, __b),
13117  vec_lvsl(__a, (unsigned char *)__b));
13118 }
13119 
13120 static __inline__ vector unsigned int __ATTRS_o_ai
13121 vec_lvrxl(int __a, const unsigned int *__b) {
13122  return vec_perm((vector unsigned int)(0), vec_ldl(__a, __b),
13123  vec_lvsl(__a, __b));
13124 }
13125 
13126 static __inline__ vector unsigned int __ATTRS_o_ai
13127 vec_lvrxl(int __a, const vector unsigned int *__b) {
13128  return vec_perm((vector unsigned int)(0), vec_ldl(__a, __b),
13129  vec_lvsl(__a, (unsigned char *)__b));
13130 }
13131 
13132 static __inline__ vector bool int __ATTRS_o_ai
13133 vec_lvrxl(int __a, const vector bool int *__b) {
13134  return vec_perm((vector bool int)(0), vec_ldl(__a, __b),
13135  vec_lvsl(__a, (unsigned char *)__b));
13136 }
13137 
13138 static __inline__ vector float __ATTRS_o_ai vec_lvrxl(int __a,
13139  const float *__b) {
13140  return vec_perm((vector float)(0), vec_ldl(__a, __b), vec_lvsl(__a, __b));
13141 }
13142 
13143 static __inline__ vector float __ATTRS_o_ai vec_lvrxl(int __a,
13144  const vector float *__b) {
13145  return vec_perm((vector float)(0), vec_ldl(__a, __b),
13146  vec_lvsl(__a, (unsigned char *)__b));
13147 }
13148 
13149 /* vec_stvlx */
13150 
13151 static __inline__ void __ATTRS_o_ai vec_stvlx(vector signed char __a, int __b,
13152  signed char *__c) {
13153  return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13154  __c);
13155 }
13156 
13157 static __inline__ void __ATTRS_o_ai vec_stvlx(vector signed char __a, int __b,
13158  vector signed char *__c) {
13159  return vec_st(
13160  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13161  __b, __c);
13162 }
13163 
13164 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned char __a, int __b,
13165  unsigned char *__c) {
13166  return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13167  __c);
13168 }
13169 
13170 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned char __a, int __b,
13171  vector unsigned char *__c) {
13172  return vec_st(
13173  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13174  __b, __c);
13175 }
13176 
13177 static __inline__ void __ATTRS_o_ai vec_stvlx(vector bool char __a, int __b,
13178  vector bool char *__c) {
13179  return vec_st(
13180  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13181  __b, __c);
13182 }
13183 
13184 static __inline__ void __ATTRS_o_ai vec_stvlx(vector short __a, int __b,
13185  short *__c) {
13186  return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13187  __c);
13188 }
13189 
13190 static __inline__ void __ATTRS_o_ai vec_stvlx(vector short __a, int __b,
13191  vector short *__c) {
13192  return vec_st(
13193  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13194  __b, __c);
13195 }
13196 
13197 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned short __a,
13198  int __b, unsigned short *__c) {
13199  return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13200  __c);
13201 }
13202 
13203 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned short __a,
13204  int __b,
13205  vector unsigned short *__c) {
13206  return vec_st(
13207  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13208  __b, __c);
13209 }
13210 
13211 static __inline__ void __ATTRS_o_ai vec_stvlx(vector bool short __a, int __b,
13212  vector bool short *__c) {
13213  return vec_st(
13214  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13215  __b, __c);
13216 }
13217 
13218 static __inline__ void __ATTRS_o_ai vec_stvlx(vector pixel __a, int __b,
13219  vector pixel *__c) {
13220  return vec_st(
13221  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13222  __b, __c);
13223 }
13224 
13225 static __inline__ void __ATTRS_o_ai vec_stvlx(vector int __a, int __b,
13226  int *__c) {
13227  return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13228  __c);
13229 }
13230 
13231 static __inline__ void __ATTRS_o_ai vec_stvlx(vector int __a, int __b,
13232  vector int *__c) {
13233  return vec_st(
13234  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13235  __b, __c);
13236 }
13237 
13238 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned int __a, int __b,
13239  unsigned int *__c) {
13240  return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13241  __c);
13242 }
13243 
13244 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned int __a, int __b,
13245  vector unsigned int *__c) {
13246  return vec_st(
13247  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13248  __b, __c);
13249 }
13250 
13251 static __inline__ void __ATTRS_o_ai vec_stvlx(vector bool int __a, int __b,
13252  vector bool int *__c) {
13253  return vec_st(
13254  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13255  __b, __c);
13256 }
13257 
13258 static __inline__ void __ATTRS_o_ai vec_stvlx(vector float __a, int __b,
13259  vector float *__c) {
13260  return vec_st(
13261  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13262  __b, __c);
13263 }
13264 
13265 /* vec_stvlxl */
13266 
13267 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector signed char __a, int __b,
13268  signed char *__c) {
13269  return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13270  __c);
13271 }
13272 
13273 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector signed char __a, int __b,
13274  vector signed char *__c) {
13275  return vec_stl(
13276  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13277  __b, __c);
13278 }
13279 
13280 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned char __a,
13281  int __b, unsigned char *__c) {
13282  return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13283  __c);
13284 }
13285 
13286 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned char __a,
13287  int __b,
13288  vector unsigned char *__c) {
13289  return vec_stl(
13290  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13291  __b, __c);
13292 }
13293 
13294 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector bool char __a, int __b,
13295  vector bool char *__c) {
13296  return vec_stl(
13297  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13298  __b, __c);
13299 }
13300 
13301 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector short __a, int __b,
13302  short *__c) {
13303  return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13304  __c);
13305 }
13306 
13307 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector short __a, int __b,
13308  vector short *__c) {
13309  return vec_stl(
13310  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13311  __b, __c);
13312 }
13313 
13314 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned short __a,
13315  int __b, unsigned short *__c) {
13316  return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13317  __c);
13318 }
13319 
13320 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned short __a,
13321  int __b,
13322  vector unsigned short *__c) {
13323  return vec_stl(
13324  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13325  __b, __c);
13326 }
13327 
13328 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector bool short __a, int __b,
13329  vector bool short *__c) {
13330  return vec_stl(
13331  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13332  __b, __c);
13333 }
13334 
13335 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector pixel __a, int __b,
13336  vector pixel *__c) {
13337  return vec_stl(
13338  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13339  __b, __c);
13340 }
13341 
13342 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector int __a, int __b,
13343  int *__c) {
13344  return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13345  __c);
13346 }
13347 
13348 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector int __a, int __b,
13349  vector int *__c) {
13350  return vec_stl(
13351  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13352  __b, __c);
13353 }
13354 
13355 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned int __a, int __b,
13356  unsigned int *__c) {
13357  return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13358  __c);
13359 }
13360 
13361 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned int __a, int __b,
13362  vector unsigned int *__c) {
13363  return vec_stl(
13364  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13365  __b, __c);
13366 }
13367 
13368 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector bool int __a, int __b,
13369  vector bool int *__c) {
13370  return vec_stl(
13371  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13372  __b, __c);
13373 }
13374 
13375 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector float __a, int __b,
13376  vector float *__c) {
13377  return vec_stl(
13378  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13379  __b, __c);
13380 }
13381 
13382 /* vec_stvrx */
13383 
13384 static __inline__ void __ATTRS_o_ai vec_stvrx(vector signed char __a, int __b,
13385  signed char *__c) {
13386  return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13387  __c);
13388 }
13389 
13390 static __inline__ void __ATTRS_o_ai vec_stvrx(vector signed char __a, int __b,
13391  vector signed char *__c) {
13392  return vec_st(
13393  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13394  __b, __c);
13395 }
13396 
13397 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned char __a, int __b,
13398  unsigned char *__c) {
13399  return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13400  __c);
13401 }
13402 
13403 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned char __a, int __b,
13404  vector unsigned char *__c) {
13405  return vec_st(
13406  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13407  __b, __c);
13408 }
13409 
13410 static __inline__ void __ATTRS_o_ai vec_stvrx(vector bool char __a, int __b,
13411  vector bool char *__c) {
13412  return vec_st(
13413  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13414  __b, __c);
13415 }
13416 
13417 static __inline__ void __ATTRS_o_ai vec_stvrx(vector short __a, int __b,
13418  short *__c) {
13419  return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13420  __c);
13421 }
13422 
13423 static __inline__ void __ATTRS_o_ai vec_stvrx(vector short __a, int __b,
13424  vector short *__c) {
13425  return vec_st(
13426  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13427  __b, __c);
13428 }
13429 
13430 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned short __a,
13431  int __b, unsigned short *__c) {
13432  return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13433  __c);
13434 }
13435 
13436 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned short __a,
13437  int __b,
13438  vector unsigned short *__c) {
13439  return vec_st(
13440  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13441  __b, __c);
13442 }
13443 
13444 static __inline__ void __ATTRS_o_ai vec_stvrx(vector bool short __a, int __b,
13445  vector bool short *__c) {
13446  return vec_st(
13447  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13448  __b, __c);
13449 }
13450 
13451 static __inline__ void __ATTRS_o_ai vec_stvrx(vector pixel __a, int __b,
13452  vector pixel *__c) {
13453  return vec_st(
13454  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13455  __b, __c);
13456 }
13457 
13458 static __inline__ void __ATTRS_o_ai vec_stvrx(vector int __a, int __b,
13459  int *__c) {
13460  return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13461  __c);
13462 }
13463 
13464 static __inline__ void __ATTRS_o_ai vec_stvrx(vector int __a, int __b,
13465  vector int *__c) {
13466  return vec_st(
13467  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13468  __b, __c);
13469 }
13470 
13471 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned int __a, int __b,
13472  unsigned int *__c) {
13473  return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13474  __c);
13475 }
13476 
13477 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned int __a, int __b,
13478  vector unsigned int *__c) {
13479  return vec_st(
13480  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13481  __b, __c);
13482 }
13483 
13484 static __inline__ void __ATTRS_o_ai vec_stvrx(vector bool int __a, int __b,
13485  vector bool int *__c) {
13486  return vec_st(
13487  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13488  __b, __c);
13489 }
13490 
13491 static __inline__ void __ATTRS_o_ai vec_stvrx(vector float __a, int __b,
13492  vector float *__c) {
13493  return vec_st(
13494  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13495  __b, __c);
13496 }
13497 
13498 /* vec_stvrxl */
13499 
13500 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector signed char __a, int __b,
13501  signed char *__c) {
13502  return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13503  __c);
13504 }
13505 
13506 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector signed char __a, int __b,
13507  vector signed char *__c) {
13508  return vec_stl(
13509  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13510  __b, __c);
13511 }
13512 
13513 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned char __a,
13514  int __b, unsigned char *__c) {
13515  return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13516  __c);
13517 }
13518 
13519 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned char __a,
13520  int __b,
13521  vector unsigned char *__c) {
13522  return vec_stl(
13523  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13524  __b, __c);
13525 }
13526 
13527 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector bool char __a, int __b,
13528  vector bool char *__c) {
13529  return vec_stl(
13530  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13531  __b, __c);
13532 }
13533 
13534 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector short __a, int __b,
13535  short *__c) {
13536  return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13537  __c);
13538 }
13539 
13540 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector short __a, int __b,
13541  vector short *__c) {
13542  return vec_stl(
13543  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13544  __b, __c);
13545 }
13546 
13547 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned short __a,
13548  int __b, unsigned short *__c) {
13549  return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13550  __c);
13551 }
13552 
13553 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned short __a,
13554  int __b,
13555  vector unsigned short *__c) {
13556  return vec_stl(
13557  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13558  __b, __c);
13559 }
13560 
13561 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector bool short __a, int __b,
13562  vector bool short *__c) {
13563  return vec_stl(
13564  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13565  __b, __c);
13566 }
13567 
13568 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector pixel __a, int __b,
13569  vector pixel *__c) {
13570  return vec_stl(
13571  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13572  __b, __c);
13573 }
13574 
13575 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector int __a, int __b,
13576  int *__c) {
13577  return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13578  __c);
13579 }
13580 
13581 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector int __a, int __b,
13582  vector int *__c) {
13583  return vec_stl(
13584  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13585  __b, __c);
13586 }
13587 
13588 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned int __a, int __b,
13589  unsigned int *__c) {
13590  return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13591  __c);
13592 }
13593 
13594 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned int __a, int __b,
13595  vector unsigned int *__c) {
13596  return vec_stl(
13597  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13598  __b, __c);
13599 }
13600 
13601 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector bool int __a, int __b,
13602  vector bool int *__c) {
13603  return vec_stl(
13604  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13605  __b, __c);
13606 }
13607 
13608 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector float __a, int __b,
13609  vector float *__c) {
13610  return vec_stl(
13611  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13612  __b, __c);
13613 }
13614 
13615 /* vec_promote */
13616 
13617 static __inline__ vector signed char __ATTRS_o_ai vec_promote(signed char __a,
13618  int __b) {
13619  vector signed char __res = (vector signed char)(0);
13620  __res[__b] = __a;
13621  return __res;
13622 }
13623 
13624 static __inline__ vector unsigned char __ATTRS_o_ai
13625 vec_promote(unsigned char __a, int __b) {
13626  vector unsigned char __res = (vector unsigned char)(0);
13627  __res[__b] = __a;
13628  return __res;
13629 }
13630 
13631 static __inline__ vector short __ATTRS_o_ai vec_promote(short __a, int __b) {
13632  vector short __res = (vector short)(0);
13633  __res[__b] = __a;
13634  return __res;
13635 }
13636 
13637 static __inline__ vector unsigned short __ATTRS_o_ai
13638 vec_promote(unsigned short __a, int __b) {
13639  vector unsigned short __res = (vector unsigned short)(0);
13640  __res[__b] = __a;
13641  return __res;
13642 }
13643 
13644 static __inline__ vector int __ATTRS_o_ai vec_promote(int __a, int __b) {
13645  vector int __res = (vector int)(0);
13646  __res[__b] = __a;
13647  return __res;
13648 }
13649 
13650 static __inline__ vector unsigned int __ATTRS_o_ai vec_promote(unsigned int __a,
13651  int __b) {
13652  vector unsigned int __res = (vector unsigned int)(0);
13653  __res[__b] = __a;
13654  return __res;
13655 }
13656 
13657 static __inline__ vector float __ATTRS_o_ai vec_promote(float __a, int __b) {
13658  vector float __res = (vector float)(0);
13659  __res[__b] = __a;
13660  return __res;
13661 }
13662 
13663 /* vec_splats */
13664 
13665 static __inline__ vector signed char __ATTRS_o_ai vec_splats(signed char __a) {
13666  return (vector signed char)(__a);
13667 }
13668 
13669 static __inline__ vector unsigned char __ATTRS_o_ai
13670 vec_splats(unsigned char __a) {
13671  return (vector unsigned char)(__a);
13672 }
13673 
13674 static __inline__ vector short __ATTRS_o_ai vec_splats(short __a) {
13675  return (vector short)(__a);
13676 }
13677 
13678 static __inline__ vector unsigned short __ATTRS_o_ai
13679 vec_splats(unsigned short __a) {
13680  return (vector unsigned short)(__a);
13681 }
13682 
13683 static __inline__ vector int __ATTRS_o_ai vec_splats(int __a) {
13684  return (vector int)(__a);
13685 }
13686 
13687 static __inline__ vector unsigned int __ATTRS_o_ai
13688 vec_splats(unsigned int __a) {
13689  return (vector unsigned int)(__a);
13690 }
13691 
13692 #ifdef __VSX__
13693 static __inline__ vector signed long long __ATTRS_o_ai
13694 vec_splats(signed long long __a) {
13695  return (vector signed long long)(__a);
13696 }
13697 
13698 static __inline__ vector unsigned long long __ATTRS_o_ai
13699 vec_splats(unsigned long long __a) {
13700  return (vector unsigned long long)(__a);
13701 }
13702 
13703 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
13704 static __inline__ vector signed __int128 __ATTRS_o_ai
13705 vec_splats(signed __int128 __a) {
13706  return (vector signed __int128)(__a);
13707 }
13708 
13709 static __inline__ vector unsigned __int128 __ATTRS_o_ai
13710 vec_splats(unsigned __int128 __a) {
13711  return (vector unsigned __int128)(__a);
13712 }
13713 
13714 #endif
13715 
13716 static __inline__ vector double __ATTRS_o_ai vec_splats(double __a) {
13717  return (vector double)(__a);
13718 }
13719 #endif
13720 
13721 static __inline__ vector float __ATTRS_o_ai vec_splats(float __a) {
13722  return (vector float)(__a);
13723 }
13724 
13725 /* ----------------------------- predicates --------------------------------- */
13726 
13727 /* vec_all_eq */
13728 
13729 static __inline__ int __ATTRS_o_ai vec_all_eq(vector signed char __a,
13730  vector signed char __b) {
13731  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
13732  (vector char)__b);
13733 }
13734 
13735 static __inline__ int __ATTRS_o_ai vec_all_eq(vector signed char __a,
13736  vector bool char __b) {
13737  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
13738  (vector char)__b);
13739 }
13740 
13741 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned char __a,
13742  vector unsigned char __b) {
13743  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
13744  (vector char)__b);
13745 }
13746 
13747 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned char __a,
13748  vector bool char __b) {
13749  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
13750  (vector char)__b);
13751 }
13752 
13753 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool char __a,
13754  vector signed char __b) {
13755  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
13756  (vector char)__b);
13757 }
13758 
13759 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool char __a,
13760  vector unsigned char __b) {
13761  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
13762  (vector char)__b);
13763 }
13764 
13765 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool char __a,
13766  vector bool char __b) {
13767  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
13768  (vector char)__b);
13769 }
13770 
13771 static __inline__ int __ATTRS_o_ai vec_all_eq(vector short __a,
13772  vector short __b) {
13773  return __builtin_altivec_vcmpequh_p(__CR6_LT, __a, __b);
13774 }
13775 
13776 static __inline__ int __ATTRS_o_ai vec_all_eq(vector short __a,
13777  vector bool short __b) {
13778  return __builtin_altivec_vcmpequh_p(__CR6_LT, __a, (vector short)__b);
13779 }
13780 
13781 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned short __a,
13782  vector unsigned short __b) {
13783  return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
13784  (vector short)__b);
13785 }
13786 
13787 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned short __a,
13788  vector bool short __b) {
13789  return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
13790  (vector short)__b);
13791 }
13792 
13793 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool short __a,
13794  vector short __b) {
13795  return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
13796  (vector short)__b);
13797 }
13798 
13799 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool short __a,
13800  vector unsigned short __b) {
13801  return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
13802  (vector short)__b);
13803 }
13804 
13805 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool short __a,
13806  vector bool short __b) {
13807  return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
13808  (vector short)__b);
13809 }
13810 
13811 static __inline__ int __ATTRS_o_ai vec_all_eq(vector pixel __a,
13812  vector pixel __b) {
13813  return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
13814  (vector short)__b);
13815 }
13816 
13817 static __inline__ int __ATTRS_o_ai vec_all_eq(vector int __a, vector int __b) {
13818  return __builtin_altivec_vcmpequw_p(__CR6_LT, __a, __b);
13819 }
13820 
13821 static __inline__ int __ATTRS_o_ai vec_all_eq(vector int __a,
13822  vector bool int __b) {
13823  return __builtin_altivec_vcmpequw_p(__CR6_LT, __a, (vector int)__b);
13824 }
13825 
13826 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned int __a,
13827  vector unsigned int __b) {
13828  return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
13829  (vector int)__b);
13830 }
13831 
13832 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned int __a,
13833  vector bool int __b) {
13834  return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
13835  (vector int)__b);
13836 }
13837 
13838 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool int __a,
13839  vector int __b) {
13840  return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
13841  (vector int)__b);
13842 }
13843 
13844 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool int __a,
13845  vector unsigned int __b) {
13846  return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
13847  (vector int)__b);
13848 }
13849 
13850 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool int __a,
13851  vector bool int __b) {
13852  return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
13853  (vector int)__b);
13854 }
13855 
13856 #ifdef __POWER8_VECTOR__
13857 static __inline__ int __ATTRS_o_ai vec_all_eq(vector signed long long __a,
13858  vector signed long long __b) {
13859  return __builtin_altivec_vcmpequd_p(__CR6_LT, __a, __b);
13860 }
13861 
13862 static __inline__ int __ATTRS_o_ai vec_all_eq(vector long long __a,
13863  vector bool long long __b) {
13864  return __builtin_altivec_vcmpequd_p(__CR6_LT, __a, (vector long long)__b);
13865 }
13866 
13867 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned long long __a,
13868  vector unsigned long long __b) {
13869  return __builtin_altivec_vcmpequd_p(__CR6_LT, (vector long long)__a,
13870  (vector long long)__b);
13871 }
13872 
13873 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned long long __a,
13874  vector bool long long __b) {
13875  return __builtin_altivec_vcmpequd_p(__CR6_LT, (vector long long)__a,
13876  (vector long long)__b);
13877 }
13878 
13879 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool long long __a,
13880  vector long long __b) {
13881  return __builtin_altivec_vcmpequd_p(__CR6_LT, (vector long long)__a,
13882  (vector long long)__b);
13883 }
13884 
13885 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool long long __a,
13886  vector unsigned long long __b) {
13887  return __builtin_altivec_vcmpequd_p(__CR6_LT, (vector long long)__a,
13888  (vector long long)__b);
13889 }
13890 
13891 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool long long __a,
13892  vector bool long long __b) {
13893  return __builtin_altivec_vcmpequd_p(__CR6_LT, (vector long long)__a,
13894  (vector long long)__b);
13895 }
13896 #endif
13897 
13898 static __inline__ int __ATTRS_o_ai vec_all_eq(vector float __a,
13899  vector float __b) {
13900 #ifdef __VSX__
13901  return __builtin_vsx_xvcmpeqsp_p(__CR6_LT, __a, __b);
13902 #else
13903  return __builtin_altivec_vcmpeqfp_p(__CR6_LT, __a, __b);
13904 #endif
13905 }
13906 
13907 #ifdef __VSX__
13908 static __inline__ int __ATTRS_o_ai vec_all_eq(vector double __a,
13909  vector double __b) {
13910  return __builtin_vsx_xvcmpeqdp_p(__CR6_LT, __a, __b);
13911 }
13912 #endif
13913 
13914 /* vec_all_ge */
13915 
13916 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed char __a,
13917  vector signed char __b) {
13918  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, __b, __a);
13919 }
13920 
13921 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed char __a,
13922  vector bool char __b) {
13923  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, (vector signed char)__b, __a);
13924 }
13925 
13926 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned char __a,
13927  vector unsigned char __b) {
13928  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __b, __a);
13929 }
13930 
13931 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned char __a,
13932  vector bool char __b) {
13933  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__b, __a);
13934 }
13935 
13936 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool char __a,
13937  vector signed char __b) {
13938  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__b,
13939  (vector unsigned char)__a);
13940 }
13941 
13942 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool char __a,
13943  vector unsigned char __b) {
13944  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __b, (vector unsigned char)__a);
13945 }
13946 
13947 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool char __a,
13948  vector bool char __b) {
13949  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__b,
13950  (vector unsigned char)__a);
13951 }
13952 
13953 static __inline__ int __ATTRS_o_ai vec_all_ge(vector short __a,
13954  vector short __b) {
13955  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, __b, __a);
13956 }
13957 
13958 static __inline__ int __ATTRS_o_ai vec_all_ge(vector short __a,
13959  vector bool short __b) {
13960  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, (vector short)__b, __a);
13961 }
13962 
13963 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned short __a,
13964  vector unsigned short __b) {
13965  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __b, __a);
13966 }
13967 
13968 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned short __a,
13969  vector bool short __b) {
13970  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__b,
13971  __a);
13972 }
13973 
13974 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool short __a,
13975  vector short __b) {
13976  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__b,
13977  (vector unsigned short)__a);
13978 }
13979 
13980 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool short __a,
13981  vector unsigned short __b) {
13982  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __b,
13983  (vector unsigned short)__a);
13984 }
13985 
13986 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool short __a,
13987  vector bool short __b) {
13988  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__b,
13989  (vector unsigned short)__a);
13990 }
13991 
13992 static __inline__ int __ATTRS_o_ai vec_all_ge(vector int __a, vector int __b) {
13993  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, __b, __a);
13994 }
13995 
13996 static __inline__ int __ATTRS_o_ai vec_all_ge(vector int __a,
13997  vector bool int __b) {
13998  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, (vector int)__b, __a);
13999 }
14000 
14001 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned int __a,
14002  vector unsigned int __b) {
14003  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __b, __a);
14004 }
14005 
14006 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned int __a,
14007  vector bool int __b) {
14008  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__b, __a);
14009 }
14010 
14011 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool int __a,
14012  vector int __b) {
14013  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__b,
14014  (vector unsigned int)__a);
14015 }
14016 
14017 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool int __a,
14018  vector unsigned int __b) {
14019  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __b, (vector unsigned int)__a);
14020 }
14021 
14022 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool int __a,
14023  vector bool int __b) {
14024  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__b,
14025  (vector unsigned int)__a);
14026 }
14027 
14028 #ifdef __POWER8_VECTOR__
14029 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed long long __a,
14030  vector signed long long __b) {
14031  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, __b, __a);
14032 }
14033 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed long long __a,
14034  vector bool long long __b) {
14035  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, (vector signed long long)__b,
14036  __a);
14037 }
14038 
14039 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned long long __a,
14040  vector unsigned long long __b) {
14041  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __b, __a);
14042 }
14043 
14044 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned long long __a,
14045  vector bool long long __b) {
14046  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__b,
14047  __a);
14048 }
14049 
14050 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool long long __a,
14051  vector signed long long __b) {
14052  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__b,
14053  (vector unsigned long long)__a);
14054 }
14055 
14056 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool long long __a,
14057  vector unsigned long long __b) {
14058  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __b,
14059  (vector unsigned long long)__a);
14060 }
14061 
14062 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool long long __a,
14063  vector bool long long __b) {
14064  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__b,
14065  (vector unsigned long long)__a);
14066 }
14067 #endif
14068 
14069 static __inline__ int __ATTRS_o_ai vec_all_ge(vector float __a,
14070  vector float __b) {
14071 #ifdef __VSX__
14072  return __builtin_vsx_xvcmpgesp_p(__CR6_LT, __a, __b);
14073 #else
14074  return __builtin_altivec_vcmpgefp_p(__CR6_LT, __a, __b);
14075 #endif
14076 }
14077 
14078 #ifdef __VSX__
14079 static __inline__ int __ATTRS_o_ai vec_all_ge(vector double __a,
14080  vector double __b) {
14081  return __builtin_vsx_xvcmpgedp_p(__CR6_LT, __a, __b);
14082 }
14083 #endif
14084 
14085 /* vec_all_gt */
14086 
14087 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed char __a,
14088  vector signed char __b) {
14089  return __builtin_altivec_vcmpgtsb_p(__CR6_LT, __a, __b);
14090 }
14091 
14092 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed char __a,
14093  vector bool char __b) {
14094  return __builtin_altivec_vcmpgtsb_p(__CR6_LT, __a, (vector signed char)__b);
14095 }
14096 
14097 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned char __a,
14098  vector unsigned char __b) {
14099  return __builtin_altivec_vcmpgtub_p(__CR6_LT, __a, __b);
14100 }
14101 
14102 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned char __a,
14103  vector bool char __b) {
14104  return __builtin_altivec_vcmpgtub_p(__CR6_LT, __a, (vector unsigned char)__b);
14105 }
14106 
14107 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool char __a,
14108  vector signed char __b) {
14109  return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__a,
14110  (vector unsigned char)__b);
14111 }
14112 
14113 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool char __a,
14114  vector unsigned char __b) {
14115  return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__a, __b);
14116 }
14117 
14118 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool char __a,
14119  vector bool char __b) {
14120  return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__a,
14121  (vector unsigned char)__b);
14122 }
14123 
14124 static __inline__ int __ATTRS_o_ai vec_all_gt(vector short __a,
14125  vector short __b) {
14126  return __builtin_altivec_vcmpgtsh_p(__CR6_LT, __a, __b);
14127 }
14128 
14129 static __inline__ int __ATTRS_o_ai vec_all_gt(vector short __a,
14130  vector bool short __b) {
14131  return __builtin_altivec_vcmpgtsh_p(__CR6_LT, __a, (vector short)__b);
14132 }
14133 
14134 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned short __a,
14135  vector unsigned short __b) {
14136  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __a, __b);
14137 }
14138 
14139 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned short __a,
14140  vector bool short __b) {
14141  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __a,
14142  (vector unsigned short)__b);
14143 }
14144 
14145 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool short __a,
14146  vector short __b) {
14147  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__a,
14148  (vector unsigned short)__b);
14149 }
14150 
14151 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool short __a,
14152  vector unsigned short __b) {
14153  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__a,
14154  __b);
14155 }
14156 
14157 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool short __a,
14158  vector bool short __b) {
14159  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__a,
14160  (vector unsigned short)__b);
14161 }
14162 
14163 static __inline__ int __ATTRS_o_ai vec_all_gt(vector int __a, vector int __b) {
14164  return __builtin_altivec_vcmpgtsw_p(__CR6_LT, __a, __b);
14165 }
14166 
14167 static __inline__ int __ATTRS_o_ai vec_all_gt(vector int __a,
14168  vector bool int __b) {
14169  return __builtin_altivec_vcmpgtsw_p(__CR6_LT, __a, (vector int)__b);
14170 }
14171 
14172 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned int __a,
14173  vector unsigned int __b) {
14174  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __a, __b);
14175 }
14176 
14177 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned int __a,
14178  vector bool int __b) {
14179  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __a, (vector unsigned int)__b);
14180 }
14181 
14182 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool int __a,
14183  vector int __b) {
14184  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__a,
14185  (vector unsigned int)__b);
14186 }
14187 
14188 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool int __a,
14189  vector unsigned int __b) {
14190  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__a, __b);
14191 }
14192 
14193 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool int __a,
14194  vector bool int __b) {
14195  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__a,
14196  (vector unsigned int)__b);
14197 }
14198 
14199 #ifdef __POWER8_VECTOR__
14200 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed long long __a,
14201  vector signed long long __b) {
14202  return __builtin_altivec_vcmpgtsd_p(__CR6_LT, __a, __b);
14203 }
14204 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed long long __a,
14205  vector bool long long __b) {
14206  return __builtin_altivec_vcmpgtsd_p(__CR6_LT, __a,
14207  (vector signed long long)__b);
14208 }
14209 
14210 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned long long __a,
14211  vector unsigned long long __b) {
14212  return __builtin_altivec_vcmpgtud_p(__CR6_LT, __a, __b);
14213 }
14214 
14215 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned long long __a,
14216  vector bool long long __b) {
14217  return __builtin_altivec_vcmpgtud_p(__CR6_LT, __a,
14218  (vector unsigned long long)__b);
14219 }
14220 
14221 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool long long __a,
14222  vector signed long long __b) {
14223  return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__a,
14224  (vector unsigned long long)__b);
14225 }
14226 
14227 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool long long __a,
14228  vector unsigned long long __b) {
14229  return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__a,
14230  __b);
14231 }
14232 
14233 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool long long __a,
14234  vector bool long long __b) {
14235  return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__a,
14236  (vector unsigned long long)__b);
14237 }
14238 #endif
14239 
14240 static __inline__ int __ATTRS_o_ai vec_all_gt(vector float __a,
14241  vector float __b) {
14242 #ifdef __VSX__
14243  return __builtin_vsx_xvcmpgtsp_p(__CR6_LT, __a, __b);
14244 #else
14245  return __builtin_altivec_vcmpgtfp_p(__CR6_LT, __a, __b);
14246 #endif
14247 }
14248 
14249 #ifdef __VSX__
14250 static __inline__ int __ATTRS_o_ai vec_all_gt(vector double __a,
14251  vector double __b) {
14252  return __builtin_vsx_xvcmpgtdp_p(__CR6_LT, __a, __b);
14253 }
14254 #endif
14255 
14256 /* vec_all_in */
14257 
14258 static __inline__ int __attribute__((__always_inline__))
14259 vec_all_in(vector float __a, vector float __b) {
14260  return __builtin_altivec_vcmpbfp_p(__CR6_EQ, __a, __b);
14261 }
14262 
14263 /* vec_all_le */
14264 
14265 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed char __a,
14266  vector signed char __b) {
14267  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, __a, __b);
14268 }
14269 
14270 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed char __a,
14271  vector bool char __b) {
14272  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, __a, (vector signed char)__b);
14273 }
14274 
14275 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned char __a,
14276  vector unsigned char __b) {
14277  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __a, __b);
14278 }
14279 
14280 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned char __a,
14281  vector bool char __b) {
14282  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __a, (vector unsigned char)__b);
14283 }
14284 
14285 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool char __a,
14286  vector signed char __b) {
14287  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__a,
14288  (vector unsigned char)__b);
14289 }
14290 
14291 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool char __a,
14292  vector unsigned char __b) {
14293  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__a, __b);
14294 }
14295 
14296 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool char __a,
14297  vector bool char __b) {
14298  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__a,
14299  (vector unsigned char)__b);
14300 }
14301 
14302 static __inline__ int __ATTRS_o_ai vec_all_le(vector short __a,
14303  vector short __b) {
14304  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, __a, __b);
14305 }
14306 
14307 static __inline__ int __ATTRS_o_ai vec_all_le(vector short __a,
14308  vector bool short __b) {
14309  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, __a, (vector short)__b);
14310 }
14311 
14312 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned short __a,
14313  vector unsigned short __b) {
14314  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __a, __b);
14315 }
14316 
14317 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned short __a,
14318  vector bool short __b) {
14319  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __a,
14320  (vector unsigned short)__b);
14321 }
14322 
14323 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool short __a,
14324  vector short __b) {
14325  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__a,
14326  (vector unsigned short)__b);
14327 }
14328 
14329 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool short __a,
14330  vector unsigned short __b) {
14331  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__a,
14332  __b);
14333 }
14334 
14335 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool short __a,
14336  vector bool short __b) {
14337  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__a,
14338  (vector unsigned short)__b);
14339 }
14340 
14341 static __inline__ int __ATTRS_o_ai vec_all_le(vector int __a, vector int __b) {
14342  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, __a, __b);
14343 }
14344 
14345 static __inline__ int __ATTRS_o_ai vec_all_le(vector int __a,
14346  vector bool int __b) {
14347  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, __a, (vector int)__b);
14348 }
14349 
14350 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned int __a,
14351  vector unsigned int __b) {
14352  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __a, __b);
14353 }
14354 
14355 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned int __a,
14356  vector bool int __b) {
14357  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __a, (vector unsigned int)__b);
14358 }
14359 
14360 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool int __a,
14361  vector int __b) {
14362  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__a,
14363  (vector unsigned int)__b);
14364 }
14365 
14366 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool int __a,
14367  vector unsigned int __b) {
14368  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__a, __b);
14369 }
14370 
14371 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool int __a,
14372  vector bool int __b) {
14373  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__a,
14374  (vector unsigned int)__b);
14375 }
14376 
14377 #ifdef __POWER8_VECTOR__
14378 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed long long __a,
14379  vector signed long long __b) {
14380  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, __a, __b);
14381 }
14382 
14383 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned long long __a,
14384  vector unsigned long long __b) {
14385  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __a, __b);
14386 }
14387 
14388 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed long long __a,
14389  vector bool long long __b) {
14390  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, __a,
14391  (vector signed long long)__b);
14392 }
14393 
14394 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned long long __a,
14395  vector bool long long __b) {
14396  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __a,
14397  (vector unsigned long long)__b);
14398 }
14399 
14400 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool long long __a,
14401  vector signed long long __b) {
14402  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__a,
14403  (vector unsigned long long)__b);
14404 }
14405 
14406 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool long long __a,
14407  vector unsigned long long __b) {
14408  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__a,
14409  __b);
14410 }
14411 
14412 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool long long __a,
14413  vector bool long long __b) {
14414  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__a,
14415  (vector unsigned long long)__b);
14416 }
14417 #endif
14418 
14419 static __inline__ int __ATTRS_o_ai vec_all_le(vector float __a,
14420  vector float __b) {
14421 #ifdef __VSX__
14422  return __builtin_vsx_xvcmpgesp_p(__CR6_LT, __b, __a);
14423 #else
14424  return __builtin_altivec_vcmpgefp_p(__CR6_LT, __b, __a);
14425 #endif
14426 }
14427 
14428 #ifdef __VSX__
14429 static __inline__ int __ATTRS_o_ai vec_all_le(vector double __a,
14430  vector double __b) {
14431  return __builtin_vsx_xvcmpgedp_p(__CR6_LT, __b, __a);
14432 }
14433 #endif
14434 
14435 /* vec_all_lt */
14436 
14437 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed char __a,
14438  vector signed char __b) {
14439  return __builtin_altivec_vcmpgtsb_p(__CR6_LT, __b, __a);
14440 }
14441 
14442 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed char __a,
14443  vector bool char __b) {
14444  return __builtin_altivec_vcmpgtsb_p(__CR6_LT, (vector signed char)__b, __a);
14445 }
14446 
14447 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned char __a,
14448  vector unsigned char __b) {
14449  return __builtin_altivec_vcmpgtub_p(__CR6_LT, __b, __a);
14450 }
14451 
14452 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned char __a,
14453  vector bool char __b) {
14454  return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__b, __a);
14455 }
14456 
14457 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool char __a,
14458  vector signed char __b) {
14459  return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__b,
14460  (vector unsigned char)__a);
14461 }
14462 
14463 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool char __a,
14464  vector unsigned char __b) {
14465  return __builtin_altivec_vcmpgtub_p(__CR6_LT, __b, (vector unsigned char)__a);
14466 }
14467 
14468 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool char __a,
14469  vector bool char __b) {
14470  return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__b,
14471  (vector unsigned char)__a);
14472 }
14473 
14474 static __inline__ int __ATTRS_o_ai vec_all_lt(vector short __a,
14475  vector short __b) {
14476  return __builtin_altivec_vcmpgtsh_p(__CR6_LT, __b, __a);
14477 }
14478 
14479 static __inline__ int __ATTRS_o_ai vec_all_lt(vector short __a,
14480  vector bool short __b) {
14481  return __builtin_altivec_vcmpgtsh_p(__CR6_LT, (vector short)__b, __a);
14482 }
14483 
14484 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned short __a,
14485  vector unsigned short __b) {
14486  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __b, __a);
14487 }
14488 
14489 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned short __a,
14490  vector bool short __b) {
14491  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__b,
14492  __a);
14493 }
14494 
14495 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool short __a,
14496  vector short __b) {
14497  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__b,
14498  (vector unsigned short)__a);
14499 }
14500 
14501 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool short __a,
14502  vector unsigned short __b) {
14503  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __b,
14504  (vector unsigned short)__a);
14505 }
14506 
14507 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool short __a,
14508  vector bool short __b) {
14509  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__b,
14510  (vector unsigned short)__a);
14511 }
14512 
14513 static __inline__ int __ATTRS_o_ai vec_all_lt(vector int __a, vector int __b) {
14514  return __builtin_altivec_vcmpgtsw_p(__CR6_LT, __b, __a);
14515 }
14516 
14517 static __inline__ int __ATTRS_o_ai vec_all_lt(vector int __a,
14518  vector bool int __b) {
14519  return __builtin_altivec_vcmpgtsw_p(__CR6_LT, (vector int)__b, __a);
14520 }
14521 
14522 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned int __a,
14523  vector unsigned int __b) {
14524  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __b, __a);
14525 }
14526 
14527 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned int __a,
14528  vector bool int __b) {
14529  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__b, __a);
14530 }
14531 
14532 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool int __a,
14533  vector int __b) {
14534  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__b,
14535  (vector unsigned int)__a);
14536 }
14537 
14538 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool int __a,
14539  vector unsigned int __b) {
14540  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __b, (vector unsigned int)__a);
14541 }
14542 
14543 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool int __a,
14544  vector bool int __b) {
14545  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__b,
14546  (vector unsigned int)__a);
14547 }
14548 
14549 #ifdef __POWER8_VECTOR__
14550 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed long long __a,
14551  vector signed long long __b) {
14552  return __builtin_altivec_vcmpgtsd_p(__CR6_LT, __b, __a);
14553 }
14554 
14555 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned long long __a,
14556  vector unsigned long long __b) {
14557  return __builtin_altivec_vcmpgtud_p(__CR6_LT, __b, __a);
14558 }
14559 
14560 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed long long __a,
14561  vector bool long long __b) {
14562  return __builtin_altivec_vcmpgtsd_p(__CR6_LT, (vector signed long long)__b,
14563  __a);
14564 }
14565 
14566 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned long long __a,
14567  vector bool long long __b) {
14568  return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__b,
14569  __a);
14570 }
14571 
14572 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool long long __a,
14573  vector signed long long __b) {
14574  return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__b,
14575  (vector unsigned long long)__a);
14576 }
14577 
14578 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool long long __a,
14579  vector unsigned long long __b) {
14580  return __builtin_altivec_vcmpgtud_p(__CR6_LT, __b,
14581  (vector unsigned long long)__a);
14582 }
14583 
14584 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool long long __a,
14585  vector bool long long __b) {
14586  return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__b,
14587  (vector unsigned long long)__a);
14588 }
14589 #endif
14590 
14591 static __inline__ int __ATTRS_o_ai vec_all_lt(vector float __a,
14592  vector float __b) {
14593 #ifdef __VSX__
14594  return __builtin_vsx_xvcmpgtsp_p(__CR6_LT, __b, __a);
14595 #else
14596  return __builtin_altivec_vcmpgtfp_p(__CR6_LT, __b, __a);
14597 #endif
14598 }
14599 
14600 #ifdef __VSX__
14601 static __inline__ int __ATTRS_o_ai vec_all_lt(vector double __a,
14602  vector double __b) {
14603  return __builtin_vsx_xvcmpgtdp_p(__CR6_LT, __b, __a);
14604 }
14605 #endif
14606 
14607 /* vec_all_nan */
14608 
14609 static __inline__ int __ATTRS_o_ai vec_all_nan(vector float __a) {
14610 #ifdef __VSX__
14611  return __builtin_vsx_xvcmpeqsp_p(__CR6_EQ, __a, __a);
14612 #else
14613  return __builtin_altivec_vcmpeqfp_p(__CR6_EQ, __a, __a);
14614 #endif
14615 }
14616 
14617 #ifdef __VSX__
14618 static __inline__ int __ATTRS_o_ai vec_all_nan(vector double __a) {
14619  return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ, __a, __a);
14620 }
14621 #endif
14622 
14623 /* vec_all_ne */
14624 
14625 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed char __a,
14626  vector signed char __b) {
14627  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
14628  (vector char)__b);
14629 }
14630 
14631 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed char __a,
14632  vector bool char __b) {
14633  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
14634  (vector char)__b);
14635 }
14636 
14637 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned char __a,
14638  vector unsigned char __b) {
14639  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
14640  (vector char)__b);
14641 }
14642 
14643 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned char __a,
14644  vector bool char __b) {
14645  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
14646  (vector char)__b);
14647 }
14648 
14649 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool char __a,
14650  vector signed char __b) {
14651  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
14652  (vector char)__b);
14653 }
14654 
14655 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool char __a,
14656  vector unsigned char __b) {
14657  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
14658  (vector char)__b);
14659 }
14660 
14661 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool char __a,
14662  vector bool char __b) {
14663  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
14664  (vector char)__b);
14665 }
14666 
14667 static __inline__ int __ATTRS_o_ai vec_all_ne(vector short __a,
14668  vector short __b) {
14669  return __builtin_altivec_vcmpequh_p(__CR6_EQ, __a, __b);
14670 }
14671 
14672 static __inline__ int __ATTRS_o_ai vec_all_ne(vector short __a,
14673  vector bool short __b) {
14674  return __builtin_altivec_vcmpequh_p(__CR6_EQ, __a, (vector short)__b);
14675 }
14676 
14677 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned short __a,
14678  vector unsigned short __b) {
14679  return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
14680  (vector short)__b);
14681 }
14682 
14683 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned short __a,
14684  vector bool short __b) {
14685  return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
14686  (vector short)__b);
14687 }
14688 
14689 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool short __a,
14690  vector short __b) {
14691  return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
14692  (vector short)__b);
14693 }
14694 
14695 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool short __a,
14696  vector unsigned short __b) {
14697  return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
14698  (vector short)__b);
14699 }
14700 
14701 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool short __a,
14702  vector bool short __b) {
14703  return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
14704  (vector short)__b);
14705 }
14706 
14707 static __inline__ int __ATTRS_o_ai vec_all_ne(vector pixel __a,
14708  vector pixel __b) {
14709  return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
14710  (vector short)__b);
14711 }
14712 
14713 static __inline__ int __ATTRS_o_ai vec_all_ne(vector int __a, vector int __b) {
14714  return __builtin_altivec_vcmpequw_p(__CR6_EQ, __a, __b);
14715 }
14716 
14717 static __inline__ int __ATTRS_o_ai vec_all_ne(vector int __a,
14718  vector bool int __b) {
14719  return __builtin_altivec_vcmpequw_p(__CR6_EQ, __a, (vector int)__b);
14720 }
14721 
14722 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned int __a,
14723  vector unsigned int __b) {
14724  return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
14725  (vector int)__b);
14726 }
14727 
14728 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned int __a,
14729  vector bool int __b) {
14730  return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
14731  (vector int)__b);
14732 }
14733 
14734 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool int __a,
14735  vector int __b) {
14736  return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
14737  (vector int)__b);
14738 }
14739 
14740 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool int __a,
14741  vector unsigned int __b) {
14742  return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
14743  (vector int)__b);
14744 }
14745 
14746 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool int __a,
14747  vector bool int __b) {
14748  return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
14749  (vector int)__b);
14750 }
14751 
14752 #ifdef __POWER8_VECTOR__
14753 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed long long __a,
14754  vector signed long long __b) {
14755  return __builtin_altivec_vcmpequd_p(__CR6_EQ, __a, __b);
14756 }
14757 
14758 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned long long __a,
14759  vector unsigned long long __b) {
14760  return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector long long)__a,
14761  (vector long long)__b);
14762 }
14763 
14764 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed long long __a,
14765  vector bool long long __b) {
14766  return __builtin_altivec_vcmpequd_p(__CR6_EQ, __a,
14767  (vector signed long long)__b);
14768 }
14769 
14770 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned long long __a,
14771  vector bool long long __b) {
14772  return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector signed long long)__a,
14773  (vector signed long long)__b);
14774 }
14775 
14776 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool long long __a,
14777  vector signed long long __b) {
14778  return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector signed long long)__a,
14779  (vector signed long long)__b);
14780 }
14781 
14782 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool long long __a,
14783  vector unsigned long long __b) {
14784  return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector signed long long)__a,
14785  (vector signed long long)__b);
14786 }
14787 
14788 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool long long __a,
14789  vector bool long long __b) {
14790  return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector signed long long)__a,
14791  (vector signed long long)__b);
14792 }
14793 #endif
14794 
14795 static __inline__ int __ATTRS_o_ai vec_all_ne(vector float __a,
14796  vector float __b) {
14797 #ifdef __VSX__
14798  return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ, __a, __b);
14799 #else
14800  return __builtin_altivec_vcmpeqfp_p(__CR6_EQ, __a, __b);
14801 #endif
14802 }
14803 
14804 #ifdef __VSX__
14805 static __inline__ int __ATTRS_o_ai vec_all_ne(vector double __a,
14806  vector double __b) {
14807  return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ, __a, __b);
14808 }
14809 #endif
14810 
14811 /* vec_all_nge */
14812 
14813 static __inline__ int __ATTRS_o_ai vec_all_nge(vector float __a,
14814  vector float __b) {
14815 #ifdef __VSX__
14816  return __builtin_vsx_xvcmpgesp_p(__CR6_EQ, __a, __b);
14817 #else
14818  return __builtin_altivec_vcmpgefp_p(__CR6_EQ, __a, __b);
14819 #endif
14820 }
14821 
14822 #ifdef __VSX__
14823 static __inline__ int __ATTRS_o_ai vec_all_nge(vector double __a,
14824  vector double __b) {
14825  return __builtin_vsx_xvcmpgedp_p(__CR6_EQ, __a, __b);
14826 }
14827 #endif
14828 
14829 /* vec_all_ngt */
14830 
14831 static __inline__ int __ATTRS_o_ai vec_all_ngt(vector float __a,
14832  vector float __b) {
14833 #ifdef __VSX__
14834  return __builtin_vsx_xvcmpgtsp_p(__CR6_EQ, __a, __b);
14835 #else
14836  return __builtin_altivec_vcmpgtfp_p(__CR6_EQ, __a, __b);
14837 #endif
14838 }
14839 
14840 #ifdef __VSX__
14841 static __inline__ int __ATTRS_o_ai vec_all_ngt(vector double __a,
14842  vector double __b) {
14843  return __builtin_vsx_xvcmpgtdp_p(__CR6_EQ, __a, __b);
14844 }
14845 #endif
14846 
14847 /* vec_all_nle */
14848 
14849 static __inline__ int __attribute__((__always_inline__))
14850 vec_all_nle(vector float __a, vector float __b) {
14851  return __builtin_altivec_vcmpgefp_p(__CR6_EQ, __b, __a);
14852 }
14853 
14854 /* vec_all_nlt */
14855 
14856 static __inline__ int __attribute__((__always_inline__))
14857 vec_all_nlt(vector float __a, vector float __b) {
14858  return __builtin_altivec_vcmpgtfp_p(__CR6_EQ, __b, __a);
14859 }
14860 
14861 /* vec_all_numeric */
14862 
14863 static __inline__ int __attribute__((__always_inline__))
14864 vec_all_numeric(vector float __a) {
14865  return __builtin_altivec_vcmpeqfp_p(__CR6_LT, __a, __a);
14866 }
14867 
14868 /* vec_any_eq */
14869 
14870 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed char __a,
14871  vector signed char __b) {
14872  return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
14873  (vector char)__b);
14874 }
14875 
14876 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed char __a,
14877  vector bool char __b) {
14878  return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
14879  (vector char)__b);
14880 }
14881 
14882 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned char __a,
14883  vector unsigned char __b) {
14884  return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
14885  (vector char)__b);
14886 }
14887 
14888 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned char __a,
14889  vector bool char __b) {
14890  return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
14891  (vector char)__b);
14892 }
14893 
14894 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool char __a,
14895  vector signed char __b) {
14896  return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
14897  (vector char)__b);
14898 }
14899 
14900 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool char __a,
14901  vector unsigned char __b) {
14902  return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
14903  (vector char)__b);
14904 }
14905 
14906 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool char __a,
14907  vector bool char __b) {
14908  return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
14909  (vector char)__b);
14910 }
14911 
14912 static __inline__ int __ATTRS_o_ai vec_any_eq(vector short __a,
14913  vector short __b) {
14914  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, __a, __b);
14915 }
14916 
14917 static __inline__ int __ATTRS_o_ai vec_any_eq(vector short __a,
14918  vector bool short __b) {
14919  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, __a, (vector short)__b);
14920 }
14921 
14922 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned short __a,
14923  vector unsigned short __b) {
14924  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
14925  (vector short)__b);
14926 }
14927 
14928 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned short __a,
14929  vector bool short __b) {
14930  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
14931  (vector short)__b);
14932 }
14933 
14934 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool short __a,
14935  vector short __b) {
14936  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
14937  (vector short)__b);
14938 }
14939 
14940 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool short __a,
14941  vector unsigned short __b) {
14942  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
14943  (vector short)__b);
14944 }
14945 
14946 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool short __a,
14947  vector bool short __b) {
14948  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
14949  (vector short)__b);
14950 }
14951 
14952 static __inline__ int __ATTRS_o_ai vec_any_eq(vector pixel __a,
14953  vector pixel __b) {
14954  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
14955  (vector short)__b);
14956 }
14957 
14958 static __inline__ int __ATTRS_o_ai vec_any_eq(vector int __a, vector int __b) {
14959  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, __a, __b);
14960 }
14961 
14962 static __inline__ int __ATTRS_o_ai vec_any_eq(vector int __a,
14963  vector bool int __b) {
14964  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, __a, (vector int)__b);
14965 }
14966 
14967 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned int __a,
14968  vector unsigned int __b) {
14969  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
14970  (vector int)__b);
14971 }
14972 
14973 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned int __a,
14974  vector bool int __b) {
14975  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
14976  (vector int)__b);
14977 }
14978 
14979 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool int __a,
14980  vector int __b) {
14981  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
14982  (vector int)__b);
14983 }
14984 
14985 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool int __a,
14986  vector unsigned int __b) {
14987  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
14988  (vector int)__b);
14989 }
14990 
14991 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool int __a,
14992  vector bool int __b) {
14993  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
14994  (vector int)__b);
14995 }
14996 
14997 #ifdef __POWER8_VECTOR__
14998 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed long long __a,
14999  vector signed long long __b) {
15000  return __builtin_altivec_vcmpequd_p(__CR6_EQ_REV, __a, __b);
15001 }
15002 
15003 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned long long __a,
15004  vector unsigned long long __b) {
15005  return __builtin_altivec_vcmpequd_p(__CR6_EQ_REV, (vector long long)__a,
15006  (vector long long)__b);
15007 }
15008 
15009 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed long long __a,
15010  vector bool long long __b) {
15011  return __builtin_altivec_vcmpequd_p(__CR6_EQ_REV, __a,
15012  (vector signed long long)__b);
15013 }
15014 
15015 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned long long __a,
15016  vector bool long long __b) {
15017  return __builtin_altivec_vcmpequd_p(
15018  __CR6_EQ_REV, (vector signed long long)__a, (vector signed long long)__b);
15019 }
15020 
15021 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool long long __a,
15022  vector signed long long __b) {
15023  return __builtin_altivec_vcmpequd_p(
15024  __CR6_EQ_REV, (vector signed long long)__a, (vector signed long long)__b);
15025 }
15026 
15027 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool long long __a,
15028  vector unsigned long long __b) {
15029  return __builtin_altivec_vcmpequd_p(
15030  __CR6_EQ_REV, (vector signed long long)__a, (vector signed long long)__b);
15031 }
15032 
15033 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool long long __a,
15034  vector bool long long __b) {
15035  return __builtin_altivec_vcmpequd_p(
15036  __CR6_EQ_REV, (vector signed long long)__a, (vector signed long long)__b);
15037 }
15038 #endif
15039 
15040 static __inline__ int __ATTRS_o_ai vec_any_eq(vector float __a,
15041  vector float __b) {
15042 #ifdef __VSX__
15043  return __builtin_vsx_xvcmpeqsp_p(__CR6_EQ_REV, __a, __b);
15044 #else
15045  return __builtin_altivec_vcmpeqfp_p(__CR6_EQ_REV, __a, __b);
15046 #endif
15047 }
15048 
15049 #ifdef __VSX__
15050 static __inline__ int __ATTRS_o_ai vec_any_eq(vector double __a,
15051  vector double __b) {
15052  return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ_REV, __a, __b);
15053 }
15054 #endif
15055 
15056 /* vec_any_ge */
15057 
15058 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed char __a,
15059  vector signed char __b) {
15060  return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, __b, __a);
15061 }
15062 
15063 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed char __a,
15064  vector bool char __b) {
15065  return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, (vector signed char)__b,
15066  __a);
15067 }
15068 
15069 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned char __a,
15070  vector unsigned char __b) {
15071  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __b, __a);
15072 }
15073 
15074 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned char __a,
15075  vector bool char __b) {
15076  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__b,
15077  __a);
15078 }
15079 
15080 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool char __a,
15081  vector signed char __b) {
15082  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__b,
15083  (vector unsigned char)__a);
15084 }
15085 
15086 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool char __a,
15087  vector unsigned char __b) {
15088  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __b,
15089  (vector unsigned char)__a);
15090 }
15091 
15092 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool char __a,
15093  vector bool char __b) {
15094  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__b,
15095  (vector unsigned char)__a);
15096 }
15097 
15098 static __inline__ int __ATTRS_o_ai vec_any_ge(vector short __a,
15099  vector short __b) {
15100  return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, __b, __a);
15101 }
15102 
15103 static __inline__ int __ATTRS_o_ai vec_any_ge(vector short __a,
15104  vector bool short __b) {
15105  return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, (vector short)__b, __a);
15106 }
15107 
15108 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned short __a,
15109  vector unsigned short __b) {
15110  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __b, __a);
15111 }
15112 
15113 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned short __a,
15114  vector bool short __b) {
15115  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__b,
15116  __a);
15117 }
15118 
15119 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool short __a,
15120  vector short __b) {
15121  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__b,
15122  (vector unsigned short)__a);
15123 }
15124 
15125 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool short __a,
15126  vector unsigned short __b) {
15127  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __b,
15128  (vector unsigned short)__a);
15129 }
15130 
15131 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool short __a,
15132  vector bool short __b) {
15133  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__b,
15134  (vector unsigned short)__a);
15135 }
15136 
15137 static __inline__ int __ATTRS_o_ai vec_any_ge(vector int __a, vector int __b) {
15138  return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, __b, __a);
15139 }
15140 
15141 static __inline__ int __ATTRS_o_ai vec_any_ge(vector int __a,
15142  vector bool int __b) {
15143  return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, (vector int)__b, __a);
15144 }
15145 
15146 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned int __a,
15147  vector unsigned int __b) {
15148  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __b, __a);
15149 }
15150 
15151 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned int __a,
15152  vector bool int __b) {
15153  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__b,
15154  __a);
15155 }
15156 
15157 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool int __a,
15158  vector int __b) {
15159  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__b,
15160  (vector unsigned int)__a);
15161 }
15162 
15163 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool int __a,
15164  vector unsigned int __b) {
15165  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __b,
15166  (vector unsigned int)__a);
15167 }
15168 
15169 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool int __a,
15170  vector bool int __b) {
15171  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__b,
15172  (vector unsigned int)__a);
15173 }
15174 
15175 #ifdef __POWER8_VECTOR__
15176 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed long long __a,
15177  vector signed long long __b) {
15178  return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV, __b, __a);
15179 }
15180 
15181 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned long long __a,
15182  vector unsigned long long __b) {
15183  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __b, __a);
15184 }
15185 
15186 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed long long __a,
15187  vector bool long long __b) {
15188  return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV,
15189  (vector signed long long)__b, __a);
15190 }
15191 
15192 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned long long __a,
15193  vector bool long long __b) {
15194  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
15195  (vector unsigned long long)__b, __a);
15196 }
15197 
15198 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool long long __a,
15199  vector signed long long __b) {
15200  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
15201  (vector unsigned long long)__b,
15202  (vector unsigned long long)__a);
15203 }
15204 
15205 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool long long __a,
15206  vector unsigned long long __b) {
15207  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __b,
15208  (vector unsigned long long)__a);
15209 }
15210 
15211 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool long long __a,
15212  vector bool long long __b) {
15213  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
15214  (vector unsigned long long)__b,
15215  (vector unsigned long long)__a);
15216 }
15217 #endif
15218 
15219 static __inline__ int __ATTRS_o_ai vec_any_ge(vector float __a,
15220  vector float __b) {
15221 #ifdef __VSX__
15222  return __builtin_vsx_xvcmpgesp_p(__CR6_EQ_REV, __a, __b);
15223 #else
15224  return __builtin_altivec_vcmpgefp_p(__CR6_EQ_REV, __a, __b);
15225 #endif
15226 }
15227 
15228 #ifdef __VSX__
15229 static __inline__ int __ATTRS_o_ai vec_any_ge(vector double __a,
15230  vector double __b) {
15231  return __builtin_vsx_xvcmpgedp_p(__CR6_EQ_REV, __a, __b);
15232 }
15233 #endif
15234 
15235 /* vec_any_gt */
15236 
15237 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed char __a,
15238  vector signed char __b) {
15239  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, __a, __b);
15240 }
15241 
15242 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed char __a,
15243  vector bool char __b) {
15244  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, __a,
15245  (vector signed char)__b);
15246 }
15247 
15248 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned char __a,
15249  vector unsigned char __b) {
15250  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __a, __b);
15251 }
15252 
15253 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned char __a,
15254  vector bool char __b) {
15255  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __a,
15256  (vector unsigned char)__b);
15257 }
15258 
15259 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool char __a,
15260  vector signed char __b) {
15261  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__a,
15262  (vector unsigned char)__b);
15263 }
15264 
15265 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool char __a,
15266  vector unsigned char __b) {
15267  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__a,
15268  __b);
15269 }
15270 
15271 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool char __a,
15272  vector bool char __b) {
15273  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__a,
15274  (vector unsigned char)__b);
15275 }
15276 
15277 static __inline__ int __ATTRS_o_ai vec_any_gt(vector short __a,
15278  vector short __b) {
15279  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, __a, __b);
15280 }
15281 
15282 static __inline__ int __ATTRS_o_ai vec_any_gt(vector short __a,
15283  vector bool short __b) {
15284  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, __a, (vector short)__b);
15285 }
15286 
15287 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned short __a,
15288  vector unsigned short __b) {
15289  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __a, __b);
15290 }
15291 
15292 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned short __a,
15293  vector bool short __b) {
15294  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __a,
15295  (vector unsigned short)__b);
15296 }
15297 
15298 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool short __a,
15299  vector short __b) {
15300  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__a,
15301  (vector unsigned short)__b);
15302 }
15303 
15304 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool short __a,
15305  vector unsigned short __b) {
15306  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__a,
15307  __b);
15308 }
15309 
15310 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool short __a,
15311  vector bool short __b) {
15312  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__a,
15313  (vector unsigned short)__b);
15314 }
15315 
15316 static __inline__ int __ATTRS_o_ai vec_any_gt(vector int __a, vector int __b) {
15317  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, __a, __b);
15318 }
15319 
15320 static __inline__ int __ATTRS_o_ai vec_any_gt(vector int __a,
15321  vector bool int __b) {
15322  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, __a, (vector int)__b);
15323 }
15324 
15325 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned int __a,
15326  vector unsigned int __b) {
15327  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __a, __b);
15328 }
15329 
15330 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned int __a,
15331  vector bool int __b) {
15332  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __a,
15333  (vector unsigned int)__b);
15334 }
15335 
15336 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool int __a,
15337  vector int __b) {
15338  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__a,
15339  (vector unsigned int)__b);
15340 }
15341 
15342 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool int __a,
15343  vector unsigned int __b) {
15344  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__a,
15345  __b);
15346 }
15347 
15348 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool int __a,
15349  vector bool int __b) {
15350  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__a,
15351  (vector unsigned int)__b);
15352 }
15353 
15354 #ifdef __POWER8_VECTOR__
15355 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed long long __a,
15356  vector signed long long __b) {
15357  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV, __a, __b);
15358 }
15359 
15360 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned long long __a,
15361  vector unsigned long long __b) {
15362  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __a, __b);
15363 }
15364 
15365 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed long long __a,
15366  vector bool long long __b) {
15367  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV, __a,
15368  (vector signed long long)__b);
15369 }
15370 
15371 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned long long __a,
15372  vector bool long long __b) {
15373  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __a,
15374  (vector unsigned long long)__b);
15375 }
15376 
15377 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool long long __a,
15378  vector signed long long __b) {
15379  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
15380  (vector unsigned long long)__a,
15381  (vector unsigned long long)__b);
15382 }
15383 
15384 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool long long __a,
15385  vector unsigned long long __b) {
15386  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
15387  (vector unsigned long long)__a, __b);
15388 }
15389 
15390 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool long long __a,
15391  vector bool long long __b) {
15392  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
15393  (vector unsigned long long)__a,
15394  (vector unsigned long long)__b);
15395 }
15396 #endif
15397 
15398 static __inline__ int __ATTRS_o_ai vec_any_gt(vector float __a,
15399  vector float __b) {
15400 #ifdef __VSX__
15401  return __builtin_vsx_xvcmpgtsp_p(__CR6_EQ_REV, __a, __b);
15402 #else
15403  return __builtin_altivec_vcmpgtfp_p(__CR6_EQ_REV, __a, __b);
15404 #endif
15405 }
15406 
15407 #ifdef __VSX__
15408 static __inline__ int __ATTRS_o_ai vec_any_gt(vector double __a,
15409  vector double __b) {
15410  return __builtin_vsx_xvcmpgtdp_p(__CR6_EQ_REV, __a, __b);
15411 }
15412 #endif
15413 
15414 /* vec_any_le */
15415 
15416 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed char __a,
15417  vector signed char __b) {
15418  return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, __a, __b);
15419 }
15420 
15421 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed char __a,
15422  vector bool char __b) {
15423  return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, __a,
15424  (vector signed char)__b);
15425 }
15426 
15427 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned char __a,
15428  vector unsigned char __b) {
15429  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __a, __b);
15430 }
15431 
15432 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned char __a,
15433  vector bool char __b) {
15434  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __a,
15435  (vector unsigned char)__b);
15436 }
15437 
15438 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool char __a,
15439  vector signed char __b) {
15440  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__a,
15441  (vector unsigned char)__b);
15442 }
15443 
15444 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool char __a,
15445  vector unsigned char __b) {
15446  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__a,
15447  __b);
15448 }
15449 
15450 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool char __a,
15451  vector bool char __b) {
15452  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__a,
15453  (vector unsigned char)__b);
15454 }
15455 
15456 static __inline__ int __ATTRS_o_ai vec_any_le(vector short __a,
15457  vector short __b) {
15458  return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, __a, __b);
15459 }
15460 
15461 static __inline__ int __ATTRS_o_ai vec_any_le(vector short __a,
15462  vector bool short __b) {
15463  return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, __a, (vector short)__b);
15464 }
15465 
15466 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned short __a,
15467  vector unsigned short __b) {
15468  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __a, __b);
15469 }
15470 
15471 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned short __a,
15472  vector bool short __b) {
15473  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __a,
15474  (vector unsigned short)__b);
15475 }
15476 
15477 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool short __a,
15478  vector short __b) {
15479  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__a,
15480  (vector unsigned short)__b);
15481 }
15482 
15483 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool short __a,
15484  vector unsigned short __b) {
15485  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__a,
15486  __b);
15487 }
15488 
15489 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool short __a,
15490  vector bool short __b) {
15491  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__a,
15492  (vector unsigned short)__b);
15493 }
15494 
15495 static __inline__ int __ATTRS_o_ai vec_any_le(vector int __a, vector int __b) {
15496  return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, __a, __b);
15497 }
15498 
15499 static __inline__ int __ATTRS_o_ai vec_any_le(vector int __a,
15500  vector bool int __b) {
15501  return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, __a, (vector int)__b);
15502 }
15503 
15504 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned int __a,
15505  vector unsigned int __b) {
15506  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __a, __b);
15507 }
15508 
15509 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned int __a,
15510  vector bool int __b) {
15511  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __a,
15512  (vector unsigned int)__b);
15513 }
15514 
15515 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool int __a,
15516  vector int __b) {
15517  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__a,
15518  (vector unsigned int)__b);
15519 }
15520 
15521 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool int __a,
15522  vector unsigned int __b) {
15523  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__a,
15524  __b);
15525 }
15526 
15527 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool int __a,
15528  vector bool int __b) {
15529  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__a,
15530  (vector unsigned int)__b);
15531 }
15532 
15533 #ifdef __POWER8_VECTOR__
15534 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed long long __a,
15535  vector signed long long __b) {
15536  return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV, __a, __b);
15537 }
15538 
15539 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned long long __a,
15540  vector unsigned long long __b) {
15541  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __a, __b);
15542 }
15543 
15544 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed long long __a,
15545  vector bool long long __b) {
15546  return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV, __a,
15547  (vector signed long long)__b);
15548 }
15549 
15550 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned long long __a,
15551  vector bool long long __b) {
15552  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __a,
15553  (vector unsigned long long)__b);
15554 }
15555 
15556 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool long long __a,
15557  vector signed long long __b) {
15558  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
15559  (vector unsigned long long)__a,
15560  (vector unsigned long long)__b);
15561 }
15562 
15563 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool long long __a,
15564  vector unsigned long long __b) {
15565  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
15566  (vector unsigned long long)__a, __b);
15567 }
15568 
15569 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool long long __a,
15570  vector bool long long __b) {
15571  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
15572  (vector unsigned long long)__a,
15573  (vector unsigned long long)__b);
15574 }
15575 #endif
15576 
15577 static __inline__ int __ATTRS_o_ai vec_any_le(vector float __a,
15578  vector float __b) {
15579 #ifdef __VSX__
15580  return __builtin_vsx_xvcmpgesp_p(__CR6_EQ_REV, __b, __a);
15581 #else
15582  return __builtin_altivec_vcmpgefp_p(__CR6_EQ_REV, __b, __a);
15583 #endif
15584 }
15585 
15586 #ifdef __VSX__
15587 static __inline__ int __ATTRS_o_ai vec_any_le(vector double __a,
15588  vector double __b) {
15589  return __builtin_vsx_xvcmpgedp_p(__CR6_EQ_REV, __b, __a);
15590 }
15591 #endif
15592 
15593 /* vec_any_lt */
15594 
15595 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed char __a,
15596  vector signed char __b) {
15597  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, __b, __a);
15598 }
15599 
15600 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed char __a,
15601  vector bool char __b) {
15602  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, (vector signed char)__b,
15603  __a);
15604 }
15605 
15606 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned char __a,
15607  vector unsigned char __b) {
15608  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __b, __a);
15609 }
15610 
15611 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned char __a,
15612  vector bool char __b) {
15613  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__b,
15614  __a);
15615 }
15616 
15617 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool char __a,
15618  vector signed char __b) {
15619  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__b,
15620  (vector unsigned char)__a);
15621 }
15622 
15623 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool char __a,
15624  vector unsigned char __b) {
15625  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __b,
15626  (vector unsigned char)__a);
15627 }
15628 
15629 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool char __a,
15630  vector bool char __b) {
15631  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__b,
15632  (vector unsigned char)__a);
15633 }
15634 
15635 static __inline__ int __ATTRS_o_ai vec_any_lt(vector short __a,
15636  vector short __b) {
15637  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, __b, __a);
15638 }
15639 
15640 static __inline__ int __ATTRS_o_ai vec_any_lt(vector short __a,
15641  vector bool short __b) {
15642  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, (vector short)__b, __a);
15643 }
15644 
15645 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned short __a,
15646  vector unsigned short __b) {
15647  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __b, __a);
15648 }
15649 
15650 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned short __a,
15651  vector bool short __b) {
15652  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__b,
15653  __a);
15654 }
15655 
15656 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool short __a,
15657  vector short __b) {
15658  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__b,
15659  (vector unsigned short)__a);
15660 }
15661 
15662 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool short __a,
15663  vector unsigned short __b) {
15664  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __b,
15665  (vector unsigned short)__a);
15666 }
15667 
15668 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool short __a,
15669  vector bool short __b) {
15670  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__b,
15671  (vector unsigned short)__a);
15672 }
15673 
15674 static __inline__ int __ATTRS_o_ai vec_any_lt(vector int __a, vector int __b) {
15675  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, __b, __a);
15676 }
15677 
15678 static __inline__ int __ATTRS_o_ai vec_any_lt(vector int __a,
15679  vector bool int __b) {
15680  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, (vector int)__b, __a);
15681 }
15682 
15683 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned int __a,
15684  vector unsigned int __b) {
15685  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __b, __a);
15686 }
15687 
15688 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned int __a,
15689  vector bool int __b) {
15690  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__b,
15691  __a);
15692 }
15693 
15694 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool int __a,
15695  vector int __b) {
15696  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__b,
15697  (vector unsigned int)__a);
15698 }
15699 
15700 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool int __a,
15701  vector unsigned int __b) {
15702  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __b,
15703  (vector unsigned int)__a);
15704 }
15705 
15706 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool int __a,
15707  vector bool int __b) {
15708  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__b,
15709  (vector unsigned int)__a);
15710 }
15711 
15712 #ifdef __POWER8_VECTOR__
15713 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed long long __a,
15714  vector signed long long __b) {
15715  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV, __b, __a);
15716 }
15717 
15718 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned long long __a,
15719  vector unsigned long long __b) {
15720  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __b, __a);
15721 }
15722 
15723 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed long long __a,
15724  vector bool long long __b) {
15725  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV,
15726  (vector signed long long)__b, __a);
15727 }
15728 
15729 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned long long __a,
15730  vector bool long long __b) {
15731  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
15732  (vector unsigned long long)__b, __a);
15733 }
15734 
15735 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool long long __a,
15736  vector signed long long __b) {
15737  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
15738  (vector unsigned long long)__b,
15739  (vector unsigned long long)__a);
15740 }
15741 
15742 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool long long __a,
15743  vector unsigned long long __b) {
15744  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __b,
15745  (vector unsigned long long)__a);
15746 }
15747 
15748 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool long long __a,
15749  vector bool long long __b) {
15750  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
15751  (vector unsigned long long)__b,
15752  (vector unsigned long long)__a);
15753 }
15754 #endif
15755 
15756 static __inline__ int __ATTRS_o_ai vec_any_lt(vector float __a,
15757  vector float __b) {
15758 #ifdef __VSX__
15759  return __builtin_vsx_xvcmpgtsp_p(__CR6_EQ_REV, __b, __a);
15760 #else
15761  return __builtin_altivec_vcmpgtfp_p(__CR6_EQ_REV, __b, __a);
15762 #endif
15763 }
15764 
15765 #ifdef __VSX__
15766 static __inline__ int __ATTRS_o_ai vec_any_lt(vector double __a,
15767  vector double __b) {
15768  return __builtin_vsx_xvcmpgtdp_p(__CR6_EQ_REV, __b, __a);
15769 }
15770 #endif
15771 
15772 /* vec_any_nan */
15773 
15774 static __inline__ int __attribute__((__always_inline__))
15775 vec_any_nan(vector float __a) {
15776  return __builtin_altivec_vcmpeqfp_p(__CR6_LT_REV, __a, __a);
15777 }
15778 
15779 /* vec_any_ne */
15780 
15781 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed char __a,
15782  vector signed char __b) {
15783  return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
15784  (vector char)__b);
15785 }
15786 
15787 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed char __a,
15788  vector bool char __b) {
15789  return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
15790  (vector char)__b);
15791 }
15792 
15793 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned char __a,
15794  vector unsigned char __b) {
15795  return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
15796  (vector char)__b);
15797 }
15798 
15799 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned char __a,
15800  vector bool char __b) {
15801  return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
15802  (vector char)__b);
15803 }
15804 
15805 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool char __a,
15806  vector signed char __b) {
15807  return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
15808  (vector char)__b);
15809 }
15810 
15811 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool char __a,
15812  vector unsigned char __b) {
15813  return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
15814  (vector char)__b);
15815 }
15816 
15817 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool char __a,
15818  vector bool char __b) {
15819  return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
15820  (vector char)__b);
15821 }
15822 
15823 static __inline__ int __ATTRS_o_ai vec_any_ne(vector short __a,
15824  vector short __b) {
15825  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, __a, __b);
15826 }
15827 
15828 static __inline__ int __ATTRS_o_ai vec_any_ne(vector short __a,
15829  vector bool short __b) {
15830  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, __a, (vector short)__b);
15831 }
15832 
15833 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned short __a,
15834  vector unsigned short __b) {
15835  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
15836  (vector short)__b);
15837 }
15838 
15839 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned short __a,
15840  vector bool short __b) {
15841  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
15842  (vector short)__b);
15843 }
15844 
15845 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool short __a,
15846  vector short __b) {
15847  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
15848  (vector short)__b);
15849 }
15850 
15851 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool short __a,
15852  vector unsigned short __b) {
15853  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
15854  (vector short)__b);
15855 }
15856 
15857 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool short __a,
15858  vector bool short __b) {
15859  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
15860  (vector short)__b);
15861 }
15862 
15863 static __inline__ int __ATTRS_o_ai vec_any_ne(vector pixel __a,
15864  vector pixel __b) {
15865  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
15866  (vector short)__b);
15867 }
15868 
15869 static __inline__ int __ATTRS_o_ai vec_any_ne(vector int __a, vector int __b) {
15870  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, __a, __b);
15871 }
15872 
15873 static __inline__ int __ATTRS_o_ai vec_any_ne(vector int __a,
15874  vector bool int __b) {
15875  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, __a, (vector int)__b);
15876 }
15877 
15878 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned int __a,
15879  vector unsigned int __b) {
15880  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
15881  (vector int)__b);
15882 }
15883 
15884 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned int __a,
15885  vector bool int __b) {
15886  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
15887  (vector int)__b);
15888 }
15889 
15890 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool int __a,
15891  vector int __b) {
15892  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
15893  (vector int)__b);
15894 }
15895 
15896 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool int __a,
15897  vector unsigned int __b) {
15898  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
15899  (vector int)__b);
15900 }
15901 
15902 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool int __a,
15903  vector bool int __b) {
15904  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
15905  (vector int)__b);
15906 }
15907 
15908 #ifdef __POWER8_VECTOR__
15909 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed long long __a,
15910  vector signed long long __b) {
15911  return __builtin_altivec_vcmpequd_p(__CR6_LT_REV, __a, __b);
15912 }
15913 
15914 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned long long __a,
15915  vector unsigned long long __b) {
15916  return __builtin_altivec_vcmpequd_p(__CR6_LT_REV, (vector long long)__a,
15917  (vector long long)__b);
15918 }
15919 
15920 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed long long __a,
15921  vector bool long long __b) {
15922  return __builtin_altivec_vcmpequd_p(__CR6_LT_REV, __a,
15923  (vector signed long long)__b);
15924 }
15925 
15926 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned long long __a,
15927  vector bool long long __b) {
15928  return __builtin_altivec_vcmpequd_p(
15929  __CR6_LT_REV, (vector signed long long)__a, (vector signed long long)__b);
15930 }
15931 
15932 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool long long __a,
15933  vector signed long long __b) {
15934  return __builtin_altivec_vcmpequd_p(
15935  __CR6_LT_REV, (vector signed long long)__a, (vector signed long long)__b);
15936 }
15937 
15938 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool long long __a,
15939  vector unsigned long long __b) {
15940  return __builtin_altivec_vcmpequd_p(
15941  __CR6_LT_REV, (vector signed long long)__a, (vector signed long long)__b);
15942 }
15943 
15944 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool long long __a,
15945  vector bool long long __b) {
15946  return __builtin_altivec_vcmpequd_p(
15947  __CR6_LT_REV, (vector signed long long)__a, (vector signed long long)__b);
15948 }
15949 #endif
15950 
15951 static __inline__ int __ATTRS_o_ai vec_any_ne(vector float __a,
15952  vector float __b) {
15953 #ifdef __VSX__
15954  return __builtin_vsx_xvcmpeqsp_p(__CR6_LT_REV, __a, __b);
15955 #else
15956  return __builtin_altivec_vcmpeqfp_p(__CR6_LT_REV, __a, __b);
15957 #endif
15958 }
15959 
15960 #ifdef __VSX__
15961 static __inline__ int __ATTRS_o_ai vec_any_ne(vector double __a,
15962  vector double __b) {
15963  return __builtin_vsx_xvcmpeqdp_p(__CR6_LT_REV, __a, __b);
15964 }
15965 #endif
15966 
15967 /* vec_any_nge */
15968 
15969 static __inline__ int __attribute__((__always_inline__))
15970 vec_any_nge(vector float __a, vector float __b) {
15971  return __builtin_altivec_vcmpgefp_p(__CR6_LT_REV, __a, __b);
15972 }
15973 
15974 /* vec_any_ngt */
15975 
15976 static __inline__ int __attribute__((__always_inline__))
15977 vec_any_ngt(vector float __a, vector float __b) {
15978  return __builtin_altivec_vcmpgtfp_p(__CR6_LT_REV, __a, __b);
15979 }
15980 
15981 /* vec_any_nle */
15982 
15983 static __inline__ int __attribute__((__always_inline__))
15984 vec_any_nle(vector float __a, vector float __b) {
15985  return __builtin_altivec_vcmpgefp_p(__CR6_LT_REV, __b, __a);
15986 }
15987 
15988 /* vec_any_nlt */
15989 
15990 static __inline__ int __attribute__((__always_inline__))
15991 vec_any_nlt(vector float __a, vector float __b) {
15992  return __builtin_altivec_vcmpgtfp_p(__CR6_LT_REV, __b, __a);
15993 }
15994 
15995 /* vec_any_numeric */
15996 
15997 static __inline__ int __attribute__((__always_inline__))
15998 vec_any_numeric(vector float __a) {
15999  return __builtin_altivec_vcmpeqfp_p(__CR6_EQ_REV, __a, __a);
16000 }
16001 
16002 /* vec_any_out */
16003 
16004 static __inline__ int __attribute__((__always_inline__))
16005 vec_any_out(vector float __a, vector float __b) {
16006  return __builtin_altivec_vcmpbfp_p(__CR6_EQ_REV, __a, __b);
16007 }
16008 
16009 /* Power 8 Crypto functions
16010 Note: We diverge from the current GCC implementation with regard
16011 to cryptography and related functions as follows:
16012 - Only the SHA and AES instructions and builtins are disabled by -mno-crypto
16013 - The remaining ones are only available on Power8 and up so
16014  require -mpower8-vector
16015 The justification for this is that export requirements require that
16016 Category:Vector.Crypto is optional (i.e. compliant hardware may not provide
16017 support). As a result, we need to be able to turn off support for those.
16018 The remaining ones (currently controlled by -mcrypto for GCC) still
16019 need to be provided on compliant hardware even if Vector.Crypto is not
16020 provided.
16021 */
16022 #ifdef __CRYPTO__
16023 #define vec_sbox_be __builtin_altivec_crypto_vsbox
16024 #define vec_cipher_be __builtin_altivec_crypto_vcipher
16025 #define vec_cipherlast_be __builtin_altivec_crypto_vcipherlast
16026 #define vec_ncipher_be __builtin_altivec_crypto_vncipher
16027 #define vec_ncipherlast_be __builtin_altivec_crypto_vncipherlast
16028 
16029 static __inline__ vector unsigned long long __attribute__((__always_inline__))
16030 __builtin_crypto_vsbox(vector unsigned long long __a) {
16031  return __builtin_altivec_crypto_vsbox(__a);
16032 }
16033 
16034 static __inline__ vector unsigned long long __attribute__((__always_inline__))
16035 __builtin_crypto_vcipher(vector unsigned long long __a,
16036  vector unsigned long long __b) {
16037  return __builtin_altivec_crypto_vcipher(__a, __b);
16038 }
16039 
16040 static __inline__ vector unsigned long long __attribute__((__always_inline__))
16041 __builtin_crypto_vcipherlast(vector unsigned long long __a,
16042  vector unsigned long long __b) {
16043  return __builtin_altivec_crypto_vcipherlast(__a, __b);
16044 }
16045 
16046 static __inline__ vector unsigned long long __attribute__((__always_inline__))
16047 __builtin_crypto_vncipher(vector unsigned long long __a,
16048  vector unsigned long long __b) {
16049  return __builtin_altivec_crypto_vncipher(__a, __b);
16050 }
16051 
16052 static __inline__ vector unsigned long long __attribute__((__always_inline__))
16053 __builtin_crypto_vncipherlast(vector unsigned long long __a,
16054  vector unsigned long long __b) {
16055  return __builtin_altivec_crypto_vncipherlast(__a, __b);
16056 }
16057 
16058 #define __builtin_crypto_vshasigmad __builtin_altivec_crypto_vshasigmad
16059 #define __builtin_crypto_vshasigmaw __builtin_altivec_crypto_vshasigmaw
16060 
16061 #define vec_shasigma_be(X, Y, Z) \
16062  _Generic((X), vector unsigned int \
16063  : __builtin_crypto_vshasigmaw, vector unsigned long long \
16064  : __builtin_crypto_vshasigmad)((X), (Y), (Z))
16065 #endif
16066 
16067 #ifdef __POWER8_VECTOR__
16068 static __inline__ vector bool char __ATTRS_o_ai
16069 vec_permxor(vector bool char __a, vector bool char __b,
16070  vector bool char __c) {
16071  return __builtin_altivec_crypto_vpermxor(__a, __b, __c);
16072 }
16073 
16074 static __inline__ vector signed char __ATTRS_o_ai
16075 vec_permxor(vector signed char __a, vector signed char __b,
16076  vector signed char __c) {
16077  return __builtin_altivec_crypto_vpermxor(__a, __b, __c);
16078 }
16079 
16080 static __inline__ vector unsigned char __ATTRS_o_ai
16081 vec_permxor(vector unsigned char __a, vector unsigned char __b,
16082  vector unsigned char __c) {
16083  return __builtin_altivec_crypto_vpermxor(__a, __b, __c);
16084 }
16085 
16086 static __inline__ vector unsigned char __ATTRS_o_ai
16087 __builtin_crypto_vpermxor(vector unsigned char __a, vector unsigned char __b,
16088  vector unsigned char __c) {
16089  return __builtin_altivec_crypto_vpermxor(__a, __b, __c);
16090 }
16091 
16092 static __inline__ vector unsigned short __ATTRS_o_ai
16093 __builtin_crypto_vpermxor(vector unsigned short __a, vector unsigned short __b,
16094  vector unsigned short __c) {
16095  return (vector unsigned short)__builtin_altivec_crypto_vpermxor(
16096  (vector unsigned char)__a, (vector unsigned char)__b,
16097  (vector unsigned char)__c);
16098 }
16099 
16100 static __inline__ vector unsigned int __ATTRS_o_ai __builtin_crypto_vpermxor(
16101  vector unsigned int __a, vector unsigned int __b, vector unsigned int __c) {
16102  return (vector unsigned int)__builtin_altivec_crypto_vpermxor(
16103  (vector unsigned char)__a, (vector unsigned char)__b,
16104  (vector unsigned char)__c);
16105 }
16106 
16107 static __inline__ vector unsigned long long __ATTRS_o_ai
16108 __builtin_crypto_vpermxor(vector unsigned long long __a,
16109  vector unsigned long long __b,
16110  vector unsigned long long __c) {
16111  return (vector unsigned long long)__builtin_altivec_crypto_vpermxor(
16112  (vector unsigned char)__a, (vector unsigned char)__b,
16113  (vector unsigned char)__c);
16114 }
16115 
16116 static __inline__ vector unsigned char __ATTRS_o_ai
16117 __builtin_crypto_vpmsumb(vector unsigned char __a, vector unsigned char __b) {
16118  return __builtin_altivec_crypto_vpmsumb(__a, __b);
16119 }
16120 
16121 static __inline__ vector unsigned short __ATTRS_o_ai
16122 __builtin_crypto_vpmsumb(vector unsigned short __a, vector unsigned short __b) {
16123  return __builtin_altivec_crypto_vpmsumh(__a, __b);
16124 }
16125 
16126 static __inline__ vector unsigned int __ATTRS_o_ai
16127 __builtin_crypto_vpmsumb(vector unsigned int __a, vector unsigned int __b) {
16128  return __builtin_altivec_crypto_vpmsumw(__a, __b);
16129 }
16130 
16131 static __inline__ vector unsigned long long __ATTRS_o_ai
16132 __builtin_crypto_vpmsumb(vector unsigned long long __a,
16133  vector unsigned long long __b) {
16134  return __builtin_altivec_crypto_vpmsumd(__a, __b);
16135 }
16136 
16137 static __inline__ vector signed char __ATTRS_o_ai
16138 vec_vgbbd(vector signed char __a) {
16139  return __builtin_altivec_vgbbd((vector unsigned char)__a);
16140 }
16141 
16142 #define vec_pmsum_be __builtin_crypto_vpmsumb
16143 #define vec_gb __builtin_altivec_vgbbd
16144 
16145 static __inline__ vector unsigned char __ATTRS_o_ai
16146 vec_vgbbd(vector unsigned char __a) {
16147  return __builtin_altivec_vgbbd(__a);
16148 }
16149 
16150 static __inline__ vector long long __ATTRS_o_ai
16151 vec_vbpermq(vector signed char __a, vector signed char __b) {
16152  return __builtin_altivec_vbpermq((vector unsigned char)__a,
16153  (vector unsigned char)__b);
16154 }
16155 
16156 static __inline__ vector long long __ATTRS_o_ai
16157 vec_vbpermq(vector unsigned char __a, vector unsigned char __b) {
16158  return __builtin_altivec_vbpermq(__a, __b);
16159 }
16160 
16161 #ifdef __powerpc64__
16162 static __inline__ vector unsigned long long __attribute__((__always_inline__))
16163 vec_bperm(vector unsigned __int128 __a, vector unsigned char __b) {
16164  return __builtin_altivec_vbpermq((vector unsigned char)__a,
16165  (vector unsigned char)__b);
16166 }
16167 #endif
16168 #endif
16169 
16170 
16171 /* vec_reve */
16172 
16173 static inline __ATTRS_o_ai vector bool char vec_reve(vector bool char __a) {
16174  return __builtin_shufflevector(__a, __a, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6,
16175  5, 4, 3, 2, 1, 0);
16176 }
16177 
16178 static inline __ATTRS_o_ai vector signed char vec_reve(vector signed char __a) {
16179  return __builtin_shufflevector(__a, __a, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6,
16180  5, 4, 3, 2, 1, 0);
16181 }
16182 
16183 static inline __ATTRS_o_ai vector unsigned char
16184 vec_reve(vector unsigned char __a) {
16185  return __builtin_shufflevector(__a, __a, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6,
16186  5, 4, 3, 2, 1, 0);
16187 }
16188 
16189 static inline __ATTRS_o_ai vector bool int vec_reve(vector bool int __a) {
16190  return __builtin_shufflevector(__a, __a, 3, 2, 1, 0);
16191 }
16192 
16193 static inline __ATTRS_o_ai vector signed int vec_reve(vector signed int __a) {
16194  return __builtin_shufflevector(__a, __a, 3, 2, 1, 0);
16195 }
16196 
16197 static inline __ATTRS_o_ai vector unsigned int
16198 vec_reve(vector unsigned int __a) {
16199  return __builtin_shufflevector(__a, __a, 3, 2, 1, 0);
16200 }
16201 
16202 static inline __ATTRS_o_ai vector bool short vec_reve(vector bool short __a) {
16203  return __builtin_shufflevector(__a, __a, 7, 6, 5, 4, 3, 2, 1, 0);
16204 }
16205 
16206 static inline __ATTRS_o_ai vector signed short
16207 vec_reve(vector signed short __a) {
16208  return __builtin_shufflevector(__a, __a, 7, 6, 5, 4, 3, 2, 1, 0);
16209 }
16210 
16211 static inline __ATTRS_o_ai vector unsigned short
16212 vec_reve(vector unsigned short __a) {
16213  return __builtin_shufflevector(__a, __a, 7, 6, 5, 4, 3, 2, 1, 0);
16214 }
16215 
16216 static inline __ATTRS_o_ai vector float vec_reve(vector float __a) {
16217  return __builtin_shufflevector(__a, __a, 3, 2, 1, 0);
16218 }
16219 
16220 #ifdef __VSX__
16221 static inline __ATTRS_o_ai vector bool long long
16222 vec_reve(vector bool long long __a) {
16223  return __builtin_shufflevector(__a, __a, 1, 0);
16224 }
16225 
16226 static inline __ATTRS_o_ai vector signed long long
16227 vec_reve(vector signed long long __a) {
16228  return __builtin_shufflevector(__a, __a, 1, 0);
16229 }
16230 
16231 static inline __ATTRS_o_ai vector unsigned long long
16232 vec_reve(vector unsigned long long __a) {
16233  return __builtin_shufflevector(__a, __a, 1, 0);
16234 }
16235 
16236 static inline __ATTRS_o_ai vector double vec_reve(vector double __a) {
16237  return __builtin_shufflevector(__a, __a, 1, 0);
16238 }
16239 #endif
16240 
16241 /* vec_revb */
16242 static __inline__ vector bool char __ATTRS_o_ai
16243 vec_revb(vector bool char __a) {
16244  return __a;
16245 }
16246 
16247 static __inline__ vector signed char __ATTRS_o_ai
16248 vec_revb(vector signed char __a) {
16249  return __a;
16250 }
16251 
16252 static __inline__ vector unsigned char __ATTRS_o_ai
16253 vec_revb(vector unsigned char __a) {
16254  return __a;
16255 }
16256 
16257 static __inline__ vector bool short __ATTRS_o_ai
16258 vec_revb(vector bool short __a) {
16259  vector unsigned char __indices =
16260  { 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14 };
16261  return vec_perm(__a, __a, __indices);
16262 }
16263 
16264 static __inline__ vector signed short __ATTRS_o_ai
16265 vec_revb(vector signed short __a) {
16266  vector unsigned char __indices =
16267  { 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14 };
16268  return vec_perm(__a, __a, __indices);
16269 }
16270 
16271 static __inline__ vector unsigned short __ATTRS_o_ai
16272 vec_revb(vector unsigned short __a) {
16273  vector unsigned char __indices =
16274  { 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14 };
16275  return vec_perm(__a, __a, __indices);
16276 }
16277 
16278 static __inline__ vector bool int __ATTRS_o_ai
16279 vec_revb(vector bool int __a) {
16280  vector unsigned char __indices =
16281  { 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12 };
16282  return vec_perm(__a, __a, __indices);
16283 }
16284 
16285 static __inline__ vector signed int __ATTRS_o_ai
16286 vec_revb(vector signed int __a) {
16287  vector unsigned char __indices =
16288  { 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12 };
16289  return vec_perm(__a, __a, __indices);
16290 }
16291 
16292 static __inline__ vector unsigned int __ATTRS_o_ai
16293 vec_revb(vector unsigned int __a) {
16294  vector unsigned char __indices =
16295  { 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12 };
16296  return vec_perm(__a, __a, __indices);
16297 }
16298 
16299 static __inline__ vector float __ATTRS_o_ai
16300 vec_revb(vector float __a) {
16301  vector unsigned char __indices =
16302  { 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12 };
16303  return vec_perm(__a, __a, __indices);
16304 }
16305 
16306 #ifdef __VSX__
16307 static __inline__ vector bool long long __ATTRS_o_ai
16308 vec_revb(vector bool long long __a) {
16309  vector unsigned char __indices =
16310  { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8 };
16311  return vec_perm(__a, __a, __indices);
16312 }
16313 
16314 static __inline__ vector signed long long __ATTRS_o_ai
16315 vec_revb(vector signed long long __a) {
16316  vector unsigned char __indices =
16317  { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8 };
16318  return vec_perm(__a, __a, __indices);
16319 }
16320 
16321 static __inline__ vector unsigned long long __ATTRS_o_ai
16322 vec_revb(vector unsigned long long __a) {
16323  vector unsigned char __indices =
16324  { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8 };
16325  return vec_perm(__a, __a, __indices);
16326 }
16327 
16328 static __inline__ vector double __ATTRS_o_ai
16329 vec_revb(vector double __a) {
16330  vector unsigned char __indices =
16331  { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8 };
16332  return vec_perm(__a, __a, __indices);
16333 }
16334 #endif /* End __VSX__ */
16335 
16336 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
16337 static __inline__ vector signed __int128 __ATTRS_o_ai
16338 vec_revb(vector signed __int128 __a) {
16339  vector unsigned char __indices =
16340  { 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
16341  return (vector signed __int128)vec_perm((vector signed int)__a,
16342  (vector signed int)__a,
16343  __indices);
16344 }
16345 
16346 static __inline__ vector unsigned __int128 __ATTRS_o_ai
16347 vec_revb(vector unsigned __int128 __a) {
16348  vector unsigned char __indices =
16349  { 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
16350  return (vector unsigned __int128)vec_perm((vector signed int)__a,
16351  (vector signed int)__a,
16352  __indices);
16353 }
16354 #endif /* END __POWER8_VECTOR__ && __powerpc64__ */
16355 
16356 /* vec_xl */
16357 
16358 typedef vector signed char unaligned_vec_schar __attribute__((aligned(1)));
16359 typedef vector unsigned char unaligned_vec_uchar __attribute__((aligned(1)));
16360 typedef vector signed short unaligned_vec_sshort __attribute__((aligned(1)));
16361 typedef vector unsigned short unaligned_vec_ushort __attribute__((aligned(1)));
16362 typedef vector signed int unaligned_vec_sint __attribute__((aligned(1)));
16363 typedef vector unsigned int unaligned_vec_uint __attribute__((aligned(1)));
16364 typedef vector float unaligned_vec_float __attribute__((aligned(1)));
16365 
16366 static inline __ATTRS_o_ai vector signed char vec_xl(signed long long __offset,
16367  signed char *__ptr) {
16368  return *(unaligned_vec_schar *)(__ptr + __offset);
16369 }
16370 
16371 static inline __ATTRS_o_ai vector unsigned char
16372 vec_xl(signed long long __offset, unsigned char *__ptr) {
16373  return *(unaligned_vec_uchar*)(__ptr + __offset);
16374 }
16375 
16376 static inline __ATTRS_o_ai vector signed short vec_xl(signed long long __offset,
16377  signed short *__ptr) {
16378  return *(unaligned_vec_sshort *)(__ptr + __offset);
16379 }
16380 
16381 static inline __ATTRS_o_ai vector unsigned short
16382 vec_xl(signed long long __offset, unsigned short *__ptr) {
16383  return *(unaligned_vec_ushort *)(__ptr + __offset);
16384 }
16385 
16386 static inline __ATTRS_o_ai vector signed int vec_xl(signed long long __offset,
16387  signed int *__ptr) {
16388  return *(unaligned_vec_sint *)(__ptr + __offset);
16389 }
16390 
16391 static inline __ATTRS_o_ai vector unsigned int vec_xl(signed long long __offset,
16392  unsigned int *__ptr) {
16393  return *(unaligned_vec_uint *)(__ptr + __offset);
16394 }
16395 
16396 static inline __ATTRS_o_ai vector float vec_xl(signed long long __offset,
16397  float *__ptr) {
16398  return *(unaligned_vec_float *)(__ptr + __offset);
16399 }
16400 
16401 #ifdef __VSX__
16402 typedef vector signed long long unaligned_vec_sll __attribute__((aligned(1)));
16403 typedef vector unsigned long long unaligned_vec_ull __attribute__((aligned(1)));
16404 typedef vector double unaligned_vec_double __attribute__((aligned(1)));
16405 
16406 static inline __ATTRS_o_ai vector signed long long
16407 vec_xl(signed long long __offset, signed long long *__ptr) {
16408  return *(unaligned_vec_sll *)(__ptr + __offset);
16409 }
16410 
16411 static inline __ATTRS_o_ai vector unsigned long long
16412 vec_xl(signed long long __offset, unsigned long long *__ptr) {
16413  return *(unaligned_vec_ull *)(__ptr + __offset);
16414 }
16415 
16416 static inline __ATTRS_o_ai vector double vec_xl(signed long long __offset,
16417  double *__ptr) {
16418  return *(unaligned_vec_double *)(__ptr + __offset);
16419 }
16420 #endif
16421 
16422 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
16423 typedef vector signed __int128 unaligned_vec_si128 __attribute__((aligned(1)));
16424 typedef vector unsigned __int128 unaligned_vec_ui128
16425  __attribute__((aligned(1)));
16426 static inline __ATTRS_o_ai vector signed __int128
16427 vec_xl(signed long long __offset, signed __int128 *__ptr) {
16428  return *(unaligned_vec_si128 *)(__ptr + __offset);
16429 }
16430 
16431 static inline __ATTRS_o_ai vector unsigned __int128
16432 vec_xl(signed long long __offset, unsigned __int128 *__ptr) {
16433  return *(unaligned_vec_ui128 *)(__ptr + __offset);
16434 }
16435 #endif
16436 
16437 /* vec_xl_be */
16438 
16439 #ifdef __LITTLE_ENDIAN__
16440 static __inline__ vector signed char __ATTRS_o_ai
16441 vec_xl_be(signed long long __offset, signed char *__ptr) {
16442  vector signed char __vec = __builtin_vsx_lxvd2x_be(__offset, __ptr);
16443  return __builtin_shufflevector(__vec, __vec, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14,
16444  13, 12, 11, 10, 9, 8);
16445 }
16446 
16447 static __inline__ vector unsigned char __ATTRS_o_ai
16448 vec_xl_be(signed long long __offset, unsigned char *__ptr) {
16449  vector unsigned char __vec = __builtin_vsx_lxvd2x_be(__offset, __ptr);
16450  return __builtin_shufflevector(__vec, __vec, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14,
16451  13, 12, 11, 10, 9, 8);
16452 }
16453 
16454 static __inline__ vector signed short __ATTRS_o_ai
16455 vec_xl_be(signed long long __offset, signed short *__ptr) {
16456  vector signed short __vec = __builtin_vsx_lxvd2x_be(__offset, __ptr);
16457  return __builtin_shufflevector(__vec, __vec, 3, 2, 1, 0, 7, 6, 5, 4);
16458 }
16459 
16460 static __inline__ vector unsigned short __ATTRS_o_ai
16461 vec_xl_be(signed long long __offset, unsigned short *__ptr) {
16462  vector unsigned short __vec = __builtin_vsx_lxvd2x_be(__offset, __ptr);
16463  return __builtin_shufflevector(__vec, __vec, 3, 2, 1, 0, 7, 6, 5, 4);
16464 }
16465 
16466 static __inline__ vector signed int __ATTRS_o_ai
16467 vec_xl_be(signed long long __offset, signed int *__ptr) {
16468  return (vector signed int)__builtin_vsx_lxvw4x_be(__offset, __ptr);
16469 }
16470 
16471 static __inline__ vector unsigned int __ATTRS_o_ai
16472 vec_xl_be(signed long long __offset, unsigned int *__ptr) {
16473  return (vector unsigned int)__builtin_vsx_lxvw4x_be(__offset, __ptr);
16474 }
16475 
16476 static __inline__ vector float __ATTRS_o_ai
16477 vec_xl_be(signed long long __offset, float *__ptr) {
16478  return (vector float)__builtin_vsx_lxvw4x_be(__offset, __ptr);
16479 }
16480 
16481 #ifdef __VSX__
16482 static __inline__ vector signed long long __ATTRS_o_ai
16483 vec_xl_be(signed long long __offset, signed long long *__ptr) {
16484  return (vector signed long long)__builtin_vsx_lxvd2x_be(__offset, __ptr);
16485 }
16486 
16487 static __inline__ vector unsigned long long __ATTRS_o_ai
16488 vec_xl_be(signed long long __offset, unsigned long long *__ptr) {
16489  return (vector unsigned long long)__builtin_vsx_lxvd2x_be(__offset, __ptr);
16490 }
16491 
16492 static __inline__ vector double __ATTRS_o_ai
16493 vec_xl_be(signed long long __offset, double *__ptr) {
16494  return (vector double)__builtin_vsx_lxvd2x_be(__offset, __ptr);
16495 }
16496 #endif
16497 
16498 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
16499 static __inline__ vector signed __int128 __ATTRS_o_ai
16500 vec_xl_be(signed long long __offset, signed __int128 *__ptr) {
16501  return vec_xl(__offset, __ptr);
16502 }
16503 
16504 static __inline__ vector unsigned __int128 __ATTRS_o_ai
16505 vec_xl_be(signed long long __offset, unsigned __int128 *__ptr) {
16506  return vec_xl(__offset, __ptr);
16507 }
16508 #endif
16509 #else
16510  #define vec_xl_be vec_xl
16511 #endif
16512 
16513 /* vec_xst */
16514 
16515 static inline __ATTRS_o_ai void vec_xst(vector signed char __vec,
16516  signed long long __offset,
16517  signed char *__ptr) {
16518  *(unaligned_vec_schar *)(__ptr + __offset) = __vec;
16519 }
16520 
16521 static inline __ATTRS_o_ai void vec_xst(vector unsigned char __vec,
16522  signed long long __offset,
16523  unsigned char *__ptr) {
16524  *(unaligned_vec_uchar *)(__ptr + __offset) = __vec;
16525 }
16526 
16527 static inline __ATTRS_o_ai void vec_xst(vector signed short __vec,
16528  signed long long __offset,
16529  signed short *__ptr) {
16530  *(unaligned_vec_sshort *)(__ptr + __offset) = __vec;
16531 }
16532 
16533 static inline __ATTRS_o_ai void vec_xst(vector unsigned short __vec,
16534  signed long long __offset,
16535  unsigned short *__ptr) {
16536  *(unaligned_vec_ushort *)(__ptr + __offset) = __vec;
16537 }
16538 
16539 static inline __ATTRS_o_ai void vec_xst(vector signed int __vec,
16540  signed long long __offset,
16541  signed int *__ptr) {
16542  *(unaligned_vec_sint *)(__ptr + __offset) = __vec;
16543 }
16544 
16545 static inline __ATTRS_o_ai void vec_xst(vector unsigned int __vec,
16546  signed long long __offset,
16547  unsigned int *__ptr) {
16548  *(unaligned_vec_uint *)(__ptr + __offset) = __vec;
16549 }
16550 
16551 static inline __ATTRS_o_ai void vec_xst(vector float __vec,
16552  signed long long __offset,
16553  float *__ptr) {
16554  *(unaligned_vec_float *)(__ptr + __offset) = __vec;
16555 }
16556 
16557 #ifdef __VSX__
16558 static inline __ATTRS_o_ai void vec_xst(vector signed long long __vec,
16559  signed long long __offset,
16560  signed long long *__ptr) {
16561  *(unaligned_vec_sll *)(__ptr + __offset) = __vec;
16562 }
16563 
16564 static inline __ATTRS_o_ai void vec_xst(vector unsigned long long __vec,
16565  signed long long __offset,
16566  unsigned long long *__ptr) {
16567  *(unaligned_vec_ull *)(__ptr + __offset) = __vec;
16568 }
16569 
16570 static inline __ATTRS_o_ai void vec_xst(vector double __vec,
16571  signed long long __offset,
16572  double *__ptr) {
16573  *(unaligned_vec_double *)(__ptr + __offset) = __vec;
16574 }
16575 #endif
16576 
16577 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
16578 static inline __ATTRS_o_ai void vec_xst(vector signed __int128 __vec,
16579  signed long long __offset,
16580  signed __int128 *__ptr) {
16581  *(unaligned_vec_si128 *)(__ptr + __offset) = __vec;
16582 }
16583 
16584 static inline __ATTRS_o_ai void vec_xst(vector unsigned __int128 __vec,
16585  signed long long __offset,
16586  unsigned __int128 *__ptr) {
16587  *(unaligned_vec_ui128 *)(__ptr + __offset) = __vec;
16588 }
16589 #endif
16590 
16591 /* vec_xst_be */
16592 
16593 #ifdef __LITTLE_ENDIAN__
16594 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed char __vec,
16595  signed long long __offset,
16596  signed char *__ptr) {
16597  vector signed char __tmp =
16598  __builtin_shufflevector(__vec, __vec, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14,
16599  13, 12, 11, 10, 9, 8);
16600  __builtin_vsx_stxvd2x_be(__tmp, __offset, __ptr);
16601 }
16602 
16603 static __inline__ void __ATTRS_o_ai vec_xst_be(vector unsigned char __vec,
16604  signed long long __offset,
16605  unsigned char *__ptr) {
16606  vector unsigned char __tmp =
16607  __builtin_shufflevector(__vec, __vec, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14,
16608  13, 12, 11, 10, 9, 8);
16609  __builtin_vsx_stxvd2x_be(__tmp, __offset, __ptr);
16610 }
16611 
16612 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed short __vec,
16613  signed long long __offset,
16614  signed short *__ptr) {
16615  vector signed short __tmp =
16616  __builtin_shufflevector(__vec, __vec, 3, 2, 1, 0, 7, 6, 5, 4);
16617  __builtin_vsx_stxvd2x_be(__tmp, __offset, __ptr);
16618 }
16619 
16620 static __inline__ void __ATTRS_o_ai vec_xst_be(vector unsigned short __vec,
16621  signed long long __offset,
16622  unsigned short *__ptr) {
16623  vector unsigned short __tmp =
16624  __builtin_shufflevector(__vec, __vec, 3, 2, 1, 0, 7, 6, 5, 4);
16625  __builtin_vsx_stxvd2x_be(__tmp, __offset, __ptr);
16626 }
16627 
16628 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed int __vec,
16629  signed long long __offset,
16630  signed int *__ptr) {
16631  __builtin_vsx_stxvw4x_be(__vec, __offset, __ptr);
16632 }
16633 
16634 static __inline__ void __ATTRS_o_ai vec_xst_be(vector unsigned int __vec,
16635  signed long long __offset,
16636  unsigned int *__ptr) {
16637  __builtin_vsx_stxvw4x_be(__vec, __offset, __ptr);
16638 }
16639 
16640 static __inline__ void __ATTRS_o_ai vec_xst_be(vector float __vec,
16641  signed long long __offset,
16642  float *__ptr) {
16643  __builtin_vsx_stxvw4x_be(__vec, __offset, __ptr);
16644 }
16645 
16646 #ifdef __VSX__
16647 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed long long __vec,
16648  signed long long __offset,
16649  signed long long *__ptr) {
16650  __builtin_vsx_stxvd2x_be(__vec, __offset, __ptr);
16651 }
16652 
16653 static __inline__ void __ATTRS_o_ai vec_xst_be(vector unsigned long long __vec,
16654  signed long long __offset,
16655  unsigned long long *__ptr) {
16656  __builtin_vsx_stxvd2x_be(__vec, __offset, __ptr);
16657 }
16658 
16659 static __inline__ void __ATTRS_o_ai vec_xst_be(vector double __vec,
16660  signed long long __offset,
16661  double *__ptr) {
16662  __builtin_vsx_stxvd2x_be(__vec, __offset, __ptr);
16663 }
16664 #endif
16665 
16666 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
16667 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed __int128 __vec,
16668  signed long long __offset,
16669  signed __int128 *__ptr) {
16670  vec_xst(__vec, __offset, __ptr);
16671 }
16672 
16673 static __inline__ void __ATTRS_o_ai vec_xst_be(vector unsigned __int128 __vec,
16674  signed long long __offset,
16675  unsigned __int128 *__ptr) {
16676  vec_xst(__vec, __offset, __ptr);
16677 }
16678 #endif
16679 #else
16680  #define vec_xst_be vec_xst
16681 #endif
16682 
16683 #ifdef __POWER9_VECTOR__
16684 #define vec_test_data_class(__a, __b) \
16685  _Generic((__a), \
16686  vector float: \
16687  (vector bool int)__builtin_vsx_xvtstdcsp((__a), (__b)), \
16688  vector double: \
16689  (vector bool long long)__builtin_vsx_xvtstdcdp((__a), (__b)) \
16690  )
16691 
16692 #endif /* #ifdef __POWER9_VECTOR__ */
16693 
16694 static vector float __ATTRS_o_ai vec_neg(vector float __a) {
16695  return -__a;
16696 }
16697 
16698 #ifdef __VSX__
16699 static vector double __ATTRS_o_ai vec_neg(vector double __a) {
16700  return -__a;
16701 }
16702 
16703 #endif
16704 
16705 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
16706 static vector long long __ATTRS_o_ai vec_neg(vector long long __a) {
16707  return -__a;
16708 }
16709 #endif
16710 
16711 static vector signed int __ATTRS_o_ai vec_neg(vector signed int __a) {
16712  return -__a;
16713 }
16714 
16715 static vector signed short __ATTRS_o_ai vec_neg(vector signed short __a) {
16716  return -__a;
16717 }
16718 
16719 static vector signed char __ATTRS_o_ai vec_neg(vector signed char __a) {
16720  return -__a;
16721 }
16722 
16723 static vector float __ATTRS_o_ai vec_nabs(vector float __a) {
16724  return - vec_abs(__a);
16725 }
16726 
16727 #ifdef __VSX__
16728 static vector double __ATTRS_o_ai vec_nabs(vector double __a) {
16729  return - vec_abs(__a);
16730 }
16731 
16732 #endif
16733 
16734 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
16735 static vector long long __ATTRS_o_ai vec_nabs(vector long long __a) {
16736  return __builtin_altivec_vminsd(__a, -__a);
16737 }
16738 #endif
16739 
16740 static vector signed int __ATTRS_o_ai vec_nabs(vector signed int __a) {
16741  return __builtin_altivec_vminsw(__a, -__a);
16742 }
16743 
16744 static vector signed short __ATTRS_o_ai vec_nabs(vector signed short __a) {
16745  return __builtin_altivec_vminsh(__a, -__a);
16746 }
16747 
16748 static vector signed char __ATTRS_o_ai vec_nabs(vector signed char __a) {
16749  return __builtin_altivec_vminsb(__a, -__a);
16750 }
16751 #undef __ATTRS_o_ai
16752 
16753 #endif /* __ALTIVEC_H */
static __inline__ vector int __ATTRS_o_ai vec_vupkhsh(vector short __a)
Definition: altivec.h:11712
#define __CR6_LT_REV
Definition: altivec.h:35
static __inline__ vector short __ATTRS_o_ai vec_vsrh(vector short __a, vector unsigned short __b)
Definition: altivec.h:9562
static __inline__ void __ATTRS_o_ai vec_stvehx(vector short __a, int __b, short *__c)
Definition: altivec.h:10594
static __inline__ vector signed char __ATTRS_o_ai vec_srl(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:9668
static __inline__ vector unsigned int __ATTRS_o_ai vec_vmaxuw(vector unsigned int __a, vector unsigned int __b)
Definition: altivec.h:4462
static __inline__ vector signed char __ATTRS_o_ai vec_rl(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:7600
static __inline__ int __ATTRS_o_ai vec_any_le(vector signed char __a, vector signed char __b)
Definition: altivec.h:15416
static __inline__ vector int __ATTRS_o_ai vec_sum4s(vector signed char __a, vector int __b)
Definition: altivec.h:11486
static __inline__ vector int __ATTRS_o_ai vec_msums(vector short __a, vector short __b, vector int __c)
Definition: altivec.h:5514
static __inline__ vector int __ATTRS_o_ai vec_vupklsh(vector short __a)
Definition: altivec.h:11851
static __inline__ vector signed char __ATTRS_o_ai vec_packs(vector short __a, vector short __b)
Definition: altivec.h:7028
static __inline__ vector signed char __ATTRS_o_ai vec_vsr(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:9855
static __inline__ vector unsigned char __ATTRS_o_ai vec_vpkshus(vector short __a, vector short __b)
Definition: altivec.h:7215
static __inline__ vector unsigned int __ATTRS_o_ai vec_vadduws(vector unsigned int __a, vector unsigned int __b)
Definition: altivec.h:751
static __inline__ vector unsigned int __ATTRS_o_ai vec_vminuw(vector unsigned int __a, vector unsigned int __b)
Definition: altivec.h:5366
static __inline__ vector signed char __ATTRS_o_ai vec_ld(int __a, const vector signed char *__b)
Definition: altivec.h:3460
static __inline__ vector float __ATTRS_o_ai vec_ceil(vector float __a)
Definition: altivec.h:1601
static __inline__ vector float __ATTRS_o_ai vec_trunc(vector float __a)
Definition: altivec.h:11596
static __inline__ vector int __ATTRS_o_ai vec_vsrw(vector int __a, vector unsigned int __b)
Definition: altivec.h:9575
static __inline__ vector unsigned char __ATTRS_o_ai vec_packsu(vector short __a, vector short __b)
Definition: altivec.h:7157
static __inline__ vector unsigned int __ATTRS_o_ai vec_vsubuws(vector unsigned int __a, vector unsigned int __b)
Definition: altivec.h:11364
static __inline__ vector bool char __ATTRS_o_ai vec_cmple(vector signed char __a, vector signed char __b)
Definition: altivec.h:2098
static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed char __a, vector signed char __b)
Definition: altivec.h:14870
static __inline__ vector signed int __ATTRS_o_ai vec_adde(vector signed int __a, vector signed int __b, vector signed int __c)
Definition: altivec.h:352
static __inline__ vector signed char __ATTRS_o_ai vec_vand(vector signed char __a, vector signed char __b)
Definition: altivec.h:1010
vector signed char unaligned_vec_schar __attribute__((aligned(1)))
Zeroes the upper 128 bits (bits 255:128) of all YMM registers.
Definition: altivec.h:16358
static __inline__ vector signed char __ATTRS_o_ai vec_vandc(vector signed char __a, vector signed char __b)
Definition: altivec.h:1363
static __inline__ vector signed char __ATTRS_o_ai vec_sel(vector signed char __a, vector signed char __b, vector unsigned char __c)
Definition: altivec.h:7789
static __inline__ vector int __ATTRS_o_ai vec_lvewx(int __a, const int *__b)
Definition: altivec.h:3695
static __inline__ vector signed char __ATTRS_o_ai vec_vspltisb(signed char __a)
Definition: altivec.h:9433
static __inline__ vector short __ATTRS_o_ai vec_vadduhm(vector short __a, vector short __b)
Definition: altivec.h:465
static __inline__ vector signed char __ATTRS_o_ai vec_vperm(vector signed char __a, vector signed char __b, vector unsigned char __c)
Definition: altivec.h:7497
static __inline__ vector signed char __ATTRS_o_ai vec_mergel(vector signed char __a, vector signed char __b)
Definition: altivec.h:4760
static __inline__ vector signed char __ATTRS_o_ai vec_abss(vector signed char __a)
Definition: altivec.h:172
static __inline__ vector signed char __ATTRS_o_ai vec_div(vector signed char __a, vector signed char __b)
Definition: altivec.h:3250
static __inline__ vector signed char __ATTRS_o_ai vec_adds(vector signed char __a, vector signed char __b)
Definition: altivec.h:574
static __inline__ vector short __ATTRS_o_ai vec_mulo(vector signed char __a, vector signed char __b)
Definition: altivec.h:5754
static __inline__ vector unsigned int __ATTRS_o_ai vec_unsigned(vector float __a)
Definition: altivec.h:3012
static __inline__ vector signed char __ATTRS_o_ai vec_lde(int __a, const signed char *__b)
Definition: altivec.h:3638
static __inline__ vector signed char __ATTRS_o_ai vec_vsububm(vector signed char __a, vector signed char __b)
Definition: altivec.h:11046
static __inline__ vector signed char __ATTRS_o_ai vec_nor(vector signed char __a, vector signed char __b)
Definition: altivec.h:6054
static __inline__ vector unsigned short __ATTRS_o_ai vec_vadduhs(vector unsigned short __a, vector unsigned short __b)
Definition: altivec.h:717
static __inline__ vector signed char __ATTRS_o_ai vec_splat(vector signed char __a, unsigned const int __b)
Definition: altivec.h:9195
static __inline__ vector signed char __ATTRS_o_ai vec_vaddubm(vector signed char __a, vector signed char __b)
Definition: altivec.h:432
static __inline__ vector bool char __ATTRS_o_ai vec_cmplt(vector signed char __a, vector signed char __b)
Definition: altivec.h:2154
static __inline__ void __ATTRS_o_ai vec_mtvscr(vector signed char __a)
Definition: altivec.h:5543
static __inline__ vector signed char __ATTRS_o_ai vec_sll(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:8629
static __inline__ vector int __ATTRS_o_ai vec_vmrglw(vector int __a, vector int __b)
Definition: altivec.h:4988
static __inline__ vector signed char __ATTRS_o_ai vec_sldw(vector signed char __a, vector signed char __b, unsigned const int __c)
Definition: altivec.h:8416
static __inline__ vector signed int __ATTRS_o_ai vec_sube(vector signed int __a, vector signed int __b, vector signed int __c)
Definition: altivec.h:11470
static __inline__ vector short __ATTRS_o_ai vec_vsubuhm(vector short __a, vector short __b)
Definition: altivec.h:11079
static __inline__ vector signed char __ATTRS_o_ai vec_vnor(vector signed char __a, vector signed char __b)
Definition: altivec.h:6117
static __inline__ vector signed char __ATTRS_o_ai vec_and(vector signed char __a, vector signed char __b)
Definition: altivec.h:824
static __inline__ vector signed char __ATTRS_o_ai vec_add(vector signed char __a, vector signed char __b)
Definition: altivec.h:212
static __inline__ vector int __ATTRS_o_ai vec_msum(vector signed char __a, vector unsigned char __b, vector int __c)
Definition: altivec.h:5458
static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed char __a, vector signed char __b)
Definition: altivec.h:13916
static __inline__ vector short __ATTRS_o_ai vec_vmrglh(vector short __a, vector short __b)
Definition: altivec.h:4952
static __inline__ vector signed char __ATTRS_o_ai vec_vsel(vector signed char __a, vector signed char __b, vector unsigned char __c)
Definition: altivec.h:7923
static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed char __a, vector signed char __b)
Definition: altivec.h:15781
#define __CR6_EQ_REV
Definition: altivec.h:33
static __inline__ vector signed short __ATTRS_o_ai vec_mladd(vector signed short, vector signed short, vector signed short)
static __inline__ void __ATTRS_o_ai vec_stvewx(vector int __a, int __b, int *__c)
Definition: altivec.h:10626
static __inline__ vector unsigned char __ATTRS_o_ai vec_xor(vector unsigned char __a, vector unsigned char __b)
Definition: altivec.h:12178
static __inline__ vector signed char __ATTRS_o_ai vec_sro(vector signed char __a, vector signed char __b)
Definition: altivec.h:10028
static __inline__ vector short __ATTRS_o_ai vec_vsplth(vector short __a, unsigned char __b)
Definition: altivec.h:9343
static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsl(int __a, const signed char *__b)
Definition: altivec.h:3917
#define __CR6_LT
Definition: altivec.h:34
static __inline__ vector signed char __ATTRS_o_ai vec_vminsb(vector signed char __a, vector signed char __b)
Definition: altivec.h:5281
static __inline__ void int __a
Definition: emmintrin.h:4204
static vector float __ATTRS_o_ai vec_nabs(vector float __a)
Definition: altivec.h:16723
static __inline__ vector signed char __ATTRS_o_ai vec_insert(signed char __a, vector signed char __b, int __c)
Definition: altivec.h:12637
static __inline__ vector signed char __ATTRS_o_ai vec_lvrxl(int __a, const signed char *__b)
Definition: altivec.h:13046
#define NULL
Definition: opencl-c.h:158
static __ATTRS_o_ai vector signed char vec_xl(signed long long __offset, signed char *__ptr)
Definition: altivec.h:16366
static __inline__ vector signed char __ATTRS_o_ai vec_vpkuhum(vector signed short __a, vector signed short __b)
Definition: altivec.h:6860
static __inline__ vector float __ATTRS_o_ai vec_rsqrte(vector float __a)
Definition: altivec.h:7764
static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed char __a, vector signed char __b)
Definition: altivec.h:15595
static __inline__ vector unsigned char __ATTRS_o_ai vec_sl(vector unsigned char __a, vector unsigned char __b)
Definition: altivec.h:8043
static __inline__ vector signed short __ATTRS_o_ai vec_madd(vector signed short __a, vector signed short __b, vector signed short __c)
Definition: altivec.h:4155
static __inline__ int __ATTRS_o_ai vec_all_nge(vector float __a, vector float __b)
Definition: altivec.h:14813
static __inline__ vector float __ATTRS_o_ai vec_float(vector signed int __a)
Definition: altivec.h:3054
static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed char __a, vector signed char __b)
Definition: altivec.h:14087
static __inline__ vector unsigned char __ATTRS_o_ai vec_vmaxub(vector unsigned char __a, vector unsigned char __b)
Definition: altivec.h:4394
static __inline__ vector signed char __ATTRS_o_ai vec_subs(vector signed char __a, vector signed char __b)
Definition: altivec.h:11187
static __inline__ vector signed char __ATTRS_o_ai vec_mul(vector signed char __a, vector signed char __b)
Definition: altivec.h:5594
static __inline__ vector int __ATTRS_o_ai vec_vadduwm(vector int __a, vector int __b)
Definition: altivec.h:499
static __inline__ vector float __ATTRS_o_ai vec_floor(vector float __a)
Definition: altivec.h:3436
static __inline__ vector signed char __ATTRS_o_ai vec_or(vector signed char __a, vector signed char __b)
Definition: altivec.h:6190
static __inline__ vector signed char __ATTRS_o_ai vec_andc(vector signed char __a, vector signed char __b)
Definition: altivec.h:1177
static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed char __a, vector signed char __b)
Definition: altivec.h:15058
static __inline__ vector unsigned char __ATTRS_o_ai vec_vsububs(vector unsigned char __a, vector unsigned char __b)
Definition: altivec.h:11296
static __inline__ vector short __ATTRS_o_ai vec_vaddshs(vector short __a, vector short __b)
Definition: altivec.h:699
static __inline__ vector signed int __ATTRS_o_ai vec_signed(vector float __a)
Definition: altivec.h:2970
static __inline__ vector signed char __ATTRS_o_ai vec_slo(vector signed char __a, vector signed char __b)
Definition: altivec.h:8989
static __inline__ vector unsigned short __ATTRS_o_ai vec_vpkswus(vector int __a, vector int __b)
Definition: altivec.h:7235
static __inline__ vector signed char __ATTRS_o_ai vec_vsrab(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:9632
static __inline__ vector bool char __ATTRS_o_ai vec_cmpeq(vector signed char __a, vector signed char __b)
Definition: altivec.h:1639
static __inline__ vector signed char __ATTRS_o_ai vec_splats(signed char __a)
Definition: altivec.h:13665
static __inline__ void __ATTRS_o_ai vec_stvlx(vector signed char __a, int __b, signed char *__c)
Definition: altivec.h:13151
static __inline__ vector signed char __ATTRS_o_ai vec_sub(vector signed char __a, vector signed char __b)
Definition: altivec.h:10918
static __inline__ vector signed char __ATTRS_o_ai vec_sra(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:9588
static __inline__ void __ATTRS_o_ai vec_stvx(vector signed char __a, int __b, vector signed char *__c)
Definition: altivec.h:10364
static __inline__ vector int __ATTRS_o_ai vec_vmrghw(vector int __a, vector int __b)
Definition: altivec.h:4725
static __inline__ vector int __ATTRS_o_ai vec_vspltw(vector int __a, unsigned char __b)
Definition: altivec.h:9383
static __inline__ vector signed int __ATTRS_o_ai vec_subc(vector signed int __a, vector signed int __b)
Definition: altivec.h:11155
static __inline__ vector signed char __ATTRS_o_ai vec_max(vector signed char __a, vector signed char __b)
Definition: altivec.h:4237
static __inline__ vector signed char __ATTRS_o_ai vec_vmaxsb(vector signed char __a, vector signed char __b)
Definition: altivec.h:4377
static __inline__ vector signed char __ATTRS_o_ai vec_vor(vector signed char __a, vector signed char __b)
Definition: altivec.h:6534
static __inline__ vector signed int __ATTRS_o_ai vec_sld(vector signed int, vector signed int, unsigned const int __c)
Definition: altivec.h:8264
static __inline__ vector int __ATTRS_o_ai vec_vminsw(vector int __a, vector int __b)
Definition: altivec.h:5348
static __inline__ vector unsigned short __ATTRS_o_ai vec_vmaxuh(vector unsigned short __a, vector unsigned short __b)
Definition: altivec.h:4428
static __inline__ vector short __ATTRS_o_ai vec_vslh(vector short __a, vector unsigned short __b)
Definition: altivec.h:8107
static __inline__ vector signed char __ATTRS_o_ai vec_vmrglb(vector signed char __a, vector signed char __b)
Definition: altivec.h:4925
static __inline__ vector float vector float __b
Definition: altivec.h:534
static __inline__ vector signed char __ATTRS_o_ai vec_perm(vector signed char __a, vector signed char __b, vector unsigned char __c)
Definition: altivec.h:7275
static __inline__ void __ATTRS_o_ai vec_stvlxl(vector signed char __a, int __b, signed char *__c)
Definition: altivec.h:13267
static __inline__ vector short __ATTRS_o_ai vec_vupklsb(vector signed char __a)
Definition: altivec.h:11832
static __inline__ vector bool char __ATTRS_o_ai vec_cmpge(vector signed char __a, vector signed char __b)
Definition: altivec.h:1982
static __inline__ vector signed char __ATTRS_o_ai vec_vsl(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:8816
static __inline__ vector short __ATTRS_o_ai vec_unpackh(vector signed char __a)
Definition: altivec.h:11623
static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed char __a, vector signed char __b)
Definition: altivec.h:14625
static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed char __a, vector signed char __b)
Definition: altivec.h:14437
static __inline__ vector int __ATTRS_o_ai vec_vsraw(vector int __a, vector unsigned int __b)
Definition: altivec.h:9655
static __inline__ vector signed char __ATTRS_o_ai vec_lvrx(int __a, const signed char *__b)
Definition: altivec.h:12940
static __inline__ vector signed char __ATTRS_o_ai vec_vmrghb(vector signed char __a, vector signed char __b)
Definition: altivec.h:4662
static __inline__ vector short __ATTRS_o_ai vec_vmladduhm(vector short __a, vector short __b, vector short __c)
Definition: altivec.h:5420
static __ATTRS_o_ai void vec_xst(vector signed char __vec, signed long long __offset, signed char *__ptr)
Definition: altivec.h:16515
static __inline__ vector unsigned short __ATTRS_o_ai vec_vminuh(vector unsigned short __a, vector unsigned short __b)
Definition: altivec.h:5332
static __inline__ vector signed char __ATTRS_o_ai vec_lvlxl(int __a, const signed char *__b)
Definition: altivec.h:12834
static __inline__ vector short __ATTRS_o_ai vec_lvehx(int __a, const short *__b)
Definition: altivec.h:3683
static __inline__ vector signed char __ATTRS_o_ai vec_vslo(vector signed char __a, vector signed char __b)
Definition: altivec.h:9105
#define vec_xl_be
Definition: altivec.h:16510
static __inline__ vector unsigned char __ATTRS_o_ai vec_vaddubs(vector unsigned char __a, vector unsigned char __b)
Definition: altivec.h:683
#define __CR6_EQ
Definition: altivec.h:32
static __inline__ vector short __ATTRS_o_ai vec_vsrah(vector short __a, vector unsigned short __b)
Definition: altivec.h:9644
static __inline__ vector int __ATTRS_o_ai vec_splat_s32(signed char __a)
Definition: altivec.h:9458
static __inline__ vector signed char __ATTRS_o_ai vec_splat_s8(signed char __a)
Definition: altivec.h:9425
static __inline__ vector signed char __ATTRS_o_ai vec_vslb(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:8093
static __inline__ vector signed char __ATTRS_o_ai vec_lvxl(int __a, const vector signed char *__b)
Definition: altivec.h:3801
static __inline__ vector signed int __ATTRS_o_ai vec_addc(vector signed int __a, vector signed int __b)
Definition: altivec.h:541
static __inline__ vector bool char __ATTRS_o_ai vec_cmpgt(vector signed char __a, vector signed char __b)
Definition: altivec.h:1922
static __inline__ vector signed char __ATTRS_o_ai vec_vspltb(vector signed char __a, unsigned char __b)
Definition: altivec.h:9325
static __inline__ vector float __ATTRS_o_ai vec_nmsub(vector float __a, vector float __b, vector float __c)
Definition: altivec.h:6024
static __inline__ vector signed char __ATTRS_o_ai vec_vxor(vector signed char __a, vector signed char __b)
Definition: altivec.h:12346
static __inline__ vector unsigned char __ATTRS_o_ai vec_splat_u8(unsigned char __a)
Definition: altivec.h:9473
static __inline__ vector unsigned short __ATTRS_o_ai vec_splat_u16(signed char __a)
Definition: altivec.h:9481
static __inline__ vector unsigned char __ATTRS_o_ai vec_vminub(vector unsigned char __a, vector unsigned char __b)
Definition: altivec.h:5298
static __inline__ vector short __ATTRS_o_ai vec_vupkhsb(vector signed char __a)
Definition: altivec.h:11693
static __inline__ void __ATTRS_o_ai vec_stl(vector signed char __a, int __b, vector signed char *__c)
Definition: altivec.h:10653
static __inline__ void __ATTRS_o_ai vec_stvrxl(vector signed char __a, int __b, signed char *__c)
Definition: altivec.h:13500
static __inline__ vector signed char __ATTRS_o_ai vec_promote(signed char __a, int __b)
Definition: altivec.h:13617
static __inline__ void __ATTRS_o_ai vec_st(vector signed char __a, int __b, vector signed char *__c)
Definition: altivec.h:10233
static __inline__ void __ATTRS_o_ai vec_ste(vector signed char __a, int __b, signed char *__c)
Definition: altivec.h:10496
static __inline__ vector signed char __ATTRS_o_ai vec_avg(vector signed char __a, vector signed char __b)
Definition: altivec.h:1528
static vector float __ATTRS_o_ai vec_neg(vector float __a)
Definition: altivec.h:16694
static __inline__ vector unsigned int __ATTRS_o_ai vec_splat_u32(signed char __a)
Definition: altivec.h:9489
static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed char __a, vector signed char __b)
Definition: altivec.h:15237
static __inline__ vector signed char __ATTRS_o_ai vec_lvlx(int __a, const signed char *__b)
Definition: altivec.h:12728
static __inline__ vector short __ATTRS_o_ai vec_vminsh(vector short __a, vector short __b)
Definition: altivec.h:5314
static __inline__ vector int __ATTRS_o_ai vec_vsubuwm(vector int __a, vector int __b)
Definition: altivec.h:11113
static __inline__ vector short __ATTRS_o_ai vec_vmaxsh(vector short __a, vector short __b)
Definition: altivec.h:4410
static __inline__ vector signed char __ATTRS_o_ai vec_pack(vector signed short __a, vector signed short __b)
Definition: altivec.h:6702
static __inline__ vector float __ATTRS_o_ai vec_re(vector float __a)
Definition: altivec.h:7576
static __inline__ vector unsigned short __ATTRS_o_ai vec_vsubuhs(vector unsigned short __a, vector unsigned short __b)
Definition: altivec.h:11330
static __inline__ vector short __ATTRS_o_ai vec_mule(vector signed char __a, vector signed char __b)
Definition: altivec.h:5652
static __inline__ vector signed char __ATTRS_o_ai vec_vsro(vector signed char __a, vector signed char __b)
Definition: altivec.h:10144
static __inline__ vector short __ATTRS_o_ai vec_vspltish(signed char __a)
Definition: altivec.h:9449
static __inline__ vector int __ATTRS_o_ai vec_vspltisw(signed char __a)
Definition: altivec.h:9465
static __inline__ vector signed char __ATTRS_o_ai vec_ldl(int __a, const vector signed char *__b)
Definition: altivec.h:3712
static __inline__ signed char __ATTRS_o_ai vec_extract(vector signed char __a, int __b)
Definition: altivec.h:12512
#define vec_xst_be
Definition: altivec.h:16680
static __inline__ vector signed char __ATTRS_o_ai vec_lvebx(int __a, const signed char *__b)
Definition: altivec.h:3672
static __inline__ void __ATTRS_o_ai vec_stvebx(vector signed char __a, int __b, signed char *__c)
Definition: altivec.h:10572
static __inline__ vector int __ATTRS_o_ai vec_vrlw(vector int __a, vector unsigned int __b)
Definition: altivec.h:7697
static __inline__ vector unsigned char __ATTRS_o_ai vec_sr(vector unsigned char __a, vector unsigned char __b)
Definition: altivec.h:9498
static __inline__ int __ATTRS_o_ai vec_all_nan(vector float __a)
Definition: altivec.h:14609
static __inline__ void __ATTRS_o_ai vec_stvrx(vector signed char __a, int __b, signed char *__c)
Definition: altivec.h:13384
static __inline__ vector short __ATTRS_o_ai vec_vrlh(vector short __a, vector unsigned short __b)
Definition: altivec.h:7686
static __inline__ vector int __ATTRS_o_ai vec_vmaxsw(vector int __a, vector int __b)
Definition: altivec.h:4444
#define __ATTRS_o_ai
Definition: altivec.h:56
static __inline__ vector short __ATTRS_o_ai vec_vmrghh(vector short __a, vector short __b)
Definition: altivec.h:4689
static __inline__ vector bool char __ATTRS_o_ai vec_revb(vector bool char __a)
Definition: altivec.h:16243
static __inline__ vector signed char __ATTRS_o_ai vec_vsrb(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:9548
static __inline__ vector signed char __ATTRS_o_ai vec_abs(vector signed char __a)
Definition: altivec.h:129
static __inline__ vector signed char __ATTRS_o_ai vec_lvx(int __a, const vector signed char *__b)
Definition: altivec.h:3549
static __inline__ vector float __ATTRS_o_ai vec_round(vector float __a)
Definition: altivec.h:7709
static __inline__ vector short __ATTRS_o_ai vec_unpackl(vector signed char __a)
Definition: altivec.h:11762
static __inline__ void __ATTRS_o_ai vec_stvxl(vector signed char __a, int __b, vector signed char *__c)
Definition: altivec.h:10784
static __inline__ int __ATTRS_o_ai vec_all_ngt(vector float __a, vector float __b)
Definition: altivec.h:14831
static __inline__ vector signed char __ATTRS_o_ai vec_vsldoi(vector signed char __a, vector signed char __b, unsigned char __c)
Definition: altivec.h:8479
static __inline__ int __ATTRS_o_ai vec_all_le(vector signed char __a, vector signed char __b)
Definition: altivec.h:14265
static __inline__ vector signed char __ATTRS_o_ai vec_vsubsbs(vector signed char __a, vector signed char __b)
Definition: altivec.h:11279
static __ATTRS_o_ai vector bool char vec_reve(vector bool char __a)
Definition: altivec.h:16173
static __inline__ vector signed char __ATTRS_o_ai vec_mergeh(vector signed char __a, vector signed char __b)
Definition: altivec.h:4490
static __inline__ vector short __ATTRS_o_ai vec_splat_s16(signed char __a)
Definition: altivec.h:9442
static __inline__ vector int __ATTRS_o_ai vec_vslw(vector int __a, vector unsigned int __b)
Definition: altivec.h:8120
static __inline__ vector signed char __ATTRS_o_ai vec_min(vector signed char __a, vector signed char __b)
Definition: altivec.h:5141
static __inline__ vector short __ATTRS_o_ai vec_vsubshs(vector short __a, vector short __b)
Definition: altivec.h:11312
static __inline__ vector float vector float vector float __c
Definition: altivec.h:4199
static __inline__ vector signed char __ATTRS_o_ai vec_vrlb(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:7674
static __inline__ vector signed char __ATTRS_o_ai vec_vaddsbs(vector signed char __a, vector signed char __b)
Definition: altivec.h:666
static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsr(int __a, const signed char *__b)
Definition: altivec.h:4038
static __inline__ vector int __ATTRS_o_ai vec_vaddsws(vector int __a, vector int __b)
Definition: altivec.h:733
static __inline__ vector short __ATTRS_o_ai vec_vpkuwum(vector int __a, vector int __b)
Definition: altivec.h:6908
static __inline__ int __ATTRS_o_ai vec_all_eq(vector signed char __a, vector signed char __b)
Definition: altivec.h:13729
static __inline__ vector int __ATTRS_o_ai vec_vsubsws(vector int __a, vector int __b)
Definition: altivec.h:11346