clang  6.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 static __inline__ vector signed char __ATTRS_o_ai
9496 vec_sr(vector signed char __a, vector unsigned char __b) {
9497  vector unsigned char __res = (vector unsigned char)__a >> __b;
9498  return (vector signed char)__res;
9499 }
9500 
9501 static __inline__ vector unsigned char __ATTRS_o_ai
9502 vec_sr(vector unsigned char __a, vector unsigned char __b) {
9503  return __a >> __b;
9504 }
9505 
9506 static __inline__ vector signed short __ATTRS_o_ai
9507 vec_sr(vector signed short __a, vector unsigned short __b) {
9508  vector unsigned short __res = (vector unsigned short)__a >> __b;
9509  return (vector signed short)__res;
9510 }
9511 
9512 static __inline__ vector unsigned short __ATTRS_o_ai
9513 vec_sr(vector unsigned short __a, vector unsigned short __b) {
9514  return __a >> __b;
9515 }
9516 
9517 static __inline__ vector signed int __ATTRS_o_ai
9518 vec_sr(vector signed int __a, vector unsigned int __b) {
9519  vector unsigned int __res = (vector unsigned int)__a >> __b;
9520  return (vector signed int)__res;
9521 }
9522 
9523 static __inline__ vector unsigned int __ATTRS_o_ai
9524 vec_sr(vector unsigned int __a, vector unsigned int __b) {
9525  return __a >> __b;
9526 }
9527 
9528 #ifdef __POWER8_VECTOR__
9529 static __inline__ vector signed long long __ATTRS_o_ai
9530 vec_sr(vector signed long long __a, vector unsigned long long __b) {
9531  vector unsigned long long __res = (vector unsigned long long)__a >> __b;
9532  return (vector signed long long)__res;
9533 }
9534 
9535 static __inline__ vector unsigned long long __ATTRS_o_ai
9536 vec_sr(vector unsigned long long __a, vector unsigned long long __b) {
9537  return __a >> __b;
9538 }
9539 #endif
9540 
9541 /* vec_vsrb */
9542 
9543 #define __builtin_altivec_vsrb vec_vsrb
9544 
9545 static __inline__ vector signed char __ATTRS_o_ai
9546 vec_vsrb(vector signed char __a, vector unsigned char __b) {
9547  return __a >> (vector signed char)__b;
9548 }
9549 
9550 static __inline__ vector unsigned char __ATTRS_o_ai
9551 vec_vsrb(vector unsigned char __a, vector unsigned char __b) {
9552  return __a >> __b;
9553 }
9554 
9555 /* vec_vsrh */
9556 
9557 #define __builtin_altivec_vsrh vec_vsrh
9558 
9559 static __inline__ vector short __ATTRS_o_ai
9560 vec_vsrh(vector short __a, vector unsigned short __b) {
9561  return __a >> (vector short)__b;
9562 }
9563 
9564 static __inline__ vector unsigned short __ATTRS_o_ai
9565 vec_vsrh(vector unsigned short __a, vector unsigned short __b) {
9566  return __a >> __b;
9567 }
9568 
9569 /* vec_vsrw */
9570 
9571 #define __builtin_altivec_vsrw vec_vsrw
9572 
9573 static __inline__ vector int __ATTRS_o_ai vec_vsrw(vector int __a,
9574  vector unsigned int __b) {
9575  return __a >> (vector int)__b;
9576 }
9577 
9578 static __inline__ vector unsigned int __ATTRS_o_ai
9579 vec_vsrw(vector unsigned int __a, vector unsigned int __b) {
9580  return __a >> __b;
9581 }
9582 
9583 /* vec_sra */
9584 
9585 static __inline__ vector signed char __ATTRS_o_ai
9586 vec_sra(vector signed char __a, vector unsigned char __b) {
9587  return (vector signed char)__builtin_altivec_vsrab((vector char)__a, __b);
9588 }
9589 
9590 static __inline__ vector unsigned char __ATTRS_o_ai
9591 vec_sra(vector unsigned char __a, vector unsigned char __b) {
9592  return (vector unsigned char)__builtin_altivec_vsrab((vector char)__a, __b);
9593 }
9594 
9595 static __inline__ vector short __ATTRS_o_ai vec_sra(vector short __a,
9596  vector unsigned short __b) {
9597  return __builtin_altivec_vsrah(__a, (vector unsigned short)__b);
9598 }
9599 
9600 static __inline__ vector unsigned short __ATTRS_o_ai
9601 vec_sra(vector unsigned short __a, vector unsigned short __b) {
9602  return (vector unsigned short)__builtin_altivec_vsrah((vector short)__a, __b);
9603 }
9604 
9605 static __inline__ vector int __ATTRS_o_ai vec_sra(vector int __a,
9606  vector unsigned int __b) {
9607  return __builtin_altivec_vsraw(__a, __b);
9608 }
9609 
9610 static __inline__ vector unsigned int __ATTRS_o_ai
9611 vec_sra(vector unsigned int __a, vector unsigned int __b) {
9612  return (vector unsigned int)__builtin_altivec_vsraw((vector int)__a, __b);
9613 }
9614 
9615 #ifdef __POWER8_VECTOR__
9616 static __inline__ vector signed long long __ATTRS_o_ai
9617 vec_sra(vector signed long long __a, vector unsigned long long __b) {
9618  return __a >> __b;
9619 }
9620 
9621 static __inline__ vector unsigned long long __ATTRS_o_ai
9622 vec_sra(vector unsigned long long __a, vector unsigned long long __b) {
9623  return (vector unsigned long long)((vector signed long long)__a >> __b);
9624 }
9625 #endif
9626 
9627 /* vec_vsrab */
9628 
9629 static __inline__ vector signed char __ATTRS_o_ai
9630 vec_vsrab(vector signed char __a, vector unsigned char __b) {
9631  return (vector signed char)__builtin_altivec_vsrab((vector char)__a, __b);
9632 }
9633 
9634 static __inline__ vector unsigned char __ATTRS_o_ai
9635 vec_vsrab(vector unsigned char __a, vector unsigned char __b) {
9636  return (vector unsigned char)__builtin_altivec_vsrab((vector char)__a, __b);
9637 }
9638 
9639 /* vec_vsrah */
9640 
9641 static __inline__ vector short __ATTRS_o_ai
9642 vec_vsrah(vector short __a, vector unsigned short __b) {
9643  return __builtin_altivec_vsrah(__a, (vector unsigned short)__b);
9644 }
9645 
9646 static __inline__ vector unsigned short __ATTRS_o_ai
9647 vec_vsrah(vector unsigned short __a, vector unsigned short __b) {
9648  return (vector unsigned short)__builtin_altivec_vsrah((vector short)__a, __b);
9649 }
9650 
9651 /* vec_vsraw */
9652 
9653 static __inline__ vector int __ATTRS_o_ai vec_vsraw(vector int __a,
9654  vector unsigned int __b) {
9655  return __builtin_altivec_vsraw(__a, __b);
9656 }
9657 
9658 static __inline__ vector unsigned int __ATTRS_o_ai
9659 vec_vsraw(vector unsigned int __a, vector unsigned int __b) {
9660  return (vector unsigned int)__builtin_altivec_vsraw((vector int)__a, __b);
9661 }
9662 
9663 /* vec_srl */
9664 
9665 static __inline__ vector signed char __ATTRS_o_ai
9666 vec_srl(vector signed char __a, vector unsigned char __b) {
9667  return (vector signed char)__builtin_altivec_vsr((vector int)__a,
9668  (vector int)__b);
9669 }
9670 
9671 static __inline__ vector signed char __ATTRS_o_ai
9672 vec_srl(vector signed char __a, vector unsigned short __b) {
9673  return (vector signed char)__builtin_altivec_vsr((vector int)__a,
9674  (vector int)__b);
9675 }
9676 
9677 static __inline__ vector signed char __ATTRS_o_ai
9678 vec_srl(vector signed char __a, vector unsigned int __b) {
9679  return (vector signed char)__builtin_altivec_vsr((vector int)__a,
9680  (vector int)__b);
9681 }
9682 
9683 static __inline__ vector unsigned char __ATTRS_o_ai
9684 vec_srl(vector unsigned char __a, vector unsigned char __b) {
9685  return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
9686  (vector int)__b);
9687 }
9688 
9689 static __inline__ vector unsigned char __ATTRS_o_ai
9690 vec_srl(vector unsigned char __a, vector unsigned short __b) {
9691  return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
9692  (vector int)__b);
9693 }
9694 
9695 static __inline__ vector unsigned char __ATTRS_o_ai
9696 vec_srl(vector unsigned char __a, vector unsigned int __b) {
9697  return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
9698  (vector int)__b);
9699 }
9700 
9701 static __inline__ vector bool char __ATTRS_o_ai
9702 vec_srl(vector bool char __a, vector unsigned char __b) {
9703  return (vector bool char)__builtin_altivec_vsr((vector int)__a,
9704  (vector int)__b);
9705 }
9706 
9707 static __inline__ vector bool char __ATTRS_o_ai
9708 vec_srl(vector bool char __a, vector unsigned short __b) {
9709  return (vector bool char)__builtin_altivec_vsr((vector int)__a,
9710  (vector int)__b);
9711 }
9712 
9713 static __inline__ vector bool char __ATTRS_o_ai
9714 vec_srl(vector bool char __a, vector unsigned int __b) {
9715  return (vector bool char)__builtin_altivec_vsr((vector int)__a,
9716  (vector int)__b);
9717 }
9718 
9719 static __inline__ vector short __ATTRS_o_ai vec_srl(vector short __a,
9720  vector unsigned char __b) {
9721  return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9722 }
9723 
9724 static __inline__ vector short __ATTRS_o_ai vec_srl(vector short __a,
9725  vector unsigned short __b) {
9726  return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9727 }
9728 
9729 static __inline__ vector short __ATTRS_o_ai vec_srl(vector short __a,
9730  vector unsigned int __b) {
9731  return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9732 }
9733 
9734 static __inline__ vector unsigned short __ATTRS_o_ai
9735 vec_srl(vector unsigned short __a, vector unsigned char __b) {
9736  return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
9737  (vector int)__b);
9738 }
9739 
9740 static __inline__ vector unsigned short __ATTRS_o_ai
9741 vec_srl(vector unsigned short __a, vector unsigned short __b) {
9742  return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
9743  (vector int)__b);
9744 }
9745 
9746 static __inline__ vector unsigned short __ATTRS_o_ai
9747 vec_srl(vector unsigned short __a, vector unsigned int __b) {
9748  return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
9749  (vector int)__b);
9750 }
9751 
9752 static __inline__ vector bool short __ATTRS_o_ai
9753 vec_srl(vector bool short __a, vector unsigned char __b) {
9754  return (vector bool short)__builtin_altivec_vsr((vector int)__a,
9755  (vector int)__b);
9756 }
9757 
9758 static __inline__ vector bool short __ATTRS_o_ai
9759 vec_srl(vector bool short __a, vector unsigned short __b) {
9760  return (vector bool short)__builtin_altivec_vsr((vector int)__a,
9761  (vector int)__b);
9762 }
9763 
9764 static __inline__ vector bool short __ATTRS_o_ai
9765 vec_srl(vector bool short __a, vector unsigned int __b) {
9766  return (vector bool short)__builtin_altivec_vsr((vector int)__a,
9767  (vector int)__b);
9768 }
9769 
9770 static __inline__ vector pixel __ATTRS_o_ai vec_srl(vector pixel __a,
9771  vector unsigned char __b) {
9772  return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9773 }
9774 
9775 static __inline__ vector pixel __ATTRS_o_ai vec_srl(vector pixel __a,
9776  vector unsigned short __b) {
9777  return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9778 }
9779 
9780 static __inline__ vector pixel __ATTRS_o_ai vec_srl(vector pixel __a,
9781  vector unsigned int __b) {
9782  return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9783 }
9784 
9785 static __inline__ vector int __ATTRS_o_ai vec_srl(vector int __a,
9786  vector unsigned char __b) {
9787  return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
9788 }
9789 
9790 static __inline__ vector int __ATTRS_o_ai vec_srl(vector int __a,
9791  vector unsigned short __b) {
9792  return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
9793 }
9794 
9795 static __inline__ vector int __ATTRS_o_ai vec_srl(vector int __a,
9796  vector unsigned int __b) {
9797  return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
9798 }
9799 
9800 static __inline__ vector unsigned int __ATTRS_o_ai
9801 vec_srl(vector unsigned int __a, vector unsigned char __b) {
9802  return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
9803  (vector int)__b);
9804 }
9805 
9806 static __inline__ vector unsigned int __ATTRS_o_ai
9807 vec_srl(vector unsigned int __a, vector unsigned short __b) {
9808  return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
9809  (vector int)__b);
9810 }
9811 
9812 static __inline__ vector unsigned int __ATTRS_o_ai
9813 vec_srl(vector unsigned int __a, vector unsigned int __b) {
9814  return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
9815  (vector int)__b);
9816 }
9817 
9818 static __inline__ vector bool int __ATTRS_o_ai
9819 vec_srl(vector bool int __a, vector unsigned char __b) {
9820  return (vector bool int)__builtin_altivec_vsr((vector int)__a,
9821  (vector int)__b);
9822 }
9823 
9824 static __inline__ vector bool int __ATTRS_o_ai
9825 vec_srl(vector bool int __a, vector unsigned short __b) {
9826  return (vector bool int)__builtin_altivec_vsr((vector int)__a,
9827  (vector int)__b);
9828 }
9829 
9830 static __inline__ vector bool int __ATTRS_o_ai
9831 vec_srl(vector bool int __a, vector unsigned int __b) {
9832  return (vector bool int)__builtin_altivec_vsr((vector int)__a,
9833  (vector int)__b);
9834 }
9835 
9836 #ifdef __VSX__
9837 static __inline__ vector signed long long __ATTRS_o_ai
9838 vec_srl(vector signed long long __a, vector unsigned char __b) {
9839  return (vector signed long long)__builtin_altivec_vsr((vector int)__a,
9840  (vector int)__b);
9841 }
9842 
9843 static __inline__ vector unsigned long long __ATTRS_o_ai
9844 vec_srl(vector unsigned long long __a, vector unsigned char __b) {
9845  return (vector unsigned long long)__builtin_altivec_vsr((vector int)__a,
9846  (vector int)__b);
9847 }
9848 #endif
9849 
9850 /* vec_vsr */
9851 
9852 static __inline__ vector signed char __ATTRS_o_ai
9853 vec_vsr(vector signed char __a, vector unsigned char __b) {
9854  return (vector signed char)__builtin_altivec_vsr((vector int)__a,
9855  (vector int)__b);
9856 }
9857 
9858 static __inline__ vector signed char __ATTRS_o_ai
9859 vec_vsr(vector signed char __a, vector unsigned short __b) {
9860  return (vector signed char)__builtin_altivec_vsr((vector int)__a,
9861  (vector int)__b);
9862 }
9863 
9864 static __inline__ vector signed char __ATTRS_o_ai
9865 vec_vsr(vector signed char __a, vector unsigned int __b) {
9866  return (vector signed char)__builtin_altivec_vsr((vector int)__a,
9867  (vector int)__b);
9868 }
9869 
9870 static __inline__ vector unsigned char __ATTRS_o_ai
9871 vec_vsr(vector unsigned char __a, vector unsigned char __b) {
9872  return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
9873  (vector int)__b);
9874 }
9875 
9876 static __inline__ vector unsigned char __ATTRS_o_ai
9877 vec_vsr(vector unsigned char __a, vector unsigned short __b) {
9878  return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
9879  (vector int)__b);
9880 }
9881 
9882 static __inline__ vector unsigned char __ATTRS_o_ai
9883 vec_vsr(vector unsigned char __a, vector unsigned int __b) {
9884  return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
9885  (vector int)__b);
9886 }
9887 
9888 static __inline__ vector bool char __ATTRS_o_ai
9889 vec_vsr(vector bool char __a, vector unsigned char __b) {
9890  return (vector bool char)__builtin_altivec_vsr((vector int)__a,
9891  (vector int)__b);
9892 }
9893 
9894 static __inline__ vector bool char __ATTRS_o_ai
9895 vec_vsr(vector bool char __a, vector unsigned short __b) {
9896  return (vector bool char)__builtin_altivec_vsr((vector int)__a,
9897  (vector int)__b);
9898 }
9899 
9900 static __inline__ vector bool char __ATTRS_o_ai
9901 vec_vsr(vector bool char __a, vector unsigned int __b) {
9902  return (vector bool char)__builtin_altivec_vsr((vector int)__a,
9903  (vector int)__b);
9904 }
9905 
9906 static __inline__ vector short __ATTRS_o_ai vec_vsr(vector short __a,
9907  vector unsigned char __b) {
9908  return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9909 }
9910 
9911 static __inline__ vector short __ATTRS_o_ai vec_vsr(vector short __a,
9912  vector unsigned short __b) {
9913  return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9914 }
9915 
9916 static __inline__ vector short __ATTRS_o_ai vec_vsr(vector short __a,
9917  vector unsigned int __b) {
9918  return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9919 }
9920 
9921 static __inline__ vector unsigned short __ATTRS_o_ai
9922 vec_vsr(vector unsigned short __a, vector unsigned char __b) {
9923  return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
9924  (vector int)__b);
9925 }
9926 
9927 static __inline__ vector unsigned short __ATTRS_o_ai
9928 vec_vsr(vector unsigned short __a, vector unsigned short __b) {
9929  return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
9930  (vector int)__b);
9931 }
9932 
9933 static __inline__ vector unsigned short __ATTRS_o_ai
9934 vec_vsr(vector unsigned short __a, vector unsigned int __b) {
9935  return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
9936  (vector int)__b);
9937 }
9938 
9939 static __inline__ vector bool short __ATTRS_o_ai
9940 vec_vsr(vector bool short __a, vector unsigned char __b) {
9941  return (vector bool short)__builtin_altivec_vsr((vector int)__a,
9942  (vector int)__b);
9943 }
9944 
9945 static __inline__ vector bool short __ATTRS_o_ai
9946 vec_vsr(vector bool short __a, vector unsigned short __b) {
9947  return (vector bool short)__builtin_altivec_vsr((vector int)__a,
9948  (vector int)__b);
9949 }
9950 
9951 static __inline__ vector bool short __ATTRS_o_ai
9952 vec_vsr(vector bool short __a, vector unsigned int __b) {
9953  return (vector bool short)__builtin_altivec_vsr((vector int)__a,
9954  (vector int)__b);
9955 }
9956 
9957 static __inline__ vector pixel __ATTRS_o_ai vec_vsr(vector pixel __a,
9958  vector unsigned char __b) {
9959  return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9960 }
9961 
9962 static __inline__ vector pixel __ATTRS_o_ai vec_vsr(vector pixel __a,
9963  vector unsigned short __b) {
9964  return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9965 }
9966 
9967 static __inline__ vector pixel __ATTRS_o_ai vec_vsr(vector pixel __a,
9968  vector unsigned int __b) {
9969  return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9970 }
9971 
9972 static __inline__ vector int __ATTRS_o_ai vec_vsr(vector int __a,
9973  vector unsigned char __b) {
9974  return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
9975 }
9976 
9977 static __inline__ vector int __ATTRS_o_ai vec_vsr(vector int __a,
9978  vector unsigned short __b) {
9979  return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
9980 }
9981 
9982 static __inline__ vector int __ATTRS_o_ai vec_vsr(vector int __a,
9983  vector unsigned int __b) {
9984  return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
9985 }
9986 
9987 static __inline__ vector unsigned int __ATTRS_o_ai
9988 vec_vsr(vector unsigned int __a, vector unsigned char __b) {
9989  return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
9990  (vector int)__b);
9991 }
9992 
9993 static __inline__ vector unsigned int __ATTRS_o_ai
9994 vec_vsr(vector unsigned int __a, vector unsigned short __b) {
9995  return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
9996  (vector int)__b);
9997 }
9998 
9999 static __inline__ vector unsigned int __ATTRS_o_ai
10000 vec_vsr(vector unsigned int __a, vector unsigned int __b) {
10001  return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
10002  (vector int)__b);
10003 }
10004 
10005 static __inline__ vector bool int __ATTRS_o_ai
10006 vec_vsr(vector bool int __a, vector unsigned char __b) {
10007  return (vector bool int)__builtin_altivec_vsr((vector int)__a,
10008  (vector int)__b);
10009 }
10010 
10011 static __inline__ vector bool int __ATTRS_o_ai
10012 vec_vsr(vector bool int __a, vector unsigned short __b) {
10013  return (vector bool int)__builtin_altivec_vsr((vector int)__a,
10014  (vector int)__b);
10015 }
10016 
10017 static __inline__ vector bool int __ATTRS_o_ai
10018 vec_vsr(vector bool int __a, vector unsigned int __b) {
10019  return (vector bool int)__builtin_altivec_vsr((vector int)__a,
10020  (vector int)__b);
10021 }
10022 
10023 /* vec_sro */
10024 
10025 static __inline__ vector signed char __ATTRS_o_ai
10026 vec_sro(vector signed char __a, vector signed char __b) {
10027  return (vector signed char)__builtin_altivec_vsro((vector int)__a,
10028  (vector int)__b);
10029 }
10030 
10031 static __inline__ vector signed char __ATTRS_o_ai
10032 vec_sro(vector signed char __a, vector unsigned char __b) {
10033  return (vector signed char)__builtin_altivec_vsro((vector int)__a,
10034  (vector int)__b);
10035 }
10036 
10037 static __inline__ vector unsigned char __ATTRS_o_ai
10038 vec_sro(vector unsigned char __a, vector signed char __b) {
10039  return (vector unsigned char)__builtin_altivec_vsro((vector int)__a,
10040  (vector int)__b);
10041 }
10042 
10043 static __inline__ vector unsigned char __ATTRS_o_ai
10044 vec_sro(vector unsigned char __a, vector unsigned char __b) {
10045  return (vector unsigned char)__builtin_altivec_vsro((vector int)__a,
10046  (vector int)__b);
10047 }
10048 
10049 static __inline__ vector short __ATTRS_o_ai vec_sro(vector short __a,
10050  vector signed char __b) {
10051  return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10052 }
10053 
10054 static __inline__ vector short __ATTRS_o_ai vec_sro(vector short __a,
10055  vector unsigned char __b) {
10056  return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10057 }
10058 
10059 static __inline__ vector unsigned short __ATTRS_o_ai
10060 vec_sro(vector unsigned short __a, vector signed char __b) {
10061  return (vector unsigned short)__builtin_altivec_vsro((vector int)__a,
10062  (vector int)__b);
10063 }
10064 
10065 static __inline__ vector unsigned short __ATTRS_o_ai
10066 vec_sro(vector unsigned short __a, vector unsigned char __b) {
10067  return (vector unsigned short)__builtin_altivec_vsro((vector int)__a,
10068  (vector int)__b);
10069 }
10070 
10071 static __inline__ vector pixel __ATTRS_o_ai vec_sro(vector pixel __a,
10072  vector signed char __b) {
10073  return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10074 }
10075 
10076 static __inline__ vector pixel __ATTRS_o_ai vec_sro(vector pixel __a,
10077  vector unsigned char __b) {
10078  return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10079 }
10080 
10081 static __inline__ vector int __ATTRS_o_ai vec_sro(vector int __a,
10082  vector signed char __b) {
10083  return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
10084 }
10085 
10086 static __inline__ vector int __ATTRS_o_ai vec_sro(vector int __a,
10087  vector unsigned char __b) {
10088  return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
10089 }
10090 
10091 static __inline__ vector unsigned int __ATTRS_o_ai
10092 vec_sro(vector unsigned int __a, vector signed char __b) {
10093  return (vector unsigned int)__builtin_altivec_vsro((vector int)__a,
10094  (vector int)__b);
10095 }
10096 
10097 static __inline__ vector unsigned int __ATTRS_o_ai
10098 vec_sro(vector unsigned int __a, vector unsigned char __b) {
10099  return (vector unsigned int)__builtin_altivec_vsro((vector int)__a,
10100  (vector int)__b);
10101 }
10102 
10103 static __inline__ vector float __ATTRS_o_ai vec_sro(vector float __a,
10104  vector signed char __b) {
10105  return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10106 }
10107 
10108 static __inline__ vector float __ATTRS_o_ai vec_sro(vector float __a,
10109  vector unsigned char __b) {
10110  return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10111 }
10112 
10113 #ifdef __VSX__
10114 static __inline__ vector signed long long __ATTRS_o_ai
10115 vec_sro(vector signed long long __a, vector signed char __b) {
10116  return (vector signed long long)__builtin_altivec_vsro((vector int)__a,
10117  (vector int)__b);
10118 }
10119 
10120 static __inline__ vector signed long long __ATTRS_o_ai
10121 vec_sro(vector signed long long __a, vector unsigned char __b) {
10122  return (vector signed long long)__builtin_altivec_vsro((vector int)__a,
10123  (vector int)__b);
10124 }
10125 
10126 static __inline__ vector unsigned long long __ATTRS_o_ai
10127 vec_sro(vector unsigned long long __a, vector signed char __b) {
10128  return (vector unsigned long long)__builtin_altivec_vsro((vector int)__a,
10129  (vector int)__b);
10130 }
10131 
10132 static __inline__ vector unsigned long long __ATTRS_o_ai
10133 vec_sro(vector unsigned long long __a, vector unsigned char __b) {
10134  return (vector unsigned long long)__builtin_altivec_vsro((vector int)__a,
10135  (vector int)__b);
10136 }
10137 #endif
10138 
10139 /* vec_vsro */
10140 
10141 static __inline__ vector signed char __ATTRS_o_ai
10142 vec_vsro(vector signed char __a, vector signed char __b) {
10143  return (vector signed char)__builtin_altivec_vsro((vector int)__a,
10144  (vector int)__b);
10145 }
10146 
10147 static __inline__ vector signed char __ATTRS_o_ai
10148 vec_vsro(vector signed char __a, vector unsigned char __b) {
10149  return (vector signed char)__builtin_altivec_vsro((vector int)__a,
10150  (vector int)__b);
10151 }
10152 
10153 static __inline__ vector unsigned char __ATTRS_o_ai
10154 vec_vsro(vector unsigned char __a, vector signed char __b) {
10155  return (vector unsigned char)__builtin_altivec_vsro((vector int)__a,
10156  (vector int)__b);
10157 }
10158 
10159 static __inline__ vector unsigned char __ATTRS_o_ai
10160 vec_vsro(vector unsigned char __a, vector unsigned char __b) {
10161  return (vector unsigned char)__builtin_altivec_vsro((vector int)__a,
10162  (vector int)__b);
10163 }
10164 
10165 static __inline__ vector short __ATTRS_o_ai vec_vsro(vector short __a,
10166  vector signed char __b) {
10167  return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10168 }
10169 
10170 static __inline__ vector short __ATTRS_o_ai vec_vsro(vector short __a,
10171  vector unsigned char __b) {
10172  return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10173 }
10174 
10175 static __inline__ vector unsigned short __ATTRS_o_ai
10176 vec_vsro(vector unsigned short __a, vector signed char __b) {
10177  return (vector unsigned short)__builtin_altivec_vsro((vector int)__a,
10178  (vector int)__b);
10179 }
10180 
10181 static __inline__ vector unsigned short __ATTRS_o_ai
10182 vec_vsro(vector unsigned short __a, vector unsigned char __b) {
10183  return (vector unsigned short)__builtin_altivec_vsro((vector int)__a,
10184  (vector int)__b);
10185 }
10186 
10187 static __inline__ vector pixel __ATTRS_o_ai vec_vsro(vector pixel __a,
10188  vector signed char __b) {
10189  return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10190 }
10191 
10192 static __inline__ vector pixel __ATTRS_o_ai vec_vsro(vector pixel __a,
10193  vector unsigned char __b) {
10194  return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10195 }
10196 
10197 static __inline__ vector int __ATTRS_o_ai vec_vsro(vector int __a,
10198  vector signed char __b) {
10199  return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
10200 }
10201 
10202 static __inline__ vector int __ATTRS_o_ai vec_vsro(vector int __a,
10203  vector unsigned char __b) {
10204  return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
10205 }
10206 
10207 static __inline__ vector unsigned int __ATTRS_o_ai
10208 vec_vsro(vector unsigned int __a, vector signed char __b) {
10209  return (vector unsigned int)__builtin_altivec_vsro((vector int)__a,
10210  (vector int)__b);
10211 }
10212 
10213 static __inline__ vector unsigned int __ATTRS_o_ai
10214 vec_vsro(vector unsigned int __a, vector unsigned char __b) {
10215  return (vector unsigned int)__builtin_altivec_vsro((vector int)__a,
10216  (vector int)__b);
10217 }
10218 
10219 static __inline__ vector float __ATTRS_o_ai vec_vsro(vector float __a,
10220  vector signed char __b) {
10221  return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10222 }
10223 
10224 static __inline__ vector float __ATTRS_o_ai vec_vsro(vector float __a,
10225  vector unsigned char __b) {
10226  return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10227 }
10228 
10229 /* vec_st */
10230 
10231 static __inline__ void __ATTRS_o_ai vec_st(vector signed char __a, int __b,
10232  vector signed char *__c) {
10233  __builtin_altivec_stvx((vector int)__a, __b, __c);
10234 }
10235 
10236 static __inline__ void __ATTRS_o_ai vec_st(vector signed char __a, int __b,
10237  signed char *__c) {
10238  __builtin_altivec_stvx((vector int)__a, __b, __c);
10239 }
10240 
10241 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned char __a, int __b,
10242  vector unsigned char *__c) {
10243  __builtin_altivec_stvx((vector int)__a, __b, __c);
10244 }
10245 
10246 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned char __a, int __b,
10247  unsigned char *__c) {
10248  __builtin_altivec_stvx((vector int)__a, __b, __c);
10249 }
10250 
10251 static __inline__ void __ATTRS_o_ai vec_st(vector bool char __a, int __b,
10252  signed char *__c) {
10253  __builtin_altivec_stvx((vector int)__a, __b, __c);
10254 }
10255 
10256 static __inline__ void __ATTRS_o_ai vec_st(vector bool char __a, int __b,
10257  unsigned char *__c) {
10258  __builtin_altivec_stvx((vector int)__a, __b, __c);
10259 }
10260 
10261 static __inline__ void __ATTRS_o_ai vec_st(vector bool char __a, int __b,
10262  vector bool char *__c) {
10263  __builtin_altivec_stvx((vector int)__a, __b, __c);
10264 }
10265 
10266 static __inline__ void __ATTRS_o_ai vec_st(vector short __a, int __b,
10267  vector short *__c) {
10268  __builtin_altivec_stvx((vector int)__a, __b, __c);
10269 }
10270 
10271 static __inline__ void __ATTRS_o_ai vec_st(vector short __a, int __b,
10272  short *__c) {
10273  __builtin_altivec_stvx((vector int)__a, __b, __c);
10274 }
10275 
10276 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned short __a, int __b,
10277  vector unsigned short *__c) {
10278  __builtin_altivec_stvx((vector int)__a, __b, __c);
10279 }
10280 
10281 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned short __a, int __b,
10282  unsigned short *__c) {
10283  __builtin_altivec_stvx((vector int)__a, __b, __c);
10284 }
10285 
10286 static __inline__ void __ATTRS_o_ai vec_st(vector bool short __a, int __b,
10287  short *__c) {
10288  __builtin_altivec_stvx((vector int)__a, __b, __c);
10289 }
10290 
10291 static __inline__ void __ATTRS_o_ai vec_st(vector bool short __a, int __b,
10292  unsigned short *__c) {
10293  __builtin_altivec_stvx((vector int)__a, __b, __c);
10294 }
10295 
10296 static __inline__ void __ATTRS_o_ai vec_st(vector bool short __a, int __b,
10297  vector bool short *__c) {
10298  __builtin_altivec_stvx((vector int)__a, __b, __c);
10299 }
10300 
10301 static __inline__ void __ATTRS_o_ai vec_st(vector pixel __a, int __b,
10302  short *__c) {
10303  __builtin_altivec_stvx((vector int)__a, __b, __c);
10304 }
10305 
10306 static __inline__ void __ATTRS_o_ai vec_st(vector pixel __a, int __b,
10307  unsigned short *__c) {
10308  __builtin_altivec_stvx((vector int)__a, __b, __c);
10309 }
10310 
10311 static __inline__ void __ATTRS_o_ai vec_st(vector pixel __a, int __b,
10312  vector pixel *__c) {
10313  __builtin_altivec_stvx((vector int)__a, __b, __c);
10314 }
10315 
10316 static __inline__ void __ATTRS_o_ai vec_st(vector int __a, int __b,
10317  vector int *__c) {
10318  __builtin_altivec_stvx(__a, __b, __c);
10319 }
10320 
10321 static __inline__ void __ATTRS_o_ai vec_st(vector int __a, int __b, int *__c) {
10322  __builtin_altivec_stvx(__a, __b, __c);
10323 }
10324 
10325 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned int __a, int __b,
10326  vector unsigned int *__c) {
10327  __builtin_altivec_stvx((vector int)__a, __b, __c);
10328 }
10329 
10330 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned int __a, int __b,
10331  unsigned int *__c) {
10332  __builtin_altivec_stvx((vector int)__a, __b, __c);
10333 }
10334 
10335 static __inline__ void __ATTRS_o_ai vec_st(vector bool int __a, int __b,
10336  int *__c) {
10337  __builtin_altivec_stvx((vector int)__a, __b, __c);
10338 }
10339 
10340 static __inline__ void __ATTRS_o_ai vec_st(vector bool int __a, int __b,
10341  unsigned int *__c) {
10342  __builtin_altivec_stvx((vector int)__a, __b, __c);
10343 }
10344 
10345 static __inline__ void __ATTRS_o_ai vec_st(vector bool int __a, int __b,
10346  vector bool int *__c) {
10347  __builtin_altivec_stvx((vector int)__a, __b, __c);
10348 }
10349 
10350 static __inline__ void __ATTRS_o_ai vec_st(vector float __a, int __b,
10351  vector float *__c) {
10352  __builtin_altivec_stvx((vector int)__a, __b, __c);
10353 }
10354 
10355 static __inline__ void __ATTRS_o_ai vec_st(vector float __a, int __b,
10356  float *__c) {
10357  __builtin_altivec_stvx((vector int)__a, __b, __c);
10358 }
10359 
10360 /* vec_stvx */
10361 
10362 static __inline__ void __ATTRS_o_ai vec_stvx(vector signed char __a, int __b,
10363  vector signed char *__c) {
10364  __builtin_altivec_stvx((vector int)__a, __b, __c);
10365 }
10366 
10367 static __inline__ void __ATTRS_o_ai vec_stvx(vector signed char __a, int __b,
10368  signed char *__c) {
10369  __builtin_altivec_stvx((vector int)__a, __b, __c);
10370 }
10371 
10372 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned char __a, int __b,
10373  vector unsigned char *__c) {
10374  __builtin_altivec_stvx((vector int)__a, __b, __c);
10375 }
10376 
10377 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned char __a, int __b,
10378  unsigned char *__c) {
10379  __builtin_altivec_stvx((vector int)__a, __b, __c);
10380 }
10381 
10382 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool char __a, int __b,
10383  signed char *__c) {
10384  __builtin_altivec_stvx((vector int)__a, __b, __c);
10385 }
10386 
10387 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool char __a, int __b,
10388  unsigned char *__c) {
10389  __builtin_altivec_stvx((vector int)__a, __b, __c);
10390 }
10391 
10392 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool char __a, int __b,
10393  vector bool char *__c) {
10394  __builtin_altivec_stvx((vector int)__a, __b, __c);
10395 }
10396 
10397 static __inline__ void __ATTRS_o_ai vec_stvx(vector short __a, int __b,
10398  vector short *__c) {
10399  __builtin_altivec_stvx((vector int)__a, __b, __c);
10400 }
10401 
10402 static __inline__ void __ATTRS_o_ai vec_stvx(vector short __a, int __b,
10403  short *__c) {
10404  __builtin_altivec_stvx((vector int)__a, __b, __c);
10405 }
10406 
10407 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned short __a, int __b,
10408  vector unsigned short *__c) {
10409  __builtin_altivec_stvx((vector int)__a, __b, __c);
10410 }
10411 
10412 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned short __a, int __b,
10413  unsigned short *__c) {
10414  __builtin_altivec_stvx((vector int)__a, __b, __c);
10415 }
10416 
10417 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool short __a, int __b,
10418  short *__c) {
10419  __builtin_altivec_stvx((vector int)__a, __b, __c);
10420 }
10421 
10422 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool short __a, int __b,
10423  unsigned short *__c) {
10424  __builtin_altivec_stvx((vector int)__a, __b, __c);
10425 }
10426 
10427 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool short __a, int __b,
10428  vector bool short *__c) {
10429  __builtin_altivec_stvx((vector int)__a, __b, __c);
10430 }
10431 
10432 static __inline__ void __ATTRS_o_ai vec_stvx(vector pixel __a, int __b,
10433  short *__c) {
10434  __builtin_altivec_stvx((vector int)__a, __b, __c);
10435 }
10436 
10437 static __inline__ void __ATTRS_o_ai vec_stvx(vector pixel __a, int __b,
10438  unsigned short *__c) {
10439  __builtin_altivec_stvx((vector int)__a, __b, __c);
10440 }
10441 
10442 static __inline__ void __ATTRS_o_ai vec_stvx(vector pixel __a, int __b,
10443  vector pixel *__c) {
10444  __builtin_altivec_stvx((vector int)__a, __b, __c);
10445 }
10446 
10447 static __inline__ void __ATTRS_o_ai vec_stvx(vector int __a, int __b,
10448  vector int *__c) {
10449  __builtin_altivec_stvx(__a, __b, __c);
10450 }
10451 
10452 static __inline__ void __ATTRS_o_ai vec_stvx(vector int __a, int __b,
10453  int *__c) {
10454  __builtin_altivec_stvx(__a, __b, __c);
10455 }
10456 
10457 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned int __a, int __b,
10458  vector unsigned int *__c) {
10459  __builtin_altivec_stvx((vector int)__a, __b, __c);
10460 }
10461 
10462 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned int __a, int __b,
10463  unsigned int *__c) {
10464  __builtin_altivec_stvx((vector int)__a, __b, __c);
10465 }
10466 
10467 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool int __a, int __b,
10468  int *__c) {
10469  __builtin_altivec_stvx((vector int)__a, __b, __c);
10470 }
10471 
10472 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool int __a, int __b,
10473  unsigned int *__c) {
10474  __builtin_altivec_stvx((vector int)__a, __b, __c);
10475 }
10476 
10477 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool int __a, int __b,
10478  vector bool int *__c) {
10479  __builtin_altivec_stvx((vector int)__a, __b, __c);
10480 }
10481 
10482 static __inline__ void __ATTRS_o_ai vec_stvx(vector float __a, int __b,
10483  vector float *__c) {
10484  __builtin_altivec_stvx((vector int)__a, __b, __c);
10485 }
10486 
10487 static __inline__ void __ATTRS_o_ai vec_stvx(vector float __a, int __b,
10488  float *__c) {
10489  __builtin_altivec_stvx((vector int)__a, __b, __c);
10490 }
10491 
10492 /* vec_ste */
10493 
10494 static __inline__ void __ATTRS_o_ai vec_ste(vector signed char __a, int __b,
10495  signed char *__c) {
10496  __builtin_altivec_stvebx((vector char)__a, __b, __c);
10497 }
10498 
10499 static __inline__ void __ATTRS_o_ai vec_ste(vector unsigned char __a, int __b,
10500  unsigned char *__c) {
10501  __builtin_altivec_stvebx((vector char)__a, __b, __c);
10502 }
10503 
10504 static __inline__ void __ATTRS_o_ai vec_ste(vector bool char __a, int __b,
10505  signed char *__c) {
10506  __builtin_altivec_stvebx((vector char)__a, __b, __c);
10507 }
10508 
10509 static __inline__ void __ATTRS_o_ai vec_ste(vector bool char __a, int __b,
10510  unsigned char *__c) {
10511  __builtin_altivec_stvebx((vector char)__a, __b, __c);
10512 }
10513 
10514 static __inline__ void __ATTRS_o_ai vec_ste(vector short __a, int __b,
10515  short *__c) {
10516  __builtin_altivec_stvehx(__a, __b, __c);
10517 }
10518 
10519 static __inline__ void __ATTRS_o_ai vec_ste(vector unsigned short __a, int __b,
10520  unsigned short *__c) {
10521  __builtin_altivec_stvehx((vector short)__a, __b, __c);
10522 }
10523 
10524 static __inline__ void __ATTRS_o_ai vec_ste(vector bool short __a, int __b,
10525  short *__c) {
10526  __builtin_altivec_stvehx((vector short)__a, __b, __c);
10527 }
10528 
10529 static __inline__ void __ATTRS_o_ai vec_ste(vector bool short __a, int __b,
10530  unsigned short *__c) {
10531  __builtin_altivec_stvehx((vector short)__a, __b, __c);
10532 }
10533 
10534 static __inline__ void __ATTRS_o_ai vec_ste(vector pixel __a, int __b,
10535  short *__c) {
10536  __builtin_altivec_stvehx((vector short)__a, __b, __c);
10537 }
10538 
10539 static __inline__ void __ATTRS_o_ai vec_ste(vector pixel __a, int __b,
10540  unsigned short *__c) {
10541  __builtin_altivec_stvehx((vector short)__a, __b, __c);
10542 }
10543 
10544 static __inline__ void __ATTRS_o_ai vec_ste(vector int __a, int __b, int *__c) {
10545  __builtin_altivec_stvewx(__a, __b, __c);
10546 }
10547 
10548 static __inline__ void __ATTRS_o_ai vec_ste(vector unsigned int __a, int __b,
10549  unsigned int *__c) {
10550  __builtin_altivec_stvewx((vector int)__a, __b, __c);
10551 }
10552 
10553 static __inline__ void __ATTRS_o_ai vec_ste(vector bool int __a, int __b,
10554  int *__c) {
10555  __builtin_altivec_stvewx((vector int)__a, __b, __c);
10556 }
10557 
10558 static __inline__ void __ATTRS_o_ai vec_ste(vector bool int __a, int __b,
10559  unsigned int *__c) {
10560  __builtin_altivec_stvewx((vector int)__a, __b, __c);
10561 }
10562 
10563 static __inline__ void __ATTRS_o_ai vec_ste(vector float __a, int __b,
10564  float *__c) {
10565  __builtin_altivec_stvewx((vector int)__a, __b, __c);
10566 }
10567 
10568 /* vec_stvebx */
10569 
10570 static __inline__ void __ATTRS_o_ai vec_stvebx(vector signed char __a, int __b,
10571  signed char *__c) {
10572  __builtin_altivec_stvebx((vector char)__a, __b, __c);
10573 }
10574 
10575 static __inline__ void __ATTRS_o_ai vec_stvebx(vector unsigned char __a,
10576  int __b, unsigned char *__c) {
10577  __builtin_altivec_stvebx((vector char)__a, __b, __c);
10578 }
10579 
10580 static __inline__ void __ATTRS_o_ai vec_stvebx(vector bool char __a, int __b,
10581  signed char *__c) {
10582  __builtin_altivec_stvebx((vector char)__a, __b, __c);
10583 }
10584 
10585 static __inline__ void __ATTRS_o_ai vec_stvebx(vector bool char __a, int __b,
10586  unsigned char *__c) {
10587  __builtin_altivec_stvebx((vector char)__a, __b, __c);
10588 }
10589 
10590 /* vec_stvehx */
10591 
10592 static __inline__ void __ATTRS_o_ai vec_stvehx(vector short __a, int __b,
10593  short *__c) {
10594  __builtin_altivec_stvehx(__a, __b, __c);
10595 }
10596 
10597 static __inline__ void __ATTRS_o_ai vec_stvehx(vector unsigned short __a,
10598  int __b, unsigned short *__c) {
10599  __builtin_altivec_stvehx((vector short)__a, __b, __c);
10600 }
10601 
10602 static __inline__ void __ATTRS_o_ai vec_stvehx(vector bool short __a, int __b,
10603  short *__c) {
10604  __builtin_altivec_stvehx((vector short)__a, __b, __c);
10605 }
10606 
10607 static __inline__ void __ATTRS_o_ai vec_stvehx(vector bool short __a, int __b,
10608  unsigned short *__c) {
10609  __builtin_altivec_stvehx((vector short)__a, __b, __c);
10610 }
10611 
10612 static __inline__ void __ATTRS_o_ai vec_stvehx(vector pixel __a, int __b,
10613  short *__c) {
10614  __builtin_altivec_stvehx((vector short)__a, __b, __c);
10615 }
10616 
10617 static __inline__ void __ATTRS_o_ai vec_stvehx(vector pixel __a, int __b,
10618  unsigned short *__c) {
10619  __builtin_altivec_stvehx((vector short)__a, __b, __c);
10620 }
10621 
10622 /* vec_stvewx */
10623 
10624 static __inline__ void __ATTRS_o_ai vec_stvewx(vector int __a, int __b,
10625  int *__c) {
10626  __builtin_altivec_stvewx(__a, __b, __c);
10627 }
10628 
10629 static __inline__ void __ATTRS_o_ai vec_stvewx(vector unsigned int __a, int __b,
10630  unsigned int *__c) {
10631  __builtin_altivec_stvewx((vector int)__a, __b, __c);
10632 }
10633 
10634 static __inline__ void __ATTRS_o_ai vec_stvewx(vector bool int __a, int __b,
10635  int *__c) {
10636  __builtin_altivec_stvewx((vector int)__a, __b, __c);
10637 }
10638 
10639 static __inline__ void __ATTRS_o_ai vec_stvewx(vector bool int __a, int __b,
10640  unsigned int *__c) {
10641  __builtin_altivec_stvewx((vector int)__a, __b, __c);
10642 }
10643 
10644 static __inline__ void __ATTRS_o_ai vec_stvewx(vector float __a, int __b,
10645  float *__c) {
10646  __builtin_altivec_stvewx((vector int)__a, __b, __c);
10647 }
10648 
10649 /* vec_stl */
10650 
10651 static __inline__ void __ATTRS_o_ai vec_stl(vector signed char __a, int __b,
10652  vector signed char *__c) {
10653  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10654 }
10655 
10656 static __inline__ void __ATTRS_o_ai vec_stl(vector signed char __a, int __b,
10657  signed char *__c) {
10658  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10659 }
10660 
10661 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned char __a, int __b,
10662  vector unsigned char *__c) {
10663  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10664 }
10665 
10666 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned char __a, int __b,
10667  unsigned char *__c) {
10668  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10669 }
10670 
10671 static __inline__ void __ATTRS_o_ai vec_stl(vector bool char __a, int __b,
10672  signed char *__c) {
10673  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10674 }
10675 
10676 static __inline__ void __ATTRS_o_ai vec_stl(vector bool char __a, int __b,
10677  unsigned char *__c) {
10678  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10679 }
10680 
10681 static __inline__ void __ATTRS_o_ai vec_stl(vector bool char __a, int __b,
10682  vector bool char *__c) {
10683  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10684 }
10685 
10686 static __inline__ void __ATTRS_o_ai vec_stl(vector short __a, int __b,
10687  vector short *__c) {
10688  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10689 }
10690 
10691 static __inline__ void __ATTRS_o_ai vec_stl(vector short __a, int __b,
10692  short *__c) {
10693  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10694 }
10695 
10696 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned short __a, int __b,
10697  vector unsigned short *__c) {
10698  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10699 }
10700 
10701 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned short __a, int __b,
10702  unsigned short *__c) {
10703  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10704 }
10705 
10706 static __inline__ void __ATTRS_o_ai vec_stl(vector bool short __a, int __b,
10707  short *__c) {
10708  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10709 }
10710 
10711 static __inline__ void __ATTRS_o_ai vec_stl(vector bool short __a, int __b,
10712  unsigned short *__c) {
10713  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10714 }
10715 
10716 static __inline__ void __ATTRS_o_ai vec_stl(vector bool short __a, int __b,
10717  vector bool short *__c) {
10718  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10719 }
10720 
10721 static __inline__ void __ATTRS_o_ai vec_stl(vector pixel __a, int __b,
10722  short *__c) {
10723  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10724 }
10725 
10726 static __inline__ void __ATTRS_o_ai vec_stl(vector pixel __a, int __b,
10727  unsigned short *__c) {
10728  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10729 }
10730 
10731 static __inline__ void __ATTRS_o_ai vec_stl(vector pixel __a, int __b,
10732  vector pixel *__c) {
10733  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10734 }
10735 
10736 static __inline__ void __ATTRS_o_ai vec_stl(vector int __a, int __b,
10737  vector int *__c) {
10738  __builtin_altivec_stvxl(__a, __b, __c);
10739 }
10740 
10741 static __inline__ void __ATTRS_o_ai vec_stl(vector int __a, int __b, int *__c) {
10742  __builtin_altivec_stvxl(__a, __b, __c);
10743 }
10744 
10745 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned int __a, int __b,
10746  vector unsigned int *__c) {
10747  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10748 }
10749 
10750 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned int __a, int __b,
10751  unsigned int *__c) {
10752  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10753 }
10754 
10755 static __inline__ void __ATTRS_o_ai vec_stl(vector bool int __a, int __b,
10756  int *__c) {
10757  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10758 }
10759 
10760 static __inline__ void __ATTRS_o_ai vec_stl(vector bool int __a, int __b,
10761  unsigned int *__c) {
10762  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10763 }
10764 
10765 static __inline__ void __ATTRS_o_ai vec_stl(vector bool int __a, int __b,
10766  vector bool int *__c) {
10767  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10768 }
10769 
10770 static __inline__ void __ATTRS_o_ai vec_stl(vector float __a, int __b,
10771  vector float *__c) {
10772  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10773 }
10774 
10775 static __inline__ void __ATTRS_o_ai vec_stl(vector float __a, int __b,
10776  float *__c) {
10777  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10778 }
10779 
10780 /* vec_stvxl */
10781 
10782 static __inline__ void __ATTRS_o_ai vec_stvxl(vector signed char __a, int __b,
10783  vector signed char *__c) {
10784  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10785 }
10786 
10787 static __inline__ void __ATTRS_o_ai vec_stvxl(vector signed char __a, int __b,
10788  signed char *__c) {
10789  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10790 }
10791 
10792 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned char __a, int __b,
10793  vector unsigned char *__c) {
10794  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10795 }
10796 
10797 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned char __a, int __b,
10798  unsigned char *__c) {
10799  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10800 }
10801 
10802 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool char __a, int __b,
10803  signed char *__c) {
10804  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10805 }
10806 
10807 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool char __a, int __b,
10808  unsigned char *__c) {
10809  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10810 }
10811 
10812 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool char __a, int __b,
10813  vector bool char *__c) {
10814  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10815 }
10816 
10817 static __inline__ void __ATTRS_o_ai vec_stvxl(vector short __a, int __b,
10818  vector short *__c) {
10819  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10820 }
10821 
10822 static __inline__ void __ATTRS_o_ai vec_stvxl(vector short __a, int __b,
10823  short *__c) {
10824  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10825 }
10826 
10827 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned short __a,
10828  int __b,
10829  vector unsigned short *__c) {
10830  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10831 }
10832 
10833 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned short __a,
10834  int __b, unsigned short *__c) {
10835  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10836 }
10837 
10838 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool short __a, int __b,
10839  short *__c) {
10840  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10841 }
10842 
10843 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool short __a, int __b,
10844  unsigned short *__c) {
10845  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10846 }
10847 
10848 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool short __a, int __b,
10849  vector bool short *__c) {
10850  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10851 }
10852 
10853 static __inline__ void __ATTRS_o_ai vec_stvxl(vector pixel __a, int __b,
10854  short *__c) {
10855  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10856 }
10857 
10858 static __inline__ void __ATTRS_o_ai vec_stvxl(vector pixel __a, int __b,
10859  unsigned short *__c) {
10860  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10861 }
10862 
10863 static __inline__ void __ATTRS_o_ai vec_stvxl(vector pixel __a, int __b,
10864  vector pixel *__c) {
10865  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10866 }
10867 
10868 static __inline__ void __ATTRS_o_ai vec_stvxl(vector int __a, int __b,
10869  vector int *__c) {
10870  __builtin_altivec_stvxl(__a, __b, __c);
10871 }
10872 
10873 static __inline__ void __ATTRS_o_ai vec_stvxl(vector int __a, int __b,
10874  int *__c) {
10875  __builtin_altivec_stvxl(__a, __b, __c);
10876 }
10877 
10878 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned int __a, int __b,
10879  vector unsigned int *__c) {
10880  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10881 }
10882 
10883 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned int __a, int __b,
10884  unsigned int *__c) {
10885  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10886 }
10887 
10888 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool int __a, int __b,
10889  int *__c) {
10890  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10891 }
10892 
10893 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool int __a, int __b,
10894  unsigned int *__c) {
10895  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10896 }
10897 
10898 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool int __a, int __b,
10899  vector bool int *__c) {
10900  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10901 }
10902 
10903 static __inline__ void __ATTRS_o_ai vec_stvxl(vector float __a, int __b,
10904  vector float *__c) {
10905  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10906 }
10907 
10908 static __inline__ void __ATTRS_o_ai vec_stvxl(vector float __a, int __b,
10909  float *__c) {
10910  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10911 }
10912 
10913 /* vec_sub */
10914 
10915 static __inline__ vector signed char __ATTRS_o_ai
10916 vec_sub(vector signed char __a, vector signed char __b) {
10917  return __a - __b;
10918 }
10919 
10920 static __inline__ vector signed char __ATTRS_o_ai
10921 vec_sub(vector bool char __a, vector signed char __b) {
10922  return (vector signed char)__a - __b;
10923 }
10924 
10925 static __inline__ vector signed char __ATTRS_o_ai
10926 vec_sub(vector signed char __a, vector bool char __b) {
10927  return __a - (vector signed char)__b;
10928 }
10929 
10930 static __inline__ vector unsigned char __ATTRS_o_ai
10931 vec_sub(vector unsigned char __a, vector unsigned char __b) {
10932  return __a - __b;
10933 }
10934 
10935 static __inline__ vector unsigned char __ATTRS_o_ai
10936 vec_sub(vector bool char __a, vector unsigned char __b) {
10937  return (vector unsigned char)__a - __b;
10938 }
10939 
10940 static __inline__ vector unsigned char __ATTRS_o_ai
10941 vec_sub(vector unsigned char __a, vector bool char __b) {
10942  return __a - (vector unsigned char)__b;
10943 }
10944 
10945 static __inline__ vector short __ATTRS_o_ai vec_sub(vector short __a,
10946  vector short __b) {
10947  return __a - __b;
10948 }
10949 
10950 static __inline__ vector short __ATTRS_o_ai vec_sub(vector bool short __a,
10951  vector short __b) {
10952  return (vector short)__a - __b;
10953 }
10954 
10955 static __inline__ vector short __ATTRS_o_ai vec_sub(vector short __a,
10956  vector bool short __b) {
10957  return __a - (vector short)__b;
10958 }
10959 
10960 static __inline__ vector unsigned short __ATTRS_o_ai
10961 vec_sub(vector unsigned short __a, vector unsigned short __b) {
10962  return __a - __b;
10963 }
10964 
10965 static __inline__ vector unsigned short __ATTRS_o_ai
10966 vec_sub(vector bool short __a, vector unsigned short __b) {
10967  return (vector unsigned short)__a - __b;
10968 }
10969 
10970 static __inline__ vector unsigned short __ATTRS_o_ai
10971 vec_sub(vector unsigned short __a, vector bool short __b) {
10972  return __a - (vector unsigned short)__b;
10973 }
10974 
10975 static __inline__ vector int __ATTRS_o_ai vec_sub(vector int __a,
10976  vector int __b) {
10977  return __a - __b;
10978 }
10979 
10980 static __inline__ vector int __ATTRS_o_ai vec_sub(vector bool int __a,
10981  vector int __b) {
10982  return (vector int)__a - __b;
10983 }
10984 
10985 static __inline__ vector int __ATTRS_o_ai vec_sub(vector int __a,
10986  vector bool int __b) {
10987  return __a - (vector int)__b;
10988 }
10989 
10990 static __inline__ vector unsigned int __ATTRS_o_ai
10991 vec_sub(vector unsigned int __a, vector unsigned int __b) {
10992  return __a - __b;
10993 }
10994 
10995 static __inline__ vector unsigned int __ATTRS_o_ai
10996 vec_sub(vector bool int __a, vector unsigned int __b) {
10997  return (vector unsigned int)__a - __b;
10998 }
10999 
11000 static __inline__ vector unsigned int __ATTRS_o_ai
11001 vec_sub(vector unsigned int __a, vector bool int __b) {
11002  return __a - (vector unsigned int)__b;
11003 }
11004 
11005 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
11006 static __inline__ vector signed __int128 __ATTRS_o_ai
11007 vec_sub(vector signed __int128 __a, vector signed __int128 __b) {
11008  return __a - __b;
11009 }
11010 
11011 static __inline__ vector unsigned __int128 __ATTRS_o_ai
11012 vec_sub(vector unsigned __int128 __a, vector unsigned __int128 __b) {
11013  return __a - __b;
11014 }
11015 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
11016 
11017 #ifdef __VSX__
11018 static __inline__ vector signed long long __ATTRS_o_ai
11019 vec_sub(vector signed long long __a, vector signed long long __b) {
11020  return __a - __b;
11021 }
11022 
11023 static __inline__ vector unsigned long long __ATTRS_o_ai
11024 vec_sub(vector unsigned long long __a, vector unsigned long long __b) {
11025  return __a - __b;
11026 }
11027 
11028 static __inline__ vector double __ATTRS_o_ai vec_sub(vector double __a,
11029  vector double __b) {
11030  return __a - __b;
11031 }
11032 #endif
11033 
11034 static __inline__ vector float __ATTRS_o_ai vec_sub(vector float __a,
11035  vector float __b) {
11036  return __a - __b;
11037 }
11038 
11039 /* vec_vsububm */
11040 
11041 #define __builtin_altivec_vsububm vec_vsububm
11042 
11043 static __inline__ vector signed char __ATTRS_o_ai
11044 vec_vsububm(vector signed char __a, vector signed char __b) {
11045  return __a - __b;
11046 }
11047 
11048 static __inline__ vector signed char __ATTRS_o_ai
11049 vec_vsububm(vector bool char __a, vector signed char __b) {
11050  return (vector signed char)__a - __b;
11051 }
11052 
11053 static __inline__ vector signed char __ATTRS_o_ai
11054 vec_vsububm(vector signed char __a, vector bool char __b) {
11055  return __a - (vector signed char)__b;
11056 }
11057 
11058 static __inline__ vector unsigned char __ATTRS_o_ai
11059 vec_vsububm(vector unsigned char __a, vector unsigned char __b) {
11060  return __a - __b;
11061 }
11062 
11063 static __inline__ vector unsigned char __ATTRS_o_ai
11064 vec_vsububm(vector bool char __a, vector unsigned char __b) {
11065  return (vector unsigned char)__a - __b;
11066 }
11067 
11068 static __inline__ vector unsigned char __ATTRS_o_ai
11069 vec_vsububm(vector unsigned char __a, vector bool char __b) {
11070  return __a - (vector unsigned char)__b;
11071 }
11072 
11073 /* vec_vsubuhm */
11074 
11075 #define __builtin_altivec_vsubuhm vec_vsubuhm
11076 
11077 static __inline__ vector short __ATTRS_o_ai vec_vsubuhm(vector short __a,
11078  vector short __b) {
11079  return __a - __b;
11080 }
11081 
11082 static __inline__ vector short __ATTRS_o_ai vec_vsubuhm(vector bool short __a,
11083  vector short __b) {
11084  return (vector short)__a - __b;
11085 }
11086 
11087 static __inline__ vector short __ATTRS_o_ai vec_vsubuhm(vector short __a,
11088  vector bool short __b) {
11089  return __a - (vector short)__b;
11090 }
11091 
11092 static __inline__ vector unsigned short __ATTRS_o_ai
11093 vec_vsubuhm(vector unsigned short __a, vector unsigned short __b) {
11094  return __a - __b;
11095 }
11096 
11097 static __inline__ vector unsigned short __ATTRS_o_ai
11098 vec_vsubuhm(vector bool short __a, vector unsigned short __b) {
11099  return (vector unsigned short)__a - __b;
11100 }
11101 
11102 static __inline__ vector unsigned short __ATTRS_o_ai
11103 vec_vsubuhm(vector unsigned short __a, vector bool short __b) {
11104  return __a - (vector unsigned short)__b;
11105 }
11106 
11107 /* vec_vsubuwm */
11108 
11109 #define __builtin_altivec_vsubuwm vec_vsubuwm
11110 
11111 static __inline__ vector int __ATTRS_o_ai vec_vsubuwm(vector int __a,
11112  vector int __b) {
11113  return __a - __b;
11114 }
11115 
11116 static __inline__ vector int __ATTRS_o_ai vec_vsubuwm(vector bool int __a,
11117  vector int __b) {
11118  return (vector int)__a - __b;
11119 }
11120 
11121 static __inline__ vector int __ATTRS_o_ai vec_vsubuwm(vector int __a,
11122  vector bool int __b) {
11123  return __a - (vector int)__b;
11124 }
11125 
11126 static __inline__ vector unsigned int __ATTRS_o_ai
11127 vec_vsubuwm(vector unsigned int __a, vector unsigned int __b) {
11128  return __a - __b;
11129 }
11130 
11131 static __inline__ vector unsigned int __ATTRS_o_ai
11132 vec_vsubuwm(vector bool int __a, vector unsigned int __b) {
11133  return (vector unsigned int)__a - __b;
11134 }
11135 
11136 static __inline__ vector unsigned int __ATTRS_o_ai
11137 vec_vsubuwm(vector unsigned int __a, vector bool int __b) {
11138  return __a - (vector unsigned int)__b;
11139 }
11140 
11141 /* vec_vsubfp */
11142 
11143 #define __builtin_altivec_vsubfp vec_vsubfp
11144 
11145 static __inline__ vector float __attribute__((__always_inline__))
11146 vec_vsubfp(vector float __a, vector float __b) {
11147  return __a - __b;
11148 }
11149 
11150 /* vec_subc */
11151 
11152 static __inline__ vector signed int __ATTRS_o_ai
11153 vec_subc(vector signed int __a, vector signed int __b) {
11154  return (vector signed int)__builtin_altivec_vsubcuw((vector unsigned int)__a,
11155  (vector unsigned int) __b);
11156 }
11157 
11158 static __inline__ vector unsigned int __ATTRS_o_ai
11159 vec_subc(vector unsigned int __a, vector unsigned int __b) {
11160  return __builtin_altivec_vsubcuw(__a, __b);
11161 }
11162 
11163 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
11164 static __inline__ vector unsigned __int128 __ATTRS_o_ai
11165 vec_subc(vector unsigned __int128 __a, vector unsigned __int128 __b) {
11166  return __builtin_altivec_vsubcuq(__a, __b);
11167 }
11168 
11169 static __inline__ vector signed __int128 __ATTRS_o_ai
11170 vec_subc(vector signed __int128 __a, vector signed __int128 __b) {
11171  return __builtin_altivec_vsubcuq(__a, __b);
11172 }
11173 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
11174 
11175 /* vec_vsubcuw */
11176 
11177 static __inline__ vector unsigned int __attribute__((__always_inline__))
11178 vec_vsubcuw(vector unsigned int __a, vector unsigned int __b) {
11179  return __builtin_altivec_vsubcuw(__a, __b);
11180 }
11181 
11182 /* vec_subs */
11183 
11184 static __inline__ vector signed char __ATTRS_o_ai
11185 vec_subs(vector signed char __a, vector signed char __b) {
11186  return __builtin_altivec_vsubsbs(__a, __b);
11187 }
11188 
11189 static __inline__ vector signed char __ATTRS_o_ai
11190 vec_subs(vector bool char __a, vector signed char __b) {
11191  return __builtin_altivec_vsubsbs((vector signed char)__a, __b);
11192 }
11193 
11194 static __inline__ vector signed char __ATTRS_o_ai
11195 vec_subs(vector signed char __a, vector bool char __b) {
11196  return __builtin_altivec_vsubsbs(__a, (vector signed char)__b);
11197 }
11198 
11199 static __inline__ vector unsigned char __ATTRS_o_ai
11200 vec_subs(vector unsigned char __a, vector unsigned char __b) {
11201  return __builtin_altivec_vsububs(__a, __b);
11202 }
11203 
11204 static __inline__ vector unsigned char __ATTRS_o_ai
11205 vec_subs(vector bool char __a, vector unsigned char __b) {
11206  return __builtin_altivec_vsububs((vector unsigned char)__a, __b);
11207 }
11208 
11209 static __inline__ vector unsigned char __ATTRS_o_ai
11210 vec_subs(vector unsigned char __a, vector bool char __b) {
11211  return __builtin_altivec_vsububs(__a, (vector unsigned char)__b);
11212 }
11213 
11214 static __inline__ vector short __ATTRS_o_ai vec_subs(vector short __a,
11215  vector short __b) {
11216  return __builtin_altivec_vsubshs(__a, __b);
11217 }
11218 
11219 static __inline__ vector short __ATTRS_o_ai vec_subs(vector bool short __a,
11220  vector short __b) {
11221  return __builtin_altivec_vsubshs((vector short)__a, __b);
11222 }
11223 
11224 static __inline__ vector short __ATTRS_o_ai vec_subs(vector short __a,
11225  vector bool short __b) {
11226  return __builtin_altivec_vsubshs(__a, (vector short)__b);
11227 }
11228 
11229 static __inline__ vector unsigned short __ATTRS_o_ai
11230 vec_subs(vector unsigned short __a, vector unsigned short __b) {
11231  return __builtin_altivec_vsubuhs(__a, __b);
11232 }
11233 
11234 static __inline__ vector unsigned short __ATTRS_o_ai
11235 vec_subs(vector bool short __a, vector unsigned short __b) {
11236  return __builtin_altivec_vsubuhs((vector unsigned short)__a, __b);
11237 }
11238 
11239 static __inline__ vector unsigned short __ATTRS_o_ai
11240 vec_subs(vector unsigned short __a, vector bool short __b) {
11241  return __builtin_altivec_vsubuhs(__a, (vector unsigned short)__b);
11242 }
11243 
11244 static __inline__ vector int __ATTRS_o_ai vec_subs(vector int __a,
11245  vector int __b) {
11246  return __builtin_altivec_vsubsws(__a, __b);
11247 }
11248 
11249 static __inline__ vector int __ATTRS_o_ai vec_subs(vector bool int __a,
11250  vector int __b) {
11251  return __builtin_altivec_vsubsws((vector int)__a, __b);
11252 }
11253 
11254 static __inline__ vector int __ATTRS_o_ai vec_subs(vector int __a,
11255  vector bool int __b) {
11256  return __builtin_altivec_vsubsws(__a, (vector int)__b);
11257 }
11258 
11259 static __inline__ vector unsigned int __ATTRS_o_ai
11260 vec_subs(vector unsigned int __a, vector unsigned int __b) {
11261  return __builtin_altivec_vsubuws(__a, __b);
11262 }
11263 
11264 static __inline__ vector unsigned int __ATTRS_o_ai
11265 vec_subs(vector bool int __a, vector unsigned int __b) {
11266  return __builtin_altivec_vsubuws((vector unsigned int)__a, __b);
11267 }
11268 
11269 static __inline__ vector unsigned int __ATTRS_o_ai
11270 vec_subs(vector unsigned int __a, vector bool int __b) {
11271  return __builtin_altivec_vsubuws(__a, (vector unsigned int)__b);
11272 }
11273 
11274 /* vec_vsubsbs */
11275 
11276 static __inline__ vector signed char __ATTRS_o_ai
11277 vec_vsubsbs(vector signed char __a, vector signed char __b) {
11278  return __builtin_altivec_vsubsbs(__a, __b);
11279 }
11280 
11281 static __inline__ vector signed char __ATTRS_o_ai
11282 vec_vsubsbs(vector bool char __a, vector signed char __b) {
11283  return __builtin_altivec_vsubsbs((vector signed char)__a, __b);
11284 }
11285 
11286 static __inline__ vector signed char __ATTRS_o_ai
11287 vec_vsubsbs(vector signed char __a, vector bool char __b) {
11288  return __builtin_altivec_vsubsbs(__a, (vector signed char)__b);
11289 }
11290 
11291 /* vec_vsububs */
11292 
11293 static __inline__ vector unsigned char __ATTRS_o_ai
11294 vec_vsububs(vector unsigned char __a, vector unsigned char __b) {
11295  return __builtin_altivec_vsububs(__a, __b);
11296 }
11297 
11298 static __inline__ vector unsigned char __ATTRS_o_ai
11299 vec_vsububs(vector bool char __a, vector unsigned char __b) {
11300  return __builtin_altivec_vsububs((vector unsigned char)__a, __b);
11301 }
11302 
11303 static __inline__ vector unsigned char __ATTRS_o_ai
11304 vec_vsububs(vector unsigned char __a, vector bool char __b) {
11305  return __builtin_altivec_vsububs(__a, (vector unsigned char)__b);
11306 }
11307 
11308 /* vec_vsubshs */
11309 
11310 static __inline__ vector short __ATTRS_o_ai vec_vsubshs(vector short __a,
11311  vector short __b) {
11312  return __builtin_altivec_vsubshs(__a, __b);
11313 }
11314 
11315 static __inline__ vector short __ATTRS_o_ai vec_vsubshs(vector bool short __a,
11316  vector short __b) {
11317  return __builtin_altivec_vsubshs((vector short)__a, __b);
11318 }
11319 
11320 static __inline__ vector short __ATTRS_o_ai vec_vsubshs(vector short __a,
11321  vector bool short __b) {
11322  return __builtin_altivec_vsubshs(__a, (vector short)__b);
11323 }
11324 
11325 /* vec_vsubuhs */
11326 
11327 static __inline__ vector unsigned short __ATTRS_o_ai
11328 vec_vsubuhs(vector unsigned short __a, vector unsigned short __b) {
11329  return __builtin_altivec_vsubuhs(__a, __b);
11330 }
11331 
11332 static __inline__ vector unsigned short __ATTRS_o_ai
11333 vec_vsubuhs(vector bool short __a, vector unsigned short __b) {
11334  return __builtin_altivec_vsubuhs((vector unsigned short)__a, __b);
11335 }
11336 
11337 static __inline__ vector unsigned short __ATTRS_o_ai
11338 vec_vsubuhs(vector unsigned short __a, vector bool short __b) {
11339  return __builtin_altivec_vsubuhs(__a, (vector unsigned short)__b);
11340 }
11341 
11342 /* vec_vsubsws */
11343 
11344 static __inline__ vector int __ATTRS_o_ai vec_vsubsws(vector int __a,
11345  vector int __b) {
11346  return __builtin_altivec_vsubsws(__a, __b);
11347 }
11348 
11349 static __inline__ vector int __ATTRS_o_ai vec_vsubsws(vector bool int __a,
11350  vector int __b) {
11351  return __builtin_altivec_vsubsws((vector int)__a, __b);
11352 }
11353 
11354 static __inline__ vector int __ATTRS_o_ai vec_vsubsws(vector int __a,
11355  vector bool int __b) {
11356  return __builtin_altivec_vsubsws(__a, (vector int)__b);
11357 }
11358 
11359 /* vec_vsubuws */
11360 
11361 static __inline__ vector unsigned int __ATTRS_o_ai
11362 vec_vsubuws(vector unsigned int __a, vector unsigned int __b) {
11363  return __builtin_altivec_vsubuws(__a, __b);
11364 }
11365 
11366 static __inline__ vector unsigned int __ATTRS_o_ai
11367 vec_vsubuws(vector bool int __a, vector unsigned int __b) {
11368  return __builtin_altivec_vsubuws((vector unsigned int)__a, __b);
11369 }
11370 
11371 static __inline__ vector unsigned int __ATTRS_o_ai
11372 vec_vsubuws(vector unsigned int __a, vector bool int __b) {
11373  return __builtin_altivec_vsubuws(__a, (vector unsigned int)__b);
11374 }
11375 
11376 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
11377 /* vec_vsubuqm */
11378 
11379 static __inline__ vector signed __int128 __ATTRS_o_ai
11380 vec_vsubuqm(vector signed __int128 __a, vector signed __int128 __b) {
11381  return __a - __b;
11382 }
11383 
11384 static __inline__ vector unsigned __int128 __ATTRS_o_ai
11385 vec_vsubuqm(vector unsigned __int128 __a, vector unsigned __int128 __b) {
11386  return __a - __b;
11387 }
11388 
11389 /* vec_vsubeuqm */
11390 
11391 
11392 static __inline__ vector signed __int128 __ATTRS_o_ai
11393 vec_vsubeuqm(vector signed __int128 __a, vector signed __int128 __b,
11394  vector signed __int128 __c) {
11395  return __builtin_altivec_vsubeuqm(__a, __b, __c);
11396 }
11397 
11398 static __inline__ vector unsigned __int128 __ATTRS_o_ai
11399 vec_vsubeuqm(vector unsigned __int128 __a, vector unsigned __int128 __b,
11400  vector unsigned __int128 __c) {
11401  return __builtin_altivec_vsubeuqm(__a, __b, __c);
11402 }
11403 
11404 static __inline__ vector signed __int128 __ATTRS_o_ai
11405 vec_sube(vector signed __int128 __a, vector signed __int128 __b,
11406  vector signed __int128 __c) {
11407  return __builtin_altivec_vsubeuqm(__a, __b, __c);
11408 }
11409 
11410 static __inline__ vector unsigned __int128 __ATTRS_o_ai
11411 vec_sube(vector unsigned __int128 __a, vector unsigned __int128 __b,
11412  vector unsigned __int128 __c) {
11413  return __builtin_altivec_vsubeuqm(__a, __b, __c);
11414 }
11415 
11416 /* vec_vsubcuq */
11417 
11418 static __inline__ vector signed __int128 __ATTRS_o_ai
11419 vec_vsubcuq(vector signed __int128 __a, vector signed __int128 __b) {
11420  return __builtin_altivec_vsubcuq(__a, __b);
11421 }
11422 
11423 static __inline__ vector unsigned __int128 __ATTRS_o_ai
11424 vec_vsubcuq(vector unsigned __int128 __a, vector unsigned __int128 __b) {
11425  return __builtin_altivec_vsubcuq(__a, __b);
11426 }
11427 
11428 /* vec_vsubecuq */
11429 
11430 static __inline__ vector signed __int128 __ATTRS_o_ai
11431 vec_vsubecuq(vector signed __int128 __a, vector signed __int128 __b,
11432  vector signed __int128 __c) {
11433  return __builtin_altivec_vsubecuq(__a, __b, __c);
11434 }
11435 
11436 static __inline__ vector unsigned __int128 __ATTRS_o_ai
11437 vec_vsubecuq(vector unsigned __int128 __a, vector unsigned __int128 __b,
11438  vector unsigned __int128 __c) {
11439  return __builtin_altivec_vsubecuq(__a, __b, __c);
11440 }
11441 
11442 static __inline__ vector signed int __ATTRS_o_ai
11443 vec_subec(vector signed int __a, vector signed int __b,
11444  vector signed int __c) {
11445  return vec_addec(__a, ~__b, __c);
11446 }
11447 
11448 static __inline__ vector unsigned int __ATTRS_o_ai
11449 vec_subec(vector unsigned int __a, vector unsigned int __b,
11450  vector unsigned int __c) {
11451  return vec_addec(__a, ~__b, __c);
11452 }
11453 
11454 static __inline__ vector signed __int128 __ATTRS_o_ai
11455 vec_subec(vector signed __int128 __a, vector signed __int128 __b,
11456  vector signed __int128 __c) {
11457  return __builtin_altivec_vsubecuq(__a, __b, __c);
11458 }
11459 
11460 static __inline__ vector unsigned __int128 __ATTRS_o_ai
11461 vec_subec(vector unsigned __int128 __a, vector unsigned __int128 __b,
11462  vector unsigned __int128 __c) {
11463  return __builtin_altivec_vsubecuq(__a, __b, __c);
11464 }
11465 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
11466 
11467 static __inline__ vector signed int __ATTRS_o_ai
11468 vec_sube(vector signed int __a, vector signed int __b,
11469  vector signed int __c) {
11470  vector signed int __mask = {1, 1, 1, 1};
11471  vector signed int __carry = __c & __mask;
11472  return vec_adde(__a, ~__b, __carry);
11473 }
11474 
11475 static __inline__ vector unsigned int __ATTRS_o_ai
11476 vec_sube(vector unsigned int __a, vector unsigned int __b,
11477  vector unsigned int __c) {
11478  vector unsigned int __mask = {1, 1, 1, 1};
11479  vector unsigned int __carry = __c & __mask;
11480  return vec_adde(__a, ~__b, __carry);
11481 }
11482 /* vec_sum4s */
11483 
11484 static __inline__ vector int __ATTRS_o_ai vec_sum4s(vector signed char __a,
11485  vector int __b) {
11486  return __builtin_altivec_vsum4sbs(__a, __b);
11487 }
11488 
11489 static __inline__ vector unsigned int __ATTRS_o_ai
11490 vec_sum4s(vector unsigned char __a, vector unsigned int __b) {
11491  return __builtin_altivec_vsum4ubs(__a, __b);
11492 }
11493 
11494 static __inline__ vector int __ATTRS_o_ai vec_sum4s(vector signed short __a,
11495  vector int __b) {
11496  return __builtin_altivec_vsum4shs(__a, __b);
11497 }
11498 
11499 /* vec_vsum4sbs */
11500 
11501 static __inline__ vector int __attribute__((__always_inline__))
11502 vec_vsum4sbs(vector signed char __a, vector int __b) {
11503  return __builtin_altivec_vsum4sbs(__a, __b);
11504 }
11505 
11506 /* vec_vsum4ubs */
11507 
11508 static __inline__ vector unsigned int __attribute__((__always_inline__))
11509 vec_vsum4ubs(vector unsigned char __a, vector unsigned int __b) {
11510  return __builtin_altivec_vsum4ubs(__a, __b);
11511 }
11512 
11513 /* vec_vsum4shs */
11514 
11515 static __inline__ vector int __attribute__((__always_inline__))
11516 vec_vsum4shs(vector signed short __a, vector int __b) {
11517  return __builtin_altivec_vsum4shs(__a, __b);
11518 }
11519 
11520 /* vec_sum2s */
11521 
11522 /* The vsum2sws instruction has a big-endian bias, so that the second
11523  input vector and the result always reference big-endian elements
11524  1 and 3 (little-endian element 0 and 2). For ease of porting the
11525  programmer wants elements 1 and 3 in both cases, so for little
11526  endian we must perform some permutes. */
11527 
11528 static __inline__ vector signed int __attribute__((__always_inline__))
11529 vec_sum2s(vector int __a, vector int __b) {
11530 #ifdef __LITTLE_ENDIAN__
11531  vector int __c = (vector signed int)vec_perm(
11532  __b, __b, (vector unsigned char)(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15,
11533  8, 9, 10, 11));
11534  __c = __builtin_altivec_vsum2sws(__a, __c);
11535  return (vector signed int)vec_perm(
11536  __c, __c, (vector unsigned char)(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15,
11537  8, 9, 10, 11));
11538 #else
11539  return __builtin_altivec_vsum2sws(__a, __b);
11540 #endif
11541 }
11542 
11543 /* vec_vsum2sws */
11544 
11545 static __inline__ vector signed int __attribute__((__always_inline__))
11546 vec_vsum2sws(vector int __a, vector int __b) {
11547 #ifdef __LITTLE_ENDIAN__
11548  vector int __c = (vector signed int)vec_perm(
11549  __b, __b, (vector unsigned char)(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15,
11550  8, 9, 10, 11));
11551  __c = __builtin_altivec_vsum2sws(__a, __c);
11552  return (vector signed int)vec_perm(
11553  __c, __c, (vector unsigned char)(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15,
11554  8, 9, 10, 11));
11555 #else
11556  return __builtin_altivec_vsum2sws(__a, __b);
11557 #endif
11558 }
11559 
11560 /* vec_sums */
11561 
11562 /* The vsumsws instruction has a big-endian bias, so that the second
11563  input vector and the result always reference big-endian element 3
11564  (little-endian element 0). For ease of porting the programmer
11565  wants element 3 in both cases, so for little endian we must perform
11566  some permutes. */
11567 
11568 static __inline__ vector signed int __attribute__((__always_inline__))
11569 vec_sums(vector signed int __a, vector signed int __b) {
11570 #ifdef __LITTLE_ENDIAN__
11571  __b = (vector signed int)vec_splat(__b, 3);
11572  __b = __builtin_altivec_vsumsws(__a, __b);
11573  return (vector signed int)(0, 0, 0, __b[0]);
11574 #else
11575  return __builtin_altivec_vsumsws(__a, __b);
11576 #endif
11577 }
11578 
11579 /* vec_vsumsws */
11580 
11581 static __inline__ vector signed int __attribute__((__always_inline__))
11582 vec_vsumsws(vector signed int __a, vector signed int __b) {
11583 #ifdef __LITTLE_ENDIAN__
11584  __b = (vector signed int)vec_splat(__b, 3);
11585  __b = __builtin_altivec_vsumsws(__a, __b);
11586  return (vector signed int)(0, 0, 0, __b[0]);
11587 #else
11588  return __builtin_altivec_vsumsws(__a, __b);
11589 #endif
11590 }
11591 
11592 /* vec_trunc */
11593 
11594 static __inline__ vector float __ATTRS_o_ai vec_trunc(vector float __a) {
11595 #ifdef __VSX__
11596  return __builtin_vsx_xvrspiz(__a);
11597 #else
11598  return __builtin_altivec_vrfiz(__a);
11599 #endif
11600 }
11601 
11602 #ifdef __VSX__
11603 static __inline__ vector double __ATTRS_o_ai vec_trunc(vector double __a) {
11604  return __builtin_vsx_xvrdpiz(__a);
11605 }
11606 #endif
11607 
11608 /* vec_vrfiz */
11609 
11610 static __inline__ vector float __attribute__((__always_inline__))
11611 vec_vrfiz(vector float __a) {
11612  return __builtin_altivec_vrfiz(__a);
11613 }
11614 
11615 /* vec_unpackh */
11616 
11617 /* The vector unpack instructions all have a big-endian bias, so for
11618  little endian we must reverse the meanings of "high" and "low." */
11619 
11620 static __inline__ vector short __ATTRS_o_ai
11621 vec_unpackh(vector signed char __a) {
11622 #ifdef __LITTLE_ENDIAN__
11623  return __builtin_altivec_vupklsb((vector char)__a);
11624 #else
11625  return __builtin_altivec_vupkhsb((vector char)__a);
11626 #endif
11627 }
11628 
11629 static __inline__ vector bool short __ATTRS_o_ai
11630 vec_unpackh(vector bool char __a) {
11631 #ifdef __LITTLE_ENDIAN__
11632  return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
11633 #else
11634  return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
11635 #endif
11636 }
11637 
11638 static __inline__ vector int __ATTRS_o_ai vec_unpackh(vector short __a) {
11639 #ifdef __LITTLE_ENDIAN__
11640  return __builtin_altivec_vupklsh(__a);
11641 #else
11642  return __builtin_altivec_vupkhsh(__a);
11643 #endif
11644 }
11645 
11646 static __inline__ vector bool int __ATTRS_o_ai
11647 vec_unpackh(vector bool short __a) {
11648 #ifdef __LITTLE_ENDIAN__
11649  return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
11650 #else
11651  return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
11652 #endif
11653 }
11654 
11655 static __inline__ vector unsigned int __ATTRS_o_ai
11656 vec_unpackh(vector pixel __a) {
11657 #ifdef __LITTLE_ENDIAN__
11658  return (vector unsigned int)__builtin_altivec_vupklpx((vector short)__a);
11659 #else
11660  return (vector unsigned int)__builtin_altivec_vupkhpx((vector short)__a);
11661 #endif
11662 }
11663 
11664 #ifdef __POWER8_VECTOR__
11665 static __inline__ vector long long __ATTRS_o_ai vec_unpackh(vector int __a) {
11666 #ifdef __LITTLE_ENDIAN__
11667  return __builtin_altivec_vupklsw(__a);
11668 #else
11669  return __builtin_altivec_vupkhsw(__a);
11670 #endif
11671 }
11672 
11673 static __inline__ vector bool long long __ATTRS_o_ai
11674 vec_unpackh(vector bool int __a) {
11675 #ifdef __LITTLE_ENDIAN__
11676  return (vector bool long long)__builtin_altivec_vupklsw((vector int)__a);
11677 #else
11678  return (vector bool long long)__builtin_altivec_vupkhsw((vector int)__a);
11679 #endif
11680 }
11681 
11682 static __inline__ vector double __ATTRS_o_ai
11683 vec_unpackh(vector float __a) {
11684  return (vector double)(__a[0], __a[1]);
11685 }
11686 #endif
11687 
11688 /* vec_vupkhsb */
11689 
11690 static __inline__ vector short __ATTRS_o_ai
11691 vec_vupkhsb(vector signed char __a) {
11692 #ifdef __LITTLE_ENDIAN__
11693  return __builtin_altivec_vupklsb((vector char)__a);
11694 #else
11695  return __builtin_altivec_vupkhsb((vector char)__a);
11696 #endif
11697 }
11698 
11699 static __inline__ vector bool short __ATTRS_o_ai
11700 vec_vupkhsb(vector bool char __a) {
11701 #ifdef __LITTLE_ENDIAN__
11702  return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
11703 #else
11704  return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
11705 #endif
11706 }
11707 
11708 /* vec_vupkhsh */
11709 
11710 static __inline__ vector int __ATTRS_o_ai vec_vupkhsh(vector short __a) {
11711 #ifdef __LITTLE_ENDIAN__
11712  return __builtin_altivec_vupklsh(__a);
11713 #else
11714  return __builtin_altivec_vupkhsh(__a);
11715 #endif
11716 }
11717 
11718 static __inline__ vector bool int __ATTRS_o_ai
11719 vec_vupkhsh(vector bool short __a) {
11720 #ifdef __LITTLE_ENDIAN__
11721  return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
11722 #else
11723  return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
11724 #endif
11725 }
11726 
11727 static __inline__ vector unsigned int __ATTRS_o_ai
11728 vec_vupkhsh(vector pixel __a) {
11729 #ifdef __LITTLE_ENDIAN__
11730  return (vector unsigned int)__builtin_altivec_vupklpx((vector short)__a);
11731 #else
11732  return (vector unsigned int)__builtin_altivec_vupkhpx((vector short)__a);
11733 #endif
11734 }
11735 
11736 /* vec_vupkhsw */
11737 
11738 #ifdef __POWER8_VECTOR__
11739 static __inline__ vector long long __ATTRS_o_ai vec_vupkhsw(vector int __a) {
11740 #ifdef __LITTLE_ENDIAN__
11741  return __builtin_altivec_vupklsw(__a);
11742 #else
11743  return __builtin_altivec_vupkhsw(__a);
11744 #endif
11745 }
11746 
11747 static __inline__ vector bool long long __ATTRS_o_ai
11748 vec_vupkhsw(vector bool int __a) {
11749 #ifdef __LITTLE_ENDIAN__
11750  return (vector bool long long)__builtin_altivec_vupklsw((vector int)__a);
11751 #else
11752  return (vector bool long long)__builtin_altivec_vupkhsw((vector int)__a);
11753 #endif
11754 }
11755 #endif
11756 
11757 /* vec_unpackl */
11758 
11759 static __inline__ vector short __ATTRS_o_ai
11760 vec_unpackl(vector signed char __a) {
11761 #ifdef __LITTLE_ENDIAN__
11762  return __builtin_altivec_vupkhsb((vector char)__a);
11763 #else
11764  return __builtin_altivec_vupklsb((vector char)__a);
11765 #endif
11766 }
11767 
11768 static __inline__ vector bool short __ATTRS_o_ai
11769 vec_unpackl(vector bool char __a) {
11770 #ifdef __LITTLE_ENDIAN__
11771  return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
11772 #else
11773  return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
11774 #endif
11775 }
11776 
11777 static __inline__ vector int __ATTRS_o_ai vec_unpackl(vector short __a) {
11778 #ifdef __LITTLE_ENDIAN__
11779  return __builtin_altivec_vupkhsh(__a);
11780 #else
11781  return __builtin_altivec_vupklsh(__a);
11782 #endif
11783 }
11784 
11785 static __inline__ vector bool int __ATTRS_o_ai
11786 vec_unpackl(vector bool short __a) {
11787 #ifdef __LITTLE_ENDIAN__
11788  return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
11789 #else
11790  return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
11791 #endif
11792 }
11793 
11794 static __inline__ vector unsigned int __ATTRS_o_ai
11795 vec_unpackl(vector pixel __a) {
11796 #ifdef __LITTLE_ENDIAN__
11797  return (vector unsigned int)__builtin_altivec_vupkhpx((vector short)__a);
11798 #else
11799  return (vector unsigned int)__builtin_altivec_vupklpx((vector short)__a);
11800 #endif
11801 }
11802 
11803 #ifdef __POWER8_VECTOR__
11804 static __inline__ vector long long __ATTRS_o_ai vec_unpackl(vector int __a) {
11805 #ifdef __LITTLE_ENDIAN__
11806  return __builtin_altivec_vupkhsw(__a);
11807 #else
11808  return __builtin_altivec_vupklsw(__a);
11809 #endif
11810 }
11811 
11812 static __inline__ vector bool long long __ATTRS_o_ai
11813 vec_unpackl(vector bool int __a) {
11814 #ifdef __LITTLE_ENDIAN__
11815  return (vector bool long long)__builtin_altivec_vupkhsw((vector int)__a);
11816 #else
11817  return (vector bool long long)__builtin_altivec_vupklsw((vector int)__a);
11818 #endif
11819 }
11820 
11821 static __inline__ vector double __ATTRS_o_ai
11822 vec_unpackl(vector float __a) {
11823  return (vector double)(__a[2], __a[3]);
11824 }
11825 #endif
11826 
11827 /* vec_vupklsb */
11828 
11829 static __inline__ vector short __ATTRS_o_ai
11830 vec_vupklsb(vector signed char __a) {
11831 #ifdef __LITTLE_ENDIAN__
11832  return __builtin_altivec_vupkhsb((vector char)__a);
11833 #else
11834  return __builtin_altivec_vupklsb((vector char)__a);
11835 #endif
11836 }
11837 
11838 static __inline__ vector bool short __ATTRS_o_ai
11839 vec_vupklsb(vector bool char __a) {
11840 #ifdef __LITTLE_ENDIAN__
11841  return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
11842 #else
11843  return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
11844 #endif
11845 }
11846 
11847 /* vec_vupklsh */
11848 
11849 static __inline__ vector int __ATTRS_o_ai vec_vupklsh(vector short __a) {
11850 #ifdef __LITTLE_ENDIAN__
11851  return __builtin_altivec_vupkhsh(__a);
11852 #else
11853  return __builtin_altivec_vupklsh(__a);
11854 #endif
11855 }
11856 
11857 static __inline__ vector bool int __ATTRS_o_ai
11858 vec_vupklsh(vector bool short __a) {
11859 #ifdef __LITTLE_ENDIAN__
11860  return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
11861 #else
11862  return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
11863 #endif
11864 }
11865 
11866 static __inline__ vector unsigned int __ATTRS_o_ai
11867 vec_vupklsh(vector pixel __a) {
11868 #ifdef __LITTLE_ENDIAN__
11869  return (vector unsigned int)__builtin_altivec_vupkhpx((vector short)__a);
11870 #else
11871  return (vector unsigned int)__builtin_altivec_vupklpx((vector short)__a);
11872 #endif
11873 }
11874 
11875 /* vec_vupklsw */
11876 
11877 #ifdef __POWER8_VECTOR__
11878 static __inline__ vector long long __ATTRS_o_ai vec_vupklsw(vector int __a) {
11879 #ifdef __LITTLE_ENDIAN__
11880  return __builtin_altivec_vupkhsw(__a);
11881 #else
11882  return __builtin_altivec_vupklsw(__a);
11883 #endif
11884 }
11885 
11886 static __inline__ vector bool long long __ATTRS_o_ai
11887 vec_vupklsw(vector bool int __a) {
11888 #ifdef __LITTLE_ENDIAN__
11889  return (vector bool long long)__builtin_altivec_vupkhsw((vector int)__a);
11890 #else
11891  return (vector bool long long)__builtin_altivec_vupklsw((vector int)__a);
11892 #endif
11893 }
11894 #endif
11895 
11896 /* vec_vsx_ld */
11897 
11898 #ifdef __VSX__
11899 
11900 static __inline__ vector bool int __ATTRS_o_ai
11901 vec_vsx_ld(int __a, const vector bool int *__b) {
11902  return (vector bool int)__builtin_vsx_lxvw4x(__a, __b);
11903 }
11904 
11905 static __inline__ vector signed int __ATTRS_o_ai
11906 vec_vsx_ld(int __a, const vector signed int *__b) {
11907  return (vector signed int)__builtin_vsx_lxvw4x(__a, __b);
11908 }
11909 
11910 static __inline__ vector signed int __ATTRS_o_ai
11911 vec_vsx_ld(int __a, const signed int *__b) {
11912  return (vector signed int)__builtin_vsx_lxvw4x(__a, __b);
11913 }
11914 
11915 static __inline__ vector unsigned int __ATTRS_o_ai
11916 vec_vsx_ld(int __a, const vector unsigned int *__b) {
11917  return (vector unsigned int)__builtin_vsx_lxvw4x(__a, __b);
11918 }
11919 
11920 static __inline__ vector unsigned int __ATTRS_o_ai
11921 vec_vsx_ld(int __a, const unsigned int *__b) {
11922  return (vector unsigned int)__builtin_vsx_lxvw4x(__a, __b);
11923 }
11924 
11925 static __inline__ vector float __ATTRS_o_ai
11926 vec_vsx_ld(int __a, const vector float *__b) {
11927  return (vector float)__builtin_vsx_lxvw4x(__a, __b);
11928 }
11929 
11930 static __inline__ vector float __ATTRS_o_ai vec_vsx_ld(int __a,
11931  const float *__b) {
11932  return (vector float)__builtin_vsx_lxvw4x(__a, __b);
11933 }
11934 
11935 static __inline__ vector signed long long __ATTRS_o_ai
11936 vec_vsx_ld(int __a, const vector signed long long *__b) {
11937  return (vector signed long long)__builtin_vsx_lxvd2x(__a, __b);
11938 }
11939 
11940 static __inline__ vector unsigned long long __ATTRS_o_ai
11941 vec_vsx_ld(int __a, const vector unsigned long long *__b) {
11942  return (vector unsigned long long)__builtin_vsx_lxvd2x(__a, __b);
11943 }
11944 
11945 static __inline__ vector double __ATTRS_o_ai
11946 vec_vsx_ld(int __a, const vector double *__b) {
11947  return (vector double)__builtin_vsx_lxvd2x(__a, __b);
11948 }
11949 
11950 static __inline__ vector double __ATTRS_o_ai
11951 vec_vsx_ld(int __a, const double *__b) {
11952  return (vector double)__builtin_vsx_lxvd2x(__a, __b);
11953 }
11954 
11955 static __inline__ vector bool short __ATTRS_o_ai
11956 vec_vsx_ld(int __a, const vector bool short *__b) {
11957  return (vector bool short)__builtin_vsx_lxvw4x(__a, __b);
11958 }
11959 
11960 static __inline__ vector signed short __ATTRS_o_ai
11961 vec_vsx_ld(int __a, const vector signed short *__b) {
11962  return (vector signed short)__builtin_vsx_lxvw4x(__a, __b);
11963 }
11964 
11965 static __inline__ vector signed short __ATTRS_o_ai
11966 vec_vsx_ld(int __a, const signed short *__b) {
11967  return (vector signed short)__builtin_vsx_lxvw4x(__a, __b);
11968 }
11969 
11970 static __inline__ vector unsigned short __ATTRS_o_ai
11971 vec_vsx_ld(int __a, const vector unsigned short *__b) {
11972  return (vector unsigned short)__builtin_vsx_lxvw4x(__a, __b);
11973 }
11974 
11975 static __inline__ vector unsigned short __ATTRS_o_ai
11976 vec_vsx_ld(int __a, const unsigned short *__b) {
11977  return (vector unsigned short)__builtin_vsx_lxvw4x(__a, __b);
11978 }
11979 
11980 static __inline__ vector bool char __ATTRS_o_ai
11981 vec_vsx_ld(int __a, const vector bool char *__b) {
11982  return (vector bool char)__builtin_vsx_lxvw4x(__a, __b);
11983 }
11984 
11985 static __inline__ vector signed char __ATTRS_o_ai
11986 vec_vsx_ld(int __a, const vector signed char *__b) {
11987  return (vector signed char)__builtin_vsx_lxvw4x(__a, __b);
11988 }
11989 
11990 static __inline__ vector signed char __ATTRS_o_ai
11991 vec_vsx_ld(int __a, const signed char *__b) {
11992  return (vector signed char)__builtin_vsx_lxvw4x(__a, __b);
11993 }
11994 
11995 static __inline__ vector unsigned char __ATTRS_o_ai
11996 vec_vsx_ld(int __a, const vector unsigned char *__b) {
11997  return (vector unsigned char)__builtin_vsx_lxvw4x(__a, __b);
11998 }
11999 
12000 static __inline__ vector unsigned char __ATTRS_o_ai
12001 vec_vsx_ld(int __a, const unsigned char *__b) {
12002  return (vector unsigned char)__builtin_vsx_lxvw4x(__a, __b);
12003 }
12004 
12005 #endif
12006 
12007 /* vec_vsx_st */
12008 
12009 #ifdef __VSX__
12010 
12011 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool int __a, int __b,
12012  vector bool int *__c) {
12013  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12014 }
12015 
12016 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool int __a, int __b,
12017  signed int *__c) {
12018  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12019 }
12020 
12021 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool int __a, int __b,
12022  unsigned int *__c) {
12023  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12024 }
12025 
12026 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed int __a, int __b,
12027  vector signed int *__c) {
12028  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12029 }
12030 
12031 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed int __a, int __b,
12032  signed int *__c) {
12033  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12034 }
12035 
12036 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned int __a, int __b,
12037  vector unsigned int *__c) {
12038  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12039 }
12040 
12041 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned int __a, int __b,
12042  unsigned int *__c) {
12043  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12044 }
12045 
12046 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector float __a, int __b,
12047  vector float *__c) {
12048  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12049 }
12050 
12051 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector float __a, int __b,
12052  float *__c) {
12053  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12054 }
12055 
12056 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed long long __a,
12057  int __b,
12058  vector signed long long *__c) {
12059  __builtin_vsx_stxvd2x((vector double)__a, __b, __c);
12060 }
12061 
12062 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned long long __a,
12063  int __b,
12064  vector unsigned long long *__c) {
12065  __builtin_vsx_stxvd2x((vector double)__a, __b, __c);
12066 }
12067 
12068 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector double __a, int __b,
12069  vector double *__c) {
12070  __builtin_vsx_stxvd2x((vector double)__a, __b, __c);
12071 }
12072 
12073 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector double __a, int __b,
12074  double *__c) {
12075  __builtin_vsx_stxvd2x((vector double)__a, __b, __c);
12076 }
12077 
12078 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool short __a, int __b,
12079  vector bool short *__c) {
12080  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12081 }
12082 
12083 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool short __a, int __b,
12084  signed short *__c) {
12085  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12086 }
12087 
12088 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool short __a, int __b,
12089  unsigned short *__c) {
12090  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12091 }
12092 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed short __a, int __b,
12093  vector signed short *__c) {
12094  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12095 }
12096 
12097 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed short __a, int __b,
12098  signed short *__c) {
12099  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12100 }
12101 
12102 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned short __a,
12103  int __b,
12104  vector unsigned short *__c) {
12105  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12106 }
12107 
12108 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned short __a,
12109  int __b, unsigned short *__c) {
12110  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12111 }
12112 
12113 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool char __a, int __b,
12114  vector bool char *__c) {
12115  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12116 }
12117 
12118 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool char __a, int __b,
12119  signed char *__c) {
12120  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12121 }
12122 
12123 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool char __a, int __b,
12124  unsigned char *__c) {
12125  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12126 }
12127 
12128 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed char __a, int __b,
12129  vector signed char *__c) {
12130  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12131 }
12132 
12133 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed char __a, int __b,
12134  signed char *__c) {
12135  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12136 }
12137 
12138 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned char __a,
12139  int __b,
12140  vector unsigned char *__c) {
12141  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12142 }
12143 
12144 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned char __a,
12145  int __b, unsigned char *__c) {
12146  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12147 }
12148 
12149 #endif
12150 
12151 #ifdef __VSX__
12152 #define vec_xxpermdi __builtin_vsx_xxpermdi
12153 #define vec_xxsldwi __builtin_vsx_xxsldwi
12154 #endif
12155 
12156 /* vec_xor */
12157 
12158 #define __builtin_altivec_vxor vec_xor
12159 
12160 static __inline__ vector signed char __ATTRS_o_ai
12161 vec_xor(vector signed char __a, vector signed char __b) {
12162  return __a ^ __b;
12163 }
12164 
12165 static __inline__ vector signed char __ATTRS_o_ai
12166 vec_xor(vector bool char __a, vector signed char __b) {
12167  return (vector signed char)__a ^ __b;
12168 }
12169 
12170 static __inline__ vector signed char __ATTRS_o_ai
12171 vec_xor(vector signed char __a, vector bool char __b) {
12172  return __a ^ (vector signed char)__b;
12173 }
12174 
12175 static __inline__ vector unsigned char __ATTRS_o_ai
12176 vec_xor(vector unsigned char __a, vector unsigned char __b) {
12177  return __a ^ __b;
12178 }
12179 
12180 static __inline__ vector unsigned char __ATTRS_o_ai
12181 vec_xor(vector bool char __a, vector unsigned char __b) {
12182  return (vector unsigned char)__a ^ __b;
12183 }
12184 
12185 static __inline__ vector unsigned char __ATTRS_o_ai
12186 vec_xor(vector unsigned char __a, vector bool char __b) {
12187  return __a ^ (vector unsigned char)__b;
12188 }
12189 
12190 static __inline__ vector bool char __ATTRS_o_ai vec_xor(vector bool char __a,
12191  vector bool char __b) {
12192  return __a ^ __b;
12193 }
12194 
12195 static __inline__ vector short __ATTRS_o_ai vec_xor(vector short __a,
12196  vector short __b) {
12197  return __a ^ __b;
12198 }
12199 
12200 static __inline__ vector short __ATTRS_o_ai vec_xor(vector bool short __a,
12201  vector short __b) {
12202  return (vector short)__a ^ __b;
12203 }
12204 
12205 static __inline__ vector short __ATTRS_o_ai vec_xor(vector short __a,
12206  vector bool short __b) {
12207  return __a ^ (vector short)__b;
12208 }
12209 
12210 static __inline__ vector unsigned short __ATTRS_o_ai
12211 vec_xor(vector unsigned short __a, vector unsigned short __b) {
12212  return __a ^ __b;
12213 }
12214 
12215 static __inline__ vector unsigned short __ATTRS_o_ai
12216 vec_xor(vector bool short __a, vector unsigned short __b) {
12217  return (vector unsigned short)__a ^ __b;
12218 }
12219 
12220 static __inline__ vector unsigned short __ATTRS_o_ai
12221 vec_xor(vector unsigned short __a, vector bool short __b) {
12222  return __a ^ (vector unsigned short)__b;
12223 }
12224 
12225 static __inline__ vector bool short __ATTRS_o_ai
12226 vec_xor(vector bool short __a, vector bool short __b) {
12227  return __a ^ __b;
12228 }
12229 
12230 static __inline__ vector int __ATTRS_o_ai vec_xor(vector int __a,
12231  vector int __b) {
12232  return __a ^ __b;
12233 }
12234 
12235 static __inline__ vector int __ATTRS_o_ai vec_xor(vector bool int __a,
12236  vector int __b) {
12237  return (vector int)__a ^ __b;
12238 }
12239 
12240 static __inline__ vector int __ATTRS_o_ai vec_xor(vector int __a,
12241  vector bool int __b) {
12242  return __a ^ (vector int)__b;
12243 }
12244 
12245 static __inline__ vector unsigned int __ATTRS_o_ai
12246 vec_xor(vector unsigned int __a, vector unsigned int __b) {
12247  return __a ^ __b;
12248 }
12249 
12250 static __inline__ vector unsigned int __ATTRS_o_ai
12251 vec_xor(vector bool int __a, vector unsigned int __b) {
12252  return (vector unsigned int)__a ^ __b;
12253 }
12254 
12255 static __inline__ vector unsigned int __ATTRS_o_ai
12256 vec_xor(vector unsigned int __a, vector bool int __b) {
12257  return __a ^ (vector unsigned int)__b;
12258 }
12259 
12260 static __inline__ vector bool int __ATTRS_o_ai vec_xor(vector bool int __a,
12261  vector bool int __b) {
12262  return __a ^ __b;
12263 }
12264 
12265 static __inline__ vector float __ATTRS_o_ai vec_xor(vector float __a,
12266  vector float __b) {
12267  vector unsigned int __res =
12268  (vector unsigned int)__a ^ (vector unsigned int)__b;
12269  return (vector float)__res;
12270 }
12271 
12272 static __inline__ vector float __ATTRS_o_ai vec_xor(vector bool int __a,
12273  vector float __b) {
12274  vector unsigned int __res =
12275  (vector unsigned int)__a ^ (vector unsigned int)__b;
12276  return (vector float)__res;
12277 }
12278 
12279 static __inline__ vector float __ATTRS_o_ai vec_xor(vector float __a,
12280  vector bool int __b) {
12281  vector unsigned int __res =
12282  (vector unsigned int)__a ^ (vector unsigned int)__b;
12283  return (vector float)__res;
12284 }
12285 
12286 #ifdef __VSX__
12287 static __inline__ vector signed long long __ATTRS_o_ai
12288 vec_xor(vector signed long long __a, vector signed long long __b) {
12289  return __a ^ __b;
12290 }
12291 
12292 static __inline__ vector signed long long __ATTRS_o_ai
12293 vec_xor(vector bool long long __a, vector signed long long __b) {
12294  return (vector signed long long)__a ^ __b;
12295 }
12296 
12297 static __inline__ vector signed long long __ATTRS_o_ai
12298 vec_xor(vector signed long long __a, vector bool long long __b) {
12299  return __a ^ (vector signed long long)__b;
12300 }
12301 
12302 static __inline__ vector unsigned long long __ATTRS_o_ai
12303 vec_xor(vector unsigned long long __a, vector unsigned long long __b) {
12304  return __a ^ __b;
12305 }
12306 
12307 static __inline__ vector unsigned long long __ATTRS_o_ai
12308 vec_xor(vector bool long long __a, vector unsigned long long __b) {
12309  return (vector unsigned long long)__a ^ __b;
12310 }
12311 
12312 static __inline__ vector unsigned long long __ATTRS_o_ai
12313 vec_xor(vector unsigned long long __a, vector bool long long __b) {
12314  return __a ^ (vector unsigned long long)__b;
12315 }
12316 
12317 static __inline__ vector bool long long __ATTRS_o_ai
12318 vec_xor(vector bool long long __a, vector bool long long __b) {
12319  return __a ^ __b;
12320 }
12321 
12322 static __inline__ vector double __ATTRS_o_ai vec_xor(vector double __a,
12323  vector double __b) {
12324  return (vector double)((vector unsigned long long)__a ^
12325  (vector unsigned long long)__b);
12326 }
12327 
12328 static __inline__ vector double __ATTRS_o_ai
12329 vec_xor(vector double __a, vector bool long long __b) {
12330  return (vector double)((vector unsigned long long)__a ^
12331  (vector unsigned long long)__b);
12332 }
12333 
12334 static __inline__ vector double __ATTRS_o_ai vec_xor(vector bool long long __a,
12335  vector double __b) {
12336  return (vector double)((vector unsigned long long)__a ^
12337  (vector unsigned long long)__b);
12338 }
12339 #endif
12340 
12341 /* vec_vxor */
12342 
12343 static __inline__ vector signed char __ATTRS_o_ai
12344 vec_vxor(vector signed char __a, vector signed char __b) {
12345  return __a ^ __b;
12346 }
12347 
12348 static __inline__ vector signed char __ATTRS_o_ai
12349 vec_vxor(vector bool char __a, vector signed char __b) {
12350  return (vector signed char)__a ^ __b;
12351 }
12352 
12353 static __inline__ vector signed char __ATTRS_o_ai
12354 vec_vxor(vector signed char __a, vector bool char __b) {
12355  return __a ^ (vector signed char)__b;
12356 }
12357 
12358 static __inline__ vector unsigned char __ATTRS_o_ai
12359 vec_vxor(vector unsigned char __a, vector unsigned char __b) {
12360  return __a ^ __b;
12361 }
12362 
12363 static __inline__ vector unsigned char __ATTRS_o_ai
12364 vec_vxor(vector bool char __a, vector unsigned char __b) {
12365  return (vector unsigned char)__a ^ __b;
12366 }
12367 
12368 static __inline__ vector unsigned char __ATTRS_o_ai
12369 vec_vxor(vector unsigned char __a, vector bool char __b) {
12370  return __a ^ (vector unsigned char)__b;
12371 }
12372 
12373 static __inline__ vector bool char __ATTRS_o_ai vec_vxor(vector bool char __a,
12374  vector bool char __b) {
12375  return __a ^ __b;
12376 }
12377 
12378 static __inline__ vector short __ATTRS_o_ai vec_vxor(vector short __a,
12379  vector short __b) {
12380  return __a ^ __b;
12381 }
12382 
12383 static __inline__ vector short __ATTRS_o_ai vec_vxor(vector bool short __a,
12384  vector short __b) {
12385  return (vector short)__a ^ __b;
12386 }
12387 
12388 static __inline__ vector short __ATTRS_o_ai vec_vxor(vector short __a,
12389  vector bool short __b) {
12390  return __a ^ (vector short)__b;
12391 }
12392 
12393 static __inline__ vector unsigned short __ATTRS_o_ai
12394 vec_vxor(vector unsigned short __a, vector unsigned short __b) {
12395  return __a ^ __b;
12396 }
12397 
12398 static __inline__ vector unsigned short __ATTRS_o_ai
12399 vec_vxor(vector bool short __a, vector unsigned short __b) {
12400  return (vector unsigned short)__a ^ __b;
12401 }
12402 
12403 static __inline__ vector unsigned short __ATTRS_o_ai
12404 vec_vxor(vector unsigned short __a, vector bool short __b) {
12405  return __a ^ (vector unsigned short)__b;
12406 }
12407 
12408 static __inline__ vector bool short __ATTRS_o_ai
12409 vec_vxor(vector bool short __a, vector bool short __b) {
12410  return __a ^ __b;
12411 }
12412 
12413 static __inline__ vector int __ATTRS_o_ai vec_vxor(vector int __a,
12414  vector int __b) {
12415  return __a ^ __b;
12416 }
12417 
12418 static __inline__ vector int __ATTRS_o_ai vec_vxor(vector bool int __a,
12419  vector int __b) {
12420  return (vector int)__a ^ __b;
12421 }
12422 
12423 static __inline__ vector int __ATTRS_o_ai vec_vxor(vector int __a,
12424  vector bool int __b) {
12425  return __a ^ (vector int)__b;
12426 }
12427 
12428 static __inline__ vector unsigned int __ATTRS_o_ai
12429 vec_vxor(vector unsigned int __a, vector unsigned int __b) {
12430  return __a ^ __b;
12431 }
12432 
12433 static __inline__ vector unsigned int __ATTRS_o_ai
12434 vec_vxor(vector bool int __a, vector unsigned int __b) {
12435  return (vector unsigned int)__a ^ __b;
12436 }
12437 
12438 static __inline__ vector unsigned int __ATTRS_o_ai
12439 vec_vxor(vector unsigned int __a, vector bool int __b) {
12440  return __a ^ (vector unsigned int)__b;
12441 }
12442 
12443 static __inline__ vector bool int __ATTRS_o_ai vec_vxor(vector bool int __a,
12444  vector bool int __b) {
12445  return __a ^ __b;
12446 }
12447 
12448 static __inline__ vector float __ATTRS_o_ai vec_vxor(vector float __a,
12449  vector float __b) {
12450  vector unsigned int __res =
12451  (vector unsigned int)__a ^ (vector unsigned int)__b;
12452  return (vector float)__res;
12453 }
12454 
12455 static __inline__ vector float __ATTRS_o_ai vec_vxor(vector bool int __a,
12456  vector float __b) {
12457  vector unsigned int __res =
12458  (vector unsigned int)__a ^ (vector unsigned int)__b;
12459  return (vector float)__res;
12460 }
12461 
12462 static __inline__ vector float __ATTRS_o_ai vec_vxor(vector float __a,
12463  vector bool int __b) {
12464  vector unsigned int __res =
12465  (vector unsigned int)__a ^ (vector unsigned int)__b;
12466  return (vector float)__res;
12467 }
12468 
12469 #ifdef __VSX__
12470 static __inline__ vector signed long long __ATTRS_o_ai
12471 vec_vxor(vector signed long long __a, vector signed long long __b) {
12472  return __a ^ __b;
12473 }
12474 
12475 static __inline__ vector signed long long __ATTRS_o_ai
12476 vec_vxor(vector bool long long __a, vector signed long long __b) {
12477  return (vector signed long long)__a ^ __b;
12478 }
12479 
12480 static __inline__ vector signed long long __ATTRS_o_ai
12481 vec_vxor(vector signed long long __a, vector bool long long __b) {
12482  return __a ^ (vector signed long long)__b;
12483 }
12484 
12485 static __inline__ vector unsigned long long __ATTRS_o_ai
12486 vec_vxor(vector unsigned long long __a, vector unsigned long long __b) {
12487  return __a ^ __b;
12488 }
12489 
12490 static __inline__ vector unsigned long long __ATTRS_o_ai
12491 vec_vxor(vector bool long long __a, vector unsigned long long __b) {
12492  return (vector unsigned long long)__a ^ __b;
12493 }
12494 
12495 static __inline__ vector unsigned long long __ATTRS_o_ai
12496 vec_vxor(vector unsigned long long __a, vector bool long long __b) {
12497  return __a ^ (vector unsigned long long)__b;
12498 }
12499 
12500 static __inline__ vector bool long long __ATTRS_o_ai
12501 vec_vxor(vector bool long long __a, vector bool long long __b) {
12502  return __a ^ __b;
12503 }
12504 #endif
12505 
12506 /* ------------------------ extensions for CBEA ----------------------------- */
12507 
12508 /* vec_extract */
12509 
12510 static __inline__ signed char __ATTRS_o_ai vec_extract(vector signed char __a,
12511  int __b) {
12512  return __a[__b];
12513 }
12514 
12515 static __inline__ unsigned char __ATTRS_o_ai
12516 vec_extract(vector unsigned char __a, int __b) {
12517  return __a[__b];
12518 }
12519 
12520 static __inline__ unsigned char __ATTRS_o_ai vec_extract(vector bool char __a,
12521  int __b) {
12522  return __a[__b];
12523 }
12524 
12525 static __inline__ signed short __ATTRS_o_ai vec_extract(vector signed short __a,
12526  int __b) {
12527  return __a[__b];
12528 }
12529 
12530 static __inline__ unsigned short __ATTRS_o_ai
12531 vec_extract(vector unsigned short __a, int __b) {
12532  return __a[__b];
12533 }
12534 
12535 static __inline__ unsigned short __ATTRS_o_ai vec_extract(vector bool short __a,
12536  int __b) {
12537  return __a[__b];
12538 }
12539 
12540 static __inline__ signed int __ATTRS_o_ai vec_extract(vector signed int __a,
12541  int __b) {
12542  return __a[__b];
12543 }
12544 
12545 static __inline__ unsigned int __ATTRS_o_ai vec_extract(vector unsigned int __a,
12546  int __b) {
12547  return __a[__b];
12548 }
12549 
12550 static __inline__ unsigned int __ATTRS_o_ai vec_extract(vector bool int __a,
12551  int __b) {
12552  return __a[__b];
12553 }
12554 
12555 #ifdef __VSX__
12556 static __inline__ signed long long __ATTRS_o_ai
12557 vec_extract(vector signed long long __a, int __b) {
12558  return __a[__b];
12559 }
12560 
12561 static __inline__ unsigned long long __ATTRS_o_ai
12562 vec_extract(vector unsigned long long __a, int __b) {
12563  return __a[__b];
12564 }
12565 
12566 static __inline__ unsigned long long __ATTRS_o_ai
12567 vec_extract(vector bool long long __a, int __b) {
12568  return __a[__b];
12569 }
12570 
12571 static __inline__ double __ATTRS_o_ai vec_extract(vector double __a, int __b) {
12572  return __a[__b];
12573 }
12574 #endif
12575 
12576 static __inline__ float __ATTRS_o_ai vec_extract(vector float __a, int __b) {
12577  return __a[__b];
12578 }
12579 
12580 #ifdef __POWER9_VECTOR__
12581 
12582 #define vec_insert4b __builtin_vsx_insertword
12583 #define vec_extract4b __builtin_vsx_extractuword
12584 
12585 /* vec_extract_exp */
12586 
12587 static __inline__ vector unsigned int __ATTRS_o_ai
12588 vec_extract_exp(vector float __a) {
12589  return __builtin_vsx_xvxexpsp(__a);
12590 }
12591 
12592 static __inline__ vector unsigned long long __ATTRS_o_ai
12593 vec_extract_exp(vector double __a) {
12594  return __builtin_vsx_xvxexpdp(__a);
12595 }
12596 
12597 /* vec_extract_sig */
12598 
12599 static __inline__ vector unsigned int __ATTRS_o_ai
12600 vec_extract_sig(vector float __a) {
12601  return __builtin_vsx_xvxsigsp(__a);
12602 }
12603 
12604 static __inline__ vector unsigned long long __ATTRS_o_ai
12605 vec_extract_sig (vector double __a) {
12606  return __builtin_vsx_xvxsigdp(__a);
12607 }
12608 
12609 static __inline__ vector float __ATTRS_o_ai
12610 vec_extract_fp32_from_shorth(vector unsigned short __a) {
12611  vector unsigned short __b =
12612 #ifdef __LITTLE_ENDIAN__
12613  __builtin_shufflevector(__a, __a, 0, -1, 1, -1, 2, -1, 3, -1);
12614 #else
12615  __builtin_shufflevector(__a, __a, -1, 0, -1, 1, -1, 2, -1, 3);
12616 #endif
12617  return __builtin_vsx_xvcvhpsp(__b);
12618 }
12619 
12620 static __inline__ vector float __ATTRS_o_ai
12621 vec_extract_fp32_from_shortl(vector unsigned short __a) {
12622  vector unsigned short __b =
12623 #ifdef __LITTLE_ENDIAN__
12624  __builtin_shufflevector(__a, __a, 4, -1, 5, -1, 6, -1, 7, -1);
12625 #else
12626  __builtin_shufflevector(__a, __a, -1, 4, -1, 5, -1, 6, -1, 7);
12627 #endif
12628  return __builtin_vsx_xvcvhpsp(__b);
12629 }
12630 #endif /* __POWER9_VECTOR__ */
12631 
12632 /* vec_insert */
12633 
12634 static __inline__ vector signed char __ATTRS_o_ai
12635 vec_insert(signed char __a, vector signed char __b, int __c) {
12636  __b[__c] = __a;
12637  return __b;
12638 }
12639 
12640 static __inline__ vector unsigned char __ATTRS_o_ai
12641 vec_insert(unsigned char __a, vector unsigned char __b, int __c) {
12642  __b[__c] = __a;
12643  return __b;
12644 }
12645 
12646 static __inline__ vector bool char __ATTRS_o_ai vec_insert(unsigned char __a,
12647  vector bool char __b,
12648  int __c) {
12649  __b[__c] = __a;
12650  return __b;
12651 }
12652 
12653 static __inline__ vector signed short __ATTRS_o_ai
12654 vec_insert(signed short __a, vector signed short __b, int __c) {
12655  __b[__c] = __a;
12656  return __b;
12657 }
12658 
12659 static __inline__ vector unsigned short __ATTRS_o_ai
12660 vec_insert(unsigned short __a, vector unsigned short __b, int __c) {
12661  __b[__c] = __a;
12662  return __b;
12663 }
12664 
12665 static __inline__ vector bool short __ATTRS_o_ai
12666 vec_insert(unsigned short __a, vector bool short __b, int __c) {
12667  __b[__c] = __a;
12668  return __b;
12669 }
12670 
12671 static __inline__ vector signed int __ATTRS_o_ai
12672 vec_insert(signed int __a, vector signed int __b, int __c) {
12673  __b[__c] = __a;
12674  return __b;
12675 }
12676 
12677 static __inline__ vector unsigned int __ATTRS_o_ai
12678 vec_insert(unsigned int __a, vector unsigned int __b, int __c) {
12679  __b[__c] = __a;
12680  return __b;
12681 }
12682 
12683 static __inline__ vector bool int __ATTRS_o_ai vec_insert(unsigned int __a,
12684  vector bool int __b,
12685  int __c) {
12686  __b[__c] = __a;
12687  return __b;
12688 }
12689 
12690 #ifdef __VSX__
12691 static __inline__ vector signed long long __ATTRS_o_ai
12692 vec_insert(signed long long __a, vector signed long long __b, int __c) {
12693  __b[__c] = __a;
12694  return __b;
12695 }
12696 
12697 static __inline__ vector unsigned long long __ATTRS_o_ai
12698 vec_insert(unsigned long long __a, vector unsigned long long __b, int __c) {
12699  __b[__c] = __a;
12700  return __b;
12701 }
12702 
12703 static __inline__ vector bool long long __ATTRS_o_ai
12704 vec_insert(unsigned long long __a, vector bool long long __b, int __c) {
12705  __b[__c] = __a;
12706  return __b;
12707 }
12708 static __inline__ vector double __ATTRS_o_ai vec_insert(double __a,
12709  vector double __b,
12710  int __c) {
12711  __b[__c] = __a;
12712  return __b;
12713 }
12714 #endif
12715 
12716 static __inline__ vector float __ATTRS_o_ai vec_insert(float __a,
12717  vector float __b,
12718  int __c) {
12719  __b[__c] = __a;
12720  return __b;
12721 }
12722 
12723 /* vec_lvlx */
12724 
12725 static __inline__ vector signed char __ATTRS_o_ai
12726 vec_lvlx(int __a, const signed char *__b) {
12727  return vec_perm(vec_ld(__a, __b), (vector signed char)(0),
12728  vec_lvsl(__a, __b));
12729 }
12730 
12731 static __inline__ vector signed char __ATTRS_o_ai
12732 vec_lvlx(int __a, const vector signed char *__b) {
12733  return vec_perm(vec_ld(__a, __b), (vector signed char)(0),
12734  vec_lvsl(__a, (unsigned char *)__b));
12735 }
12736 
12737 static __inline__ vector unsigned char __ATTRS_o_ai
12738 vec_lvlx(int __a, const unsigned char *__b) {
12739  return vec_perm(vec_ld(__a, __b), (vector unsigned char)(0),
12740  vec_lvsl(__a, __b));
12741 }
12742 
12743 static __inline__ vector unsigned char __ATTRS_o_ai
12744 vec_lvlx(int __a, const vector unsigned char *__b) {
12745  return vec_perm(vec_ld(__a, __b), (vector unsigned char)(0),
12746  vec_lvsl(__a, (unsigned char *)__b));
12747 }
12748 
12749 static __inline__ vector bool char __ATTRS_o_ai
12750 vec_lvlx(int __a, const vector bool char *__b) {
12751  return vec_perm(vec_ld(__a, __b), (vector bool char)(0),
12752  vec_lvsl(__a, (unsigned char *)__b));
12753 }
12754 
12755 static __inline__ vector short __ATTRS_o_ai vec_lvlx(int __a,
12756  const short *__b) {
12757  return vec_perm(vec_ld(__a, __b), (vector short)(0), vec_lvsl(__a, __b));
12758 }
12759 
12760 static __inline__ vector short __ATTRS_o_ai vec_lvlx(int __a,
12761  const vector short *__b) {
12762  return vec_perm(vec_ld(__a, __b), (vector short)(0),
12763  vec_lvsl(__a, (unsigned char *)__b));
12764 }
12765 
12766 static __inline__ vector unsigned short __ATTRS_o_ai
12767 vec_lvlx(int __a, const unsigned short *__b) {
12768  return vec_perm(vec_ld(__a, __b), (vector unsigned short)(0),
12769  vec_lvsl(__a, __b));
12770 }
12771 
12772 static __inline__ vector unsigned short __ATTRS_o_ai
12773 vec_lvlx(int __a, const vector unsigned short *__b) {
12774  return vec_perm(vec_ld(__a, __b), (vector unsigned short)(0),
12775  vec_lvsl(__a, (unsigned char *)__b));
12776 }
12777 
12778 static __inline__ vector bool short __ATTRS_o_ai
12779 vec_lvlx(int __a, const vector bool short *__b) {
12780  return vec_perm(vec_ld(__a, __b), (vector bool short)(0),
12781  vec_lvsl(__a, (unsigned char *)__b));
12782 }
12783 
12784 static __inline__ vector pixel __ATTRS_o_ai vec_lvlx(int __a,
12785  const vector pixel *__b) {
12786  return vec_perm(vec_ld(__a, __b), (vector pixel)(0),
12787  vec_lvsl(__a, (unsigned char *)__b));
12788 }
12789 
12790 static __inline__ vector int __ATTRS_o_ai vec_lvlx(int __a, const int *__b) {
12791  return vec_perm(vec_ld(__a, __b), (vector int)(0), vec_lvsl(__a, __b));
12792 }
12793 
12794 static __inline__ vector int __ATTRS_o_ai vec_lvlx(int __a,
12795  const vector int *__b) {
12796  return vec_perm(vec_ld(__a, __b), (vector int)(0),
12797  vec_lvsl(__a, (unsigned char *)__b));
12798 }
12799 
12800 static __inline__ vector unsigned int __ATTRS_o_ai
12801 vec_lvlx(int __a, const unsigned int *__b) {
12802  return vec_perm(vec_ld(__a, __b), (vector unsigned int)(0),
12803  vec_lvsl(__a, __b));
12804 }
12805 
12806 static __inline__ vector unsigned int __ATTRS_o_ai
12807 vec_lvlx(int __a, const vector unsigned int *__b) {
12808  return vec_perm(vec_ld(__a, __b), (vector unsigned int)(0),
12809  vec_lvsl(__a, (unsigned char *)__b));
12810 }
12811 
12812 static __inline__ vector bool int __ATTRS_o_ai
12813 vec_lvlx(int __a, const vector bool int *__b) {
12814  return vec_perm(vec_ld(__a, __b), (vector bool int)(0),
12815  vec_lvsl(__a, (unsigned char *)__b));
12816 }
12817 
12818 static __inline__ vector float __ATTRS_o_ai vec_lvlx(int __a,
12819  const float *__b) {
12820  return vec_perm(vec_ld(__a, __b), (vector float)(0), vec_lvsl(__a, __b));
12821 }
12822 
12823 static __inline__ vector float __ATTRS_o_ai vec_lvlx(int __a,
12824  const vector float *__b) {
12825  return vec_perm(vec_ld(__a, __b), (vector float)(0),
12826  vec_lvsl(__a, (unsigned char *)__b));
12827 }
12828 
12829 /* vec_lvlxl */
12830 
12831 static __inline__ vector signed char __ATTRS_o_ai
12832 vec_lvlxl(int __a, const signed char *__b) {
12833  return vec_perm(vec_ldl(__a, __b), (vector signed char)(0),
12834  vec_lvsl(__a, __b));
12835 }
12836 
12837 static __inline__ vector signed char __ATTRS_o_ai
12838 vec_lvlxl(int __a, const vector signed char *__b) {
12839  return vec_perm(vec_ldl(__a, __b), (vector signed char)(0),
12840  vec_lvsl(__a, (unsigned char *)__b));
12841 }
12842 
12843 static __inline__ vector unsigned char __ATTRS_o_ai
12844 vec_lvlxl(int __a, const unsigned char *__b) {
12845  return vec_perm(vec_ldl(__a, __b), (vector unsigned char)(0),
12846  vec_lvsl(__a, __b));
12847 }
12848 
12849 static __inline__ vector unsigned char __ATTRS_o_ai
12850 vec_lvlxl(int __a, const vector unsigned char *__b) {
12851  return vec_perm(vec_ldl(__a, __b), (vector unsigned char)(0),
12852  vec_lvsl(__a, (unsigned char *)__b));
12853 }
12854 
12855 static __inline__ vector bool char __ATTRS_o_ai
12856 vec_lvlxl(int __a, const vector bool char *__b) {
12857  return vec_perm(vec_ldl(__a, __b), (vector bool char)(0),
12858  vec_lvsl(__a, (unsigned char *)__b));
12859 }
12860 
12861 static __inline__ vector short __ATTRS_o_ai vec_lvlxl(int __a,
12862  const short *__b) {
12863  return vec_perm(vec_ldl(__a, __b), (vector short)(0), vec_lvsl(__a, __b));
12864 }
12865 
12866 static __inline__ vector short __ATTRS_o_ai vec_lvlxl(int __a,
12867  const vector short *__b) {
12868  return vec_perm(vec_ldl(__a, __b), (vector short)(0),
12869  vec_lvsl(__a, (unsigned char *)__b));
12870 }
12871 
12872 static __inline__ vector unsigned short __ATTRS_o_ai
12873 vec_lvlxl(int __a, const unsigned short *__b) {
12874  return vec_perm(vec_ldl(__a, __b), (vector unsigned short)(0),
12875  vec_lvsl(__a, __b));
12876 }
12877 
12878 static __inline__ vector unsigned short __ATTRS_o_ai
12879 vec_lvlxl(int __a, const vector unsigned short *__b) {
12880  return vec_perm(vec_ldl(__a, __b), (vector unsigned short)(0),
12881  vec_lvsl(__a, (unsigned char *)__b));
12882 }
12883 
12884 static __inline__ vector bool short __ATTRS_o_ai
12885 vec_lvlxl(int __a, const vector bool short *__b) {
12886  return vec_perm(vec_ldl(__a, __b), (vector bool short)(0),
12887  vec_lvsl(__a, (unsigned char *)__b));
12888 }
12889 
12890 static __inline__ vector pixel __ATTRS_o_ai vec_lvlxl(int __a,
12891  const vector pixel *__b) {
12892  return vec_perm(vec_ldl(__a, __b), (vector pixel)(0),
12893  vec_lvsl(__a, (unsigned char *)__b));
12894 }
12895 
12896 static __inline__ vector int __ATTRS_o_ai vec_lvlxl(int __a, const int *__b) {
12897  return vec_perm(vec_ldl(__a, __b), (vector int)(0), vec_lvsl(__a, __b));
12898 }
12899 
12900 static __inline__ vector int __ATTRS_o_ai vec_lvlxl(int __a,
12901  const vector int *__b) {
12902  return vec_perm(vec_ldl(__a, __b), (vector int)(0),
12903  vec_lvsl(__a, (unsigned char *)__b));
12904 }
12905 
12906 static __inline__ vector unsigned int __ATTRS_o_ai
12907 vec_lvlxl(int __a, const unsigned int *__b) {
12908  return vec_perm(vec_ldl(__a, __b), (vector unsigned int)(0),
12909  vec_lvsl(__a, __b));
12910 }
12911 
12912 static __inline__ vector unsigned int __ATTRS_o_ai
12913 vec_lvlxl(int __a, const vector unsigned int *__b) {
12914  return vec_perm(vec_ldl(__a, __b), (vector unsigned int)(0),
12915  vec_lvsl(__a, (unsigned char *)__b));
12916 }
12917 
12918 static __inline__ vector bool int __ATTRS_o_ai
12919 vec_lvlxl(int __a, const vector bool int *__b) {
12920  return vec_perm(vec_ldl(__a, __b), (vector bool int)(0),
12921  vec_lvsl(__a, (unsigned char *)__b));
12922 }
12923 
12924 static __inline__ vector float __ATTRS_o_ai vec_lvlxl(int __a,
12925  const float *__b) {
12926  return vec_perm(vec_ldl(__a, __b), (vector float)(0), vec_lvsl(__a, __b));
12927 }
12928 
12929 static __inline__ vector float __ATTRS_o_ai vec_lvlxl(int __a,
12930  vector float *__b) {
12931  return vec_perm(vec_ldl(__a, __b), (vector float)(0),
12932  vec_lvsl(__a, (unsigned char *)__b));
12933 }
12934 
12935 /* vec_lvrx */
12936 
12937 static __inline__ vector signed char __ATTRS_o_ai
12938 vec_lvrx(int __a, const signed char *__b) {
12939  return vec_perm((vector signed char)(0), vec_ld(__a, __b),
12940  vec_lvsl(__a, __b));
12941 }
12942 
12943 static __inline__ vector signed char __ATTRS_o_ai
12944 vec_lvrx(int __a, const vector signed char *__b) {
12945  return vec_perm((vector signed char)(0), vec_ld(__a, __b),
12946  vec_lvsl(__a, (unsigned char *)__b));
12947 }
12948 
12949 static __inline__ vector unsigned char __ATTRS_o_ai
12950 vec_lvrx(int __a, const unsigned char *__b) {
12951  return vec_perm((vector unsigned char)(0), vec_ld(__a, __b),
12952  vec_lvsl(__a, __b));
12953 }
12954 
12955 static __inline__ vector unsigned char __ATTRS_o_ai
12956 vec_lvrx(int __a, const vector unsigned char *__b) {
12957  return vec_perm((vector unsigned char)(0), vec_ld(__a, __b),
12958  vec_lvsl(__a, (unsigned char *)__b));
12959 }
12960 
12961 static __inline__ vector bool char __ATTRS_o_ai
12962 vec_lvrx(int __a, const vector bool char *__b) {
12963  return vec_perm((vector bool char)(0), vec_ld(__a, __b),
12964  vec_lvsl(__a, (unsigned char *)__b));
12965 }
12966 
12967 static __inline__ vector short __ATTRS_o_ai vec_lvrx(int __a,
12968  const short *__b) {
12969  return vec_perm((vector short)(0), vec_ld(__a, __b), vec_lvsl(__a, __b));
12970 }
12971 
12972 static __inline__ vector short __ATTRS_o_ai vec_lvrx(int __a,
12973  const vector short *__b) {
12974  return vec_perm((vector short)(0), vec_ld(__a, __b),
12975  vec_lvsl(__a, (unsigned char *)__b));
12976 }
12977 
12978 static __inline__ vector unsigned short __ATTRS_o_ai
12979 vec_lvrx(int __a, const unsigned short *__b) {
12980  return vec_perm((vector unsigned short)(0), vec_ld(__a, __b),
12981  vec_lvsl(__a, __b));
12982 }
12983 
12984 static __inline__ vector unsigned short __ATTRS_o_ai
12985 vec_lvrx(int __a, const vector unsigned short *__b) {
12986  return vec_perm((vector unsigned short)(0), vec_ld(__a, __b),
12987  vec_lvsl(__a, (unsigned char *)__b));
12988 }
12989 
12990 static __inline__ vector bool short __ATTRS_o_ai
12991 vec_lvrx(int __a, const vector bool short *__b) {
12992  return vec_perm((vector bool short)(0), vec_ld(__a, __b),
12993  vec_lvsl(__a, (unsigned char *)__b));
12994 }
12995 
12996 static __inline__ vector pixel __ATTRS_o_ai vec_lvrx(int __a,
12997  const vector pixel *__b) {
12998  return vec_perm((vector pixel)(0), vec_ld(__a, __b),
12999  vec_lvsl(__a, (unsigned char *)__b));
13000 }
13001 
13002 static __inline__ vector int __ATTRS_o_ai vec_lvrx(int __a, const int *__b) {
13003  return vec_perm((vector int)(0), vec_ld(__a, __b), vec_lvsl(__a, __b));
13004 }
13005 
13006 static __inline__ vector int __ATTRS_o_ai vec_lvrx(int __a,
13007  const vector int *__b) {
13008  return vec_perm((vector int)(0), vec_ld(__a, __b),
13009  vec_lvsl(__a, (unsigned char *)__b));
13010 }
13011 
13012 static __inline__ vector unsigned int __ATTRS_o_ai
13013 vec_lvrx(int __a, const unsigned int *__b) {
13014  return vec_perm((vector unsigned int)(0), vec_ld(__a, __b),
13015  vec_lvsl(__a, __b));
13016 }
13017 
13018 static __inline__ vector unsigned int __ATTRS_o_ai
13019 vec_lvrx(int __a, const vector unsigned int *__b) {
13020  return vec_perm((vector unsigned int)(0), vec_ld(__a, __b),
13021  vec_lvsl(__a, (unsigned char *)__b));
13022 }
13023 
13024 static __inline__ vector bool int __ATTRS_o_ai
13025 vec_lvrx(int __a, const vector bool int *__b) {
13026  return vec_perm((vector bool int)(0), vec_ld(__a, __b),
13027  vec_lvsl(__a, (unsigned char *)__b));
13028 }
13029 
13030 static __inline__ vector float __ATTRS_o_ai vec_lvrx(int __a,
13031  const float *__b) {
13032  return vec_perm((vector float)(0), vec_ld(__a, __b), vec_lvsl(__a, __b));
13033 }
13034 
13035 static __inline__ vector float __ATTRS_o_ai vec_lvrx(int __a,
13036  const vector float *__b) {
13037  return vec_perm((vector float)(0), vec_ld(__a, __b),
13038  vec_lvsl(__a, (unsigned char *)__b));
13039 }
13040 
13041 /* vec_lvrxl */
13042 
13043 static __inline__ vector signed char __ATTRS_o_ai
13044 vec_lvrxl(int __a, const signed char *__b) {
13045  return vec_perm((vector signed char)(0), vec_ldl(__a, __b),
13046  vec_lvsl(__a, __b));
13047 }
13048 
13049 static __inline__ vector signed char __ATTRS_o_ai
13050 vec_lvrxl(int __a, const vector signed char *__b) {
13051  return vec_perm((vector signed char)(0), vec_ldl(__a, __b),
13052  vec_lvsl(__a, (unsigned char *)__b));
13053 }
13054 
13055 static __inline__ vector unsigned char __ATTRS_o_ai
13056 vec_lvrxl(int __a, const unsigned char *__b) {
13057  return vec_perm((vector unsigned char)(0), vec_ldl(__a, __b),
13058  vec_lvsl(__a, __b));
13059 }
13060 
13061 static __inline__ vector unsigned char __ATTRS_o_ai
13062 vec_lvrxl(int __a, const vector unsigned char *__b) {
13063  return vec_perm((vector unsigned char)(0), vec_ldl(__a, __b),
13064  vec_lvsl(__a, (unsigned char *)__b));
13065 }
13066 
13067 static __inline__ vector bool char __ATTRS_o_ai
13068 vec_lvrxl(int __a, const vector bool char *__b) {
13069  return vec_perm((vector bool char)(0), vec_ldl(__a, __b),
13070  vec_lvsl(__a, (unsigned char *)__b));
13071 }
13072 
13073 static __inline__ vector short __ATTRS_o_ai vec_lvrxl(int __a,
13074  const short *__b) {
13075  return vec_perm((vector short)(0), vec_ldl(__a, __b), vec_lvsl(__a, __b));
13076 }
13077 
13078 static __inline__ vector short __ATTRS_o_ai vec_lvrxl(int __a,
13079  const vector short *__b) {
13080  return vec_perm((vector short)(0), vec_ldl(__a, __b),
13081  vec_lvsl(__a, (unsigned char *)__b));
13082 }
13083 
13084 static __inline__ vector unsigned short __ATTRS_o_ai
13085 vec_lvrxl(int __a, const unsigned short *__b) {
13086  return vec_perm((vector unsigned short)(0), vec_ldl(__a, __b),
13087  vec_lvsl(__a, __b));
13088 }
13089 
13090 static __inline__ vector unsigned short __ATTRS_o_ai
13091 vec_lvrxl(int __a, const vector unsigned short *__b) {
13092  return vec_perm((vector unsigned short)(0), vec_ldl(__a, __b),
13093  vec_lvsl(__a, (unsigned char *)__b));
13094 }
13095 
13096 static __inline__ vector bool short __ATTRS_o_ai
13097 vec_lvrxl(int __a, const vector bool short *__b) {
13098  return vec_perm((vector bool short)(0), vec_ldl(__a, __b),
13099  vec_lvsl(__a, (unsigned char *)__b));
13100 }
13101 
13102 static __inline__ vector pixel __ATTRS_o_ai vec_lvrxl(int __a,
13103  const vector pixel *__b) {
13104  return vec_perm((vector pixel)(0), vec_ldl(__a, __b),
13105  vec_lvsl(__a, (unsigned char *)__b));
13106 }
13107 
13108 static __inline__ vector int __ATTRS_o_ai vec_lvrxl(int __a, const int *__b) {
13109  return vec_perm((vector int)(0), vec_ldl(__a, __b), vec_lvsl(__a, __b));
13110 }
13111 
13112 static __inline__ vector int __ATTRS_o_ai vec_lvrxl(int __a,
13113  const vector int *__b) {
13114  return vec_perm((vector int)(0), vec_ldl(__a, __b),
13115  vec_lvsl(__a, (unsigned char *)__b));
13116 }
13117 
13118 static __inline__ vector unsigned int __ATTRS_o_ai
13119 vec_lvrxl(int __a, const unsigned int *__b) {
13120  return vec_perm((vector unsigned int)(0), vec_ldl(__a, __b),
13121  vec_lvsl(__a, __b));
13122 }
13123 
13124 static __inline__ vector unsigned int __ATTRS_o_ai
13125 vec_lvrxl(int __a, const vector unsigned int *__b) {
13126  return vec_perm((vector unsigned int)(0), vec_ldl(__a, __b),
13127  vec_lvsl(__a, (unsigned char *)__b));
13128 }
13129 
13130 static __inline__ vector bool int __ATTRS_o_ai
13131 vec_lvrxl(int __a, const vector bool int *__b) {
13132  return vec_perm((vector bool int)(0), vec_ldl(__a, __b),
13133  vec_lvsl(__a, (unsigned char *)__b));
13134 }
13135 
13136 static __inline__ vector float __ATTRS_o_ai vec_lvrxl(int __a,
13137  const float *__b) {
13138  return vec_perm((vector float)(0), vec_ldl(__a, __b), vec_lvsl(__a, __b));
13139 }
13140 
13141 static __inline__ vector float __ATTRS_o_ai vec_lvrxl(int __a,
13142  const vector float *__b) {
13143  return vec_perm((vector float)(0), vec_ldl(__a, __b),
13144  vec_lvsl(__a, (unsigned char *)__b));
13145 }
13146 
13147 /* vec_stvlx */
13148 
13149 static __inline__ void __ATTRS_o_ai vec_stvlx(vector signed char __a, int __b,
13150  signed char *__c) {
13151  return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13152  __c);
13153 }
13154 
13155 static __inline__ void __ATTRS_o_ai vec_stvlx(vector signed char __a, int __b,
13156  vector signed char *__c) {
13157  return vec_st(
13158  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13159  __b, __c);
13160 }
13161 
13162 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned char __a, int __b,
13163  unsigned char *__c) {
13164  return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13165  __c);
13166 }
13167 
13168 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned char __a, int __b,
13169  vector unsigned char *__c) {
13170  return vec_st(
13171  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13172  __b, __c);
13173 }
13174 
13175 static __inline__ void __ATTRS_o_ai vec_stvlx(vector bool char __a, int __b,
13176  vector bool char *__c) {
13177  return vec_st(
13178  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13179  __b, __c);
13180 }
13181 
13182 static __inline__ void __ATTRS_o_ai vec_stvlx(vector short __a, int __b,
13183  short *__c) {
13184  return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13185  __c);
13186 }
13187 
13188 static __inline__ void __ATTRS_o_ai vec_stvlx(vector short __a, int __b,
13189  vector short *__c) {
13190  return vec_st(
13191  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13192  __b, __c);
13193 }
13194 
13195 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned short __a,
13196  int __b, unsigned short *__c) {
13197  return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13198  __c);
13199 }
13200 
13201 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned short __a,
13202  int __b,
13203  vector unsigned short *__c) {
13204  return vec_st(
13205  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13206  __b, __c);
13207 }
13208 
13209 static __inline__ void __ATTRS_o_ai vec_stvlx(vector bool short __a, int __b,
13210  vector bool short *__c) {
13211  return vec_st(
13212  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13213  __b, __c);
13214 }
13215 
13216 static __inline__ void __ATTRS_o_ai vec_stvlx(vector pixel __a, int __b,
13217  vector pixel *__c) {
13218  return vec_st(
13219  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13220  __b, __c);
13221 }
13222 
13223 static __inline__ void __ATTRS_o_ai vec_stvlx(vector int __a, int __b,
13224  int *__c) {
13225  return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13226  __c);
13227 }
13228 
13229 static __inline__ void __ATTRS_o_ai vec_stvlx(vector int __a, int __b,
13230  vector int *__c) {
13231  return vec_st(
13232  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13233  __b, __c);
13234 }
13235 
13236 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned int __a, int __b,
13237  unsigned int *__c) {
13238  return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13239  __c);
13240 }
13241 
13242 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned int __a, int __b,
13243  vector unsigned int *__c) {
13244  return vec_st(
13245  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13246  __b, __c);
13247 }
13248 
13249 static __inline__ void __ATTRS_o_ai vec_stvlx(vector bool int __a, int __b,
13250  vector bool int *__c) {
13251  return vec_st(
13252  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13253  __b, __c);
13254 }
13255 
13256 static __inline__ void __ATTRS_o_ai vec_stvlx(vector float __a, int __b,
13257  vector float *__c) {
13258  return vec_st(
13259  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13260  __b, __c);
13261 }
13262 
13263 /* vec_stvlxl */
13264 
13265 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector signed char __a, int __b,
13266  signed char *__c) {
13267  return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13268  __c);
13269 }
13270 
13271 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector signed char __a, int __b,
13272  vector signed char *__c) {
13273  return vec_stl(
13274  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13275  __b, __c);
13276 }
13277 
13278 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned char __a,
13279  int __b, unsigned char *__c) {
13280  return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13281  __c);
13282 }
13283 
13284 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned char __a,
13285  int __b,
13286  vector unsigned char *__c) {
13287  return vec_stl(
13288  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13289  __b, __c);
13290 }
13291 
13292 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector bool char __a, int __b,
13293  vector bool char *__c) {
13294  return vec_stl(
13295  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13296  __b, __c);
13297 }
13298 
13299 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector short __a, int __b,
13300  short *__c) {
13301  return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13302  __c);
13303 }
13304 
13305 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector short __a, int __b,
13306  vector short *__c) {
13307  return vec_stl(
13308  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13309  __b, __c);
13310 }
13311 
13312 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned short __a,
13313  int __b, unsigned short *__c) {
13314  return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13315  __c);
13316 }
13317 
13318 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned short __a,
13319  int __b,
13320  vector unsigned short *__c) {
13321  return vec_stl(
13322  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13323  __b, __c);
13324 }
13325 
13326 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector bool short __a, int __b,
13327  vector bool short *__c) {
13328  return vec_stl(
13329  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13330  __b, __c);
13331 }
13332 
13333 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector pixel __a, int __b,
13334  vector pixel *__c) {
13335  return vec_stl(
13336  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13337  __b, __c);
13338 }
13339 
13340 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector int __a, int __b,
13341  int *__c) {
13342  return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13343  __c);
13344 }
13345 
13346 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector int __a, int __b,
13347  vector int *__c) {
13348  return vec_stl(
13349  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13350  __b, __c);
13351 }
13352 
13353 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned int __a, int __b,
13354  unsigned int *__c) {
13355  return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13356  __c);
13357 }
13358 
13359 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned int __a, int __b,
13360  vector unsigned int *__c) {
13361  return vec_stl(
13362  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13363  __b, __c);
13364 }
13365 
13366 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector bool int __a, int __b,
13367  vector bool int *__c) {
13368  return vec_stl(
13369  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13370  __b, __c);
13371 }
13372 
13373 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector float __a, int __b,
13374  vector float *__c) {
13375  return vec_stl(
13376  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13377  __b, __c);
13378 }
13379 
13380 /* vec_stvrx */
13381 
13382 static __inline__ void __ATTRS_o_ai vec_stvrx(vector signed char __a, int __b,
13383  signed char *__c) {
13384  return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13385  __c);
13386 }
13387 
13388 static __inline__ void __ATTRS_o_ai vec_stvrx(vector signed char __a, int __b,
13389  vector signed char *__c) {
13390  return vec_st(
13391  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13392  __b, __c);
13393 }
13394 
13395 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned char __a, int __b,
13396  unsigned char *__c) {
13397  return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13398  __c);
13399 }
13400 
13401 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned char __a, int __b,
13402  vector unsigned char *__c) {
13403  return vec_st(
13404  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13405  __b, __c);
13406 }
13407 
13408 static __inline__ void __ATTRS_o_ai vec_stvrx(vector bool char __a, int __b,
13409  vector bool char *__c) {
13410  return vec_st(
13411  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13412  __b, __c);
13413 }
13414 
13415 static __inline__ void __ATTRS_o_ai vec_stvrx(vector short __a, int __b,
13416  short *__c) {
13417  return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13418  __c);
13419 }
13420 
13421 static __inline__ void __ATTRS_o_ai vec_stvrx(vector short __a, int __b,
13422  vector short *__c) {
13423  return vec_st(
13424  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13425  __b, __c);
13426 }
13427 
13428 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned short __a,
13429  int __b, unsigned short *__c) {
13430  return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13431  __c);
13432 }
13433 
13434 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned short __a,
13435  int __b,
13436  vector unsigned short *__c) {
13437  return vec_st(
13438  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13439  __b, __c);
13440 }
13441 
13442 static __inline__ void __ATTRS_o_ai vec_stvrx(vector bool short __a, int __b,
13443  vector bool short *__c) {
13444  return vec_st(
13445  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13446  __b, __c);
13447 }
13448 
13449 static __inline__ void __ATTRS_o_ai vec_stvrx(vector pixel __a, int __b,
13450  vector pixel *__c) {
13451  return vec_st(
13452  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13453  __b, __c);
13454 }
13455 
13456 static __inline__ void __ATTRS_o_ai vec_stvrx(vector int __a, int __b,
13457  int *__c) {
13458  return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13459  __c);
13460 }
13461 
13462 static __inline__ void __ATTRS_o_ai vec_stvrx(vector int __a, int __b,
13463  vector int *__c) {
13464  return vec_st(
13465  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13466  __b, __c);
13467 }
13468 
13469 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned int __a, int __b,
13470  unsigned int *__c) {
13471  return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13472  __c);
13473 }
13474 
13475 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned int __a, int __b,
13476  vector unsigned int *__c) {
13477  return vec_st(
13478  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13479  __b, __c);
13480 }
13481 
13482 static __inline__ void __ATTRS_o_ai vec_stvrx(vector bool int __a, int __b,
13483  vector bool int *__c) {
13484  return vec_st(
13485  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13486  __b, __c);
13487 }
13488 
13489 static __inline__ void __ATTRS_o_ai vec_stvrx(vector float __a, int __b,
13490  vector float *__c) {
13491  return vec_st(
13492  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13493  __b, __c);
13494 }
13495 
13496 /* vec_stvrxl */
13497 
13498 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector signed char __a, int __b,
13499  signed char *__c) {
13500  return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13501  __c);
13502 }
13503 
13504 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector signed char __a, int __b,
13505  vector signed char *__c) {
13506  return vec_stl(
13507  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13508  __b, __c);
13509 }
13510 
13511 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned char __a,
13512  int __b, unsigned char *__c) {
13513  return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13514  __c);
13515 }
13516 
13517 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned char __a,
13518  int __b,
13519  vector unsigned char *__c) {
13520  return vec_stl(
13521  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13522  __b, __c);
13523 }
13524 
13525 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector bool char __a, int __b,
13526  vector bool char *__c) {
13527  return vec_stl(
13528  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13529  __b, __c);
13530 }
13531 
13532 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector short __a, int __b,
13533  short *__c) {
13534  return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13535  __c);
13536 }
13537 
13538 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector short __a, int __b,
13539  vector short *__c) {
13540  return vec_stl(
13541  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13542  __b, __c);
13543 }
13544 
13545 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned short __a,
13546  int __b, unsigned short *__c) {
13547  return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13548  __c);
13549 }
13550 
13551 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned short __a,
13552  int __b,
13553  vector unsigned short *__c) {
13554  return vec_stl(
13555  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13556  __b, __c);
13557 }
13558 
13559 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector bool short __a, int __b,
13560  vector bool short *__c) {
13561  return vec_stl(
13562  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13563  __b, __c);
13564 }
13565 
13566 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector pixel __a, int __b,
13567  vector pixel *__c) {
13568  return vec_stl(
13569  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13570  __b, __c);
13571 }
13572 
13573 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector int __a, int __b,
13574  int *__c) {
13575  return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13576  __c);
13577 }
13578 
13579 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector int __a, int __b,
13580  vector int *__c) {
13581  return vec_stl(
13582  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13583  __b, __c);
13584 }
13585 
13586 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned int __a, int __b,
13587  unsigned int *__c) {
13588  return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13589  __c);
13590 }
13591 
13592 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned int __a, int __b,
13593  vector unsigned int *__c) {
13594  return vec_stl(
13595  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13596  __b, __c);
13597 }
13598 
13599 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector bool int __a, int __b,
13600  vector bool int *__c) {
13601  return vec_stl(
13602  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13603  __b, __c);
13604 }
13605 
13606 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector float __a, int __b,
13607  vector float *__c) {
13608  return vec_stl(
13609  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13610  __b, __c);
13611 }
13612 
13613 /* vec_promote */
13614 
13615 static __inline__ vector signed char __ATTRS_o_ai vec_promote(signed char __a,
13616  int __b) {
13617  vector signed char __res = (vector signed char)(0);
13618  __res[__b] = __a;
13619  return __res;
13620 }
13621 
13622 static __inline__ vector unsigned char __ATTRS_o_ai
13623 vec_promote(unsigned char __a, int __b) {
13624  vector unsigned char __res = (vector unsigned char)(0);
13625  __res[__b] = __a;
13626  return __res;
13627 }
13628 
13629 static __inline__ vector short __ATTRS_o_ai vec_promote(short __a, int __b) {
13630  vector short __res = (vector short)(0);
13631  __res[__b] = __a;
13632  return __res;
13633 }
13634 
13635 static __inline__ vector unsigned short __ATTRS_o_ai
13636 vec_promote(unsigned short __a, int __b) {
13637  vector unsigned short __res = (vector unsigned short)(0);
13638  __res[__b] = __a;
13639  return __res;
13640 }
13641 
13642 static __inline__ vector int __ATTRS_o_ai vec_promote(int __a, int __b) {
13643  vector int __res = (vector int)(0);
13644  __res[__b] = __a;
13645  return __res;
13646 }
13647 
13648 static __inline__ vector unsigned int __ATTRS_o_ai vec_promote(unsigned int __a,
13649  int __b) {
13650  vector unsigned int __res = (vector unsigned int)(0);
13651  __res[__b] = __a;
13652  return __res;
13653 }
13654 
13655 static __inline__ vector float __ATTRS_o_ai vec_promote(float __a, int __b) {
13656  vector float __res = (vector float)(0);
13657  __res[__b] = __a;
13658  return __res;
13659 }
13660 
13661 /* vec_splats */
13662 
13663 static __inline__ vector signed char __ATTRS_o_ai vec_splats(signed char __a) {
13664  return (vector signed char)(__a);
13665 }
13666 
13667 static __inline__ vector unsigned char __ATTRS_o_ai
13668 vec_splats(unsigned char __a) {
13669  return (vector unsigned char)(__a);
13670 }
13671 
13672 static __inline__ vector short __ATTRS_o_ai vec_splats(short __a) {
13673  return (vector short)(__a);
13674 }
13675 
13676 static __inline__ vector unsigned short __ATTRS_o_ai
13677 vec_splats(unsigned short __a) {
13678  return (vector unsigned short)(__a);
13679 }
13680 
13681 static __inline__ vector int __ATTRS_o_ai vec_splats(int __a) {
13682  return (vector int)(__a);
13683 }
13684 
13685 static __inline__ vector unsigned int __ATTRS_o_ai
13686 vec_splats(unsigned int __a) {
13687  return (vector unsigned int)(__a);
13688 }
13689 
13690 #ifdef __VSX__
13691 static __inline__ vector signed long long __ATTRS_o_ai
13692 vec_splats(signed long long __a) {
13693  return (vector signed long long)(__a);
13694 }
13695 
13696 static __inline__ vector unsigned long long __ATTRS_o_ai
13697 vec_splats(unsigned long long __a) {
13698  return (vector unsigned long long)(__a);
13699 }
13700 
13701 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
13702 static __inline__ vector signed __int128 __ATTRS_o_ai
13703 vec_splats(signed __int128 __a) {
13704  return (vector signed __int128)(__a);
13705 }
13706 
13707 static __inline__ vector unsigned __int128 __ATTRS_o_ai
13708 vec_splats(unsigned __int128 __a) {
13709  return (vector unsigned __int128)(__a);
13710 }
13711 
13712 #endif
13713 
13714 static __inline__ vector double __ATTRS_o_ai vec_splats(double __a) {
13715  return (vector double)(__a);
13716 }
13717 #endif
13718 
13719 static __inline__ vector float __ATTRS_o_ai vec_splats(float __a) {
13720  return (vector float)(__a);
13721 }
13722 
13723 /* ----------------------------- predicates --------------------------------- */
13724 
13725 /* vec_all_eq */
13726 
13727 static __inline__ int __ATTRS_o_ai vec_all_eq(vector signed char __a,
13728  vector signed char __b) {
13729  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
13730  (vector char)__b);
13731 }
13732 
13733 static __inline__ int __ATTRS_o_ai vec_all_eq(vector signed char __a,
13734  vector bool char __b) {
13735  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
13736  (vector char)__b);
13737 }
13738 
13739 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned char __a,
13740  vector unsigned char __b) {
13741  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
13742  (vector char)__b);
13743 }
13744 
13745 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned char __a,
13746  vector bool char __b) {
13747  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
13748  (vector char)__b);
13749 }
13750 
13751 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool char __a,
13752  vector signed char __b) {
13753  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
13754  (vector char)__b);
13755 }
13756 
13757 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool char __a,
13758  vector unsigned char __b) {
13759  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
13760  (vector char)__b);
13761 }
13762 
13763 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool char __a,
13764  vector bool char __b) {
13765  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
13766  (vector char)__b);
13767 }
13768 
13769 static __inline__ int __ATTRS_o_ai vec_all_eq(vector short __a,
13770  vector short __b) {
13771  return __builtin_altivec_vcmpequh_p(__CR6_LT, __a, __b);
13772 }
13773 
13774 static __inline__ int __ATTRS_o_ai vec_all_eq(vector short __a,
13775  vector bool short __b) {
13776  return __builtin_altivec_vcmpequh_p(__CR6_LT, __a, (vector short)__b);
13777 }
13778 
13779 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned short __a,
13780  vector unsigned short __b) {
13781  return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
13782  (vector short)__b);
13783 }
13784 
13785 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned short __a,
13786  vector bool short __b) {
13787  return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
13788  (vector short)__b);
13789 }
13790 
13791 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool short __a,
13792  vector short __b) {
13793  return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
13794  (vector short)__b);
13795 }
13796 
13797 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool short __a,
13798  vector unsigned short __b) {
13799  return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
13800  (vector short)__b);
13801 }
13802 
13803 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool short __a,
13804  vector bool short __b) {
13805  return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
13806  (vector short)__b);
13807 }
13808 
13809 static __inline__ int __ATTRS_o_ai vec_all_eq(vector pixel __a,
13810  vector pixel __b) {
13811  return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
13812  (vector short)__b);
13813 }
13814 
13815 static __inline__ int __ATTRS_o_ai vec_all_eq(vector int __a, vector int __b) {
13816  return __builtin_altivec_vcmpequw_p(__CR6_LT, __a, __b);
13817 }
13818 
13819 static __inline__ int __ATTRS_o_ai vec_all_eq(vector int __a,
13820  vector bool int __b) {
13821  return __builtin_altivec_vcmpequw_p(__CR6_LT, __a, (vector int)__b);
13822 }
13823 
13824 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned int __a,
13825  vector unsigned int __b) {
13826  return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
13827  (vector int)__b);
13828 }
13829 
13830 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned int __a,
13831  vector bool int __b) {
13832  return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
13833  (vector int)__b);
13834 }
13835 
13836 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool int __a,
13837  vector int __b) {
13838  return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
13839  (vector int)__b);
13840 }
13841 
13842 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool int __a,
13843  vector unsigned int __b) {
13844  return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
13845  (vector int)__b);
13846 }
13847 
13848 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool int __a,
13849  vector bool int __b) {
13850  return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
13851  (vector int)__b);
13852 }
13853 
13854 #ifdef __POWER8_VECTOR__
13855 static __inline__ int __ATTRS_o_ai vec_all_eq(vector signed long long __a,
13856  vector signed long long __b) {
13857  return __builtin_altivec_vcmpequd_p(__CR6_LT, __a, __b);
13858 }
13859 
13860 static __inline__ int __ATTRS_o_ai vec_all_eq(vector long long __a,
13861  vector bool long long __b) {
13862  return __builtin_altivec_vcmpequd_p(__CR6_LT, __a, (vector long long)__b);
13863 }
13864 
13865 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned long long __a,
13866  vector unsigned long long __b) {
13867  return __builtin_altivec_vcmpequd_p(__CR6_LT, (vector long long)__a,
13868  (vector long long)__b);
13869 }
13870 
13871 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned long long __a,
13872  vector bool long long __b) {
13873  return __builtin_altivec_vcmpequd_p(__CR6_LT, (vector long long)__a,
13874  (vector long long)__b);
13875 }
13876 
13877 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool long long __a,
13878  vector long long __b) {
13879  return __builtin_altivec_vcmpequd_p(__CR6_LT, (vector long long)__a,
13880  (vector long long)__b);
13881 }
13882 
13883 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool long long __a,
13884  vector unsigned long long __b) {
13885  return __builtin_altivec_vcmpequd_p(__CR6_LT, (vector long long)__a,
13886  (vector long long)__b);
13887 }
13888 
13889 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool long long __a,
13890  vector bool long long __b) {
13891  return __builtin_altivec_vcmpequd_p(__CR6_LT, (vector long long)__a,
13892  (vector long long)__b);
13893 }
13894 #endif
13895 
13896 static __inline__ int __ATTRS_o_ai vec_all_eq(vector float __a,
13897  vector float __b) {
13898 #ifdef __VSX__
13899  return __builtin_vsx_xvcmpeqsp_p(__CR6_LT, __a, __b);
13900 #else
13901  return __builtin_altivec_vcmpeqfp_p(__CR6_LT, __a, __b);
13902 #endif
13903 }
13904 
13905 #ifdef __VSX__
13906 static __inline__ int __ATTRS_o_ai vec_all_eq(vector double __a,
13907  vector double __b) {
13908  return __builtin_vsx_xvcmpeqdp_p(__CR6_LT, __a, __b);
13909 }
13910 #endif
13911 
13912 /* vec_all_ge */
13913 
13914 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed char __a,
13915  vector signed char __b) {
13916  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, __b, __a);
13917 }
13918 
13919 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed char __a,
13920  vector bool char __b) {
13921  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, (vector signed char)__b, __a);
13922 }
13923 
13924 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned char __a,
13925  vector unsigned char __b) {
13926  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __b, __a);
13927 }
13928 
13929 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned char __a,
13930  vector bool char __b) {
13931  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__b, __a);
13932 }
13933 
13934 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool char __a,
13935  vector signed char __b) {
13936  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__b,
13937  (vector unsigned char)__a);
13938 }
13939 
13940 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool char __a,
13941  vector unsigned char __b) {
13942  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __b, (vector unsigned char)__a);
13943 }
13944 
13945 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool char __a,
13946  vector bool char __b) {
13947  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__b,
13948  (vector unsigned char)__a);
13949 }
13950 
13951 static __inline__ int __ATTRS_o_ai vec_all_ge(vector short __a,
13952  vector short __b) {
13953  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, __b, __a);
13954 }
13955 
13956 static __inline__ int __ATTRS_o_ai vec_all_ge(vector short __a,
13957  vector bool short __b) {
13958  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, (vector short)__b, __a);
13959 }
13960 
13961 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned short __a,
13962  vector unsigned short __b) {
13963  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __b, __a);
13964 }
13965 
13966 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned short __a,
13967  vector bool short __b) {
13968  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__b,
13969  __a);
13970 }
13971 
13972 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool short __a,
13973  vector short __b) {
13974  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__b,
13975  (vector unsigned short)__a);
13976 }
13977 
13978 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool short __a,
13979  vector unsigned short __b) {
13980  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __b,
13981  (vector unsigned short)__a);
13982 }
13983 
13984 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool short __a,
13985  vector bool short __b) {
13986  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__b,
13987  (vector unsigned short)__a);
13988 }
13989 
13990 static __inline__ int __ATTRS_o_ai vec_all_ge(vector int __a, vector int __b) {
13991  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, __b, __a);
13992 }
13993 
13994 static __inline__ int __ATTRS_o_ai vec_all_ge(vector int __a,
13995  vector bool int __b) {
13996  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, (vector int)__b, __a);
13997 }
13998 
13999 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned int __a,
14000  vector unsigned int __b) {
14001  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __b, __a);
14002 }
14003 
14004 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned int __a,
14005  vector bool int __b) {
14006  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__b, __a);
14007 }
14008 
14009 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool int __a,
14010  vector int __b) {
14011  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__b,
14012  (vector unsigned int)__a);
14013 }
14014 
14015 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool int __a,
14016  vector unsigned int __b) {
14017  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __b, (vector unsigned int)__a);
14018 }
14019 
14020 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool int __a,
14021  vector bool int __b) {
14022  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__b,
14023  (vector unsigned int)__a);
14024 }
14025 
14026 #ifdef __POWER8_VECTOR__
14027 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed long long __a,
14028  vector signed long long __b) {
14029  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, __b, __a);
14030 }
14031 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed long long __a,
14032  vector bool long long __b) {
14033  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, (vector signed long long)__b,
14034  __a);
14035 }
14036 
14037 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned long long __a,
14038  vector unsigned long long __b) {
14039  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __b, __a);
14040 }
14041 
14042 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned long long __a,
14043  vector bool long long __b) {
14044  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__b,
14045  __a);
14046 }
14047 
14048 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool long long __a,
14049  vector signed long long __b) {
14050  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__b,
14051  (vector unsigned long long)__a);
14052 }
14053 
14054 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool long long __a,
14055  vector unsigned long long __b) {
14056  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __b,
14057  (vector unsigned long long)__a);
14058 }
14059 
14060 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool long long __a,
14061  vector bool long long __b) {
14062  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__b,
14063  (vector unsigned long long)__a);
14064 }
14065 #endif
14066 
14067 static __inline__ int __ATTRS_o_ai vec_all_ge(vector float __a,
14068  vector float __b) {
14069 #ifdef __VSX__
14070  return __builtin_vsx_xvcmpgesp_p(__CR6_LT, __a, __b);
14071 #else
14072  return __builtin_altivec_vcmpgefp_p(__CR6_LT, __a, __b);
14073 #endif
14074 }
14075 
14076 #ifdef __VSX__
14077 static __inline__ int __ATTRS_o_ai vec_all_ge(vector double __a,
14078  vector double __b) {
14079  return __builtin_vsx_xvcmpgedp_p(__CR6_LT, __a, __b);
14080 }
14081 #endif
14082 
14083 /* vec_all_gt */
14084 
14085 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed char __a,
14086  vector signed char __b) {
14087  return __builtin_altivec_vcmpgtsb_p(__CR6_LT, __a, __b);
14088 }
14089 
14090 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed char __a,
14091  vector bool char __b) {
14092  return __builtin_altivec_vcmpgtsb_p(__CR6_LT, __a, (vector signed char)__b);
14093 }
14094 
14095 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned char __a,
14096  vector unsigned char __b) {
14097  return __builtin_altivec_vcmpgtub_p(__CR6_LT, __a, __b);
14098 }
14099 
14100 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned char __a,
14101  vector bool char __b) {
14102  return __builtin_altivec_vcmpgtub_p(__CR6_LT, __a, (vector unsigned char)__b);
14103 }
14104 
14105 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool char __a,
14106  vector signed char __b) {
14107  return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__a,
14108  (vector unsigned char)__b);
14109 }
14110 
14111 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool char __a,
14112  vector unsigned char __b) {
14113  return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__a, __b);
14114 }
14115 
14116 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool char __a,
14117  vector bool char __b) {
14118  return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__a,
14119  (vector unsigned char)__b);
14120 }
14121 
14122 static __inline__ int __ATTRS_o_ai vec_all_gt(vector short __a,
14123  vector short __b) {
14124  return __builtin_altivec_vcmpgtsh_p(__CR6_LT, __a, __b);
14125 }
14126 
14127 static __inline__ int __ATTRS_o_ai vec_all_gt(vector short __a,
14128  vector bool short __b) {
14129  return __builtin_altivec_vcmpgtsh_p(__CR6_LT, __a, (vector short)__b);
14130 }
14131 
14132 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned short __a,
14133  vector unsigned short __b) {
14134  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __a, __b);
14135 }
14136 
14137 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned short __a,
14138  vector bool short __b) {
14139  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __a,
14140  (vector unsigned short)__b);
14141 }
14142 
14143 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool short __a,
14144  vector short __b) {
14145  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__a,
14146  (vector unsigned short)__b);
14147 }
14148 
14149 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool short __a,
14150  vector unsigned short __b) {
14151  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__a,
14152  __b);
14153 }
14154 
14155 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool short __a,
14156  vector bool short __b) {
14157  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__a,
14158  (vector unsigned short)__b);
14159 }
14160 
14161 static __inline__ int __ATTRS_o_ai vec_all_gt(vector int __a, vector int __b) {
14162  return __builtin_altivec_vcmpgtsw_p(__CR6_LT, __a, __b);
14163 }
14164 
14165 static __inline__ int __ATTRS_o_ai vec_all_gt(vector int __a,
14166  vector bool int __b) {
14167  return __builtin_altivec_vcmpgtsw_p(__CR6_LT, __a, (vector int)__b);
14168 }
14169 
14170 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned int __a,
14171  vector unsigned int __b) {
14172  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __a, __b);
14173 }
14174 
14175 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned int __a,
14176  vector bool int __b) {
14177  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __a, (vector unsigned int)__b);
14178 }
14179 
14180 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool int __a,
14181  vector int __b) {
14182  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__a,
14183  (vector unsigned int)__b);
14184 }
14185 
14186 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool int __a,
14187  vector unsigned int __b) {
14188  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__a, __b);
14189 }
14190 
14191 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool int __a,
14192  vector bool int __b) {
14193  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__a,
14194  (vector unsigned int)__b);
14195 }
14196 
14197 #ifdef __POWER8_VECTOR__
14198 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed long long __a,
14199  vector signed long long __b) {
14200  return __builtin_altivec_vcmpgtsd_p(__CR6_LT, __a, __b);
14201 }
14202 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed long long __a,
14203  vector bool long long __b) {
14204  return __builtin_altivec_vcmpgtsd_p(__CR6_LT, __a,
14205  (vector signed long long)__b);
14206 }
14207 
14208 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned long long __a,
14209  vector unsigned long long __b) {
14210  return __builtin_altivec_vcmpgtud_p(__CR6_LT, __a, __b);
14211 }
14212 
14213 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned long long __a,
14214  vector bool long long __b) {
14215  return __builtin_altivec_vcmpgtud_p(__CR6_LT, __a,
14216  (vector unsigned long long)__b);
14217 }
14218 
14219 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool long long __a,
14220  vector signed long long __b) {
14221  return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__a,
14222  (vector unsigned long long)__b);
14223 }
14224 
14225 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool long long __a,
14226  vector unsigned long long __b) {
14227  return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__a,
14228  __b);
14229 }
14230 
14231 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool long long __a,
14232  vector bool long long __b) {
14233  return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__a,
14234  (vector unsigned long long)__b);
14235 }
14236 #endif
14237 
14238 static __inline__ int __ATTRS_o_ai vec_all_gt(vector float __a,
14239  vector float __b) {
14240 #ifdef __VSX__
14241  return __builtin_vsx_xvcmpgtsp_p(__CR6_LT, __a, __b);
14242 #else
14243  return __builtin_altivec_vcmpgtfp_p(__CR6_LT, __a, __b);
14244 #endif
14245 }
14246 
14247 #ifdef __VSX__
14248 static __inline__ int __ATTRS_o_ai vec_all_gt(vector double __a,
14249  vector double __b) {
14250  return __builtin_vsx_xvcmpgtdp_p(__CR6_LT, __a, __b);
14251 }
14252 #endif
14253 
14254 /* vec_all_in */
14255 
14256 static __inline__ int __attribute__((__always_inline__))
14257 vec_all_in(vector float __a, vector float __b) {
14258  return __builtin_altivec_vcmpbfp_p(__CR6_EQ, __a, __b);
14259 }
14260 
14261 /* vec_all_le */
14262 
14263 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed char __a,
14264  vector signed char __b) {
14265  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, __a, __b);
14266 }
14267 
14268 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed char __a,
14269  vector bool char __b) {
14270  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, __a, (vector signed char)__b);
14271 }
14272 
14273 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned char __a,
14274  vector unsigned char __b) {
14275  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __a, __b);
14276 }
14277 
14278 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned char __a,
14279  vector bool char __b) {
14280  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __a, (vector unsigned char)__b);
14281 }
14282 
14283 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool char __a,
14284  vector signed char __b) {
14285  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__a,
14286  (vector unsigned char)__b);
14287 }
14288 
14289 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool char __a,
14290  vector unsigned char __b) {
14291  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__a, __b);
14292 }
14293 
14294 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool char __a,
14295  vector bool char __b) {
14296  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__a,
14297  (vector unsigned char)__b);
14298 }
14299 
14300 static __inline__ int __ATTRS_o_ai vec_all_le(vector short __a,
14301  vector short __b) {
14302  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, __a, __b);
14303 }
14304 
14305 static __inline__ int __ATTRS_o_ai vec_all_le(vector short __a,
14306  vector bool short __b) {
14307  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, __a, (vector short)__b);
14308 }
14309 
14310 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned short __a,
14311  vector unsigned short __b) {
14312  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __a, __b);
14313 }
14314 
14315 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned short __a,
14316  vector bool short __b) {
14317  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __a,
14318  (vector unsigned short)__b);
14319 }
14320 
14321 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool short __a,
14322  vector short __b) {
14323  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__a,
14324  (vector unsigned short)__b);
14325 }
14326 
14327 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool short __a,
14328  vector unsigned short __b) {
14329  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__a,
14330  __b);
14331 }
14332 
14333 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool short __a,
14334  vector bool short __b) {
14335  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__a,
14336  (vector unsigned short)__b);
14337 }
14338 
14339 static __inline__ int __ATTRS_o_ai vec_all_le(vector int __a, vector int __b) {
14340  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, __a, __b);
14341 }
14342 
14343 static __inline__ int __ATTRS_o_ai vec_all_le(vector int __a,
14344  vector bool int __b) {
14345  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, __a, (vector int)__b);
14346 }
14347 
14348 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned int __a,
14349  vector unsigned int __b) {
14350  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __a, __b);
14351 }
14352 
14353 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned int __a,
14354  vector bool int __b) {
14355  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __a, (vector unsigned int)__b);
14356 }
14357 
14358 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool int __a,
14359  vector int __b) {
14360  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__a,
14361  (vector unsigned int)__b);
14362 }
14363 
14364 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool int __a,
14365  vector unsigned int __b) {
14366  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__a, __b);
14367 }
14368 
14369 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool int __a,
14370  vector bool int __b) {
14371  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__a,
14372  (vector unsigned int)__b);
14373 }
14374 
14375 #ifdef __POWER8_VECTOR__
14376 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed long long __a,
14377  vector signed long long __b) {
14378  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, __a, __b);
14379 }
14380 
14381 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned long long __a,
14382  vector unsigned long long __b) {
14383  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __a, __b);
14384 }
14385 
14386 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed long long __a,
14387  vector bool long long __b) {
14388  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, __a,
14389  (vector signed long long)__b);
14390 }
14391 
14392 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned long long __a,
14393  vector bool long long __b) {
14394  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __a,
14395  (vector unsigned long long)__b);
14396 }
14397 
14398 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool long long __a,
14399  vector signed long long __b) {
14400  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__a,
14401  (vector unsigned long long)__b);
14402 }
14403 
14404 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool long long __a,
14405  vector unsigned long long __b) {
14406  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__a,
14407  __b);
14408 }
14409 
14410 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool long long __a,
14411  vector bool long long __b) {
14412  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__a,
14413  (vector unsigned long long)__b);
14414 }
14415 #endif
14416 
14417 static __inline__ int __ATTRS_o_ai vec_all_le(vector float __a,
14418  vector float __b) {
14419 #ifdef __VSX__
14420  return __builtin_vsx_xvcmpgesp_p(__CR6_LT, __b, __a);
14421 #else
14422  return __builtin_altivec_vcmpgefp_p(__CR6_LT, __b, __a);
14423 #endif
14424 }
14425 
14426 #ifdef __VSX__
14427 static __inline__ int __ATTRS_o_ai vec_all_le(vector double __a,
14428  vector double __b) {
14429  return __builtin_vsx_xvcmpgedp_p(__CR6_LT, __b, __a);
14430 }
14431 #endif
14432 
14433 /* vec_all_lt */
14434 
14435 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed char __a,
14436  vector signed char __b) {
14437  return __builtin_altivec_vcmpgtsb_p(__CR6_LT, __b, __a);
14438 }
14439 
14440 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed char __a,
14441  vector bool char __b) {
14442  return __builtin_altivec_vcmpgtsb_p(__CR6_LT, (vector signed char)__b, __a);
14443 }
14444 
14445 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned char __a,
14446  vector unsigned char __b) {
14447  return __builtin_altivec_vcmpgtub_p(__CR6_LT, __b, __a);
14448 }
14449 
14450 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned char __a,
14451  vector bool char __b) {
14452  return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__b, __a);
14453 }
14454 
14455 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool char __a,
14456  vector signed char __b) {
14457  return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__b,
14458  (vector unsigned char)__a);
14459 }
14460 
14461 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool char __a,
14462  vector unsigned char __b) {
14463  return __builtin_altivec_vcmpgtub_p(__CR6_LT, __b, (vector unsigned char)__a);
14464 }
14465 
14466 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool char __a,
14467  vector bool char __b) {
14468  return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__b,
14469  (vector unsigned char)__a);
14470 }
14471 
14472 static __inline__ int __ATTRS_o_ai vec_all_lt(vector short __a,
14473  vector short __b) {
14474  return __builtin_altivec_vcmpgtsh_p(__CR6_LT, __b, __a);
14475 }
14476 
14477 static __inline__ int __ATTRS_o_ai vec_all_lt(vector short __a,
14478  vector bool short __b) {
14479  return __builtin_altivec_vcmpgtsh_p(__CR6_LT, (vector short)__b, __a);
14480 }
14481 
14482 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned short __a,
14483  vector unsigned short __b) {
14484  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __b, __a);
14485 }
14486 
14487 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned short __a,
14488  vector bool short __b) {
14489  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__b,
14490  __a);
14491 }
14492 
14493 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool short __a,
14494  vector short __b) {
14495  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__b,
14496  (vector unsigned short)__a);
14497 }
14498 
14499 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool short __a,
14500  vector unsigned short __b) {
14501  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __b,
14502  (vector unsigned short)__a);
14503 }
14504 
14505 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool short __a,
14506  vector bool short __b) {
14507  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__b,
14508  (vector unsigned short)__a);
14509 }
14510 
14511 static __inline__ int __ATTRS_o_ai vec_all_lt(vector int __a, vector int __b) {
14512  return __builtin_altivec_vcmpgtsw_p(__CR6_LT, __b, __a);
14513 }
14514 
14515 static __inline__ int __ATTRS_o_ai vec_all_lt(vector int __a,
14516  vector bool int __b) {
14517  return __builtin_altivec_vcmpgtsw_p(__CR6_LT, (vector int)__b, __a);
14518 }
14519 
14520 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned int __a,
14521  vector unsigned int __b) {
14522  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __b, __a);
14523 }
14524 
14525 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned int __a,
14526  vector bool int __b) {
14527  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__b, __a);
14528 }
14529 
14530 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool int __a,
14531  vector int __b) {
14532  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__b,
14533  (vector unsigned int)__a);
14534 }
14535 
14536 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool int __a,
14537  vector unsigned int __b) {
14538  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __b, (vector unsigned int)__a);
14539 }
14540 
14541 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool int __a,
14542  vector bool int __b) {
14543  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__b,
14544  (vector unsigned int)__a);
14545 }
14546 
14547 #ifdef __POWER8_VECTOR__
14548 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed long long __a,
14549  vector signed long long __b) {
14550  return __builtin_altivec_vcmpgtsd_p(__CR6_LT, __b, __a);
14551 }
14552 
14553 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned long long __a,
14554  vector unsigned long long __b) {
14555  return __builtin_altivec_vcmpgtud_p(__CR6_LT, __b, __a);
14556 }
14557 
14558 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed long long __a,
14559  vector bool long long __b) {
14560  return __builtin_altivec_vcmpgtsd_p(__CR6_LT, (vector signed long long)__b,
14561  __a);
14562 }
14563 
14564 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned long long __a,
14565  vector bool long long __b) {
14566  return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__b,
14567  __a);
14568 }
14569 
14570 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool long long __a,
14571  vector signed long long __b) {
14572  return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__b,
14573  (vector unsigned long long)__a);
14574 }
14575 
14576 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool long long __a,
14577  vector unsigned long long __b) {
14578  return __builtin_altivec_vcmpgtud_p(__CR6_LT, __b,
14579  (vector unsigned long long)__a);
14580 }
14581 
14582 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool long long __a,
14583  vector bool long long __b) {
14584  return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__b,
14585  (vector unsigned long long)__a);
14586 }
14587 #endif
14588 
14589 static __inline__ int __ATTRS_o_ai vec_all_lt(vector float __a,
14590  vector float __b) {
14591 #ifdef __VSX__
14592  return __builtin_vsx_xvcmpgtsp_p(__CR6_LT, __b, __a);
14593 #else
14594  return __builtin_altivec_vcmpgtfp_p(__CR6_LT, __b, __a);
14595 #endif
14596 }
14597 
14598 #ifdef __VSX__
14599 static __inline__ int __ATTRS_o_ai vec_all_lt(vector double __a,
14600  vector double __b) {
14601  return __builtin_vsx_xvcmpgtdp_p(__CR6_LT, __b, __a);
14602 }
14603 #endif
14604 
14605 /* vec_all_nan */
14606 
14607 static __inline__ int __ATTRS_o_ai vec_all_nan(vector float __a) {
14608 #ifdef __VSX__
14609  return __builtin_vsx_xvcmpeqsp_p(__CR6_EQ, __a, __a);
14610 #else
14611  return __builtin_altivec_vcmpeqfp_p(__CR6_EQ, __a, __a);
14612 #endif
14613 }
14614 
14615 #ifdef __VSX__
14616 static __inline__ int __ATTRS_o_ai vec_all_nan(vector double __a) {
14617  return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ, __a, __a);
14618 }
14619 #endif
14620 
14621 /* vec_all_ne */
14622 
14623 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed char __a,
14624  vector signed char __b) {
14625  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
14626  (vector char)__b);
14627 }
14628 
14629 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed char __a,
14630  vector bool char __b) {
14631  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
14632  (vector char)__b);
14633 }
14634 
14635 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned char __a,
14636  vector unsigned char __b) {
14637  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
14638  (vector char)__b);
14639 }
14640 
14641 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned char __a,
14642  vector bool char __b) {
14643  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
14644  (vector char)__b);
14645 }
14646 
14647 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool char __a,
14648  vector signed char __b) {
14649  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
14650  (vector char)__b);
14651 }
14652 
14653 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool char __a,
14654  vector unsigned char __b) {
14655  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
14656  (vector char)__b);
14657 }
14658 
14659 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool char __a,
14660  vector bool char __b) {
14661  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
14662  (vector char)__b);
14663 }
14664 
14665 static __inline__ int __ATTRS_o_ai vec_all_ne(vector short __a,
14666  vector short __b) {
14667  return __builtin_altivec_vcmpequh_p(__CR6_EQ, __a, __b);
14668 }
14669 
14670 static __inline__ int __ATTRS_o_ai vec_all_ne(vector short __a,
14671  vector bool short __b) {
14672  return __builtin_altivec_vcmpequh_p(__CR6_EQ, __a, (vector short)__b);
14673 }
14674 
14675 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned short __a,
14676  vector unsigned short __b) {
14677  return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
14678  (vector short)__b);
14679 }
14680 
14681 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned short __a,
14682  vector bool short __b) {
14683  return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
14684  (vector short)__b);
14685 }
14686 
14687 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool short __a,
14688  vector short __b) {
14689  return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
14690  (vector short)__b);
14691 }
14692 
14693 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool short __a,
14694  vector unsigned short __b) {
14695  return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
14696  (vector short)__b);
14697 }
14698 
14699 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool short __a,
14700  vector bool short __b) {
14701  return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
14702  (vector short)__b);
14703 }
14704 
14705 static __inline__ int __ATTRS_o_ai vec_all_ne(vector pixel __a,
14706  vector pixel __b) {
14707  return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
14708  (vector short)__b);
14709 }
14710 
14711 static __inline__ int __ATTRS_o_ai vec_all_ne(vector int __a, vector int __b) {
14712  return __builtin_altivec_vcmpequw_p(__CR6_EQ, __a, __b);
14713 }
14714 
14715 static __inline__ int __ATTRS_o_ai vec_all_ne(vector int __a,
14716  vector bool int __b) {
14717  return __builtin_altivec_vcmpequw_p(__CR6_EQ, __a, (vector int)__b);
14718 }
14719 
14720 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned int __a,
14721  vector unsigned int __b) {
14722  return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
14723  (vector int)__b);
14724 }
14725 
14726 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned int __a,
14727  vector bool int __b) {
14728  return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
14729  (vector int)__b);
14730 }
14731 
14732 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool int __a,
14733  vector int __b) {
14734  return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
14735  (vector int)__b);
14736 }
14737 
14738 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool int __a,
14739  vector unsigned int __b) {
14740  return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
14741  (vector int)__b);
14742 }
14743 
14744 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool int __a,
14745  vector bool int __b) {
14746  return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
14747  (vector int)__b);
14748 }
14749 
14750 #ifdef __POWER8_VECTOR__
14751 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed long long __a,
14752  vector signed long long __b) {
14753  return __builtin_altivec_vcmpequd_p(__CR6_EQ, __a, __b);
14754 }
14755 
14756 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned long long __a,
14757  vector unsigned long long __b) {
14758  return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector long long)__a,
14759  (vector long long)__b);
14760 }
14761 
14762 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed long long __a,
14763  vector bool long long __b) {
14764  return __builtin_altivec_vcmpequd_p(__CR6_EQ, __a,
14765  (vector signed long long)__b);
14766 }
14767 
14768 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned long long __a,
14769  vector bool long long __b) {
14770  return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector signed long long)__a,
14771  (vector signed long long)__b);
14772 }
14773 
14774 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool long long __a,
14775  vector signed long long __b) {
14776  return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector signed long long)__a,
14777  (vector signed long long)__b);
14778 }
14779 
14780 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool long long __a,
14781  vector unsigned long long __b) {
14782  return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector signed long long)__a,
14783  (vector signed long long)__b);
14784 }
14785 
14786 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool long long __a,
14787  vector bool long long __b) {
14788  return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector signed long long)__a,
14789  (vector signed long long)__b);
14790 }
14791 #endif
14792 
14793 static __inline__ int __ATTRS_o_ai vec_all_ne(vector float __a,
14794  vector float __b) {
14795 #ifdef __VSX__
14796  return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ, __a, __b);
14797 #else
14798  return __builtin_altivec_vcmpeqfp_p(__CR6_EQ, __a, __b);
14799 #endif
14800 }
14801 
14802 #ifdef __VSX__
14803 static __inline__ int __ATTRS_o_ai vec_all_ne(vector double __a,
14804  vector double __b) {
14805  return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ, __a, __b);
14806 }
14807 #endif
14808 
14809 /* vec_all_nge */
14810 
14811 static __inline__ int __ATTRS_o_ai vec_all_nge(vector float __a,
14812  vector float __b) {
14813 #ifdef __VSX__
14814  return __builtin_vsx_xvcmpgesp_p(__CR6_EQ, __a, __b);
14815 #else
14816  return __builtin_altivec_vcmpgefp_p(__CR6_EQ, __a, __b);
14817 #endif
14818 }
14819 
14820 #ifdef __VSX__
14821 static __inline__ int __ATTRS_o_ai vec_all_nge(vector double __a,
14822  vector double __b) {
14823  return __builtin_vsx_xvcmpgedp_p(__CR6_EQ, __a, __b);
14824 }
14825 #endif
14826 
14827 /* vec_all_ngt */
14828 
14829 static __inline__ int __ATTRS_o_ai vec_all_ngt(vector float __a,
14830  vector float __b) {
14831 #ifdef __VSX__
14832  return __builtin_vsx_xvcmpgtsp_p(__CR6_EQ, __a, __b);
14833 #else
14834  return __builtin_altivec_vcmpgtfp_p(__CR6_EQ, __a, __b);
14835 #endif
14836 }
14837 
14838 #ifdef __VSX__
14839 static __inline__ int __ATTRS_o_ai vec_all_ngt(vector double __a,
14840  vector double __b) {
14841  return __builtin_vsx_xvcmpgtdp_p(__CR6_EQ, __a, __b);
14842 }
14843 #endif
14844 
14845 /* vec_all_nle */
14846 
14847 static __inline__ int __attribute__((__always_inline__))
14848 vec_all_nle(vector float __a, vector float __b) {
14849  return __builtin_altivec_vcmpgefp_p(__CR6_EQ, __b, __a);
14850 }
14851 
14852 /* vec_all_nlt */
14853 
14854 static __inline__ int __attribute__((__always_inline__))
14855 vec_all_nlt(vector float __a, vector float __b) {
14856  return __builtin_altivec_vcmpgtfp_p(__CR6_EQ, __b, __a);
14857 }
14858 
14859 /* vec_all_numeric */
14860 
14861 static __inline__ int __attribute__((__always_inline__))
14862 vec_all_numeric(vector float __a) {
14863  return __builtin_altivec_vcmpeqfp_p(__CR6_LT, __a, __a);
14864 }
14865 
14866 /* vec_any_eq */
14867 
14868 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed char __a,
14869  vector signed char __b) {
14870  return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
14871  (vector char)__b);
14872 }
14873 
14874 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed char __a,
14875  vector bool char __b) {
14876  return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
14877  (vector char)__b);
14878 }
14879 
14880 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned char __a,
14881  vector unsigned char __b) {
14882  return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
14883  (vector char)__b);
14884 }
14885 
14886 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned char __a,
14887  vector bool char __b) {
14888  return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
14889  (vector char)__b);
14890 }
14891 
14892 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool char __a,
14893  vector signed char __b) {
14894  return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
14895  (vector char)__b);
14896 }
14897 
14898 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool char __a,
14899  vector unsigned char __b) {
14900  return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
14901  (vector char)__b);
14902 }
14903 
14904 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool char __a,
14905  vector bool char __b) {
14906  return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
14907  (vector char)__b);
14908 }
14909 
14910 static __inline__ int __ATTRS_o_ai vec_any_eq(vector short __a,
14911  vector short __b) {
14912  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, __a, __b);
14913 }
14914 
14915 static __inline__ int __ATTRS_o_ai vec_any_eq(vector short __a,
14916  vector bool short __b) {
14917  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, __a, (vector short)__b);
14918 }
14919 
14920 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned short __a,
14921  vector unsigned short __b) {
14922  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
14923  (vector short)__b);
14924 }
14925 
14926 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned short __a,
14927  vector bool short __b) {
14928  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
14929  (vector short)__b);
14930 }
14931 
14932 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool short __a,
14933  vector short __b) {
14934  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
14935  (vector short)__b);
14936 }
14937 
14938 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool short __a,
14939  vector unsigned short __b) {
14940  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
14941  (vector short)__b);
14942 }
14943 
14944 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool short __a,
14945  vector bool short __b) {
14946  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
14947  (vector short)__b);
14948 }
14949 
14950 static __inline__ int __ATTRS_o_ai vec_any_eq(vector pixel __a,
14951  vector pixel __b) {
14952  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
14953  (vector short)__b);
14954 }
14955 
14956 static __inline__ int __ATTRS_o_ai vec_any_eq(vector int __a, vector int __b) {
14957  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, __a, __b);
14958 }
14959 
14960 static __inline__ int __ATTRS_o_ai vec_any_eq(vector int __a,
14961  vector bool int __b) {
14962  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, __a, (vector int)__b);
14963 }
14964 
14965 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned int __a,
14966  vector unsigned int __b) {
14967  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
14968  (vector int)__b);
14969 }
14970 
14971 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned int __a,
14972  vector bool int __b) {
14973  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
14974  (vector int)__b);
14975 }
14976 
14977 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool int __a,
14978  vector int __b) {
14979  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
14980  (vector int)__b);
14981 }
14982 
14983 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool int __a,
14984  vector unsigned int __b) {
14985  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
14986  (vector int)__b);
14987 }
14988 
14989 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool int __a,
14990  vector bool int __b) {
14991  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
14992  (vector int)__b);
14993 }
14994 
14995 #ifdef __POWER8_VECTOR__
14996 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed long long __a,
14997  vector signed long long __b) {
14998  return __builtin_altivec_vcmpequd_p(__CR6_EQ_REV, __a, __b);
14999 }
15000 
15001 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned long long __a,
15002  vector unsigned long long __b) {
15003  return __builtin_altivec_vcmpequd_p(__CR6_EQ_REV, (vector long long)__a,
15004  (vector long long)__b);
15005 }
15006 
15007 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed long long __a,
15008  vector bool long long __b) {
15009  return __builtin_altivec_vcmpequd_p(__CR6_EQ_REV, __a,
15010  (vector signed long long)__b);
15011 }
15012 
15013 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned long long __a,
15014  vector bool long long __b) {
15015  return __builtin_altivec_vcmpequd_p(
15016  __CR6_EQ_REV, (vector signed long long)__a, (vector signed long long)__b);
15017 }
15018 
15019 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool long long __a,
15020  vector signed long long __b) {
15021  return __builtin_altivec_vcmpequd_p(
15022  __CR6_EQ_REV, (vector signed long long)__a, (vector signed long long)__b);
15023 }
15024 
15025 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool long long __a,
15026  vector unsigned long long __b) {
15027  return __builtin_altivec_vcmpequd_p(
15028  __CR6_EQ_REV, (vector signed long long)__a, (vector signed long long)__b);
15029 }
15030 
15031 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool long long __a,
15032  vector bool long long __b) {
15033  return __builtin_altivec_vcmpequd_p(
15034  __CR6_EQ_REV, (vector signed long long)__a, (vector signed long long)__b);
15035 }
15036 #endif
15037 
15038 static __inline__ int __ATTRS_o_ai vec_any_eq(vector float __a,
15039  vector float __b) {
15040 #ifdef __VSX__
15041  return __builtin_vsx_xvcmpeqsp_p(__CR6_EQ_REV, __a, __b);
15042 #else
15043  return __builtin_altivec_vcmpeqfp_p(__CR6_EQ_REV, __a, __b);
15044 #endif
15045 }
15046 
15047 #ifdef __VSX__
15048 static __inline__ int __ATTRS_o_ai vec_any_eq(vector double __a,
15049  vector double __b) {
15050  return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ_REV, __a, __b);
15051 }
15052 #endif
15053 
15054 /* vec_any_ge */
15055 
15056 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed char __a,
15057  vector signed char __b) {
15058  return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, __b, __a);
15059 }
15060 
15061 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed char __a,
15062  vector bool char __b) {
15063  return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, (vector signed char)__b,
15064  __a);
15065 }
15066 
15067 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned char __a,
15068  vector unsigned char __b) {
15069  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __b, __a);
15070 }
15071 
15072 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned char __a,
15073  vector bool char __b) {
15074  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__b,
15075  __a);
15076 }
15077 
15078 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool char __a,
15079  vector signed char __b) {
15080  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__b,
15081  (vector unsigned char)__a);
15082 }
15083 
15084 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool char __a,
15085  vector unsigned char __b) {
15086  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __b,
15087  (vector unsigned char)__a);
15088 }
15089 
15090 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool char __a,
15091  vector bool char __b) {
15092  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__b,
15093  (vector unsigned char)__a);
15094 }
15095 
15096 static __inline__ int __ATTRS_o_ai vec_any_ge(vector short __a,
15097  vector short __b) {
15098  return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, __b, __a);
15099 }
15100 
15101 static __inline__ int __ATTRS_o_ai vec_any_ge(vector short __a,
15102  vector bool short __b) {
15103  return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, (vector short)__b, __a);
15104 }
15105 
15106 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned short __a,
15107  vector unsigned short __b) {
15108  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __b, __a);
15109 }
15110 
15111 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned short __a,
15112  vector bool short __b) {
15113  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__b,
15114  __a);
15115 }
15116 
15117 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool short __a,
15118  vector short __b) {
15119  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__b,
15120  (vector unsigned short)__a);
15121 }
15122 
15123 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool short __a,
15124  vector unsigned short __b) {
15125  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __b,
15126  (vector unsigned short)__a);
15127 }
15128 
15129 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool short __a,
15130  vector bool short __b) {
15131  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__b,
15132  (vector unsigned short)__a);
15133 }
15134 
15135 static __inline__ int __ATTRS_o_ai vec_any_ge(vector int __a, vector int __b) {
15136  return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, __b, __a);
15137 }
15138 
15139 static __inline__ int __ATTRS_o_ai vec_any_ge(vector int __a,
15140  vector bool int __b) {
15141  return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, (vector int)__b, __a);
15142 }
15143 
15144 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned int __a,
15145  vector unsigned int __b) {
15146  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __b, __a);
15147 }
15148 
15149 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned int __a,
15150  vector bool int __b) {
15151  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__b,
15152  __a);
15153 }
15154 
15155 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool int __a,
15156  vector int __b) {
15157  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__b,
15158  (vector unsigned int)__a);
15159 }
15160 
15161 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool int __a,
15162  vector unsigned int __b) {
15163  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __b,
15164  (vector unsigned int)__a);
15165 }
15166 
15167 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool int __a,
15168  vector bool int __b) {
15169  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__b,
15170  (vector unsigned int)__a);
15171 }
15172 
15173 #ifdef __POWER8_VECTOR__
15174 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed long long __a,
15175  vector signed long long __b) {
15176  return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV, __b, __a);
15177 }
15178 
15179 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned long long __a,
15180  vector unsigned long long __b) {
15181  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __b, __a);
15182 }
15183 
15184 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed long long __a,
15185  vector bool long long __b) {
15186  return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV,
15187  (vector signed long long)__b, __a);
15188 }
15189 
15190 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned long long __a,
15191  vector bool long long __b) {
15192  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
15193  (vector unsigned long long)__b, __a);
15194 }
15195 
15196 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool long long __a,
15197  vector signed long long __b) {
15198  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
15199  (vector unsigned long long)__b,
15200  (vector unsigned long long)__a);
15201 }
15202 
15203 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool long long __a,
15204  vector unsigned long long __b) {
15205  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __b,
15206  (vector unsigned long long)__a);
15207 }
15208 
15209 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool long long __a,
15210  vector bool long long __b) {
15211  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
15212  (vector unsigned long long)__b,
15213  (vector unsigned long long)__a);
15214 }
15215 #endif
15216 
15217 static __inline__ int __ATTRS_o_ai vec_any_ge(vector float __a,
15218  vector float __b) {
15219 #ifdef __VSX__
15220  return __builtin_vsx_xvcmpgesp_p(__CR6_EQ_REV, __a, __b);
15221 #else
15222  return __builtin_altivec_vcmpgefp_p(__CR6_EQ_REV, __a, __b);
15223 #endif
15224 }
15225 
15226 #ifdef __VSX__
15227 static __inline__ int __ATTRS_o_ai vec_any_ge(vector double __a,
15228  vector double __b) {
15229  return __builtin_vsx_xvcmpgedp_p(__CR6_EQ_REV, __a, __b);
15230 }
15231 #endif
15232 
15233 /* vec_any_gt */
15234 
15235 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed char __a,
15236  vector signed char __b) {
15237  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, __a, __b);
15238 }
15239 
15240 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed char __a,
15241  vector bool char __b) {
15242  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, __a,
15243  (vector signed char)__b);
15244 }
15245 
15246 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned char __a,
15247  vector unsigned char __b) {
15248  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __a, __b);
15249 }
15250 
15251 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned char __a,
15252  vector bool char __b) {
15253  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __a,
15254  (vector unsigned char)__b);
15255 }
15256 
15257 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool char __a,
15258  vector signed char __b) {
15259  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__a,
15260  (vector unsigned char)__b);
15261 }
15262 
15263 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool char __a,
15264  vector unsigned char __b) {
15265  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__a,
15266  __b);
15267 }
15268 
15269 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool char __a,
15270  vector bool char __b) {
15271  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__a,
15272  (vector unsigned char)__b);
15273 }
15274 
15275 static __inline__ int __ATTRS_o_ai vec_any_gt(vector short __a,
15276  vector short __b) {
15277  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, __a, __b);
15278 }
15279 
15280 static __inline__ int __ATTRS_o_ai vec_any_gt(vector short __a,
15281  vector bool short __b) {
15282  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, __a, (vector short)__b);
15283 }
15284 
15285 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned short __a,
15286  vector unsigned short __b) {
15287  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __a, __b);
15288 }
15289 
15290 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned short __a,
15291  vector bool short __b) {
15292  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __a,
15293  (vector unsigned short)__b);
15294 }
15295 
15296 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool short __a,
15297  vector short __b) {
15298  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__a,
15299  (vector unsigned short)__b);
15300 }
15301 
15302 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool short __a,
15303  vector unsigned short __b) {
15304  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__a,
15305  __b);
15306 }
15307 
15308 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool short __a,
15309  vector bool short __b) {
15310  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__a,
15311  (vector unsigned short)__b);
15312 }
15313 
15314 static __inline__ int __ATTRS_o_ai vec_any_gt(vector int __a, vector int __b) {
15315  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, __a, __b);
15316 }
15317 
15318 static __inline__ int __ATTRS_o_ai vec_any_gt(vector int __a,
15319  vector bool int __b) {
15320  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, __a, (vector int)__b);
15321 }
15322 
15323 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned int __a,
15324  vector unsigned int __b) {
15325  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __a, __b);
15326 }
15327 
15328 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned int __a,
15329  vector bool int __b) {
15330  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __a,
15331  (vector unsigned int)__b);
15332 }
15333 
15334 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool int __a,
15335  vector int __b) {
15336  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__a,
15337  (vector unsigned int)__b);
15338 }
15339 
15340 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool int __a,
15341  vector unsigned int __b) {
15342  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__a,
15343  __b);
15344 }
15345 
15346 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool int __a,
15347  vector bool int __b) {
15348  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__a,
15349  (vector unsigned int)__b);
15350 }
15351 
15352 #ifdef __POWER8_VECTOR__
15353 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed long long __a,
15354  vector signed long long __b) {
15355  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV, __a, __b);
15356 }
15357 
15358 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned long long __a,
15359  vector unsigned long long __b) {
15360  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __a, __b);
15361 }
15362 
15363 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed long long __a,
15364  vector bool long long __b) {
15365  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV, __a,
15366  (vector signed long long)__b);
15367 }
15368 
15369 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned long long __a,
15370  vector bool long long __b) {
15371  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __a,
15372  (vector unsigned long long)__b);
15373 }
15374 
15375 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool long long __a,
15376  vector signed long long __b) {
15377  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
15378  (vector unsigned long long)__a,
15379  (vector unsigned long long)__b);
15380 }
15381 
15382 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool long long __a,
15383  vector unsigned long long __b) {
15384  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
15385  (vector unsigned long long)__a, __b);
15386 }
15387 
15388 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool long long __a,
15389  vector bool long long __b) {
15390  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
15391  (vector unsigned long long)__a,
15392  (vector unsigned long long)__b);
15393 }
15394 #endif
15395 
15396 static __inline__ int __ATTRS_o_ai vec_any_gt(vector float __a,
15397  vector float __b) {
15398 #ifdef __VSX__
15399  return __builtin_vsx_xvcmpgtsp_p(__CR6_EQ_REV, __a, __b);
15400 #else
15401  return __builtin_altivec_vcmpgtfp_p(__CR6_EQ_REV, __a, __b);
15402 #endif
15403 }
15404 
15405 #ifdef __VSX__
15406 static __inline__ int __ATTRS_o_ai vec_any_gt(vector double __a,
15407  vector double __b) {
15408  return __builtin_vsx_xvcmpgtdp_p(__CR6_EQ_REV, __a, __b);
15409 }
15410 #endif
15411 
15412 /* vec_any_le */
15413 
15414 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed char __a,
15415  vector signed char __b) {
15416  return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, __a, __b);
15417 }
15418 
15419 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed char __a,
15420  vector bool char __b) {
15421  return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, __a,
15422  (vector signed char)__b);
15423 }
15424 
15425 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned char __a,
15426  vector unsigned char __b) {
15427  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __a, __b);
15428 }
15429 
15430 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned char __a,
15431  vector bool char __b) {
15432  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __a,
15433  (vector unsigned char)__b);
15434 }
15435 
15436 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool char __a,
15437  vector signed char __b) {
15438  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__a,
15439  (vector unsigned char)__b);
15440 }
15441 
15442 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool char __a,
15443  vector unsigned char __b) {
15444  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__a,
15445  __b);
15446 }
15447 
15448 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool char __a,
15449  vector bool char __b) {
15450  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__a,
15451  (vector unsigned char)__b);
15452 }
15453 
15454 static __inline__ int __ATTRS_o_ai vec_any_le(vector short __a,
15455  vector short __b) {
15456  return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, __a, __b);
15457 }
15458 
15459 static __inline__ int __ATTRS_o_ai vec_any_le(vector short __a,
15460  vector bool short __b) {
15461  return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, __a, (vector short)__b);
15462 }
15463 
15464 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned short __a,
15465  vector unsigned short __b) {
15466  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __a, __b);
15467 }
15468 
15469 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned short __a,
15470  vector bool short __b) {
15471  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __a,
15472  (vector unsigned short)__b);
15473 }
15474 
15475 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool short __a,
15476  vector short __b) {
15477  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__a,
15478  (vector unsigned short)__b);
15479 }
15480 
15481 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool short __a,
15482  vector unsigned short __b) {
15483  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__a,
15484  __b);
15485 }
15486 
15487 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool short __a,
15488  vector bool short __b) {
15489  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__a,
15490  (vector unsigned short)__b);
15491 }
15492 
15493 static __inline__ int __ATTRS_o_ai vec_any_le(vector int __a, vector int __b) {
15494  return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, __a, __b);
15495 }
15496 
15497 static __inline__ int __ATTRS_o_ai vec_any_le(vector int __a,
15498  vector bool int __b) {
15499  return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, __a, (vector int)__b);
15500 }
15501 
15502 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned int __a,
15503  vector unsigned int __b) {
15504  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __a, __b);
15505 }
15506 
15507 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned int __a,
15508  vector bool int __b) {
15509  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __a,
15510  (vector unsigned int)__b);
15511 }
15512 
15513 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool int __a,
15514  vector int __b) {
15515  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__a,
15516  (vector unsigned int)__b);
15517 }
15518 
15519 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool int __a,
15520  vector unsigned int __b) {
15521  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__a,
15522  __b);
15523 }
15524 
15525 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool int __a,
15526  vector bool int __b) {
15527  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__a,
15528  (vector unsigned int)__b);
15529 }
15530 
15531 #ifdef __POWER8_VECTOR__
15532 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed long long __a,
15533  vector signed long long __b) {
15534  return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV, __a, __b);
15535 }
15536 
15537 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned long long __a,
15538  vector unsigned long long __b) {
15539  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __a, __b);
15540 }
15541 
15542 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed long long __a,
15543  vector bool long long __b) {
15544  return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV, __a,
15545  (vector signed long long)__b);
15546 }
15547 
15548 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned long long __a,
15549  vector bool long long __b) {
15550  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __a,
15551  (vector unsigned long long)__b);
15552 }
15553 
15554 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool long long __a,
15555  vector signed long long __b) {
15556  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
15557  (vector unsigned long long)__a,
15558  (vector unsigned long long)__b);
15559 }
15560 
15561 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool long long __a,
15562  vector unsigned long long __b) {
15563  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
15564  (vector unsigned long long)__a, __b);
15565 }
15566 
15567 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool long long __a,
15568  vector bool long long __b) {
15569  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
15570  (vector unsigned long long)__a,
15571  (vector unsigned long long)__b);
15572 }
15573 #endif
15574 
15575 static __inline__ int __ATTRS_o_ai vec_any_le(vector float __a,
15576  vector float __b) {
15577 #ifdef __VSX__
15578  return __builtin_vsx_xvcmpgesp_p(__CR6_EQ_REV, __b, __a);
15579 #else
15580  return __builtin_altivec_vcmpgefp_p(__CR6_EQ_REV, __b, __a);
15581 #endif
15582 }
15583 
15584 #ifdef __VSX__
15585 static __inline__ int __ATTRS_o_ai vec_any_le(vector double __a,
15586  vector double __b) {
15587  return __builtin_vsx_xvcmpgedp_p(__CR6_EQ_REV, __b, __a);
15588 }
15589 #endif
15590 
15591 /* vec_any_lt */
15592 
15593 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed char __a,
15594  vector signed char __b) {
15595  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, __b, __a);
15596 }
15597 
15598 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed char __a,
15599  vector bool char __b) {
15600  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, (vector signed char)__b,
15601  __a);
15602 }
15603 
15604 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned char __a,
15605  vector unsigned char __b) {
15606  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __b, __a);
15607 }
15608 
15609 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned char __a,
15610  vector bool char __b) {
15611  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__b,
15612  __a);
15613 }
15614 
15615 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool char __a,
15616  vector signed char __b) {
15617  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__b,
15618  (vector unsigned char)__a);
15619 }
15620 
15621 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool char __a,
15622  vector unsigned char __b) {
15623  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __b,
15624  (vector unsigned char)__a);
15625 }
15626 
15627 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool char __a,
15628  vector bool char __b) {
15629  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__b,
15630  (vector unsigned char)__a);
15631 }
15632 
15633 static __inline__ int __ATTRS_o_ai vec_any_lt(vector short __a,
15634  vector short __b) {
15635  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, __b, __a);
15636 }
15637 
15638 static __inline__ int __ATTRS_o_ai vec_any_lt(vector short __a,
15639  vector bool short __b) {
15640  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, (vector short)__b, __a);
15641 }
15642 
15643 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned short __a,
15644  vector unsigned short __b) {
15645  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __b, __a);
15646 }
15647 
15648 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned short __a,
15649  vector bool short __b) {
15650  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__b,
15651  __a);
15652 }
15653 
15654 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool short __a,
15655  vector short __b) {
15656  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__b,
15657  (vector unsigned short)__a);
15658 }
15659 
15660 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool short __a,
15661  vector unsigned short __b) {
15662  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __b,
15663  (vector unsigned short)__a);
15664 }
15665 
15666 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool short __a,
15667  vector bool short __b) {
15668  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__b,
15669  (vector unsigned short)__a);
15670 }
15671 
15672 static __inline__ int __ATTRS_o_ai vec_any_lt(vector int __a, vector int __b) {
15673  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, __b, __a);
15674 }
15675 
15676 static __inline__ int __ATTRS_o_ai vec_any_lt(vector int __a,
15677  vector bool int __b) {
15678  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, (vector int)__b, __a);
15679 }
15680 
15681 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned int __a,
15682  vector unsigned int __b) {
15683  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __b, __a);
15684 }
15685 
15686 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned int __a,
15687  vector bool int __b) {
15688  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__b,
15689  __a);
15690 }
15691 
15692 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool int __a,
15693  vector int __b) {
15694  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__b,
15695  (vector unsigned int)__a);
15696 }
15697 
15698 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool int __a,
15699  vector unsigned int __b) {
15700  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __b,
15701  (vector unsigned int)__a);
15702 }
15703 
15704 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool int __a,
15705  vector bool int __b) {
15706  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__b,
15707  (vector unsigned int)__a);
15708 }
15709 
15710 #ifdef __POWER8_VECTOR__
15711 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed long long __a,
15712  vector signed long long __b) {
15713  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV, __b, __a);
15714 }
15715 
15716 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned long long __a,
15717  vector unsigned long long __b) {
15718  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __b, __a);
15719 }
15720 
15721 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed long long __a,
15722  vector bool long long __b) {
15723  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV,
15724  (vector signed long long)__b, __a);
15725 }
15726 
15727 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned long long __a,
15728  vector bool long long __b) {
15729  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
15730  (vector unsigned long long)__b, __a);
15731 }
15732 
15733 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool long long __a,
15734  vector signed long long __b) {
15735  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
15736  (vector unsigned long long)__b,
15737  (vector unsigned long long)__a);
15738 }
15739 
15740 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool long long __a,
15741  vector unsigned long long __b) {
15742  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __b,
15743  (vector unsigned long long)__a);
15744 }
15745 
15746 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool long long __a,
15747  vector bool long long __b) {
15748  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
15749  (vector unsigned long long)__b,
15750  (vector unsigned long long)__a);
15751 }
15752 #endif
15753 
15754 static __inline__ int __ATTRS_o_ai vec_any_lt(vector float __a,
15755  vector float __b) {
15756 #ifdef __VSX__
15757  return __builtin_vsx_xvcmpgtsp_p(__CR6_EQ_REV, __b, __a);
15758 #else
15759  return __builtin_altivec_vcmpgtfp_p(__CR6_EQ_REV, __b, __a);
15760 #endif
15761 }
15762 
15763 #ifdef __VSX__
15764 static __inline__ int __ATTRS_o_ai vec_any_lt(vector double __a,
15765  vector double __b) {
15766  return __builtin_vsx_xvcmpgtdp_p(__CR6_EQ_REV, __b, __a);
15767 }
15768 #endif
15769 
15770 /* vec_any_nan */
15771 
15772 static __inline__ int __attribute__((__always_inline__))
15773 vec_any_nan(vector float __a) {
15774  return __builtin_altivec_vcmpeqfp_p(__CR6_LT_REV, __a, __a);
15775 }
15776 
15777 /* vec_any_ne */
15778 
15779 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed char __a,
15780  vector signed char __b) {
15781  return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
15782  (vector char)__b);
15783 }
15784 
15785 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed char __a,
15786  vector bool char __b) {
15787  return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
15788  (vector char)__b);
15789 }
15790 
15791 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned char __a,
15792  vector unsigned char __b) {
15793  return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
15794  (vector char)__b);
15795 }
15796 
15797 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned char __a,
15798  vector bool char __b) {
15799  return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
15800  (vector char)__b);
15801 }
15802 
15803 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool char __a,
15804  vector signed char __b) {
15805  return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
15806  (vector char)__b);
15807 }
15808 
15809 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool char __a,
15810  vector unsigned char __b) {
15811  return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
15812  (vector char)__b);
15813 }
15814 
15815 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool char __a,
15816  vector bool char __b) {
15817  return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
15818  (vector char)__b);
15819 }
15820 
15821 static __inline__ int __ATTRS_o_ai vec_any_ne(vector short __a,
15822  vector short __b) {
15823  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, __a, __b);
15824 }
15825 
15826 static __inline__ int __ATTRS_o_ai vec_any_ne(vector short __a,
15827  vector bool short __b) {
15828  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, __a, (vector short)__b);
15829 }
15830 
15831 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned short __a,
15832  vector unsigned short __b) {
15833  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
15834  (vector short)__b);
15835 }
15836 
15837 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned short __a,
15838  vector bool short __b) {
15839  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
15840  (vector short)__b);
15841 }
15842 
15843 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool short __a,
15844  vector short __b) {
15845  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
15846  (vector short)__b);
15847 }
15848 
15849 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool short __a,
15850  vector unsigned short __b) {
15851  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
15852  (vector short)__b);
15853 }
15854 
15855 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool short __a,
15856  vector bool short __b) {
15857  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
15858  (vector short)__b);
15859 }
15860 
15861 static __inline__ int __ATTRS_o_ai vec_any_ne(vector pixel __a,
15862  vector pixel __b) {
15863  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
15864  (vector short)__b);
15865 }
15866 
15867 static __inline__ int __ATTRS_o_ai vec_any_ne(vector int __a, vector int __b) {
15868  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, __a, __b);
15869 }
15870 
15871 static __inline__ int __ATTRS_o_ai vec_any_ne(vector int __a,
15872  vector bool int __b) {
15873  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, __a, (vector int)__b);
15874 }
15875 
15876 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned int __a,
15877  vector unsigned int __b) {
15878  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
15879  (vector int)__b);
15880 }
15881 
15882 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned int __a,
15883  vector bool int __b) {
15884  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
15885  (vector int)__b);
15886 }
15887 
15888 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool int __a,
15889  vector int __b) {
15890  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
15891  (vector int)__b);
15892 }
15893 
15894 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool int __a,
15895  vector unsigned int __b) {
15896  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
15897  (vector int)__b);
15898 }
15899 
15900 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool int __a,
15901  vector bool int __b) {
15902  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
15903  (vector int)__b);
15904 }
15905 
15906 #ifdef __POWER8_VECTOR__
15907 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed long long __a,
15908  vector signed long long __b) {
15909  return __builtin_altivec_vcmpequd_p(__CR6_LT_REV, __a, __b);
15910 }
15911 
15912 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned long long __a,
15913  vector unsigned long long __b) {
15914  return __builtin_altivec_vcmpequd_p(__CR6_LT_REV, (vector long long)__a,
15915  (vector long long)__b);
15916 }
15917 
15918 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed long long __a,
15919  vector bool long long __b) {
15920  return __builtin_altivec_vcmpequd_p(__CR6_LT_REV, __a,
15921  (vector signed long long)__b);
15922 }
15923 
15924 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned long long __a,
15925  vector bool long long __b) {
15926  return __builtin_altivec_vcmpequd_p(
15927  __CR6_LT_REV, (vector signed long long)__a, (vector signed long long)__b);
15928 }
15929 
15930 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool long long __a,
15931  vector signed long long __b) {
15932  return __builtin_altivec_vcmpequd_p(
15933  __CR6_LT_REV, (vector signed long long)__a, (vector signed long long)__b);
15934 }
15935 
15936 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool long long __a,
15937  vector unsigned long long __b) {
15938  return __builtin_altivec_vcmpequd_p(
15939  __CR6_LT_REV, (vector signed long long)__a, (vector signed long long)__b);
15940 }
15941 
15942 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool long long __a,
15943  vector bool long long __b) {
15944  return __builtin_altivec_vcmpequd_p(
15945  __CR6_LT_REV, (vector signed long long)__a, (vector signed long long)__b);
15946 }
15947 #endif
15948 
15949 static __inline__ int __ATTRS_o_ai vec_any_ne(vector float __a,
15950  vector float __b) {
15951 #ifdef __VSX__
15952  return __builtin_vsx_xvcmpeqsp_p(__CR6_LT_REV, __a, __b);
15953 #else
15954  return __builtin_altivec_vcmpeqfp_p(__CR6_LT_REV, __a, __b);
15955 #endif
15956 }
15957 
15958 #ifdef __VSX__
15959 static __inline__ int __ATTRS_o_ai vec_any_ne(vector double __a,
15960  vector double __b) {
15961  return __builtin_vsx_xvcmpeqdp_p(__CR6_LT_REV, __a, __b);
15962 }
15963 #endif
15964 
15965 /* vec_any_nge */
15966 
15967 static __inline__ int __attribute__((__always_inline__))
15968 vec_any_nge(vector float __a, vector float __b) {
15969  return __builtin_altivec_vcmpgefp_p(__CR6_LT_REV, __a, __b);
15970 }
15971 
15972 /* vec_any_ngt */
15973 
15974 static __inline__ int __attribute__((__always_inline__))
15975 vec_any_ngt(vector float __a, vector float __b) {
15976  return __builtin_altivec_vcmpgtfp_p(__CR6_LT_REV, __a, __b);
15977 }
15978 
15979 /* vec_any_nle */
15980 
15981 static __inline__ int __attribute__((__always_inline__))
15982 vec_any_nle(vector float __a, vector float __b) {
15983  return __builtin_altivec_vcmpgefp_p(__CR6_LT_REV, __b, __a);
15984 }
15985 
15986 /* vec_any_nlt */
15987 
15988 static __inline__ int __attribute__((__always_inline__))
15989 vec_any_nlt(vector float __a, vector float __b) {
15990  return __builtin_altivec_vcmpgtfp_p(__CR6_LT_REV, __b, __a);
15991 }
15992 
15993 /* vec_any_numeric */
15994 
15995 static __inline__ int __attribute__((__always_inline__))
15996 vec_any_numeric(vector float __a) {
15997  return __builtin_altivec_vcmpeqfp_p(__CR6_EQ_REV, __a, __a);
15998 }
15999 
16000 /* vec_any_out */
16001 
16002 static __inline__ int __attribute__((__always_inline__))
16003 vec_any_out(vector float __a, vector float __b) {
16004  return __builtin_altivec_vcmpbfp_p(__CR6_EQ_REV, __a, __b);
16005 }
16006 
16007 /* Power 8 Crypto functions
16008 Note: We diverge from the current GCC implementation with regard
16009 to cryptography and related functions as follows:
16010 - Only the SHA and AES instructions and builtins are disabled by -mno-crypto
16011 - The remaining ones are only available on Power8 and up so
16012  require -mpower8-vector
16013 The justification for this is that export requirements require that
16014 Category:Vector.Crypto is optional (i.e. compliant hardware may not provide
16015 support). As a result, we need to be able to turn off support for those.
16016 The remaining ones (currently controlled by -mcrypto for GCC) still
16017 need to be provided on compliant hardware even if Vector.Crypto is not
16018 provided.
16019 */
16020 #ifdef __CRYPTO__
16021 #define vec_sbox_be __builtin_altivec_crypto_vsbox
16022 #define vec_cipher_be __builtin_altivec_crypto_vcipher
16023 #define vec_cipherlast_be __builtin_altivec_crypto_vcipherlast
16024 #define vec_ncipher_be __builtin_altivec_crypto_vncipher
16025 #define vec_ncipherlast_be __builtin_altivec_crypto_vncipherlast
16026 
16027 static __inline__ vector unsigned long long __attribute__((__always_inline__))
16028 __builtin_crypto_vsbox(vector unsigned long long __a) {
16029  return __builtin_altivec_crypto_vsbox(__a);
16030 }
16031 
16032 static __inline__ vector unsigned long long __attribute__((__always_inline__))
16033 __builtin_crypto_vcipher(vector unsigned long long __a,
16034  vector unsigned long long __b) {
16035  return __builtin_altivec_crypto_vcipher(__a, __b);
16036 }
16037 
16038 static __inline__ vector unsigned long long __attribute__((__always_inline__))
16039 __builtin_crypto_vcipherlast(vector unsigned long long __a,
16040  vector unsigned long long __b) {
16041  return __builtin_altivec_crypto_vcipherlast(__a, __b);
16042 }
16043 
16044 static __inline__ vector unsigned long long __attribute__((__always_inline__))
16045 __builtin_crypto_vncipher(vector unsigned long long __a,
16046  vector unsigned long long __b) {
16047  return __builtin_altivec_crypto_vncipher(__a, __b);
16048 }
16049 
16050 static __inline__ vector unsigned long long __attribute__((__always_inline__))
16051 __builtin_crypto_vncipherlast(vector unsigned long long __a,
16052  vector unsigned long long __b) {
16053  return __builtin_altivec_crypto_vncipherlast(__a, __b);
16054 }
16055 
16056 #define __builtin_crypto_vshasigmad __builtin_altivec_crypto_vshasigmad
16057 #define __builtin_crypto_vshasigmaw __builtin_altivec_crypto_vshasigmaw
16058 
16059 #define vec_shasigma_be(X, Y, Z) \
16060  _Generic((X), vector unsigned int \
16061  : __builtin_crypto_vshasigmaw, vector unsigned long long \
16062  : __builtin_crypto_vshasigmad)((X), (Y), (Z))
16063 #endif
16064 
16065 #ifdef __POWER8_VECTOR__
16066 static __inline__ vector bool char __ATTRS_o_ai
16067 vec_permxor(vector bool char __a, vector bool char __b,
16068  vector bool char __c) {
16069  return __builtin_altivec_crypto_vpermxor(__a, __b, __c);
16070 }
16071 
16072 static __inline__ vector signed char __ATTRS_o_ai
16073 vec_permxor(vector signed char __a, vector signed char __b,
16074  vector signed char __c) {
16075  return __builtin_altivec_crypto_vpermxor(__a, __b, __c);
16076 }
16077 
16078 static __inline__ vector unsigned char __ATTRS_o_ai
16079 vec_permxor(vector unsigned char __a, vector unsigned char __b,
16080  vector unsigned char __c) {
16081  return __builtin_altivec_crypto_vpermxor(__a, __b, __c);
16082 }
16083 
16084 static __inline__ vector unsigned char __ATTRS_o_ai
16085 __builtin_crypto_vpermxor(vector unsigned char __a, vector unsigned char __b,
16086  vector unsigned char __c) {
16087  return __builtin_altivec_crypto_vpermxor(__a, __b, __c);
16088 }
16089 
16090 static __inline__ vector unsigned short __ATTRS_o_ai
16091 __builtin_crypto_vpermxor(vector unsigned short __a, vector unsigned short __b,
16092  vector unsigned short __c) {
16093  return (vector unsigned short)__builtin_altivec_crypto_vpermxor(
16094  (vector unsigned char)__a, (vector unsigned char)__b,
16095  (vector unsigned char)__c);
16096 }
16097 
16098 static __inline__ vector unsigned int __ATTRS_o_ai __builtin_crypto_vpermxor(
16099  vector unsigned int __a, vector unsigned int __b, vector unsigned int __c) {
16100  return (vector unsigned int)__builtin_altivec_crypto_vpermxor(
16101  (vector unsigned char)__a, (vector unsigned char)__b,
16102  (vector unsigned char)__c);
16103 }
16104 
16105 static __inline__ vector unsigned long long __ATTRS_o_ai
16106 __builtin_crypto_vpermxor(vector unsigned long long __a,
16107  vector unsigned long long __b,
16108  vector unsigned long long __c) {
16109  return (vector unsigned long long)__builtin_altivec_crypto_vpermxor(
16110  (vector unsigned char)__a, (vector unsigned char)__b,
16111  (vector unsigned char)__c);
16112 }
16113 
16114 static __inline__ vector unsigned char __ATTRS_o_ai
16115 __builtin_crypto_vpmsumb(vector unsigned char __a, vector unsigned char __b) {
16116  return __builtin_altivec_crypto_vpmsumb(__a, __b);
16117 }
16118 
16119 static __inline__ vector unsigned short __ATTRS_o_ai
16120 __builtin_crypto_vpmsumb(vector unsigned short __a, vector unsigned short __b) {
16121  return __builtin_altivec_crypto_vpmsumh(__a, __b);
16122 }
16123 
16124 static __inline__ vector unsigned int __ATTRS_o_ai
16125 __builtin_crypto_vpmsumb(vector unsigned int __a, vector unsigned int __b) {
16126  return __builtin_altivec_crypto_vpmsumw(__a, __b);
16127 }
16128 
16129 static __inline__ vector unsigned long long __ATTRS_o_ai
16130 __builtin_crypto_vpmsumb(vector unsigned long long __a,
16131  vector unsigned long long __b) {
16132  return __builtin_altivec_crypto_vpmsumd(__a, __b);
16133 }
16134 
16135 static __inline__ vector signed char __ATTRS_o_ai
16136 vec_vgbbd(vector signed char __a) {
16137  return __builtin_altivec_vgbbd((vector unsigned char)__a);
16138 }
16139 
16140 #define vec_pmsum_be __builtin_crypto_vpmsumb
16141 #define vec_gb __builtin_altivec_vgbbd
16142 
16143 static __inline__ vector unsigned char __ATTRS_o_ai
16144 vec_vgbbd(vector unsigned char __a) {
16145  return __builtin_altivec_vgbbd(__a);
16146 }
16147 
16148 static __inline__ vector long long __ATTRS_o_ai
16149 vec_vbpermq(vector signed char __a, vector signed char __b) {
16150  return __builtin_altivec_vbpermq((vector unsigned char)__a,
16151  (vector unsigned char)__b);
16152 }
16153 
16154 static __inline__ vector long long __ATTRS_o_ai
16155 vec_vbpermq(vector unsigned char __a, vector unsigned char __b) {
16156  return __builtin_altivec_vbpermq(__a, __b);
16157 }
16158 
16159 #ifdef __powerpc64__
16160 static __inline__ vector unsigned long long __attribute__((__always_inline__))
16161 vec_bperm(vector unsigned __int128 __a, vector unsigned char __b) {
16162  return __builtin_altivec_vbpermq((vector unsigned char)__a,
16163  (vector unsigned char)__b);
16164 }
16165 #endif
16166 #endif
16167 
16168 
16169 /* vec_reve */
16170 
16171 static inline __ATTRS_o_ai vector bool char vec_reve(vector bool char __a) {
16172  return __builtin_shufflevector(__a, __a, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6,
16173  5, 4, 3, 2, 1, 0);
16174 }
16175 
16176 static inline __ATTRS_o_ai vector signed char vec_reve(vector signed char __a) {
16177  return __builtin_shufflevector(__a, __a, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6,
16178  5, 4, 3, 2, 1, 0);
16179 }
16180 
16181 static inline __ATTRS_o_ai vector unsigned char
16182 vec_reve(vector unsigned char __a) {
16183  return __builtin_shufflevector(__a, __a, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6,
16184  5, 4, 3, 2, 1, 0);
16185 }
16186 
16187 static inline __ATTRS_o_ai vector bool int vec_reve(vector bool int __a) {
16188  return __builtin_shufflevector(__a, __a, 3, 2, 1, 0);
16189 }
16190 
16191 static inline __ATTRS_o_ai vector signed int vec_reve(vector signed int __a) {
16192  return __builtin_shufflevector(__a, __a, 3, 2, 1, 0);
16193 }
16194 
16195 static inline __ATTRS_o_ai vector unsigned int
16196 vec_reve(vector unsigned int __a) {
16197  return __builtin_shufflevector(__a, __a, 3, 2, 1, 0);
16198 }
16199 
16200 static inline __ATTRS_o_ai vector bool short vec_reve(vector bool short __a) {
16201  return __builtin_shufflevector(__a, __a, 7, 6, 5, 4, 3, 2, 1, 0);
16202 }
16203 
16204 static inline __ATTRS_o_ai vector signed short
16205 vec_reve(vector signed short __a) {
16206  return __builtin_shufflevector(__a, __a, 7, 6, 5, 4, 3, 2, 1, 0);
16207 }
16208 
16209 static inline __ATTRS_o_ai vector unsigned short
16210 vec_reve(vector unsigned short __a) {
16211  return __builtin_shufflevector(__a, __a, 7, 6, 5, 4, 3, 2, 1, 0);
16212 }
16213 
16214 static inline __ATTRS_o_ai vector float vec_reve(vector float __a) {
16215  return __builtin_shufflevector(__a, __a, 3, 2, 1, 0);
16216 }
16217 
16218 #ifdef __VSX__
16219 static inline __ATTRS_o_ai vector bool long long
16220 vec_reve(vector bool long long __a) {
16221  return __builtin_shufflevector(__a, __a, 1, 0);
16222 }
16223 
16224 static inline __ATTRS_o_ai vector signed long long
16225 vec_reve(vector signed long long __a) {
16226  return __builtin_shufflevector(__a, __a, 1, 0);
16227 }
16228 
16229 static inline __ATTRS_o_ai vector unsigned long long
16230 vec_reve(vector unsigned long long __a) {
16231  return __builtin_shufflevector(__a, __a, 1, 0);
16232 }
16233 
16234 static inline __ATTRS_o_ai vector double vec_reve(vector double __a) {
16235  return __builtin_shufflevector(__a, __a, 1, 0);
16236 }
16237 #endif
16238 
16239 /* vec_revb */
16240 static __inline__ vector bool char __ATTRS_o_ai
16241 vec_revb(vector bool char __a) {
16242  return __a;
16243 }
16244 
16245 static __inline__ vector signed char __ATTRS_o_ai
16246 vec_revb(vector signed char __a) {
16247  return __a;
16248 }
16249 
16250 static __inline__ vector unsigned char __ATTRS_o_ai
16251 vec_revb(vector unsigned char __a) {
16252  return __a;
16253 }
16254 
16255 static __inline__ vector bool short __ATTRS_o_ai
16256 vec_revb(vector bool short __a) {
16257  vector unsigned char __indices =
16258  { 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14 };
16259  return vec_perm(__a, __a, __indices);
16260 }
16261 
16262 static __inline__ vector signed short __ATTRS_o_ai
16263 vec_revb(vector signed short __a) {
16264  vector unsigned char __indices =
16265  { 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14 };
16266  return vec_perm(__a, __a, __indices);
16267 }
16268 
16269 static __inline__ vector unsigned short __ATTRS_o_ai
16270 vec_revb(vector unsigned short __a) {
16271  vector unsigned char __indices =
16272  { 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14 };
16273  return vec_perm(__a, __a, __indices);
16274 }
16275 
16276 static __inline__ vector bool int __ATTRS_o_ai
16277 vec_revb(vector bool int __a) {
16278  vector unsigned char __indices =
16279  { 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12 };
16280  return vec_perm(__a, __a, __indices);
16281 }
16282 
16283 static __inline__ vector signed int __ATTRS_o_ai
16284 vec_revb(vector signed int __a) {
16285  vector unsigned char __indices =
16286  { 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12 };
16287  return vec_perm(__a, __a, __indices);
16288 }
16289 
16290 static __inline__ vector unsigned int __ATTRS_o_ai
16291 vec_revb(vector unsigned int __a) {
16292  vector unsigned char __indices =
16293  { 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12 };
16294  return vec_perm(__a, __a, __indices);
16295 }
16296 
16297 static __inline__ vector float __ATTRS_o_ai
16298 vec_revb(vector float __a) {
16299  vector unsigned char __indices =
16300  { 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12 };
16301  return vec_perm(__a, __a, __indices);
16302 }
16303 
16304 #ifdef __VSX__
16305 static __inline__ vector bool long long __ATTRS_o_ai
16306 vec_revb(vector bool long long __a) {
16307  vector unsigned char __indices =
16308  { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8 };
16309  return vec_perm(__a, __a, __indices);
16310 }
16311 
16312 static __inline__ vector signed long long __ATTRS_o_ai
16313 vec_revb(vector signed long long __a) {
16314  vector unsigned char __indices =
16315  { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8 };
16316  return vec_perm(__a, __a, __indices);
16317 }
16318 
16319 static __inline__ vector unsigned long long __ATTRS_o_ai
16320 vec_revb(vector unsigned long long __a) {
16321  vector unsigned char __indices =
16322  { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8 };
16323  return vec_perm(__a, __a, __indices);
16324 }
16325 
16326 static __inline__ vector double __ATTRS_o_ai
16327 vec_revb(vector double __a) {
16328  vector unsigned char __indices =
16329  { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8 };
16330  return vec_perm(__a, __a, __indices);
16331 }
16332 #endif /* End __VSX__ */
16333 
16334 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
16335 static __inline__ vector signed __int128 __ATTRS_o_ai
16336 vec_revb(vector signed __int128 __a) {
16337  vector unsigned char __indices =
16338  { 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
16339  return (vector signed __int128)vec_perm((vector signed int)__a,
16340  (vector signed int)__a,
16341  __indices);
16342 }
16343 
16344 static __inline__ vector unsigned __int128 __ATTRS_o_ai
16345 vec_revb(vector unsigned __int128 __a) {
16346  vector unsigned char __indices =
16347  { 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
16348  return (vector unsigned __int128)vec_perm((vector signed int)__a,
16349  (vector signed int)__a,
16350  __indices);
16351 }
16352 #endif /* END __POWER8_VECTOR__ && __powerpc64__ */
16353 
16354 /* vec_xl */
16355 
16356 static inline __ATTRS_o_ai vector signed char vec_xl(signed long long __offset,
16357  signed char *__ptr) {
16358  return *(vector signed char *)(__ptr + __offset);
16359 }
16360 
16361 static inline __ATTRS_o_ai vector unsigned char
16362 vec_xl(signed long long __offset, unsigned char *__ptr) {
16363  return *(vector unsigned char *)(__ptr + __offset);
16364 }
16365 
16366 static inline __ATTRS_o_ai vector signed short vec_xl(signed long long __offset,
16367  signed short *__ptr) {
16368  return *(vector signed short *)(__ptr + __offset);
16369 }
16370 
16371 static inline __ATTRS_o_ai vector unsigned short
16372 vec_xl(signed long long __offset, unsigned short *__ptr) {
16373  return *(vector unsigned short *)(__ptr + __offset);
16374 }
16375 
16376 static inline __ATTRS_o_ai vector signed int vec_xl(signed long long __offset,
16377  signed int *__ptr) {
16378  return *(vector signed int *)(__ptr + __offset);
16379 }
16380 
16381 static inline __ATTRS_o_ai vector unsigned int vec_xl(signed long long __offset,
16382  unsigned int *__ptr) {
16383  return *(vector unsigned int *)(__ptr + __offset);
16384 }
16385 
16386 static inline __ATTRS_o_ai vector float vec_xl(signed long long __offset,
16387  float *__ptr) {
16388  return *(vector float *)(__ptr + __offset);
16389 }
16390 
16391 #ifdef __VSX__
16392 static inline __ATTRS_o_ai vector signed long long
16393 vec_xl(signed long long __offset, signed long long *__ptr) {
16394  return *(vector signed long long *)(__ptr + __offset);
16395 }
16396 
16397 static inline __ATTRS_o_ai vector unsigned long long
16398 vec_xl(signed long long __offset, unsigned long long *__ptr) {
16399  return *(vector unsigned long long *)(__ptr + __offset);
16400 }
16401 
16402 static inline __ATTRS_o_ai vector double vec_xl(signed long long __offset,
16403  double *__ptr) {
16404  return *(vector double *)(__ptr + __offset);
16405 }
16406 #endif
16407 
16408 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
16409 static inline __ATTRS_o_ai vector signed __int128
16410 vec_xl(signed long long __offset, signed __int128 *__ptr) {
16411  return *(vector signed __int128 *)(__ptr + __offset);
16412 }
16413 
16414 static inline __ATTRS_o_ai vector unsigned __int128
16415 vec_xl(signed long long __offset, unsigned __int128 *__ptr) {
16416  return *(vector unsigned __int128 *)(__ptr + __offset);
16417 }
16418 #endif
16419 
16420 /* vec_xl_be */
16421 
16422 #ifdef __LITTLE_ENDIAN__
16423 static __inline__ vector signed char __ATTRS_o_ai
16424 vec_xl_be(signed long long __offset, signed char *__ptr) {
16425  vector signed char __vec = __builtin_vsx_lxvd2x_be(__offset, __ptr);
16426  return __builtin_shufflevector(__vec, __vec, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14,
16427  13, 12, 11, 10, 9, 8);
16428 }
16429 
16430 static __inline__ vector unsigned char __ATTRS_o_ai
16431 vec_xl_be(signed long long __offset, unsigned char *__ptr) {
16432  vector unsigned char __vec = __builtin_vsx_lxvd2x_be(__offset, __ptr);
16433  return __builtin_shufflevector(__vec, __vec, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14,
16434  13, 12, 11, 10, 9, 8);
16435 }
16436 
16437 static __inline__ vector signed short __ATTRS_o_ai
16438 vec_xl_be(signed long long __offset, signed short *__ptr) {
16439  vector signed short __vec = __builtin_vsx_lxvd2x_be(__offset, __ptr);
16440  return __builtin_shufflevector(__vec, __vec, 3, 2, 1, 0, 7, 6, 5, 4);
16441 }
16442 
16443 static __inline__ vector unsigned short __ATTRS_o_ai
16444 vec_xl_be(signed long long __offset, unsigned short *__ptr) {
16445  vector unsigned short __vec = __builtin_vsx_lxvd2x_be(__offset, __ptr);
16446  return __builtin_shufflevector(__vec, __vec, 3, 2, 1, 0, 7, 6, 5, 4);
16447 }
16448 
16449 static __inline__ vector signed int __ATTRS_o_ai
16450 vec_xl_be(signed long long __offset, signed int *__ptr) {
16451  return (vector signed int)__builtin_vsx_lxvw4x_be(__offset, __ptr);
16452 }
16453 
16454 static __inline__ vector unsigned int __ATTRS_o_ai
16455 vec_xl_be(signed long long __offset, unsigned int *__ptr) {
16456  return (vector unsigned int)__builtin_vsx_lxvw4x_be(__offset, __ptr);
16457 }
16458 
16459 static __inline__ vector float __ATTRS_o_ai
16460 vec_xl_be(signed long long __offset, float *__ptr) {
16461  return (vector float)__builtin_vsx_lxvw4x_be(__offset, __ptr);
16462 }
16463 
16464 #ifdef __VSX__
16465 static __inline__ vector signed long long __ATTRS_o_ai
16466 vec_xl_be(signed long long __offset, signed long long *__ptr) {
16467  return (vector signed long long)__builtin_vsx_lxvd2x_be(__offset, __ptr);
16468 }
16469 
16470 static __inline__ vector unsigned long long __ATTRS_o_ai
16471 vec_xl_be(signed long long __offset, unsigned long long *__ptr) {
16472  return (vector unsigned long long)__builtin_vsx_lxvd2x_be(__offset, __ptr);
16473 }
16474 
16475 static __inline__ vector double __ATTRS_o_ai
16476 vec_xl_be(signed long long __offset, double *__ptr) {
16477  return (vector double)__builtin_vsx_lxvd2x_be(__offset, __ptr);
16478 }
16479 #endif
16480 
16481 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
16482 static __inline__ vector signed __int128 __ATTRS_o_ai
16483 vec_xl_be(signed long long __offset, signed __int128 *__ptr) {
16484  return vec_xl(__offset, __ptr);
16485 }
16486 
16487 static __inline__ vector unsigned __int128 __ATTRS_o_ai
16488 vec_xl_be(signed long long __offset, unsigned __int128 *__ptr) {
16489  return vec_xl(__offset, __ptr);
16490 }
16491 #endif
16492 #else
16493  #define vec_xl_be vec_xl
16494 #endif
16495 
16496 /* vec_xst */
16497 
16498 static inline __ATTRS_o_ai void vec_xst(vector signed char __vec,
16499  signed long long __offset,
16500  signed char *__ptr) {
16501  *(vector signed char *)(__ptr + __offset) = __vec;
16502 }
16503 
16504 static inline __ATTRS_o_ai void vec_xst(vector unsigned char __vec,
16505  signed long long __offset,
16506  unsigned char *__ptr) {
16507  *(vector unsigned char *)(__ptr + __offset) = __vec;
16508 }
16509 
16510 static inline __ATTRS_o_ai void vec_xst(vector signed short __vec,
16511  signed long long __offset,
16512  signed short *__ptr) {
16513  *(vector signed short *)(__ptr + __offset) = __vec;
16514 }
16515 
16516 static inline __ATTRS_o_ai void vec_xst(vector unsigned short __vec,
16517  signed long long __offset,
16518  unsigned short *__ptr) {
16519  *(vector unsigned short *)(__ptr + __offset) = __vec;
16520 }
16521 
16522 static inline __ATTRS_o_ai void vec_xst(vector signed int __vec,
16523  signed long long __offset,
16524  signed int *__ptr) {
16525  *(vector signed int *)(__ptr + __offset) = __vec;
16526 }
16527 
16528 static inline __ATTRS_o_ai void vec_xst(vector unsigned int __vec,
16529  signed long long __offset,
16530  unsigned int *__ptr) {
16531  *(vector unsigned int *)(__ptr + __offset) = __vec;
16532 }
16533 
16534 static inline __ATTRS_o_ai void vec_xst(vector float __vec,
16535  signed long long __offset,
16536  float *__ptr) {
16537  *(vector float *)(__ptr + __offset) = __vec;
16538 }
16539 
16540 #ifdef __VSX__
16541 static inline __ATTRS_o_ai void vec_xst(vector signed long long __vec,
16542  signed long long __offset,
16543  signed long long *__ptr) {
16544  *(vector signed long long *)(__ptr + __offset) = __vec;
16545 }
16546 
16547 static inline __ATTRS_o_ai void vec_xst(vector unsigned long long __vec,
16548  signed long long __offset,
16549  unsigned long long *__ptr) {
16550  *(vector unsigned long long *)(__ptr + __offset) = __vec;
16551 }
16552 
16553 static inline __ATTRS_o_ai void vec_xst(vector double __vec,
16554  signed long long __offset,
16555  double *__ptr) {
16556  *(vector double *)(__ptr + __offset) = __vec;
16557 }
16558 #endif
16559 
16560 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
16561 static inline __ATTRS_o_ai void vec_xst(vector signed __int128 __vec,
16562  signed long long __offset,
16563  signed __int128 *__ptr) {
16564  *(vector signed __int128 *)(__ptr + __offset) = __vec;
16565 }
16566 
16567 static inline __ATTRS_o_ai void vec_xst(vector unsigned __int128 __vec,
16568  signed long long __offset,
16569  unsigned __int128 *__ptr) {
16570  *(vector unsigned __int128 *)(__ptr + __offset) = __vec;
16571 }
16572 #endif
16573 
16574 /* vec_xst_be */
16575 
16576 #ifdef __LITTLE_ENDIAN__
16577 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed char __vec,
16578  signed long long __offset,
16579  signed char *__ptr) {
16580  vector signed char __tmp =
16581  __builtin_shufflevector(__vec, __vec, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14,
16582  13, 12, 11, 10, 9, 8);
16583  __builtin_vsx_stxvd2x_be(__tmp, __offset, __ptr);
16584 }
16585 
16586 static __inline__ void __ATTRS_o_ai vec_xst_be(vector unsigned char __vec,
16587  signed long long __offset,
16588  unsigned char *__ptr) {
16589  vector unsigned char __tmp =
16590  __builtin_shufflevector(__vec, __vec, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14,
16591  13, 12, 11, 10, 9, 8);
16592  __builtin_vsx_stxvd2x_be(__tmp, __offset, __ptr);
16593 }
16594 
16595 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed short __vec,
16596  signed long long __offset,
16597  signed short *__ptr) {
16598  vector signed short __tmp =
16599  __builtin_shufflevector(__vec, __vec, 3, 2, 1, 0, 7, 6, 5, 4);
16600  __builtin_vsx_stxvd2x_be(__tmp, __offset, __ptr);
16601 }
16602 
16603 static __inline__ void __ATTRS_o_ai vec_xst_be(vector unsigned short __vec,
16604  signed long long __offset,
16605  unsigned short *__ptr) {
16606  vector unsigned short __tmp =
16607  __builtin_shufflevector(__vec, __vec, 3, 2, 1, 0, 7, 6, 5, 4);
16608  __builtin_vsx_stxvd2x_be(__tmp, __offset, __ptr);
16609 }
16610 
16611 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed int __vec,
16612  signed long long __offset,
16613  signed int *__ptr) {
16614  __builtin_vsx_stxvw4x_be(__vec, __offset, __ptr);
16615 }
16616 
16617 static __inline__ void __ATTRS_o_ai vec_xst_be(vector unsigned int __vec,
16618  signed long long __offset,
16619  unsigned int *__ptr) {
16620  __builtin_vsx_stxvw4x_be(__vec, __offset, __ptr);
16621 }
16622 
16623 static __inline__ void __ATTRS_o_ai vec_xst_be(vector float __vec,
16624  signed long long __offset,
16625  float *__ptr) {
16626  __builtin_vsx_stxvw4x_be(__vec, __offset, __ptr);
16627 }
16628 
16629 #ifdef __VSX__
16630 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed long long __vec,
16631  signed long long __offset,
16632  signed long long *__ptr) {
16633  __builtin_vsx_stxvd2x_be(__vec, __offset, __ptr);
16634 }
16635 
16636 static __inline__ void __ATTRS_o_ai vec_xst_be(vector unsigned long long __vec,
16637  signed long long __offset,
16638  unsigned long long *__ptr) {
16639  __builtin_vsx_stxvd2x_be(__vec, __offset, __ptr);
16640 }
16641 
16642 static __inline__ void __ATTRS_o_ai vec_xst_be(vector double __vec,
16643  signed long long __offset,
16644  double *__ptr) {
16645  __builtin_vsx_stxvd2x_be(__vec, __offset, __ptr);
16646 }
16647 #endif
16648 
16649 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
16650 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed __int128 __vec,
16651  signed long long __offset,
16652  signed __int128 *__ptr) {
16653  vec_xst(__vec, __offset, __ptr);
16654 }
16655 
16656 static __inline__ void __ATTRS_o_ai vec_xst_be(vector unsigned __int128 __vec,
16657  signed long long __offset,
16658  unsigned __int128 *__ptr) {
16659  vec_xst(__vec, __offset, __ptr);
16660 }
16661 #endif
16662 #else
16663  #define vec_xst_be vec_xst
16664 #endif
16665 
16666 #ifdef __POWER9_VECTOR__
16667 #define vec_test_data_class(__a, __b) \
16668  _Generic((__a), \
16669  vector float: \
16670  (vector bool int)__builtin_vsx_xvtstdcsp((__a), (__b)), \
16671  vector double: \
16672  (vector bool long long)__builtin_vsx_xvtstdcdp((__a), (__b)) \
16673  )
16674 
16675 #endif /* #ifdef __POWER9_VECTOR__ */
16676 
16677 static vector float __ATTRS_o_ai vec_neg(vector float __a) {
16678  return -__a;
16679 }
16680 
16681 #ifdef __VSX__
16682 static vector double __ATTRS_o_ai vec_neg(vector double __a) {
16683  return -__a;
16684 }
16685 
16686 #endif
16687 
16688 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
16689 static vector long long __ATTRS_o_ai vec_neg(vector long long __a) {
16690  return -__a;
16691 }
16692 #endif
16693 
16694 static vector signed int __ATTRS_o_ai vec_neg(vector signed int __a) {
16695  return -__a;
16696 }
16697 
16698 static vector signed short __ATTRS_o_ai vec_neg(vector signed short __a) {
16699  return -__a;
16700 }
16701 
16702 static vector signed char __ATTRS_o_ai vec_neg(vector signed char __a) {
16703  return -__a;
16704 }
16705 
16706 static vector float __ATTRS_o_ai vec_nabs(vector float __a) {
16707  return - vec_abs(__a);
16708 }
16709 
16710 #ifdef __VSX__
16711 static vector double __ATTRS_o_ai vec_nabs(vector double __a) {
16712  return - vec_abs(__a);
16713 }
16714 
16715 #endif
16716 
16717 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
16718 static vector long long __ATTRS_o_ai vec_nabs(vector long long __a) {
16719  return __builtin_altivec_vminsd(__a, -__a);
16720 }
16721 #endif
16722 
16723 static vector signed int __ATTRS_o_ai vec_nabs(vector signed int __a) {
16724  return __builtin_altivec_vminsw(__a, -__a);
16725 }
16726 
16727 static vector signed short __ATTRS_o_ai vec_nabs(vector signed short __a) {
16728  return __builtin_altivec_vminsh(__a, -__a);
16729 }
16730 
16731 static vector signed char __ATTRS_o_ai vec_nabs(vector signed char __a) {
16732  return __builtin_altivec_vminsb(__a, -__a);
16733 }
16734 #undef __ATTRS_o_ai
16735 
16736 #endif /* __ALTIVEC_H */
static __inline__ vector int __ATTRS_o_ai vec_vupkhsh(vector short __a)
Definition: altivec.h:11710
#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:9560
static __inline__ void __ATTRS_o_ai vec_stvehx(vector short __a, int __b, short *__c)
Definition: altivec.h:10592
static __inline__ vector signed char __ATTRS_o_ai vec_srl(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:9666
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:15414
static __inline__ vector int __ATTRS_o_ai vec_sum4s(vector signed char __a, vector int __b)
Definition: altivec.h:11484
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:11849
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:9853
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:11594
static __inline__ vector int __ATTRS_o_ai vec_vsrw(vector int __a, vector unsigned int __b)
Definition: altivec.h:9573
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:11362
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:14868
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
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:11044
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:11468
static __inline__ vector short __ATTRS_o_ai vec_vsubuhm(vector short __a, vector short __b)
Definition: altivec.h:11077
static __inline__ vector signed char __ATTRS_o_ai vec_sr(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:9496
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:13914
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:15779
#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:10624
static __inline__ vector unsigned char __ATTRS_o_ai vec_xor(vector unsigned char __a, vector unsigned char __b)
Definition: altivec.h:12176
static __inline__ vector signed char __ATTRS_o_ai vec_sro(vector signed char __a, vector signed char __b)
Definition: altivec.h:10026
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 vector float __ATTRS_o_ai vec_nabs(vector float __a)
Definition: altivec.h:16706
static __inline__ vector signed char __ATTRS_o_ai vec_insert(signed char __a, vector signed char __b, int __c)
Definition: altivec.h:12635
static __inline__ vector signed char __ATTRS_o_ai vec_lvrxl(int __a, const signed char *__b)
Definition: altivec.h:13044
#define NULL
Definition: opencl-c.h:150
static __ATTRS_o_ai vector signed char vec_xl(signed long long __offset, signed char *__ptr)
Definition: altivec.h:16356
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:15593
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:14811
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:14085
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:11185
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:15056
static __inline__ vector unsigned char __ATTRS_o_ai vec_vsububs(vector unsigned char __a, vector unsigned char __b)
Definition: altivec.h:11294
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:9630
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:13663
static __inline__ void __ATTRS_o_ai vec_stvlx(vector signed char __a, int __b, signed char *__c)
Definition: altivec.h:13149
static __inline__ vector signed char __ATTRS_o_ai vec_sub(vector signed char __a, vector signed char __b)
Definition: altivec.h:10916
static __inline__ vector signed char __ATTRS_o_ai vec_sra(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:9586
static __inline__ void __ATTRS_o_ai vec_stvx(vector signed char __a, int __b, vector signed char *__c)
Definition: altivec.h:10362
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:11153
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:13265
static __inline__ vector short __ATTRS_o_ai vec_vupklsb(vector signed char __a)
Definition: altivec.h:11830
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:11621
static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed char __a, vector signed char __b)
Definition: altivec.h:14623
static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed char __a, vector signed char __b)
Definition: altivec.h:14435
static __inline__ vector int __ATTRS_o_ai vec_vsraw(vector int __a, vector unsigned int __b)
Definition: altivec.h:9653
static __inline__ vector signed char __ATTRS_o_ai vec_lvrx(int __a, const signed char *__b)
Definition: altivec.h:12938
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:16498
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:12832
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:16493
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:9642
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:12344
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:11691
static __inline__ void __ATTRS_o_ai vec_stl(vector signed char __a, int __b, vector signed char *__c)
Definition: altivec.h:10651
static __inline__ void __ATTRS_o_ai vec_stvrxl(vector signed char __a, int __b, signed char *__c)
Definition: altivec.h:13498
static __inline__ vector signed char __ATTRS_o_ai vec_promote(signed char __a, int __b)
Definition: altivec.h:13615
static __inline__ void __ATTRS_o_ai vec_st(vector signed char __a, int __b, vector signed char *__c)
Definition: altivec.h:10231
static __inline__ void __ATTRS_o_ai vec_ste(vector signed char __a, int __b, signed char *__c)
Definition: altivec.h:10494
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:16677
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:15235
static __inline__ vector signed char __ATTRS_o_ai vec_lvlx(int __a, const signed char *__b)
Definition: altivec.h:12726
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:11111
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:11328
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:10142
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:12510
static __inline__ vector float __attribute__((__always_inline__)) vec_vaddfp(vector float __a
Definition: altivec.h:1617
#define vec_xst_be
Definition: altivec.h:16663
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:10570
static __inline__ vector int __ATTRS_o_ai vec_vrlw(vector int __a, vector unsigned int __b)
Definition: altivec.h:7697
static __inline__ int __ATTRS_o_ai vec_all_nan(vector float __a)
Definition: altivec.h:14607
static __inline__ void __ATTRS_o_ai vec_stvrx(vector signed char __a, int __b, signed char *__c)
Definition: altivec.h:13382
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:16241
static __inline__ vector signed char __ATTRS_o_ai vec_vsrb(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:9546
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:11760
static __inline__ void __ATTRS_o_ai vec_stvxl(vector signed char __a, int __b, vector signed char *__c)
Definition: altivec.h:10782
static __inline__ int __ATTRS_o_ai vec_all_ngt(vector float __a, vector float __b)
Definition: altivec.h:14829
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:14263
static __inline__ vector signed char __ATTRS_o_ai vec_vsubsbs(vector signed char __a, vector signed char __b)
Definition: altivec.h:11277
static __ATTRS_o_ai vector bool char vec_reve(vector bool char __a)
Definition: altivec.h:16171
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:11310
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:13727
static __inline__ vector int __ATTRS_o_ai vec_vsubsws(vector int __a, vector int __b)
Definition: altivec.h:11344