clang  9.0.0
altivec.h
Go to the documentation of this file.
1 /*===---- altivec.h - Standard header for type generic math ---------------===*\
2  *
3  * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4  * See https://llvm.org/LICENSE.txt for license information.
5  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6  *
7 \*===----------------------------------------------------------------------===*/
8 
9 #ifndef __ALTIVEC_H
10 #define __ALTIVEC_H
11 
12 #ifndef __ALTIVEC__
13 #error "AltiVec support not enabled"
14 #endif
15 
16 /* Constants for mapping CR6 bits to predicate result. */
17 
18 #define __CR6_EQ 0
19 #define __CR6_EQ_REV 1
20 #define __CR6_LT 2
21 #define __CR6_LT_REV 3
22 
23 /* Constants for vec_test_data_class */
24 #define __VEC_CLASS_FP_SUBNORMAL_N (1 << 0)
25 #define __VEC_CLASS_FP_SUBNORMAL_P (1 << 1)
26 #define __VEC_CLASS_FP_SUBNORMAL (__VEC_CLASS_FP_SUBNORMAL_P | \
27  __VEC_CLASS_FP_SUBNORMAL_N)
28 #define __VEC_CLASS_FP_ZERO_N (1<<2)
29 #define __VEC_CLASS_FP_ZERO_P (1<<3)
30 #define __VEC_CLASS_FP_ZERO (__VEC_CLASS_FP_ZERO_P | \
31  __VEC_CLASS_FP_ZERO_N)
32 #define __VEC_CLASS_FP_INFINITY_N (1<<4)
33 #define __VEC_CLASS_FP_INFINITY_P (1<<5)
34 #define __VEC_CLASS_FP_INFINITY (__VEC_CLASS_FP_INFINITY_P | \
35  __VEC_CLASS_FP_INFINITY_N)
36 #define __VEC_CLASS_FP_NAN (1<<6)
37 #define __VEC_CLASS_FP_NOT_NORMAL (__VEC_CLASS_FP_NAN | \
38  __VEC_CLASS_FP_SUBNORMAL | \
39  __VEC_CLASS_FP_ZERO | \
40  __VEC_CLASS_FP_INFINITY)
41 
42 #define __ATTRS_o_ai __attribute__((__overloadable__, __always_inline__))
43 
44 #ifdef __POWER9_VECTOR__
45 #include <stddef.h>
46 #endif
47 
48 static __inline__ vector signed char __ATTRS_o_ai vec_perm(
49  vector signed char __a, vector signed char __b, vector unsigned char __c);
50 
51 static __inline__ vector unsigned char __ATTRS_o_ai
52 vec_perm(vector unsigned char __a, vector unsigned char __b,
53  vector unsigned char __c);
54 
55 static __inline__ vector bool char __ATTRS_o_ai
56 vec_perm(vector bool char __a, vector bool char __b, vector unsigned char __c);
57 
58 static __inline__ vector short __ATTRS_o_ai vec_perm(vector signed short __a,
59  vector signed short __b,
60  vector unsigned char __c);
61 
62 static __inline__ vector unsigned short __ATTRS_o_ai
63 vec_perm(vector unsigned short __a, vector unsigned short __b,
64  vector unsigned char __c);
65 
66 static __inline__ vector bool short __ATTRS_o_ai vec_perm(
67  vector bool short __a, vector bool short __b, vector unsigned char __c);
68 
69 static __inline__ vector pixel __ATTRS_o_ai vec_perm(vector pixel __a,
70  vector pixel __b,
71  vector unsigned char __c);
72 
73 static __inline__ vector int __ATTRS_o_ai vec_perm(vector signed int __a,
74  vector signed int __b,
75  vector unsigned char __c);
76 
77 static __inline__ vector unsigned int __ATTRS_o_ai vec_perm(
78  vector unsigned int __a, vector unsigned int __b, vector unsigned char __c);
79 
80 static __inline__ vector bool int __ATTRS_o_ai
81 vec_perm(vector bool int __a, vector bool int __b, vector unsigned char __c);
82 
83 static __inline__ vector float __ATTRS_o_ai vec_perm(vector float __a,
84  vector float __b,
85  vector unsigned char __c);
86 
87 #ifdef __VSX__
88 static __inline__ vector long long __ATTRS_o_ai
89 vec_perm(vector signed long long __a, vector signed long long __b,
90  vector unsigned char __c);
91 
92 static __inline__ vector unsigned long long __ATTRS_o_ai
93 vec_perm(vector unsigned long long __a, vector unsigned long long __b,
94  vector unsigned char __c);
95 
96 static __inline__ vector bool long long __ATTRS_o_ai
97 vec_perm(vector bool long long __a, vector bool long long __b,
98  vector unsigned char __c);
99 
100 static __inline__ vector double __ATTRS_o_ai vec_perm(vector double __a,
101  vector double __b,
102  vector unsigned char __c);
103 #endif
104 
105 static __inline__ vector unsigned char __ATTRS_o_ai
106 vec_xor(vector unsigned char __a, vector unsigned char __b);
107 
108 /* vec_abs */
109 
110 #define __builtin_altivec_abs_v16qi vec_abs
111 #define __builtin_altivec_abs_v8hi vec_abs
112 #define __builtin_altivec_abs_v4si vec_abs
113 
114 static __inline__ vector signed char __ATTRS_o_ai
115 vec_abs(vector signed char __a) {
116  return __builtin_altivec_vmaxsb(__a, -__a);
117 }
118 
119 static __inline__ vector signed short __ATTRS_o_ai
120 vec_abs(vector signed short __a) {
121  return __builtin_altivec_vmaxsh(__a, -__a);
122 }
123 
124 static __inline__ vector signed int __ATTRS_o_ai
125 vec_abs(vector signed int __a) {
126  return __builtin_altivec_vmaxsw(__a, -__a);
127 }
128 
129 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
130 static __inline__ vector signed long long __ATTRS_o_ai
131 vec_abs(vector signed long long __a) {
132  return __builtin_altivec_vmaxsd(__a, -__a);
133 }
134 #endif
135 
136 static __inline__ vector float __ATTRS_o_ai vec_abs(vector float __a) {
137 #ifdef __VSX__
138  return __builtin_vsx_xvabssp(__a);
139 #else
140  vector unsigned int __res =
141  (vector unsigned int)__a & (vector unsigned int)(0x7FFFFFFF);
142  return (vector float)__res;
143 #endif
144 }
145 
146 #ifdef __VSX__
147 static __inline__ vector double __ATTRS_o_ai vec_abs(vector double __a) {
148  return __builtin_vsx_xvabsdp(__a);
149 }
150 #endif
151 
152 /* vec_abss */
153 #define __builtin_altivec_abss_v16qi vec_abss
154 #define __builtin_altivec_abss_v8hi vec_abss
155 #define __builtin_altivec_abss_v4si vec_abss
156 
157 static __inline__ vector signed char __ATTRS_o_ai
158 vec_abss(vector signed char __a) {
159  return __builtin_altivec_vmaxsb(
160  __a, __builtin_altivec_vsubsbs((vector signed char)(0), __a));
161 }
162 
163 static __inline__ vector signed short __ATTRS_o_ai
164 vec_abss(vector signed short __a) {
165  return __builtin_altivec_vmaxsh(
166  __a, __builtin_altivec_vsubshs((vector signed short)(0), __a));
167 }
168 
169 static __inline__ vector signed int __ATTRS_o_ai
170 vec_abss(vector signed int __a) {
171  return __builtin_altivec_vmaxsw(
172  __a, __builtin_altivec_vsubsws((vector signed int)(0), __a));
173 }
174 
175 /* vec_absd */
176 #if defined(__POWER9_VECTOR__)
177 
178 static __inline__ vector unsigned char __ATTRS_o_ai
179 vec_absd(vector unsigned char __a, vector unsigned char __b) {
180  return __builtin_altivec_vabsdub(__a, __b);
181 }
182 
183 static __inline__ vector unsigned short __ATTRS_o_ai
184 vec_absd(vector unsigned short __a, vector unsigned short __b) {
185  return __builtin_altivec_vabsduh(__a, __b);
186 }
187 
188 static __inline__ vector unsigned int __ATTRS_o_ai
189 vec_absd(vector unsigned int __a, vector unsigned int __b) {
190  return __builtin_altivec_vabsduw(__a, __b);
191 }
192 
193 #endif /* End __POWER9_VECTOR__ */
194 
195 /* vec_add */
196 
197 static __inline__ vector signed char __ATTRS_o_ai
198 vec_add(vector signed char __a, vector signed char __b) {
199  return __a + __b;
200 }
201 
202 static __inline__ vector signed char __ATTRS_o_ai
203 vec_add(vector bool char __a, vector signed char __b) {
204  return (vector signed char)__a + __b;
205 }
206 
207 static __inline__ vector signed char __ATTRS_o_ai
208 vec_add(vector signed char __a, vector bool char __b) {
209  return __a + (vector signed char)__b;
210 }
211 
212 static __inline__ vector unsigned char __ATTRS_o_ai
213 vec_add(vector unsigned char __a, vector unsigned char __b) {
214  return __a + __b;
215 }
216 
217 static __inline__ vector unsigned char __ATTRS_o_ai
218 vec_add(vector bool char __a, vector unsigned char __b) {
219  return (vector unsigned char)__a + __b;
220 }
221 
222 static __inline__ vector unsigned char __ATTRS_o_ai
223 vec_add(vector unsigned char __a, vector bool char __b) {
224  return __a + (vector unsigned char)__b;
225 }
226 
227 static __inline__ vector short __ATTRS_o_ai vec_add(vector short __a,
228  vector short __b) {
229  return __a + __b;
230 }
231 
232 static __inline__ vector short __ATTRS_o_ai vec_add(vector bool short __a,
233  vector short __b) {
234  return (vector short)__a + __b;
235 }
236 
237 static __inline__ vector short __ATTRS_o_ai vec_add(vector short __a,
238  vector bool short __b) {
239  return __a + (vector short)__b;
240 }
241 
242 static __inline__ vector unsigned short __ATTRS_o_ai
243 vec_add(vector unsigned short __a, vector unsigned short __b) {
244  return __a + __b;
245 }
246 
247 static __inline__ vector unsigned short __ATTRS_o_ai
248 vec_add(vector bool short __a, vector unsigned short __b) {
249  return (vector unsigned short)__a + __b;
250 }
251 
252 static __inline__ vector unsigned short __ATTRS_o_ai
253 vec_add(vector unsigned short __a, vector bool short __b) {
254  return __a + (vector unsigned short)__b;
255 }
256 
257 static __inline__ vector int __ATTRS_o_ai vec_add(vector int __a,
258  vector int __b) {
259  return __a + __b;
260 }
261 
262 static __inline__ vector int __ATTRS_o_ai vec_add(vector bool int __a,
263  vector int __b) {
264  return (vector int)__a + __b;
265 }
266 
267 static __inline__ vector int __ATTRS_o_ai vec_add(vector int __a,
268  vector bool int __b) {
269  return __a + (vector int)__b;
270 }
271 
272 static __inline__ vector unsigned int __ATTRS_o_ai
273 vec_add(vector unsigned int __a, vector unsigned int __b) {
274  return __a + __b;
275 }
276 
277 static __inline__ vector unsigned int __ATTRS_o_ai
278 vec_add(vector bool int __a, vector unsigned int __b) {
279  return (vector unsigned int)__a + __b;
280 }
281 
282 static __inline__ vector unsigned int __ATTRS_o_ai
283 vec_add(vector unsigned int __a, vector bool int __b) {
284  return __a + (vector unsigned int)__b;
285 }
286 
287 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
288 static __inline__ vector signed long long __ATTRS_o_ai
289 vec_add(vector signed long long __a, vector signed long long __b) {
290  return __a + __b;
291 }
292 
293 static __inline__ vector unsigned long long __ATTRS_o_ai
294 vec_add(vector unsigned long long __a, vector unsigned long long __b) {
295  return __a + __b;
296 }
297 
298 static __inline__ vector signed __int128 __ATTRS_o_ai
299 vec_add(vector signed __int128 __a, vector signed __int128 __b) {
300  return __a + __b;
301 }
302 
303 static __inline__ vector unsigned __int128 __ATTRS_o_ai
304 vec_add(vector unsigned __int128 __a, vector unsigned __int128 __b) {
305  return __a + __b;
306 }
307 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
308 
309 static __inline__ vector float __ATTRS_o_ai vec_add(vector float __a,
310  vector float __b) {
311  return __a + __b;
312 }
313 
314 #ifdef __VSX__
315 static __inline__ vector double __ATTRS_o_ai vec_add(vector double __a,
316  vector double __b) {
317  return __a + __b;
318 }
319 #endif // __VSX__
320 
321 /* vec_adde */
322 
323 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
324 static __inline__ vector signed __int128 __ATTRS_o_ai
325 vec_adde(vector signed __int128 __a, vector signed __int128 __b,
326  vector signed __int128 __c) {
327  return __builtin_altivec_vaddeuqm(__a, __b, __c);
328 }
329 
330 static __inline__ vector unsigned __int128 __ATTRS_o_ai
331 vec_adde(vector unsigned __int128 __a, vector unsigned __int128 __b,
332  vector unsigned __int128 __c) {
333  return __builtin_altivec_vaddeuqm(__a, __b, __c);
334 }
335 #endif
336 
337 static __inline__ vector signed int __ATTRS_o_ai
338 vec_adde(vector signed int __a, vector signed int __b,
339  vector signed int __c) {
340  vector signed int __mask = {1, 1, 1, 1};
341  vector signed int __carry = __c & __mask;
342  return vec_add(vec_add(__a, __b), __carry);
343 }
344 
345 static __inline__ vector unsigned int __ATTRS_o_ai
346 vec_adde(vector unsigned int __a, vector unsigned int __b,
347  vector unsigned int __c) {
348  vector unsigned int __mask = {1, 1, 1, 1};
349  vector unsigned int __carry = __c & __mask;
350  return vec_add(vec_add(__a, __b), __carry);
351 }
352 
353 /* vec_addec */
354 
355 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
356 static __inline__ vector signed __int128 __ATTRS_o_ai
357 vec_addec(vector signed __int128 __a, vector signed __int128 __b,
358  vector signed __int128 __c) {
359  return __builtin_altivec_vaddecuq(__a, __b, __c);
360 }
361 
362 static __inline__ vector unsigned __int128 __ATTRS_o_ai
363 vec_addec(vector unsigned __int128 __a, vector unsigned __int128 __b,
364  vector unsigned __int128 __c) {
365  return __builtin_altivec_vaddecuq(__a, __b, __c);
366 }
367 
368 static __inline__ vector signed int __ATTRS_o_ai
369 vec_addec(vector signed int __a, vector signed int __b,
370  vector signed int __c) {
371 
372  signed int __result[4];
373  for (int i = 0; i < 4; i++) {
374  unsigned int __tempa = (unsigned int) __a[i];
375  unsigned int __tempb = (unsigned int) __b[i];
376  unsigned int __tempc = (unsigned int) __c[i];
377  __tempc = __tempc & 0x00000001;
378  unsigned long long __longa = (unsigned long long) __tempa;
379  unsigned long long __longb = (unsigned long long) __tempb;
380  unsigned long long __longc = (unsigned long long) __tempc;
381  unsigned long long __sum = __longa + __longb + __longc;
382  unsigned long long __res = (__sum >> 32) & 0x01;
383  unsigned long long __tempres = (unsigned int) __res;
384  __result[i] = (signed int) __tempres;
385  }
386 
387  vector signed int ret = { __result[0], __result[1], __result[2], __result[3] };
388  return ret;
389 }
390 
391 static __inline__ vector unsigned int __ATTRS_o_ai
392 vec_addec(vector unsigned int __a, vector unsigned int __b,
393  vector unsigned int __c) {
394 
395  unsigned int __result[4];
396  for (int i = 0; i < 4; i++) {
397  unsigned int __tempc = __c[i] & 1;
398  unsigned long long __longa = (unsigned long long) __a[i];
399  unsigned long long __longb = (unsigned long long) __b[i];
400  unsigned long long __longc = (unsigned long long) __tempc;
401  unsigned long long __sum = __longa + __longb + __longc;
402  unsigned long long __res = (__sum >> 32) & 0x01;
403  unsigned long long __tempres = (unsigned int) __res;
404  __result[i] = (signed int) __tempres;
405  }
406 
407  vector unsigned int ret = { __result[0], __result[1], __result[2], __result[3] };
408  return ret;
409 }
410 
411 #endif
412 
413 /* vec_vaddubm */
414 
415 #define __builtin_altivec_vaddubm vec_vaddubm
416 
417 static __inline__ vector signed char __ATTRS_o_ai
418 vec_vaddubm(vector signed char __a, vector signed char __b) {
419  return __a + __b;
420 }
421 
422 static __inline__ vector signed char __ATTRS_o_ai
423 vec_vaddubm(vector bool char __a, vector signed char __b) {
424  return (vector signed char)__a + __b;
425 }
426 
427 static __inline__ vector signed char __ATTRS_o_ai
428 vec_vaddubm(vector signed char __a, vector bool char __b) {
429  return __a + (vector signed char)__b;
430 }
431 
432 static __inline__ vector unsigned char __ATTRS_o_ai
433 vec_vaddubm(vector unsigned char __a, vector unsigned char __b) {
434  return __a + __b;
435 }
436 
437 static __inline__ vector unsigned char __ATTRS_o_ai
438 vec_vaddubm(vector bool char __a, vector unsigned char __b) {
439  return (vector unsigned char)__a + __b;
440 }
441 
442 static __inline__ vector unsigned char __ATTRS_o_ai
443 vec_vaddubm(vector unsigned char __a, vector bool char __b) {
444  return __a + (vector unsigned char)__b;
445 }
446 
447 /* vec_vadduhm */
448 
449 #define __builtin_altivec_vadduhm vec_vadduhm
450 
451 static __inline__ vector short __ATTRS_o_ai vec_vadduhm(vector short __a,
452  vector short __b) {
453  return __a + __b;
454 }
455 
456 static __inline__ vector short __ATTRS_o_ai vec_vadduhm(vector bool short __a,
457  vector short __b) {
458  return (vector short)__a + __b;
459 }
460 
461 static __inline__ vector short __ATTRS_o_ai vec_vadduhm(vector short __a,
462  vector bool short __b) {
463  return __a + (vector short)__b;
464 }
465 
466 static __inline__ vector unsigned short __ATTRS_o_ai
467 vec_vadduhm(vector unsigned short __a, vector unsigned short __b) {
468  return __a + __b;
469 }
470 
471 static __inline__ vector unsigned short __ATTRS_o_ai
472 vec_vadduhm(vector bool short __a, vector unsigned short __b) {
473  return (vector unsigned short)__a + __b;
474 }
475 
476 static __inline__ vector unsigned short __ATTRS_o_ai
477 vec_vadduhm(vector unsigned short __a, vector bool short __b) {
478  return __a + (vector unsigned short)__b;
479 }
480 
481 /* vec_vadduwm */
482 
483 #define __builtin_altivec_vadduwm vec_vadduwm
484 
485 static __inline__ vector int __ATTRS_o_ai vec_vadduwm(vector int __a,
486  vector int __b) {
487  return __a + __b;
488 }
489 
490 static __inline__ vector int __ATTRS_o_ai vec_vadduwm(vector bool int __a,
491  vector int __b) {
492  return (vector int)__a + __b;
493 }
494 
495 static __inline__ vector int __ATTRS_o_ai vec_vadduwm(vector int __a,
496  vector bool int __b) {
497  return __a + (vector int)__b;
498 }
499 
500 static __inline__ vector unsigned int __ATTRS_o_ai
501 vec_vadduwm(vector unsigned int __a, vector unsigned int __b) {
502  return __a + __b;
503 }
504 
505 static __inline__ vector unsigned int __ATTRS_o_ai
506 vec_vadduwm(vector bool int __a, vector unsigned int __b) {
507  return (vector unsigned int)__a + __b;
508 }
509 
510 static __inline__ vector unsigned int __ATTRS_o_ai
511 vec_vadduwm(vector unsigned int __a, vector bool int __b) {
512  return __a + (vector unsigned int)__b;
513 }
514 
515 /* vec_vaddfp */
516 
517 #define __builtin_altivec_vaddfp vec_vaddfp
518 
519 static __inline__ vector float __attribute__((__always_inline__))
520 vec_vaddfp(vector float __a, vector float __b) {
521  return __a + __b;
522 }
523 
524 /* vec_addc */
525 
526 static __inline__ vector signed int __ATTRS_o_ai
527 vec_addc(vector signed int __a, vector signed int __b) {
528  return (vector signed int)__builtin_altivec_vaddcuw((vector unsigned int)__a,
529  (vector unsigned int)__b);
530 }
531 
532 static __inline__ vector unsigned int __ATTRS_o_ai
533 vec_addc(vector unsigned int __a, vector unsigned int __b) {
534  return __builtin_altivec_vaddcuw(__a, __b);
535 }
536 
537 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
538 static __inline__ vector signed __int128 __ATTRS_o_ai
539 vec_addc(vector signed __int128 __a, vector signed __int128 __b) {
540  return (vector signed __int128)__builtin_altivec_vaddcuq(
541  (vector unsigned __int128)__a, (vector unsigned __int128)__b);
542 }
543 
544 static __inline__ vector unsigned __int128 __ATTRS_o_ai
545 vec_addc(vector unsigned __int128 __a, vector unsigned __int128 __b) {
546  return __builtin_altivec_vaddcuq(__a, __b);
547 }
548 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
549 
550 /* vec_vaddcuw */
551 
552 static __inline__ vector unsigned int __attribute__((__always_inline__))
553 vec_vaddcuw(vector unsigned int __a, vector unsigned int __b) {
554  return __builtin_altivec_vaddcuw(__a, __b);
555 }
556 
557 /* vec_adds */
558 
559 static __inline__ vector signed char __ATTRS_o_ai
560 vec_adds(vector signed char __a, vector signed char __b) {
561  return __builtin_altivec_vaddsbs(__a, __b);
562 }
563 
564 static __inline__ vector signed char __ATTRS_o_ai
565 vec_adds(vector bool char __a, vector signed char __b) {
566  return __builtin_altivec_vaddsbs((vector signed char)__a, __b);
567 }
568 
569 static __inline__ vector signed char __ATTRS_o_ai
570 vec_adds(vector signed char __a, vector bool char __b) {
571  return __builtin_altivec_vaddsbs(__a, (vector signed char)__b);
572 }
573 
574 static __inline__ vector unsigned char __ATTRS_o_ai
575 vec_adds(vector unsigned char __a, vector unsigned char __b) {
576  return __builtin_altivec_vaddubs(__a, __b);
577 }
578 
579 static __inline__ vector unsigned char __ATTRS_o_ai
580 vec_adds(vector bool char __a, vector unsigned char __b) {
581  return __builtin_altivec_vaddubs((vector unsigned char)__a, __b);
582 }
583 
584 static __inline__ vector unsigned char __ATTRS_o_ai
585 vec_adds(vector unsigned char __a, vector bool char __b) {
586  return __builtin_altivec_vaddubs(__a, (vector unsigned char)__b);
587 }
588 
589 static __inline__ vector short __ATTRS_o_ai vec_adds(vector short __a,
590  vector short __b) {
591  return __builtin_altivec_vaddshs(__a, __b);
592 }
593 
594 static __inline__ vector short __ATTRS_o_ai vec_adds(vector bool short __a,
595  vector short __b) {
596  return __builtin_altivec_vaddshs((vector short)__a, __b);
597 }
598 
599 static __inline__ vector short __ATTRS_o_ai vec_adds(vector short __a,
600  vector bool short __b) {
601  return __builtin_altivec_vaddshs(__a, (vector short)__b);
602 }
603 
604 static __inline__ vector unsigned short __ATTRS_o_ai
605 vec_adds(vector unsigned short __a, vector unsigned short __b) {
606  return __builtin_altivec_vadduhs(__a, __b);
607 }
608 
609 static __inline__ vector unsigned short __ATTRS_o_ai
610 vec_adds(vector bool short __a, vector unsigned short __b) {
611  return __builtin_altivec_vadduhs((vector unsigned short)__a, __b);
612 }
613 
614 static __inline__ vector unsigned short __ATTRS_o_ai
615 vec_adds(vector unsigned short __a, vector bool short __b) {
616  return __builtin_altivec_vadduhs(__a, (vector unsigned short)__b);
617 }
618 
619 static __inline__ vector int __ATTRS_o_ai vec_adds(vector int __a,
620  vector int __b) {
621  return __builtin_altivec_vaddsws(__a, __b);
622 }
623 
624 static __inline__ vector int __ATTRS_o_ai vec_adds(vector bool int __a,
625  vector int __b) {
626  return __builtin_altivec_vaddsws((vector int)__a, __b);
627 }
628 
629 static __inline__ vector int __ATTRS_o_ai vec_adds(vector int __a,
630  vector bool int __b) {
631  return __builtin_altivec_vaddsws(__a, (vector int)__b);
632 }
633 
634 static __inline__ vector unsigned int __ATTRS_o_ai
635 vec_adds(vector unsigned int __a, vector unsigned int __b) {
636  return __builtin_altivec_vadduws(__a, __b);
637 }
638 
639 static __inline__ vector unsigned int __ATTRS_o_ai
640 vec_adds(vector bool int __a, vector unsigned int __b) {
641  return __builtin_altivec_vadduws((vector unsigned int)__a, __b);
642 }
643 
644 static __inline__ vector unsigned int __ATTRS_o_ai
645 vec_adds(vector unsigned int __a, vector bool int __b) {
646  return __builtin_altivec_vadduws(__a, (vector unsigned int)__b);
647 }
648 
649 /* vec_vaddsbs */
650 
651 static __inline__ vector signed char __ATTRS_o_ai
652 vec_vaddsbs(vector signed char __a, vector signed char __b) {
653  return __builtin_altivec_vaddsbs(__a, __b);
654 }
655 
656 static __inline__ vector signed char __ATTRS_o_ai
657 vec_vaddsbs(vector bool char __a, vector signed char __b) {
658  return __builtin_altivec_vaddsbs((vector signed char)__a, __b);
659 }
660 
661 static __inline__ vector signed char __ATTRS_o_ai
662 vec_vaddsbs(vector signed char __a, vector bool char __b) {
663  return __builtin_altivec_vaddsbs(__a, (vector signed char)__b);
664 }
665 
666 /* vec_vaddubs */
667 
668 static __inline__ vector unsigned char __ATTRS_o_ai
669 vec_vaddubs(vector unsigned char __a, vector unsigned char __b) {
670  return __builtin_altivec_vaddubs(__a, __b);
671 }
672 
673 static __inline__ vector unsigned char __ATTRS_o_ai
674 vec_vaddubs(vector bool char __a, vector unsigned char __b) {
675  return __builtin_altivec_vaddubs((vector unsigned char)__a, __b);
676 }
677 
678 static __inline__ vector unsigned char __ATTRS_o_ai
679 vec_vaddubs(vector unsigned char __a, vector bool char __b) {
680  return __builtin_altivec_vaddubs(__a, (vector unsigned char)__b);
681 }
682 
683 /* vec_vaddshs */
684 
685 static __inline__ vector short __ATTRS_o_ai vec_vaddshs(vector short __a,
686  vector short __b) {
687  return __builtin_altivec_vaddshs(__a, __b);
688 }
689 
690 static __inline__ vector short __ATTRS_o_ai vec_vaddshs(vector bool short __a,
691  vector short __b) {
692  return __builtin_altivec_vaddshs((vector short)__a, __b);
693 }
694 
695 static __inline__ vector short __ATTRS_o_ai vec_vaddshs(vector short __a,
696  vector bool short __b) {
697  return __builtin_altivec_vaddshs(__a, (vector short)__b);
698 }
699 
700 /* vec_vadduhs */
701 
702 static __inline__ vector unsigned short __ATTRS_o_ai
703 vec_vadduhs(vector unsigned short __a, vector unsigned short __b) {
704  return __builtin_altivec_vadduhs(__a, __b);
705 }
706 
707 static __inline__ vector unsigned short __ATTRS_o_ai
708 vec_vadduhs(vector bool short __a, vector unsigned short __b) {
709  return __builtin_altivec_vadduhs((vector unsigned short)__a, __b);
710 }
711 
712 static __inline__ vector unsigned short __ATTRS_o_ai
713 vec_vadduhs(vector unsigned short __a, vector bool short __b) {
714  return __builtin_altivec_vadduhs(__a, (vector unsigned short)__b);
715 }
716 
717 /* vec_vaddsws */
718 
719 static __inline__ vector int __ATTRS_o_ai vec_vaddsws(vector int __a,
720  vector int __b) {
721  return __builtin_altivec_vaddsws(__a, __b);
722 }
723 
724 static __inline__ vector int __ATTRS_o_ai vec_vaddsws(vector bool int __a,
725  vector int __b) {
726  return __builtin_altivec_vaddsws((vector int)__a, __b);
727 }
728 
729 static __inline__ vector int __ATTRS_o_ai vec_vaddsws(vector int __a,
730  vector bool int __b) {
731  return __builtin_altivec_vaddsws(__a, (vector int)__b);
732 }
733 
734 /* vec_vadduws */
735 
736 static __inline__ vector unsigned int __ATTRS_o_ai
737 vec_vadduws(vector unsigned int __a, vector unsigned int __b) {
738  return __builtin_altivec_vadduws(__a, __b);
739 }
740 
741 static __inline__ vector unsigned int __ATTRS_o_ai
742 vec_vadduws(vector bool int __a, vector unsigned int __b) {
743  return __builtin_altivec_vadduws((vector unsigned int)__a, __b);
744 }
745 
746 static __inline__ vector unsigned int __ATTRS_o_ai
747 vec_vadduws(vector unsigned int __a, vector bool int __b) {
748  return __builtin_altivec_vadduws(__a, (vector unsigned int)__b);
749 }
750 
751 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
752 /* vec_vadduqm */
753 
754 static __inline__ vector signed __int128 __ATTRS_o_ai
755 vec_vadduqm(vector signed __int128 __a, vector signed __int128 __b) {
756  return __a + __b;
757 }
758 
759 static __inline__ vector unsigned __int128 __ATTRS_o_ai
760 vec_vadduqm(vector unsigned __int128 __a, vector unsigned __int128 __b) {
761  return __a + __b;
762 }
763 
764 /* vec_vaddeuqm */
765 
766 static __inline__ vector signed __int128 __ATTRS_o_ai
767 vec_vaddeuqm(vector signed __int128 __a, vector signed __int128 __b,
768  vector signed __int128 __c) {
769  return __builtin_altivec_vaddeuqm(__a, __b, __c);
770 }
771 
772 static __inline__ vector unsigned __int128 __ATTRS_o_ai
773 vec_vaddeuqm(vector unsigned __int128 __a, vector unsigned __int128 __b,
774  vector unsigned __int128 __c) {
775  return __builtin_altivec_vaddeuqm(__a, __b, __c);
776 }
777 
778 /* vec_vaddcuq */
779 
780 static __inline__ vector signed __int128 __ATTRS_o_ai
781 vec_vaddcuq(vector signed __int128 __a, vector signed __int128 __b) {
782  return __builtin_altivec_vaddcuq(__a, __b);
783 }
784 
785 static __inline__ vector unsigned __int128 __ATTRS_o_ai
786 vec_vaddcuq(vector unsigned __int128 __a, vector unsigned __int128 __b) {
787  return __builtin_altivec_vaddcuq(__a, __b);
788 }
789 
790 /* vec_vaddecuq */
791 
792 static __inline__ vector signed __int128 __ATTRS_o_ai
793 vec_vaddecuq(vector signed __int128 __a, vector signed __int128 __b,
794  vector signed __int128 __c) {
795  return __builtin_altivec_vaddecuq(__a, __b, __c);
796 }
797 
798 static __inline__ vector unsigned __int128 __ATTRS_o_ai
799 vec_vaddecuq(vector unsigned __int128 __a, vector unsigned __int128 __b,
800  vector unsigned __int128 __c) {
801  return __builtin_altivec_vaddecuq(__a, __b, __c);
802 }
803 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
804 
805 /* vec_and */
806 
807 #define __builtin_altivec_vand vec_and
808 
809 static __inline__ vector signed char __ATTRS_o_ai
810 vec_and(vector signed char __a, vector signed char __b) {
811  return __a & __b;
812 }
813 
814 static __inline__ vector signed char __ATTRS_o_ai
815 vec_and(vector bool char __a, vector signed char __b) {
816  return (vector signed char)__a & __b;
817 }
818 
819 static __inline__ vector signed char __ATTRS_o_ai
820 vec_and(vector signed char __a, vector bool char __b) {
821  return __a & (vector signed char)__b;
822 }
823 
824 static __inline__ vector unsigned char __ATTRS_o_ai
825 vec_and(vector unsigned char __a, vector unsigned char __b) {
826  return __a & __b;
827 }
828 
829 static __inline__ vector unsigned char __ATTRS_o_ai
830 vec_and(vector bool char __a, vector unsigned char __b) {
831  return (vector unsigned char)__a & __b;
832 }
833 
834 static __inline__ vector unsigned char __ATTRS_o_ai
835 vec_and(vector unsigned char __a, vector bool char __b) {
836  return __a & (vector unsigned char)__b;
837 }
838 
839 static __inline__ vector bool char __ATTRS_o_ai vec_and(vector bool char __a,
840  vector bool char __b) {
841  return __a & __b;
842 }
843 
844 static __inline__ vector short __ATTRS_o_ai vec_and(vector short __a,
845  vector short __b) {
846  return __a & __b;
847 }
848 
849 static __inline__ vector short __ATTRS_o_ai vec_and(vector bool short __a,
850  vector short __b) {
851  return (vector short)__a & __b;
852 }
853 
854 static __inline__ vector short __ATTRS_o_ai vec_and(vector short __a,
855  vector bool short __b) {
856  return __a & (vector short)__b;
857 }
858 
859 static __inline__ vector unsigned short __ATTRS_o_ai
860 vec_and(vector unsigned short __a, vector unsigned short __b) {
861  return __a & __b;
862 }
863 
864 static __inline__ vector unsigned short __ATTRS_o_ai
865 vec_and(vector bool short __a, vector unsigned short __b) {
866  return (vector unsigned short)__a & __b;
867 }
868 
869 static __inline__ vector unsigned short __ATTRS_o_ai
870 vec_and(vector unsigned short __a, vector bool short __b) {
871  return __a & (vector unsigned short)__b;
872 }
873 
874 static __inline__ vector bool short __ATTRS_o_ai
875 vec_and(vector bool short __a, vector bool short __b) {
876  return __a & __b;
877 }
878 
879 static __inline__ vector int __ATTRS_o_ai vec_and(vector int __a,
880  vector int __b) {
881  return __a & __b;
882 }
883 
884 static __inline__ vector int __ATTRS_o_ai vec_and(vector bool int __a,
885  vector int __b) {
886  return (vector int)__a & __b;
887 }
888 
889 static __inline__ vector int __ATTRS_o_ai vec_and(vector int __a,
890  vector bool int __b) {
891  return __a & (vector int)__b;
892 }
893 
894 static __inline__ vector unsigned int __ATTRS_o_ai
895 vec_and(vector unsigned int __a, vector unsigned int __b) {
896  return __a & __b;
897 }
898 
899 static __inline__ vector unsigned int __ATTRS_o_ai
900 vec_and(vector bool int __a, vector unsigned int __b) {
901  return (vector unsigned int)__a & __b;
902 }
903 
904 static __inline__ vector unsigned int __ATTRS_o_ai
905 vec_and(vector unsigned int __a, vector bool int __b) {
906  return __a & (vector unsigned int)__b;
907 }
908 
909 static __inline__ vector bool int __ATTRS_o_ai vec_and(vector bool int __a,
910  vector bool int __b) {
911  return __a & __b;
912 }
913 
914 static __inline__ vector float __ATTRS_o_ai vec_and(vector float __a,
915  vector float __b) {
916  vector unsigned int __res =
917  (vector unsigned int)__a & (vector unsigned int)__b;
918  return (vector float)__res;
919 }
920 
921 static __inline__ vector float __ATTRS_o_ai vec_and(vector bool int __a,
922  vector float __b) {
923  vector unsigned int __res =
924  (vector unsigned int)__a & (vector unsigned int)__b;
925  return (vector float)__res;
926 }
927 
928 static __inline__ vector float __ATTRS_o_ai vec_and(vector float __a,
929  vector bool int __b) {
930  vector unsigned int __res =
931  (vector unsigned int)__a & (vector unsigned int)__b;
932  return (vector float)__res;
933 }
934 
935 #ifdef __VSX__
936 static __inline__ vector double __ATTRS_o_ai vec_and(vector bool long long __a,
937  vector double __b) {
938  vector unsigned long long __res =
939  (vector unsigned long long)__a & (vector unsigned long long)__b;
940  return (vector double)__res;
941 }
942 
943 static __inline__ vector double __ATTRS_o_ai
944 vec_and(vector double __a, vector bool long long __b) {
945  vector unsigned long long __res =
946  (vector unsigned long long)__a & (vector unsigned long long)__b;
947  return (vector double)__res;
948 }
949 
950 static __inline__ vector double __ATTRS_o_ai vec_and(vector double __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 signed long long __ATTRS_o_ai
958 vec_and(vector signed long long __a, vector signed long long __b) {
959  return __a & __b;
960 }
961 
962 static __inline__ vector signed long long __ATTRS_o_ai
963 vec_and(vector bool long long __a, vector signed long long __b) {
964  return (vector signed long long)__a & __b;
965 }
966 
967 static __inline__ vector signed long long __ATTRS_o_ai
968 vec_and(vector signed long long __a, vector bool long long __b) {
969  return __a & (vector signed long long)__b;
970 }
971 
972 static __inline__ vector unsigned long long __ATTRS_o_ai
973 vec_and(vector unsigned long long __a, vector unsigned long long __b) {
974  return __a & __b;
975 }
976 
977 static __inline__ vector unsigned long long __ATTRS_o_ai
978 vec_and(vector bool long long __a, vector unsigned long long __b) {
979  return (vector unsigned long long)__a & __b;
980 }
981 
982 static __inline__ vector unsigned long long __ATTRS_o_ai
983 vec_and(vector unsigned long long __a, vector bool long long __b) {
984  return __a & (vector unsigned long long)__b;
985 }
986 
987 static __inline__ vector bool long long __ATTRS_o_ai
988 vec_and(vector bool long long __a, vector bool long long __b) {
989  return __a & __b;
990 }
991 #endif
992 
993 /* vec_vand */
994 
995 static __inline__ vector signed char __ATTRS_o_ai
996 vec_vand(vector signed char __a, vector signed char __b) {
997  return __a & __b;
998 }
999 
1000 static __inline__ vector signed char __ATTRS_o_ai
1001 vec_vand(vector bool char __a, vector signed char __b) {
1002  return (vector signed char)__a & __b;
1003 }
1004 
1005 static __inline__ vector signed char __ATTRS_o_ai
1006 vec_vand(vector signed char __a, vector bool char __b) {
1007  return __a & (vector signed char)__b;
1008 }
1009 
1010 static __inline__ vector unsigned char __ATTRS_o_ai
1011 vec_vand(vector unsigned char __a, vector unsigned char __b) {
1012  return __a & __b;
1013 }
1014 
1015 static __inline__ vector unsigned char __ATTRS_o_ai
1016 vec_vand(vector bool char __a, vector unsigned char __b) {
1017  return (vector unsigned char)__a & __b;
1018 }
1019 
1020 static __inline__ vector unsigned char __ATTRS_o_ai
1021 vec_vand(vector unsigned char __a, vector bool char __b) {
1022  return __a & (vector unsigned char)__b;
1023 }
1024 
1025 static __inline__ vector bool char __ATTRS_o_ai vec_vand(vector bool char __a,
1026  vector bool char __b) {
1027  return __a & __b;
1028 }
1029 
1030 static __inline__ vector short __ATTRS_o_ai vec_vand(vector short __a,
1031  vector short __b) {
1032  return __a & __b;
1033 }
1034 
1035 static __inline__ vector short __ATTRS_o_ai vec_vand(vector bool short __a,
1036  vector short __b) {
1037  return (vector short)__a & __b;
1038 }
1039 
1040 static __inline__ vector short __ATTRS_o_ai vec_vand(vector short __a,
1041  vector bool short __b) {
1042  return __a & (vector short)__b;
1043 }
1044 
1045 static __inline__ vector unsigned short __ATTRS_o_ai
1046 vec_vand(vector unsigned short __a, vector unsigned short __b) {
1047  return __a & __b;
1048 }
1049 
1050 static __inline__ vector unsigned short __ATTRS_o_ai
1051 vec_vand(vector bool short __a, vector unsigned short __b) {
1052  return (vector unsigned short)__a & __b;
1053 }
1054 
1055 static __inline__ vector unsigned short __ATTRS_o_ai
1056 vec_vand(vector unsigned short __a, vector bool short __b) {
1057  return __a & (vector unsigned short)__b;
1058 }
1059 
1060 static __inline__ vector bool short __ATTRS_o_ai
1061 vec_vand(vector bool short __a, vector bool short __b) {
1062  return __a & __b;
1063 }
1064 
1065 static __inline__ vector int __ATTRS_o_ai vec_vand(vector int __a,
1066  vector int __b) {
1067  return __a & __b;
1068 }
1069 
1070 static __inline__ vector int __ATTRS_o_ai vec_vand(vector bool int __a,
1071  vector int __b) {
1072  return (vector int)__a & __b;
1073 }
1074 
1075 static __inline__ vector int __ATTRS_o_ai vec_vand(vector int __a,
1076  vector bool int __b) {
1077  return __a & (vector int)__b;
1078 }
1079 
1080 static __inline__ vector unsigned int __ATTRS_o_ai
1081 vec_vand(vector unsigned int __a, vector unsigned int __b) {
1082  return __a & __b;
1083 }
1084 
1085 static __inline__ vector unsigned int __ATTRS_o_ai
1086 vec_vand(vector bool int __a, vector unsigned int __b) {
1087  return (vector unsigned int)__a & __b;
1088 }
1089 
1090 static __inline__ vector unsigned int __ATTRS_o_ai
1091 vec_vand(vector unsigned int __a, vector bool int __b) {
1092  return __a & (vector unsigned int)__b;
1093 }
1094 
1095 static __inline__ vector bool int __ATTRS_o_ai vec_vand(vector bool int __a,
1096  vector bool int __b) {
1097  return __a & __b;
1098 }
1099 
1100 static __inline__ vector float __ATTRS_o_ai vec_vand(vector float __a,
1101  vector float __b) {
1102  vector unsigned int __res =
1103  (vector unsigned int)__a & (vector unsigned int)__b;
1104  return (vector float)__res;
1105 }
1106 
1107 static __inline__ vector float __ATTRS_o_ai vec_vand(vector bool int __a,
1108  vector float __b) {
1109  vector unsigned int __res =
1110  (vector unsigned int)__a & (vector unsigned int)__b;
1111  return (vector float)__res;
1112 }
1113 
1114 static __inline__ vector float __ATTRS_o_ai vec_vand(vector float __a,
1115  vector bool int __b) {
1116  vector unsigned int __res =
1117  (vector unsigned int)__a & (vector unsigned int)__b;
1118  return (vector float)__res;
1119 }
1120 
1121 #ifdef __VSX__
1122 static __inline__ vector signed long long __ATTRS_o_ai
1123 vec_vand(vector signed long long __a, vector signed long long __b) {
1124  return __a & __b;
1125 }
1126 
1127 static __inline__ vector signed long long __ATTRS_o_ai
1128 vec_vand(vector bool long long __a, vector signed long long __b) {
1129  return (vector signed long long)__a & __b;
1130 }
1131 
1132 static __inline__ vector signed long long __ATTRS_o_ai
1133 vec_vand(vector signed long long __a, vector bool long long __b) {
1134  return __a & (vector signed long long)__b;
1135 }
1136 
1137 static __inline__ vector unsigned long long __ATTRS_o_ai
1138 vec_vand(vector unsigned long long __a, vector unsigned long long __b) {
1139  return __a & __b;
1140 }
1141 
1142 static __inline__ vector unsigned long long __ATTRS_o_ai
1143 vec_vand(vector bool long long __a, vector unsigned long long __b) {
1144  return (vector unsigned long long)__a & __b;
1145 }
1146 
1147 static __inline__ vector unsigned long long __ATTRS_o_ai
1148 vec_vand(vector unsigned long long __a, vector bool long long __b) {
1149  return __a & (vector unsigned long long)__b;
1150 }
1151 
1152 static __inline__ vector bool long long __ATTRS_o_ai
1153 vec_vand(vector bool long long __a, vector bool long long __b) {
1154  return __a & __b;
1155 }
1156 #endif
1157 
1158 /* vec_andc */
1159 
1160 #define __builtin_altivec_vandc vec_andc
1161 
1162 static __inline__ vector signed char __ATTRS_o_ai
1163 vec_andc(vector signed char __a, vector signed char __b) {
1164  return __a & ~__b;
1165 }
1166 
1167 static __inline__ vector signed char __ATTRS_o_ai
1168 vec_andc(vector bool char __a, vector signed char __b) {
1169  return (vector signed char)__a & ~__b;
1170 }
1171 
1172 static __inline__ vector signed char __ATTRS_o_ai
1173 vec_andc(vector signed char __a, vector bool char __b) {
1174  return __a & ~(vector signed char)__b;
1175 }
1176 
1177 static __inline__ vector unsigned char __ATTRS_o_ai
1178 vec_andc(vector unsigned char __a, vector unsigned char __b) {
1179  return __a & ~__b;
1180 }
1181 
1182 static __inline__ vector unsigned char __ATTRS_o_ai
1183 vec_andc(vector bool char __a, vector unsigned char __b) {
1184  return (vector unsigned char)__a & ~__b;
1185 }
1186 
1187 static __inline__ vector unsigned char __ATTRS_o_ai
1188 vec_andc(vector unsigned char __a, vector bool char __b) {
1189  return __a & ~(vector unsigned char)__b;
1190 }
1191 
1192 static __inline__ vector bool char __ATTRS_o_ai vec_andc(vector bool char __a,
1193  vector bool char __b) {
1194  return __a & ~__b;
1195 }
1196 
1197 static __inline__ vector short __ATTRS_o_ai vec_andc(vector short __a,
1198  vector short __b) {
1199  return __a & ~__b;
1200 }
1201 
1202 static __inline__ vector short __ATTRS_o_ai vec_andc(vector bool short __a,
1203  vector short __b) {
1204  return (vector short)__a & ~__b;
1205 }
1206 
1207 static __inline__ vector short __ATTRS_o_ai vec_andc(vector short __a,
1208  vector bool short __b) {
1209  return __a & ~(vector short)__b;
1210 }
1211 
1212 static __inline__ vector unsigned short __ATTRS_o_ai
1213 vec_andc(vector unsigned short __a, vector unsigned short __b) {
1214  return __a & ~__b;
1215 }
1216 
1217 static __inline__ vector unsigned short __ATTRS_o_ai
1218 vec_andc(vector bool short __a, vector unsigned short __b) {
1219  return (vector unsigned short)__a & ~__b;
1220 }
1221 
1222 static __inline__ vector unsigned short __ATTRS_o_ai
1223 vec_andc(vector unsigned short __a, vector bool short __b) {
1224  return __a & ~(vector unsigned short)__b;
1225 }
1226 
1227 static __inline__ vector bool short __ATTRS_o_ai
1228 vec_andc(vector bool short __a, vector bool short __b) {
1229  return __a & ~__b;
1230 }
1231 
1232 static __inline__ vector int __ATTRS_o_ai vec_andc(vector int __a,
1233  vector int __b) {
1234  return __a & ~__b;
1235 }
1236 
1237 static __inline__ vector int __ATTRS_o_ai vec_andc(vector bool int __a,
1238  vector int __b) {
1239  return (vector int)__a & ~__b;
1240 }
1241 
1242 static __inline__ vector int __ATTRS_o_ai vec_andc(vector int __a,
1243  vector bool int __b) {
1244  return __a & ~(vector int)__b;
1245 }
1246 
1247 static __inline__ vector unsigned int __ATTRS_o_ai
1248 vec_andc(vector unsigned int __a, vector unsigned int __b) {
1249  return __a & ~__b;
1250 }
1251 
1252 static __inline__ vector unsigned int __ATTRS_o_ai
1253 vec_andc(vector bool int __a, vector unsigned int __b) {
1254  return (vector unsigned int)__a & ~__b;
1255 }
1256 
1257 static __inline__ vector unsigned int __ATTRS_o_ai
1258 vec_andc(vector unsigned int __a, vector bool int __b) {
1259  return __a & ~(vector unsigned int)__b;
1260 }
1261 
1262 static __inline__ vector bool int __ATTRS_o_ai vec_andc(vector bool int __a,
1263  vector bool int __b) {
1264  return __a & ~__b;
1265 }
1266 
1267 static __inline__ vector float __ATTRS_o_ai vec_andc(vector float __a,
1268  vector float __b) {
1269  vector unsigned int __res =
1270  (vector unsigned int)__a & ~(vector unsigned int)__b;
1271  return (vector float)__res;
1272 }
1273 
1274 static __inline__ vector float __ATTRS_o_ai vec_andc(vector bool int __a,
1275  vector float __b) {
1276  vector unsigned int __res =
1277  (vector unsigned int)__a & ~(vector unsigned int)__b;
1278  return (vector float)__res;
1279 }
1280 
1281 static __inline__ vector float __ATTRS_o_ai vec_andc(vector float __a,
1282  vector bool int __b) {
1283  vector unsigned int __res =
1284  (vector unsigned int)__a & ~(vector unsigned int)__b;
1285  return (vector float)__res;
1286 }
1287 
1288 #ifdef __VSX__
1289 static __inline__ vector double __ATTRS_o_ai vec_andc(vector bool long long __a,
1290  vector double __b) {
1291  vector unsigned long long __res =
1292  (vector unsigned long long)__a & ~(vector unsigned long long)__b;
1293  return (vector double)__res;
1294 }
1295 
1296 static __inline__ vector double __ATTRS_o_ai
1297 vec_andc(vector double __a, vector bool long long __b) {
1298  vector unsigned long long __res =
1299  (vector unsigned long long)__a & ~(vector unsigned long long)__b;
1300  return (vector double)__res;
1301 }
1302 
1303 static __inline__ vector double __ATTRS_o_ai vec_andc(vector double __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 signed long long __ATTRS_o_ai
1311 vec_andc(vector signed long long __a, vector signed long long __b) {
1312  return __a & ~__b;
1313 }
1314 
1315 static __inline__ vector signed long long __ATTRS_o_ai
1316 vec_andc(vector bool long long __a, vector signed long long __b) {
1317  return (vector signed long long)__a & ~__b;
1318 }
1319 
1320 static __inline__ vector signed long long __ATTRS_o_ai
1321 vec_andc(vector signed long long __a, vector bool long long __b) {
1322  return __a & ~(vector signed long long)__b;
1323 }
1324 
1325 static __inline__ vector unsigned long long __ATTRS_o_ai
1326 vec_andc(vector unsigned long long __a, vector unsigned long long __b) {
1327  return __a & ~__b;
1328 }
1329 
1330 static __inline__ vector unsigned long long __ATTRS_o_ai
1331 vec_andc(vector bool long long __a, vector unsigned long long __b) {
1332  return (vector unsigned long long)__a & ~__b;
1333 }
1334 
1335 static __inline__ vector unsigned long long __ATTRS_o_ai
1336 vec_andc(vector unsigned long long __a, vector bool long long __b) {
1337  return __a & ~(vector unsigned long long)__b;
1338 }
1339 
1340 static __inline__ vector bool long long __ATTRS_o_ai
1341 vec_andc(vector bool long long __a, vector bool long long __b) {
1342  return __a & ~__b;
1343 }
1344 #endif
1345 
1346 /* vec_vandc */
1347 
1348 static __inline__ vector signed char __ATTRS_o_ai
1349 vec_vandc(vector signed char __a, vector signed char __b) {
1350  return __a & ~__b;
1351 }
1352 
1353 static __inline__ vector signed char __ATTRS_o_ai
1354 vec_vandc(vector bool char __a, vector signed char __b) {
1355  return (vector signed char)__a & ~__b;
1356 }
1357 
1358 static __inline__ vector signed char __ATTRS_o_ai
1359 vec_vandc(vector signed char __a, vector bool char __b) {
1360  return __a & ~(vector signed char)__b;
1361 }
1362 
1363 static __inline__ vector unsigned char __ATTRS_o_ai
1364 vec_vandc(vector unsigned char __a, vector unsigned char __b) {
1365  return __a & ~__b;
1366 }
1367 
1368 static __inline__ vector unsigned char __ATTRS_o_ai
1369 vec_vandc(vector bool char __a, vector unsigned char __b) {
1370  return (vector unsigned char)__a & ~__b;
1371 }
1372 
1373 static __inline__ vector unsigned char __ATTRS_o_ai
1374 vec_vandc(vector unsigned char __a, vector bool char __b) {
1375  return __a & ~(vector unsigned char)__b;
1376 }
1377 
1378 static __inline__ vector bool char __ATTRS_o_ai
1379 vec_vandc(vector bool char __a, vector bool char __b) {
1380  return __a & ~__b;
1381 }
1382 
1383 static __inline__ vector short __ATTRS_o_ai vec_vandc(vector short __a,
1384  vector short __b) {
1385  return __a & ~__b;
1386 }
1387 
1388 static __inline__ vector short __ATTRS_o_ai vec_vandc(vector bool short __a,
1389  vector short __b) {
1390  return (vector short)__a & ~__b;
1391 }
1392 
1393 static __inline__ vector short __ATTRS_o_ai vec_vandc(vector short __a,
1394  vector bool short __b) {
1395  return __a & ~(vector short)__b;
1396 }
1397 
1398 static __inline__ vector unsigned short __ATTRS_o_ai
1399 vec_vandc(vector unsigned short __a, vector unsigned short __b) {
1400  return __a & ~__b;
1401 }
1402 
1403 static __inline__ vector unsigned short __ATTRS_o_ai
1404 vec_vandc(vector bool short __a, vector unsigned short __b) {
1405  return (vector unsigned short)__a & ~__b;
1406 }
1407 
1408 static __inline__ vector unsigned short __ATTRS_o_ai
1409 vec_vandc(vector unsigned short __a, vector bool short __b) {
1410  return __a & ~(vector unsigned short)__b;
1411 }
1412 
1413 static __inline__ vector bool short __ATTRS_o_ai
1414 vec_vandc(vector bool short __a, vector bool short __b) {
1415  return __a & ~__b;
1416 }
1417 
1418 static __inline__ vector int __ATTRS_o_ai vec_vandc(vector int __a,
1419  vector int __b) {
1420  return __a & ~__b;
1421 }
1422 
1423 static __inline__ vector int __ATTRS_o_ai vec_vandc(vector bool int __a,
1424  vector int __b) {
1425  return (vector int)__a & ~__b;
1426 }
1427 
1428 static __inline__ vector int __ATTRS_o_ai vec_vandc(vector int __a,
1429  vector bool int __b) {
1430  return __a & ~(vector int)__b;
1431 }
1432 
1433 static __inline__ vector unsigned int __ATTRS_o_ai
1434 vec_vandc(vector unsigned int __a, vector unsigned int __b) {
1435  return __a & ~__b;
1436 }
1437 
1438 static __inline__ vector unsigned int __ATTRS_o_ai
1439 vec_vandc(vector bool int __a, vector unsigned int __b) {
1440  return (vector unsigned int)__a & ~__b;
1441 }
1442 
1443 static __inline__ vector unsigned int __ATTRS_o_ai
1444 vec_vandc(vector unsigned int __a, vector bool int __b) {
1445  return __a & ~(vector unsigned int)__b;
1446 }
1447 
1448 static __inline__ vector bool int __ATTRS_o_ai vec_vandc(vector bool int __a,
1449  vector bool int __b) {
1450  return __a & ~__b;
1451 }
1452 
1453 static __inline__ vector float __ATTRS_o_ai vec_vandc(vector float __a,
1454  vector float __b) {
1455  vector unsigned int __res =
1456  (vector unsigned int)__a & ~(vector unsigned int)__b;
1457  return (vector float)__res;
1458 }
1459 
1460 static __inline__ vector float __ATTRS_o_ai vec_vandc(vector bool int __a,
1461  vector float __b) {
1462  vector unsigned int __res =
1463  (vector unsigned int)__a & ~(vector unsigned int)__b;
1464  return (vector float)__res;
1465 }
1466 
1467 static __inline__ vector float __ATTRS_o_ai vec_vandc(vector float __a,
1468  vector bool int __b) {
1469  vector unsigned int __res =
1470  (vector unsigned int)__a & ~(vector unsigned int)__b;
1471  return (vector float)__res;
1472 }
1473 
1474 #ifdef __VSX__
1475 static __inline__ vector signed long long __ATTRS_o_ai
1476 vec_vandc(vector signed long long __a, vector signed long long __b) {
1477  return __a & ~__b;
1478 }
1479 
1480 static __inline__ vector signed long long __ATTRS_o_ai
1481 vec_vandc(vector bool long long __a, vector signed long long __b) {
1482  return (vector signed long long)__a & ~__b;
1483 }
1484 
1485 static __inline__ vector signed long long __ATTRS_o_ai
1486 vec_vandc(vector signed long long __a, vector bool long long __b) {
1487  return __a & ~(vector signed long long)__b;
1488 }
1489 
1490 static __inline__ vector unsigned long long __ATTRS_o_ai
1491 vec_vandc(vector unsigned long long __a, vector unsigned long long __b) {
1492  return __a & ~__b;
1493 }
1494 
1495 static __inline__ vector unsigned long long __ATTRS_o_ai
1496 vec_vandc(vector bool long long __a, vector unsigned long long __b) {
1497  return (vector unsigned long long)__a & ~__b;
1498 }
1499 
1500 static __inline__ vector unsigned long long __ATTRS_o_ai
1501 vec_vandc(vector unsigned long long __a, vector bool long long __b) {
1502  return __a & ~(vector unsigned long long)__b;
1503 }
1504 
1505 static __inline__ vector bool long long __ATTRS_o_ai
1506 vec_vandc(vector bool long long __a, vector bool long long __b) {
1507  return __a & ~__b;
1508 }
1509 #endif
1510 
1511 /* vec_avg */
1512 
1513 static __inline__ vector signed char __ATTRS_o_ai
1514 vec_avg(vector signed char __a, vector signed char __b) {
1515  return __builtin_altivec_vavgsb(__a, __b);
1516 }
1517 
1518 static __inline__ vector unsigned char __ATTRS_o_ai
1519 vec_avg(vector unsigned char __a, vector unsigned char __b) {
1520  return __builtin_altivec_vavgub(__a, __b);
1521 }
1522 
1523 static __inline__ vector short __ATTRS_o_ai vec_avg(vector short __a,
1524  vector short __b) {
1525  return __builtin_altivec_vavgsh(__a, __b);
1526 }
1527 
1528 static __inline__ vector unsigned short __ATTRS_o_ai
1529 vec_avg(vector unsigned short __a, vector unsigned short __b) {
1530  return __builtin_altivec_vavguh(__a, __b);
1531 }
1532 
1533 static __inline__ vector int __ATTRS_o_ai vec_avg(vector int __a,
1534  vector int __b) {
1535  return __builtin_altivec_vavgsw(__a, __b);
1536 }
1537 
1538 static __inline__ vector unsigned int __ATTRS_o_ai
1539 vec_avg(vector unsigned int __a, vector unsigned int __b) {
1540  return __builtin_altivec_vavguw(__a, __b);
1541 }
1542 
1543 /* vec_vavgsb */
1544 
1545 static __inline__ vector signed char __attribute__((__always_inline__))
1546 vec_vavgsb(vector signed char __a, vector signed char __b) {
1547  return __builtin_altivec_vavgsb(__a, __b);
1548 }
1549 
1550 /* vec_vavgub */
1551 
1552 static __inline__ vector unsigned char __attribute__((__always_inline__))
1553 vec_vavgub(vector unsigned char __a, vector unsigned char __b) {
1554  return __builtin_altivec_vavgub(__a, __b);
1555 }
1556 
1557 /* vec_vavgsh */
1558 
1559 static __inline__ vector short __attribute__((__always_inline__))
1560 vec_vavgsh(vector short __a, vector short __b) {
1561  return __builtin_altivec_vavgsh(__a, __b);
1562 }
1563 
1564 /* vec_vavguh */
1565 
1566 static __inline__ vector unsigned short __attribute__((__always_inline__))
1567 vec_vavguh(vector unsigned short __a, vector unsigned short __b) {
1568  return __builtin_altivec_vavguh(__a, __b);
1569 }
1570 
1571 /* vec_vavgsw */
1572 
1573 static __inline__ vector int __attribute__((__always_inline__))
1574 vec_vavgsw(vector int __a, vector int __b) {
1575  return __builtin_altivec_vavgsw(__a, __b);
1576 }
1577 
1578 /* vec_vavguw */
1579 
1580 static __inline__ vector unsigned int __attribute__((__always_inline__))
1581 vec_vavguw(vector unsigned int __a, vector unsigned int __b) {
1582  return __builtin_altivec_vavguw(__a, __b);
1583 }
1584 
1585 /* vec_ceil */
1586 
1587 static __inline__ vector float __ATTRS_o_ai vec_ceil(vector float __a) {
1588 #ifdef __VSX__
1589  return __builtin_vsx_xvrspip(__a);
1590 #else
1591  return __builtin_altivec_vrfip(__a);
1592 #endif
1593 }
1594 
1595 #ifdef __VSX__
1596 static __inline__ vector double __ATTRS_o_ai vec_ceil(vector double __a) {
1597  return __builtin_vsx_xvrdpip(__a);
1598 }
1599 #endif
1600 
1601 /* vec_vrfip */
1602 
1603 static __inline__ vector float __attribute__((__always_inline__))
1604 vec_vrfip(vector float __a) {
1605  return __builtin_altivec_vrfip(__a);
1606 }
1607 
1608 /* vec_cmpb */
1609 
1610 static __inline__ vector int __attribute__((__always_inline__))
1611 vec_cmpb(vector float __a, vector float __b) {
1612  return __builtin_altivec_vcmpbfp(__a, __b);
1613 }
1614 
1615 /* vec_vcmpbfp */
1616 
1617 static __inline__ vector int __attribute__((__always_inline__))
1618 vec_vcmpbfp(vector float __a, vector float __b) {
1619  return __builtin_altivec_vcmpbfp(__a, __b);
1620 }
1621 
1622 /* vec_cmpeq */
1623 
1624 static __inline__ vector bool char __ATTRS_o_ai
1625 vec_cmpeq(vector signed char __a, vector signed char __b) {
1626  return (vector bool char)__builtin_altivec_vcmpequb((vector char)__a,
1627  (vector char)__b);
1628 }
1629 
1630 static __inline__ vector bool char __ATTRS_o_ai
1631 vec_cmpeq(vector unsigned char __a, vector unsigned char __b) {
1632  return (vector bool char)__builtin_altivec_vcmpequb((vector char)__a,
1633  (vector char)__b);
1634 }
1635 
1636 static __inline__ vector bool char __ATTRS_o_ai
1637 vec_cmpeq(vector bool char __a, vector bool char __b) {
1638  return (vector bool char)__builtin_altivec_vcmpequb((vector char)__a,
1639  (vector char)__b);
1640 }
1641 
1642 static __inline__ vector bool short __ATTRS_o_ai vec_cmpeq(vector short __a,
1643  vector short __b) {
1644  return (vector bool short)__builtin_altivec_vcmpequh(__a, __b);
1645 }
1646 
1647 static __inline__ vector bool short __ATTRS_o_ai
1648 vec_cmpeq(vector unsigned short __a, vector unsigned short __b) {
1649  return (vector bool short)__builtin_altivec_vcmpequh((vector short)__a,
1650  (vector short)__b);
1651 }
1652 
1653 static __inline__ vector bool short __ATTRS_o_ai
1654 vec_cmpeq(vector bool short __a, vector bool short __b) {
1655  return (vector bool short)__builtin_altivec_vcmpequh((vector short)__a,
1656  (vector short)__b);
1657 }
1658 
1659 static __inline__ vector bool int __ATTRS_o_ai vec_cmpeq(vector int __a,
1660  vector int __b) {
1661  return (vector bool int)__builtin_altivec_vcmpequw(__a, __b);
1662 }
1663 
1664 static __inline__ vector bool int __ATTRS_o_ai
1665 vec_cmpeq(vector unsigned int __a, vector unsigned int __b) {
1666  return (vector bool int)__builtin_altivec_vcmpequw((vector int)__a,
1667  (vector int)__b);
1668 }
1669 
1670 static __inline__ vector bool int __ATTRS_o_ai vec_cmpeq(vector bool int __a,
1671  vector bool int __b) {
1672  return (vector bool int)__builtin_altivec_vcmpequw((vector int)__a,
1673  (vector int)__b);
1674 }
1675 
1676 #ifdef __POWER8_VECTOR__
1677 static __inline__ vector bool long long __ATTRS_o_ai
1678 vec_cmpeq(vector signed long long __a, vector signed long long __b) {
1679  return (vector bool long long)__builtin_altivec_vcmpequd(__a, __b);
1680 }
1681 
1682 static __inline__ vector bool long long __ATTRS_o_ai
1683 vec_cmpeq(vector unsigned long long __a, vector unsigned long long __b) {
1684  return (vector bool long long)__builtin_altivec_vcmpequd(
1685  (vector long long)__a, (vector long long)__b);
1686 }
1687 
1688 static __inline__ vector bool long long __ATTRS_o_ai
1689 vec_cmpeq(vector bool long long __a, vector bool long long __b) {
1690  return (vector bool long long)__builtin_altivec_vcmpequd(
1691  (vector long long)__a, (vector long long)__b);
1692 }
1693 
1694 #endif
1695 
1696 static __inline__ vector bool int __ATTRS_o_ai vec_cmpeq(vector float __a,
1697  vector float __b) {
1698 #ifdef __VSX__
1699  return (vector bool int)__builtin_vsx_xvcmpeqsp(__a, __b);
1700 #else
1701  return (vector bool int)__builtin_altivec_vcmpeqfp(__a, __b);
1702 #endif
1703 }
1704 
1705 #ifdef __VSX__
1706 static __inline__ vector bool long long __ATTRS_o_ai
1707 vec_cmpeq(vector double __a, vector double __b) {
1708  return (vector bool long long)__builtin_vsx_xvcmpeqdp(__a, __b);
1709 }
1710 #endif
1711 
1712 #ifdef __POWER9_VECTOR__
1713 /* vec_cmpne */
1714 
1715 static __inline__ vector bool char __ATTRS_o_ai
1716 vec_cmpne(vector bool char __a, vector bool char __b) {
1717  return (vector bool char)__builtin_altivec_vcmpneb((vector char)__a,
1718  (vector char)__b);
1719 }
1720 
1721 static __inline__ vector bool char __ATTRS_o_ai
1722 vec_cmpne(vector signed char __a, vector signed char __b) {
1723  return (vector bool char)__builtin_altivec_vcmpneb((vector char)__a,
1724  (vector char)__b);
1725 }
1726 
1727 static __inline__ vector bool char __ATTRS_o_ai
1728 vec_cmpne(vector unsigned char __a, vector unsigned char __b) {
1729  return (vector bool char)__builtin_altivec_vcmpneb((vector char)__a,
1730  (vector char)__b);
1731 }
1732 
1733 static __inline__ vector bool short __ATTRS_o_ai
1734 vec_cmpne(vector bool short __a, vector bool short __b) {
1735  return (vector bool short)__builtin_altivec_vcmpneh((vector short)__a,
1736  (vector short)__b);
1737 }
1738 
1739 static __inline__ vector bool short __ATTRS_o_ai
1740 vec_cmpne(vector signed short __a, vector signed short __b) {
1741  return (vector bool short)__builtin_altivec_vcmpneh((vector short)__a,
1742  (vector short)__b);
1743 }
1744 
1745 static __inline__ vector bool short __ATTRS_o_ai
1746 vec_cmpne(vector unsigned short __a, vector unsigned short __b) {
1747  return (vector bool short)__builtin_altivec_vcmpneh((vector short)__a,
1748  (vector short)__b);
1749 }
1750 
1751 static __inline__ vector bool int __ATTRS_o_ai
1752 vec_cmpne(vector bool int __a, vector bool int __b) {
1753  return (vector bool int)__builtin_altivec_vcmpnew((vector int)__a,
1754  (vector int)__b);
1755 }
1756 
1757 static __inline__ vector bool int __ATTRS_o_ai
1758 vec_cmpne(vector signed int __a, vector signed int __b) {
1759  return (vector bool int)__builtin_altivec_vcmpnew((vector int)__a,
1760  (vector int)__b);
1761 }
1762 
1763 static __inline__ vector bool int __ATTRS_o_ai
1764 vec_cmpne(vector unsigned int __a, vector unsigned int __b) {
1765  return (vector bool int)__builtin_altivec_vcmpnew((vector int)__a,
1766  (vector int)__b);
1767 }
1768 
1769 static __inline__ vector bool long long __ATTRS_o_ai
1770 vec_cmpne(vector bool long long __a, vector bool long long __b) {
1771  return (vector bool long long)
1772  ~(__builtin_altivec_vcmpequd((vector long long)__a, (vector long long)__b));
1773 }
1774 
1775 static __inline__ vector bool long long __ATTRS_o_ai
1776 vec_cmpne(vector signed long long __a, vector signed long long __b) {
1777  return (vector bool long long)
1778  ~(__builtin_altivec_vcmpequd((vector long long)__a, (vector long long)__b));
1779 }
1780 
1781 static __inline__ vector bool long long __ATTRS_o_ai
1782 vec_cmpne(vector unsigned long long __a, vector unsigned long long __b) {
1783  return (vector bool long long)
1784  ~(__builtin_altivec_vcmpequd((vector long long)__a, (vector long long)__b));
1785 }
1786 
1787 static __inline__ vector bool int __ATTRS_o_ai
1788 vec_cmpne(vector float __a, vector float __b) {
1789  return (vector bool int)__builtin_altivec_vcmpnew((vector int)__a,
1790  (vector int)__b);
1791 }
1792 
1793 static __inline__ vector bool long long __ATTRS_o_ai
1794 vec_cmpne(vector double __a, vector double __b) {
1795  return (vector bool long long)
1796  ~(__builtin_altivec_vcmpequd((vector long long)__a, (vector long long)__b));
1797 }
1798 
1799 /* vec_cmpnez */
1800 
1801 static __inline__ vector bool char __ATTRS_o_ai
1802 vec_cmpnez(vector signed char __a, vector signed char __b) {
1803  return (vector bool char)__builtin_altivec_vcmpnezb((vector char)__a,
1804  (vector char)__b);
1805 }
1806 
1807 static __inline__ vector bool char __ATTRS_o_ai
1808 vec_cmpnez(vector unsigned char __a, vector unsigned char __b) {
1809  return (vector bool char)__builtin_altivec_vcmpnezb((vector char)__a,
1810  (vector char)__b);
1811 }
1812 
1813 static __inline__ vector bool short __ATTRS_o_ai
1814 vec_cmpnez(vector signed short __a, vector signed short __b) {
1815  return (vector bool short)__builtin_altivec_vcmpnezh((vector short)__a,
1816  (vector short)__b);
1817 }
1818 
1819 static __inline__ vector bool short __ATTRS_o_ai
1820 vec_cmpnez(vector unsigned short __a, vector unsigned short __b) {
1821  return (vector bool short)__builtin_altivec_vcmpnezh((vector short)__a,
1822  (vector short)__b);
1823 }
1824 
1825 static __inline__ vector bool int __ATTRS_o_ai
1826 vec_cmpnez(vector signed int __a, vector signed int __b) {
1827  return (vector bool int)__builtin_altivec_vcmpnezw((vector int)__a,
1828  (vector int)__b);
1829 }
1830 
1831 static __inline__ vector bool int __ATTRS_o_ai
1832 vec_cmpnez(vector unsigned int __a, vector unsigned int __b) {
1833  return (vector bool int)__builtin_altivec_vcmpnezw((vector int)__a,
1834  (vector int)__b);
1835 }
1836 
1837 static __inline__ signed int __ATTRS_o_ai
1838 vec_cntlz_lsbb(vector signed char __a) {
1839 #ifdef __LITTLE_ENDIAN__
1840  return __builtin_altivec_vctzlsbb(__a);
1841 #else
1842  return __builtin_altivec_vclzlsbb(__a);
1843 #endif
1844 }
1845 
1846 static __inline__ signed int __ATTRS_o_ai
1847 vec_cntlz_lsbb(vector unsigned char __a) {
1848 #ifdef __LITTLE_ENDIAN__
1849  return __builtin_altivec_vctzlsbb(__a);
1850 #else
1851  return __builtin_altivec_vclzlsbb(__a);
1852 #endif
1853 }
1854 
1855 static __inline__ signed int __ATTRS_o_ai
1856 vec_cnttz_lsbb(vector signed char __a) {
1857 #ifdef __LITTLE_ENDIAN__
1858  return __builtin_altivec_vclzlsbb(__a);
1859 #else
1860  return __builtin_altivec_vctzlsbb(__a);
1861 #endif
1862 }
1863 
1864 static __inline__ signed int __ATTRS_o_ai
1865 vec_cnttz_lsbb(vector unsigned char __a) {
1866 #ifdef __LITTLE_ENDIAN__
1867  return __builtin_altivec_vclzlsbb(__a);
1868 #else
1869  return __builtin_altivec_vctzlsbb(__a);
1870 #endif
1871 }
1872 
1873 static __inline__ vector unsigned int __ATTRS_o_ai
1874 vec_parity_lsbb(vector unsigned int __a) {
1875  return __builtin_altivec_vprtybw(__a);
1876 }
1877 
1878 static __inline__ vector unsigned int __ATTRS_o_ai
1879 vec_parity_lsbb(vector signed int __a) {
1880  return __builtin_altivec_vprtybw(__a);
1881 }
1882 
1883 static __inline__ vector unsigned __int128 __ATTRS_o_ai
1884 vec_parity_lsbb(vector unsigned __int128 __a) {
1885  return __builtin_altivec_vprtybq(__a);
1886 }
1887 
1888 static __inline__ vector unsigned __int128 __ATTRS_o_ai
1889 vec_parity_lsbb(vector signed __int128 __a) {
1890  return __builtin_altivec_vprtybq(__a);
1891 }
1892 
1893 static __inline__ vector unsigned long long __ATTRS_o_ai
1894 vec_parity_lsbb(vector unsigned long long __a) {
1895  return __builtin_altivec_vprtybd(__a);
1896 }
1897 
1898 static __inline__ vector unsigned long long __ATTRS_o_ai
1899 vec_parity_lsbb(vector signed long long __a) {
1900  return __builtin_altivec_vprtybd(__a);
1901 }
1902 
1903 #endif
1904 
1905 /* vec_cmpgt */
1906 
1907 static __inline__ vector bool char __ATTRS_o_ai
1908 vec_cmpgt(vector signed char __a, vector signed char __b) {
1909  return (vector bool char)__builtin_altivec_vcmpgtsb(__a, __b);
1910 }
1911 
1912 static __inline__ vector bool char __ATTRS_o_ai
1913 vec_cmpgt(vector unsigned char __a, vector unsigned char __b) {
1914  return (vector bool char)__builtin_altivec_vcmpgtub(__a, __b);
1915 }
1916 
1917 static __inline__ vector bool short __ATTRS_o_ai vec_cmpgt(vector short __a,
1918  vector short __b) {
1919  return (vector bool short)__builtin_altivec_vcmpgtsh(__a, __b);
1920 }
1921 
1922 static __inline__ vector bool short __ATTRS_o_ai
1923 vec_cmpgt(vector unsigned short __a, vector unsigned short __b) {
1924  return (vector bool short)__builtin_altivec_vcmpgtuh(__a, __b);
1925 }
1926 
1927 static __inline__ vector bool int __ATTRS_o_ai vec_cmpgt(vector int __a,
1928  vector int __b) {
1929  return (vector bool int)__builtin_altivec_vcmpgtsw(__a, __b);
1930 }
1931 
1932 static __inline__ vector bool int __ATTRS_o_ai
1933 vec_cmpgt(vector unsigned int __a, vector unsigned int __b) {
1934  return (vector bool int)__builtin_altivec_vcmpgtuw(__a, __b);
1935 }
1936 
1937 #ifdef __POWER8_VECTOR__
1938 static __inline__ vector bool long long __ATTRS_o_ai
1939 vec_cmpgt(vector signed long long __a, vector signed long long __b) {
1940  return (vector bool long long)__builtin_altivec_vcmpgtsd(__a, __b);
1941 }
1942 
1943 static __inline__ vector bool long long __ATTRS_o_ai
1944 vec_cmpgt(vector unsigned long long __a, vector unsigned long long __b) {
1945  return (vector bool long long)__builtin_altivec_vcmpgtud(__a, __b);
1946 }
1947 #endif
1948 
1949 static __inline__ vector bool int __ATTRS_o_ai vec_cmpgt(vector float __a,
1950  vector float __b) {
1951 #ifdef __VSX__
1952  return (vector bool int)__builtin_vsx_xvcmpgtsp(__a, __b);
1953 #else
1954  return (vector bool int)__builtin_altivec_vcmpgtfp(__a, __b);
1955 #endif
1956 }
1957 
1958 #ifdef __VSX__
1959 static __inline__ vector bool long long __ATTRS_o_ai
1960 vec_cmpgt(vector double __a, vector double __b) {
1961  return (vector bool long long)__builtin_vsx_xvcmpgtdp(__a, __b);
1962 }
1963 #endif
1964 
1965 /* vec_cmpge */
1966 
1967 static __inline__ vector bool char __ATTRS_o_ai
1968 vec_cmpge(vector signed char __a, vector signed char __b) {
1969  return ~(vec_cmpgt(__b, __a));
1970 }
1971 
1972 static __inline__ vector bool char __ATTRS_o_ai
1973 vec_cmpge(vector unsigned char __a, vector unsigned char __b) {
1974  return ~(vec_cmpgt(__b, __a));
1975 }
1976 
1977 static __inline__ vector bool short __ATTRS_o_ai
1978 vec_cmpge(vector signed short __a, vector signed short __b) {
1979  return ~(vec_cmpgt(__b, __a));
1980 }
1981 
1982 static __inline__ vector bool short __ATTRS_o_ai
1983 vec_cmpge(vector unsigned short __a, vector unsigned short __b) {
1984  return ~(vec_cmpgt(__b, __a));
1985 }
1986 
1987 static __inline__ vector bool int __ATTRS_o_ai
1988 vec_cmpge(vector signed int __a, vector signed int __b) {
1989  return ~(vec_cmpgt(__b, __a));
1990 }
1991 
1992 static __inline__ vector bool int __ATTRS_o_ai
1993 vec_cmpge(vector unsigned int __a, vector unsigned int __b) {
1994  return ~(vec_cmpgt(__b, __a));
1995 }
1996 
1997 static __inline__ vector bool int __ATTRS_o_ai vec_cmpge(vector float __a,
1998  vector float __b) {
1999 #ifdef __VSX__
2000  return (vector bool int)__builtin_vsx_xvcmpgesp(__a, __b);
2001 #else
2002  return (vector bool int)__builtin_altivec_vcmpgefp(__a, __b);
2003 #endif
2004 }
2005 
2006 #ifdef __VSX__
2007 static __inline__ vector bool long long __ATTRS_o_ai
2008 vec_cmpge(vector double __a, vector double __b) {
2009  return (vector bool long long)__builtin_vsx_xvcmpgedp(__a, __b);
2010 }
2011 #endif
2012 
2013 #ifdef __POWER8_VECTOR__
2014 static __inline__ vector bool long long __ATTRS_o_ai
2015 vec_cmpge(vector signed long long __a, vector signed long long __b) {
2016  return ~(vec_cmpgt(__b, __a));
2017 }
2018 
2019 static __inline__ vector bool long long __ATTRS_o_ai
2020 vec_cmpge(vector unsigned long long __a, vector unsigned long long __b) {
2021  return ~(vec_cmpgt(__b, __a));
2022 }
2023 #endif
2024 
2025 /* vec_vcmpgefp */
2026 
2027 static __inline__ vector bool int __attribute__((__always_inline__))
2028 vec_vcmpgefp(vector float __a, vector float __b) {
2029  return (vector bool int)__builtin_altivec_vcmpgefp(__a, __b);
2030 }
2031 
2032 /* vec_vcmpgtsb */
2033 
2034 static __inline__ vector bool char __attribute__((__always_inline__))
2035 vec_vcmpgtsb(vector signed char __a, vector signed char __b) {
2036  return (vector bool char)__builtin_altivec_vcmpgtsb(__a, __b);
2037 }
2038 
2039 /* vec_vcmpgtub */
2040 
2041 static __inline__ vector bool char __attribute__((__always_inline__))
2042 vec_vcmpgtub(vector unsigned char __a, vector unsigned char __b) {
2043  return (vector bool char)__builtin_altivec_vcmpgtub(__a, __b);
2044 }
2045 
2046 /* vec_vcmpgtsh */
2047 
2048 static __inline__ vector bool short __attribute__((__always_inline__))
2049 vec_vcmpgtsh(vector short __a, vector short __b) {
2050  return (vector bool short)__builtin_altivec_vcmpgtsh(__a, __b);
2051 }
2052 
2053 /* vec_vcmpgtuh */
2054 
2055 static __inline__ vector bool short __attribute__((__always_inline__))
2056 vec_vcmpgtuh(vector unsigned short __a, vector unsigned short __b) {
2057  return (vector bool short)__builtin_altivec_vcmpgtuh(__a, __b);
2058 }
2059 
2060 /* vec_vcmpgtsw */
2061 
2062 static __inline__ vector bool int __attribute__((__always_inline__))
2063 vec_vcmpgtsw(vector int __a, vector int __b) {
2064  return (vector bool int)__builtin_altivec_vcmpgtsw(__a, __b);
2065 }
2066 
2067 /* vec_vcmpgtuw */
2068 
2069 static __inline__ vector bool int __attribute__((__always_inline__))
2070 vec_vcmpgtuw(vector unsigned int __a, vector unsigned int __b) {
2071  return (vector bool int)__builtin_altivec_vcmpgtuw(__a, __b);
2072 }
2073 
2074 /* vec_vcmpgtfp */
2075 
2076 static __inline__ vector bool int __attribute__((__always_inline__))
2077 vec_vcmpgtfp(vector float __a, vector float __b) {
2078  return (vector bool int)__builtin_altivec_vcmpgtfp(__a, __b);
2079 }
2080 
2081 /* vec_cmple */
2082 
2083 static __inline__ vector bool char __ATTRS_o_ai
2084 vec_cmple(vector signed char __a, vector signed char __b) {
2085  return vec_cmpge(__b, __a);
2086 }
2087 
2088 static __inline__ vector bool char __ATTRS_o_ai
2089 vec_cmple(vector unsigned char __a, vector unsigned char __b) {
2090  return vec_cmpge(__b, __a);
2091 }
2092 
2093 static __inline__ vector bool short __ATTRS_o_ai
2094 vec_cmple(vector signed short __a, vector signed short __b) {
2095  return vec_cmpge(__b, __a);
2096 }
2097 
2098 static __inline__ vector bool short __ATTRS_o_ai
2099 vec_cmple(vector unsigned short __a, vector unsigned short __b) {
2100  return vec_cmpge(__b, __a);
2101 }
2102 
2103 static __inline__ vector bool int __ATTRS_o_ai
2104 vec_cmple(vector signed int __a, vector signed int __b) {
2105  return vec_cmpge(__b, __a);
2106 }
2107 
2108 static __inline__ vector bool int __ATTRS_o_ai
2109 vec_cmple(vector unsigned int __a, vector unsigned int __b) {
2110  return vec_cmpge(__b, __a);
2111 }
2112 
2113 static __inline__ vector bool int __ATTRS_o_ai vec_cmple(vector float __a,
2114  vector float __b) {
2115  return vec_cmpge(__b, __a);
2116 }
2117 
2118 #ifdef __VSX__
2119 static __inline__ vector bool long long __ATTRS_o_ai
2120 vec_cmple(vector double __a, vector double __b) {
2121  return vec_cmpge(__b, __a);
2122 }
2123 #endif
2124 
2125 #ifdef __POWER8_VECTOR__
2126 static __inline__ vector bool long long __ATTRS_o_ai
2127 vec_cmple(vector signed long long __a, vector signed long long __b) {
2128  return vec_cmpge(__b, __a);
2129 }
2130 
2131 static __inline__ vector bool long long __ATTRS_o_ai
2132 vec_cmple(vector unsigned long long __a, vector unsigned long long __b) {
2133  return vec_cmpge(__b, __a);
2134 }
2135 #endif
2136 
2137 /* vec_cmplt */
2138 
2139 static __inline__ vector bool char __ATTRS_o_ai
2140 vec_cmplt(vector signed char __a, vector signed char __b) {
2141  return vec_cmpgt(__b, __a);
2142 }
2143 
2144 static __inline__ vector bool char __ATTRS_o_ai
2145 vec_cmplt(vector unsigned char __a, vector unsigned char __b) {
2146  return vec_cmpgt(__b, __a);
2147 }
2148 
2149 static __inline__ vector bool short __ATTRS_o_ai vec_cmplt(vector short __a,
2150  vector short __b) {
2151  return vec_cmpgt(__b, __a);
2152 }
2153 
2154 static __inline__ vector bool short __ATTRS_o_ai
2155 vec_cmplt(vector unsigned short __a, vector unsigned short __b) {
2156  return vec_cmpgt(__b, __a);
2157 }
2158 
2159 static __inline__ vector bool int __ATTRS_o_ai vec_cmplt(vector int __a,
2160  vector int __b) {
2161  return vec_cmpgt(__b, __a);
2162 }
2163 
2164 static __inline__ vector bool int __ATTRS_o_ai
2165 vec_cmplt(vector unsigned int __a, vector unsigned int __b) {
2166  return vec_cmpgt(__b, __a);
2167 }
2168 
2169 static __inline__ vector bool int __ATTRS_o_ai vec_cmplt(vector float __a,
2170  vector float __b) {
2171  return vec_cmpgt(__b, __a);
2172 }
2173 
2174 #ifdef __VSX__
2175 static __inline__ vector bool long long __ATTRS_o_ai
2176 vec_cmplt(vector double __a, vector double __b) {
2177  return vec_cmpgt(__b, __a);
2178 }
2179 #endif
2180 
2181 #ifdef __POWER8_VECTOR__
2182 static __inline__ vector bool long long __ATTRS_o_ai
2183 vec_cmplt(vector signed long long __a, vector signed long long __b) {
2184  return vec_cmpgt(__b, __a);
2185 }
2186 
2187 static __inline__ vector bool long long __ATTRS_o_ai
2188 vec_cmplt(vector unsigned long long __a, vector unsigned long long __b) {
2189  return vec_cmpgt(__b, __a);
2190 }
2191 
2192 /* vec_popcnt */
2193 
2194 static __inline__ vector signed char __ATTRS_o_ai
2195 vec_popcnt(vector signed char __a) {
2196  return __builtin_altivec_vpopcntb(__a);
2197 }
2198 static __inline__ vector unsigned char __ATTRS_o_ai
2199 vec_popcnt(vector unsigned char __a) {
2200  return __builtin_altivec_vpopcntb(__a);
2201 }
2202 static __inline__ vector signed short __ATTRS_o_ai
2203 vec_popcnt(vector signed short __a) {
2204  return __builtin_altivec_vpopcnth(__a);
2205 }
2206 static __inline__ vector unsigned short __ATTRS_o_ai
2207 vec_popcnt(vector unsigned short __a) {
2208  return __builtin_altivec_vpopcnth(__a);
2209 }
2210 static __inline__ vector signed int __ATTRS_o_ai
2211 vec_popcnt(vector signed int __a) {
2212  return __builtin_altivec_vpopcntw(__a);
2213 }
2214 static __inline__ vector unsigned int __ATTRS_o_ai
2215 vec_popcnt(vector unsigned int __a) {
2216  return __builtin_altivec_vpopcntw(__a);
2217 }
2218 static __inline__ vector signed long long __ATTRS_o_ai
2219 vec_popcnt(vector signed long long __a) {
2220  return __builtin_altivec_vpopcntd(__a);
2221 }
2222 static __inline__ vector unsigned long long __ATTRS_o_ai
2223 vec_popcnt(vector unsigned long long __a) {
2224  return __builtin_altivec_vpopcntd(__a);
2225 }
2226 
2227 /* vec_cntlz */
2228 
2229 static __inline__ vector signed char __ATTRS_o_ai
2230 vec_cntlz(vector signed char __a) {
2231  return __builtin_altivec_vclzb(__a);
2232 }
2233 static __inline__ vector unsigned char __ATTRS_o_ai
2234 vec_cntlz(vector unsigned char __a) {
2235  return __builtin_altivec_vclzb(__a);
2236 }
2237 static __inline__ vector signed short __ATTRS_o_ai
2238 vec_cntlz(vector signed short __a) {
2239  return __builtin_altivec_vclzh(__a);
2240 }
2241 static __inline__ vector unsigned short __ATTRS_o_ai
2242 vec_cntlz(vector unsigned short __a) {
2243  return __builtin_altivec_vclzh(__a);
2244 }
2245 static __inline__ vector signed int __ATTRS_o_ai
2246 vec_cntlz(vector signed int __a) {
2247  return __builtin_altivec_vclzw(__a);
2248 }
2249 static __inline__ vector unsigned int __ATTRS_o_ai
2250 vec_cntlz(vector unsigned int __a) {
2251  return __builtin_altivec_vclzw(__a);
2252 }
2253 static __inline__ vector signed long long __ATTRS_o_ai
2254 vec_cntlz(vector signed long long __a) {
2255  return __builtin_altivec_vclzd(__a);
2256 }
2257 static __inline__ vector unsigned long long __ATTRS_o_ai
2258 vec_cntlz(vector unsigned long long __a) {
2259  return __builtin_altivec_vclzd(__a);
2260 }
2261 #endif
2262 
2263 #ifdef __POWER9_VECTOR__
2264 
2265 /* vec_cnttz */
2266 
2267 static __inline__ vector signed char __ATTRS_o_ai
2268 vec_cnttz(vector signed char __a) {
2269  return __builtin_altivec_vctzb(__a);
2270 }
2271 static __inline__ vector unsigned char __ATTRS_o_ai
2272 vec_cnttz(vector unsigned char __a) {
2273  return __builtin_altivec_vctzb(__a);
2274 }
2275 static __inline__ vector signed short __ATTRS_o_ai
2276 vec_cnttz(vector signed short __a) {
2277  return __builtin_altivec_vctzh(__a);
2278 }
2279 static __inline__ vector unsigned short __ATTRS_o_ai
2280 vec_cnttz(vector unsigned short __a) {
2281  return __builtin_altivec_vctzh(__a);
2282 }
2283 static __inline__ vector signed int __ATTRS_o_ai
2284 vec_cnttz(vector signed int __a) {
2285  return __builtin_altivec_vctzw(__a);
2286 }
2287 static __inline__ vector unsigned int __ATTRS_o_ai
2288 vec_cnttz(vector unsigned int __a) {
2289  return __builtin_altivec_vctzw(__a);
2290 }
2291 static __inline__ vector signed long long __ATTRS_o_ai
2292 vec_cnttz(vector signed long long __a) {
2293  return __builtin_altivec_vctzd(__a);
2294 }
2295 static __inline__ vector unsigned long long __ATTRS_o_ai
2296 vec_cnttz(vector unsigned long long __a) {
2297  return __builtin_altivec_vctzd(__a);
2298 }
2299 
2300 /* vec_first_match_index */
2301 
2302 static __inline__ unsigned __ATTRS_o_ai
2303 vec_first_match_index(vector signed char __a, vector signed char __b) {
2304  vector unsigned long long __res =
2305 #ifdef __LITTLE_ENDIAN__
2306  vec_cnttz((vector unsigned long long)vec_cmpeq(__a, __b));
2307 #else
2308  vec_cntlz((vector unsigned long long)vec_cmpeq(__a, __b));
2309 #endif
2310  if (__res[0] == 64) {
2311  return (__res[1] + 64) >> 3;
2312  }
2313  return __res[0] >> 3;
2314 }
2315 
2316 static __inline__ unsigned __ATTRS_o_ai
2317 vec_first_match_index(vector unsigned char __a, vector unsigned 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 signed short __a, vector signed short __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) >> 4;
2340  }
2341  return __res[0] >> 4;
2342 }
2343 
2344 static __inline__ unsigned __ATTRS_o_ai
2345 vec_first_match_index(vector unsigned short __a, vector unsigned 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 signed int __a, vector signed int __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) >> 5;
2368  }
2369  return __res[0] >> 5;
2370 }
2371 
2372 static __inline__ unsigned __ATTRS_o_ai
2373 vec_first_match_index(vector unsigned int __a, vector unsigned 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 /* vec_first_match_or_eos_index */
2387 
2388 static __inline__ unsigned __ATTRS_o_ai
2389 vec_first_match_or_eos_index(vector signed char __a, vector signed char __b) {
2390  /* Compare the result of the comparison of two vectors with either and OR the
2391  result. Either the elements are equal or one will equal the comparison
2392  result if either is zero.
2393  */
2394  vector bool char __tmp1 = vec_cmpeq(__a, __b);
2395  vector bool char __tmp2 = __tmp1 |
2396  vec_cmpeq((vector signed char)__tmp1, __a) |
2397  vec_cmpeq((vector signed char)__tmp1, __b);
2398 
2399  vector unsigned long long __res =
2400 #ifdef __LITTLE_ENDIAN__
2401  vec_cnttz((vector unsigned long long)__tmp2);
2402 #else
2403  vec_cntlz((vector unsigned long long)__tmp2);
2404 #endif
2405  if (__res[0] == 64) {
2406  return (__res[1] + 64) >> 3;
2407  }
2408  return __res[0] >> 3;
2409 }
2410 
2411 static __inline__ unsigned __ATTRS_o_ai
2412 vec_first_match_or_eos_index(vector unsigned char __a,
2413  vector unsigned char __b) {
2414  vector bool char __tmp1 = vec_cmpeq(__a, __b);
2415  vector bool char __tmp2 = __tmp1 |
2416  vec_cmpeq((vector unsigned char)__tmp1, __a) |
2417  vec_cmpeq((vector unsigned char)__tmp1, __b);
2418 
2419  vector unsigned long long __res =
2420 #ifdef __LITTLE_ENDIAN__
2421  vec_cnttz((vector unsigned long long)__tmp2);
2422 #else
2423  vec_cntlz((vector unsigned long long)__tmp2);
2424 #endif
2425  if (__res[0] == 64) {
2426  return (__res[1] + 64) >> 3;
2427  }
2428  return __res[0] >> 3;
2429 }
2430 
2431 static __inline__ unsigned __ATTRS_o_ai
2432 vec_first_match_or_eos_index(vector signed short __a, vector signed short __b) {
2433  vector bool short __tmp1 = vec_cmpeq(__a, __b);
2434  vector bool short __tmp2 = __tmp1 |
2435  vec_cmpeq((vector signed short)__tmp1, __a) |
2436  vec_cmpeq((vector signed short)__tmp1, __b);
2437 
2438  vector unsigned long long __res =
2439 #ifdef __LITTLE_ENDIAN__
2440  vec_cnttz((vector unsigned long long)__tmp2);
2441 #else
2442  vec_cntlz((vector unsigned long long)__tmp2);
2443 #endif
2444  if (__res[0] == 64) {
2445  return (__res[1] + 64) >> 4;
2446  }
2447  return __res[0] >> 4;
2448 }
2449 
2450 static __inline__ unsigned __ATTRS_o_ai
2451 vec_first_match_or_eos_index(vector unsigned short __a,
2452  vector unsigned short __b) {
2453  vector bool short __tmp1 = vec_cmpeq(__a, __b);
2454  vector bool short __tmp2 = __tmp1 |
2455  vec_cmpeq((vector unsigned short)__tmp1, __a) |
2456  vec_cmpeq((vector unsigned short)__tmp1, __b);
2457 
2458  vector unsigned long long __res =
2459 #ifdef __LITTLE_ENDIAN__
2460  vec_cnttz((vector unsigned long long)__tmp2);
2461 #else
2462  vec_cntlz((vector unsigned long long)__tmp2);
2463 #endif
2464  if (__res[0] == 64) {
2465  return (__res[1] + 64) >> 4;
2466  }
2467  return __res[0] >> 4;
2468 }
2469 
2470 static __inline__ unsigned __ATTRS_o_ai
2471 vec_first_match_or_eos_index(vector signed int __a, vector signed int __b) {
2472  vector bool int __tmp1 = vec_cmpeq(__a, __b);
2473  vector bool int __tmp2 = __tmp1 | vec_cmpeq((vector signed int)__tmp1, __a) |
2474  vec_cmpeq((vector signed int)__tmp1, __b);
2475 
2476  vector unsigned long long __res =
2477 #ifdef __LITTLE_ENDIAN__
2478  vec_cnttz((vector unsigned long long)__tmp2);
2479 #else
2480  vec_cntlz((vector unsigned long long)__tmp2);
2481 #endif
2482  if (__res[0] == 64) {
2483  return (__res[1] + 64) >> 5;
2484  }
2485  return __res[0] >> 5;
2486 }
2487 
2488 static __inline__ unsigned __ATTRS_o_ai
2489 vec_first_match_or_eos_index(vector unsigned int __a, vector unsigned int __b) {
2490  vector bool int __tmp1 = vec_cmpeq(__a, __b);
2491  vector bool int __tmp2 = __tmp1 |
2492  vec_cmpeq((vector unsigned int)__tmp1, __a) |
2493  vec_cmpeq((vector unsigned int)__tmp1, __b);
2494 
2495  vector unsigned long long __res =
2496 #ifdef __LITTLE_ENDIAN__
2497  vec_cnttz((vector unsigned long long)__tmp2);
2498 #else
2499  vec_cntlz((vector unsigned long long)__tmp2);
2500 #endif
2501  if (__res[0] == 64) {
2502  return (__res[1] + 64) >> 5;
2503  }
2504  return __res[0] >> 5;
2505 }
2506 
2507 /* vec_first_mismatch_index */
2508 
2509 static __inline__ unsigned __ATTRS_o_ai
2510 vec_first_mismatch_index(vector signed char __a, vector signed char __b) {
2511  vector unsigned long long __res =
2512 #ifdef __LITTLE_ENDIAN__
2513  vec_cnttz((vector unsigned long long)vec_cmpne(__a, __b));
2514 #else
2515  vec_cntlz((vector unsigned long long)vec_cmpne(__a, __b));
2516 #endif
2517  if (__res[0] == 64) {
2518  return (__res[1] + 64) >> 3;
2519  }
2520  return __res[0] >> 3;
2521 }
2522 
2523 static __inline__ unsigned __ATTRS_o_ai
2524 vec_first_mismatch_index(vector unsigned char __a, vector unsigned 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 signed short __a, vector signed short __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) >> 4;
2547  }
2548  return __res[0] >> 4;
2549 }
2550 
2551 static __inline__ unsigned __ATTRS_o_ai
2552 vec_first_mismatch_index(vector unsigned short __a, vector unsigned 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 signed int __a, vector signed int __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) >> 5;
2575  }
2576  return __res[0] >> 5;
2577 }
2578 
2579 static __inline__ unsigned __ATTRS_o_ai
2580 vec_first_mismatch_index(vector unsigned int __a, vector unsigned 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 /* vec_first_mismatch_or_eos_index */
2594 
2595 static __inline__ unsigned __ATTRS_o_ai
2596 vec_first_mismatch_or_eos_index(vector signed char __a,
2597  vector signed char __b) {
2598  vector unsigned long long __res =
2599 #ifdef __LITTLE_ENDIAN__
2600  vec_cnttz((vector unsigned long long)vec_cmpnez(__a, __b));
2601 #else
2602  vec_cntlz((vector unsigned long long)vec_cmpnez(__a, __b));
2603 #endif
2604  if (__res[0] == 64) {
2605  return (__res[1] + 64) >> 3;
2606  }
2607  return __res[0] >> 3;
2608 }
2609 
2610 static __inline__ unsigned __ATTRS_o_ai
2611 vec_first_mismatch_or_eos_index(vector unsigned char __a,
2612  vector unsigned char __b) {
2613  vector unsigned long long __res =
2614 #ifdef __LITTLE_ENDIAN__
2615  vec_cnttz((vector unsigned long long)vec_cmpnez(__a, __b));
2616 #else
2617  vec_cntlz((vector unsigned long long)vec_cmpnez(__a, __b));
2618 #endif
2619  if (__res[0] == 64) {
2620  return (__res[1] + 64) >> 3;
2621  }
2622  return __res[0] >> 3;
2623 }
2624 
2625 static __inline__ unsigned __ATTRS_o_ai
2626 vec_first_mismatch_or_eos_index(vector signed short __a,
2627  vector signed short __b) {
2628  vector unsigned long long __res =
2629 #ifdef __LITTLE_ENDIAN__
2630  vec_cnttz((vector unsigned long long)vec_cmpnez(__a, __b));
2631 #else
2632  vec_cntlz((vector unsigned long long)vec_cmpnez(__a, __b));
2633 #endif
2634  if (__res[0] == 64) {
2635  return (__res[1] + 64) >> 4;
2636  }
2637  return __res[0] >> 4;
2638 }
2639 
2640 static __inline__ unsigned __ATTRS_o_ai
2641 vec_first_mismatch_or_eos_index(vector unsigned short __a,
2642  vector unsigned short __b) {
2643  vector unsigned long long __res =
2644 #ifdef __LITTLE_ENDIAN__
2645  vec_cnttz((vector unsigned long long)vec_cmpnez(__a, __b));
2646 #else
2647  vec_cntlz((vector unsigned long long)vec_cmpnez(__a, __b));
2648 #endif
2649  if (__res[0] == 64) {
2650  return (__res[1] + 64) >> 4;
2651  }
2652  return __res[0] >> 4;
2653 }
2654 
2655 static __inline__ unsigned __ATTRS_o_ai
2656 vec_first_mismatch_or_eos_index(vector signed int __a, vector signed int __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) >> 5;
2665  }
2666  return __res[0] >> 5;
2667 }
2668 
2669 static __inline__ unsigned __ATTRS_o_ai
2670 vec_first_mismatch_or_eos_index(vector unsigned int __a,
2671  vector unsigned int __b) {
2672  vector unsigned long long __res =
2673 #ifdef __LITTLE_ENDIAN__
2674  vec_cnttz((vector unsigned long long)vec_cmpnez(__a, __b));
2675 #else
2676  vec_cntlz((vector unsigned long long)vec_cmpnez(__a, __b));
2677 #endif
2678  if (__res[0] == 64) {
2679  return (__res[1] + 64) >> 5;
2680  }
2681  return __res[0] >> 5;
2682 }
2683 
2684 static __inline__ vector double __ATTRS_o_ai
2685 vec_insert_exp(vector double __a, vector unsigned long long __b) {
2686  return __builtin_vsx_xviexpdp((vector unsigned long long)__a,__b);
2687 }
2688 
2689 static __inline__ vector double __ATTRS_o_ai
2690 vec_insert_exp(vector unsigned long long __a, vector unsigned long long __b) {
2691  return __builtin_vsx_xviexpdp(__a,__b);
2692 }
2693 
2694 static __inline__ vector float __ATTRS_o_ai
2695 vec_insert_exp(vector float __a, vector unsigned int __b) {
2696  return __builtin_vsx_xviexpsp((vector unsigned int)__a,__b);
2697 }
2698 
2699 static __inline__ vector float __ATTRS_o_ai
2700 vec_insert_exp(vector unsigned int __a, vector unsigned int __b) {
2701  return __builtin_vsx_xviexpsp(__a,__b);
2702 }
2703 
2704 #if defined(__powerpc64__)
2705 static __inline__ vector signed char __ATTRS_o_ai vec_xl_len(signed char *__a,
2706  size_t __b) {
2707  return (vector signed char)__builtin_vsx_lxvl(__a, (__b << 56));
2708 }
2709 
2710 static __inline__ vector unsigned char __ATTRS_o_ai
2711 vec_xl_len(unsigned char *__a, size_t __b) {
2712  return (vector unsigned char)__builtin_vsx_lxvl(__a, (__b << 56));
2713 }
2714 
2715 static __inline__ vector signed short __ATTRS_o_ai vec_xl_len(signed short *__a,
2716  size_t __b) {
2717  return (vector signed short)__builtin_vsx_lxvl(__a, (__b << 56));
2718 }
2719 
2720 static __inline__ vector unsigned short __ATTRS_o_ai
2721 vec_xl_len(unsigned short *__a, size_t __b) {
2722  return (vector unsigned short)__builtin_vsx_lxvl(__a, (__b << 56));
2723 }
2724 
2725 static __inline__ vector signed int __ATTRS_o_ai vec_xl_len(signed int *__a,
2726  size_t __b) {
2727  return (vector signed int)__builtin_vsx_lxvl(__a, (__b << 56));
2728 }
2729 
2730 static __inline__ vector unsigned int __ATTRS_o_ai vec_xl_len(unsigned int *__a,
2731  size_t __b) {
2732  return (vector unsigned int)__builtin_vsx_lxvl(__a, (__b << 56));
2733 }
2734 
2735 static __inline__ vector float __ATTRS_o_ai vec_xl_len(float *__a, size_t __b) {
2736  return (vector float)__builtin_vsx_lxvl(__a, (__b << 56));
2737 }
2738 
2739 static __inline__ vector signed __int128 __ATTRS_o_ai
2740 vec_xl_len(signed __int128 *__a, size_t __b) {
2741  return (vector signed __int128)__builtin_vsx_lxvl(__a, (__b << 56));
2742 }
2743 
2744 static __inline__ vector unsigned __int128 __ATTRS_o_ai
2745 vec_xl_len(unsigned __int128 *__a, size_t __b) {
2746  return (vector unsigned __int128)__builtin_vsx_lxvl(__a, (__b << 56));
2747 }
2748 
2749 static __inline__ vector signed long long __ATTRS_o_ai
2750 vec_xl_len(signed long long *__a, size_t __b) {
2751  return (vector signed long long)__builtin_vsx_lxvl(__a, (__b << 56));
2752 }
2753 
2754 static __inline__ vector unsigned long long __ATTRS_o_ai
2755 vec_xl_len(unsigned long long *__a, size_t __b) {
2756  return (vector unsigned long long)__builtin_vsx_lxvl(__a, (__b << 56));
2757 }
2758 
2759 static __inline__ vector double __ATTRS_o_ai vec_xl_len(double *__a,
2760  size_t __b) {
2761  return (vector double)__builtin_vsx_lxvl(__a, (__b << 56));
2762 }
2763 
2764 static __inline__ vector double __ATTRS_o_ai vec_xl_len_r(unsigned char *__a,
2765  size_t __b) {
2766  vector unsigned char __res =
2767  (vector unsigned char)__builtin_vsx_lxvll(__a, (__b << 56));
2768 #ifdef __LITTLE_ENDIAN__
2769  vector unsigned char __mask =
2770  (vector unsigned char)__builtin_altivec_lvsr(16 - __b, (int *)NULL);
2771  __res = (vector unsigned char)__builtin_altivec_vperm_4si(
2772  (vector int)__res, (vector int)__res, __mask);
2773 #endif
2774  return __res;
2775 }
2776 
2777 // vec_xst_len
2778 static __inline__ void __ATTRS_o_ai vec_xst_len(vector unsigned char __a,
2779  unsigned char *__b,
2780  size_t __c) {
2781  return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
2782 }
2783 
2784 static __inline__ void __ATTRS_o_ai vec_xst_len(vector signed char __a,
2785  signed char *__b, size_t __c) {
2786  return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
2787 }
2788 
2789 static __inline__ void __ATTRS_o_ai vec_xst_len(vector signed short __a,
2790  signed short *__b, size_t __c) {
2791  return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
2792 }
2793 
2794 static __inline__ void __ATTRS_o_ai vec_xst_len(vector unsigned short __a,
2795  unsigned short *__b,
2796  size_t __c) {
2797  return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
2798 }
2799 
2800 static __inline__ void __ATTRS_o_ai vec_xst_len(vector signed int __a,
2801  signed int *__b, size_t __c) {
2802  return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
2803 }
2804 
2805 static __inline__ void __ATTRS_o_ai vec_xst_len(vector unsigned int __a,
2806  unsigned int *__b, size_t __c) {
2807  return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
2808 }
2809 
2810 static __inline__ void __ATTRS_o_ai vec_xst_len(vector float __a, float *__b,
2811  size_t __c) {
2812  return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
2813 }
2814 
2815 static __inline__ void __ATTRS_o_ai vec_xst_len(vector signed __int128 __a,
2816  signed __int128 *__b,
2817  size_t __c) {
2818  return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
2819 }
2820 
2821 static __inline__ void __ATTRS_o_ai vec_xst_len(vector unsigned __int128 __a,
2822  unsigned __int128 *__b,
2823  size_t __c) {
2824  return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
2825 }
2826 
2827 static __inline__ void __ATTRS_o_ai vec_xst_len(vector signed long long __a,
2828  signed long long *__b,
2829  size_t __c) {
2830  return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
2831 }
2832 
2833 static __inline__ void __ATTRS_o_ai vec_xst_len(vector unsigned long long __a,
2834  unsigned long long *__b,
2835  size_t __c) {
2836  return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
2837 }
2838 
2839 static __inline__ void __ATTRS_o_ai vec_xst_len(vector double __a, double *__b,
2840  size_t __c) {
2841  return __builtin_vsx_stxvl((vector int)__a, __b, (__c << 56));
2842 }
2843 
2844 static __inline__ void __ATTRS_o_ai vec_xst_len_r(vector unsigned char __a,
2845  unsigned char *__b,
2846  size_t __c) {
2847 #ifdef __LITTLE_ENDIAN__
2848  vector unsigned char __mask =
2849  (vector unsigned char)__builtin_altivec_lvsl(16 - __c, (int *)NULL);
2850  vector unsigned char __res =
2851  __builtin_altivec_vperm_4si((vector int)__a, (vector int)__a, __mask);
2852  return __builtin_vsx_stxvll((vector int)__res, __b, (__c << 56));
2853 #else
2854  return __builtin_vsx_stxvll((vector int)__a, __b, (__c << 56));
2855 #endif
2856 }
2857 #endif
2858 #endif
2859 
2860 /* vec_cpsgn */
2861 
2862 #ifdef __VSX__
2863 static __inline__ vector float __ATTRS_o_ai vec_cpsgn(vector float __a,
2864  vector float __b) {
2865  return __builtin_vsx_xvcpsgnsp(__a, __b);
2866 }
2867 
2868 static __inline__ vector double __ATTRS_o_ai vec_cpsgn(vector double __a,
2869  vector double __b) {
2870  return __builtin_vsx_xvcpsgndp(__a, __b);
2871 }
2872 #endif
2873 
2874 /* vec_ctf */
2875 
2876 #ifdef __VSX__
2877 #define vec_ctf(__a, __b) \
2878  _Generic((__a), vector int \
2879  : (vector float)__builtin_altivec_vcfsx((__a), (__b)), \
2880  vector unsigned int \
2881  : (vector float)__builtin_altivec_vcfux((vector int)(__a), (__b)), \
2882  vector unsigned long long \
2883  : (__builtin_convertvector((vector unsigned long long)(__a), \
2884  vector double) * \
2885  (vector double)(vector unsigned long long)((0x3ffULL - (__b)) \
2886  << 52)), \
2887  vector signed long long \
2888  : (__builtin_convertvector((vector signed long long)(__a), \
2889  vector double) * \
2890  (vector double)(vector unsigned long long)((0x3ffULL - (__b)) \
2891  << 52)))
2892 #else
2893 #define vec_ctf(__a, __b) \
2894  _Generic((__a), vector int \
2895  : (vector float)__builtin_altivec_vcfsx((__a), (__b)), \
2896  vector unsigned int \
2897  : (vector float)__builtin_altivec_vcfux((vector int)(__a), (__b)))
2898 #endif
2899 
2900 /* vec_vcfsx */
2901 
2902 #define vec_vcfux __builtin_altivec_vcfux
2903 
2904 /* vec_vcfux */
2905 
2906 #define vec_vcfsx(__a, __b) __builtin_altivec_vcfsx((vector int)(__a), (__b))
2907 
2908 /* vec_cts */
2909 
2910 #ifdef __VSX__
2911 #define vec_cts(__a, __b) \
2912  _Generic((__a), vector float \
2913  : __builtin_altivec_vctsxs((__a), (__b)), vector double \
2914  : __extension__({ \
2915  vector double __ret = \
2916  (__a) * \
2917  (vector double)(vector unsigned long long)((0x3ffULL + (__b)) \
2918  << 52); \
2919  __builtin_convertvector(__ret, vector signed long long); \
2920  }))
2921 #else
2922 #define vec_cts __builtin_altivec_vctsxs
2923 #endif
2924 
2925 /* vec_vctsxs */
2926 
2927 #define vec_vctsxs __builtin_altivec_vctsxs
2928 
2929 /* vec_ctu */
2930 
2931 #ifdef __VSX__
2932 #define vec_ctu(__a, __b) \
2933  _Generic((__a), vector float \
2934  : __builtin_altivec_vctuxs((__a), (__b)), vector double \
2935  : __extension__({ \
2936  vector double __ret = \
2937  (__a) * \
2938  (vector double)(vector unsigned long long)((0x3ffULL + __b) \
2939  << 52); \
2940  __builtin_convertvector(__ret, vector unsigned long long); \
2941  }))
2942 #else
2943 #define vec_ctu __builtin_altivec_vctuxs
2944 #endif
2945 
2946 /* vec_vctuxs */
2947 
2948 #define vec_vctuxs __builtin_altivec_vctuxs
2949 
2950 /* vec_signed */
2951 
2952 static __inline__ vector signed int __ATTRS_o_ai
2953 vec_sld(vector signed int, vector signed int, unsigned const int __c);
2954 
2955 static __inline__ vector signed int __ATTRS_o_ai
2956 vec_signed(vector float __a) {
2957  return __builtin_convertvector(__a, vector signed int);
2958 }
2959 
2960 #ifdef __VSX__
2961 static __inline__ vector signed long long __ATTRS_o_ai
2962 vec_signed(vector double __a) {
2963  return __builtin_convertvector(__a, vector signed long long);
2964 }
2965 
2966 static __inline__ vector signed int __attribute__((__always_inline__))
2967 vec_signed2(vector double __a, vector double __b) {
2968  return (vector signed int) { __a[0], __a[1], __b[0], __b[1] };
2969 }
2970 
2971 static __inline__ vector signed int __ATTRS_o_ai
2972 vec_signede(vector double __a) {
2973 #ifdef __LITTLE_ENDIAN__
2974  vector signed int __ret = __builtin_vsx_xvcvdpsxws(__a);
2975  return vec_sld(__ret, __ret, 12);
2976 #else
2977  return __builtin_vsx_xvcvdpsxws(__a);
2978 #endif
2979 }
2980 
2981 static __inline__ vector signed int __ATTRS_o_ai
2982 vec_signedo(vector double __a) {
2983 #ifdef __LITTLE_ENDIAN__
2984  return __builtin_vsx_xvcvdpsxws(__a);
2985 #else
2986  vector signed int __ret = __builtin_vsx_xvcvdpsxws(__a);
2987  return vec_sld(__ret, __ret, 12);
2988 #endif
2989 }
2990 #endif
2991 
2992 /* vec_unsigned */
2993 
2994 static __inline__ vector unsigned int __ATTRS_o_ai
2995 vec_sld(vector unsigned int, vector unsigned int, unsigned const int __c);
2996 
2997 static __inline__ vector unsigned int __ATTRS_o_ai
2998 vec_unsigned(vector float __a) {
2999  return __builtin_convertvector(__a, vector unsigned int);
3000 }
3001 
3002 #ifdef __VSX__
3003 static __inline__ vector unsigned long long __ATTRS_o_ai
3004 vec_unsigned(vector double __a) {
3005  return __builtin_convertvector(__a, vector unsigned long long);
3006 }
3007 
3008 static __inline__ vector unsigned int __attribute__((__always_inline__))
3009 vec_unsigned2(vector double __a, vector double __b) {
3010  return (vector unsigned int) { __a[0], __a[1], __b[0], __b[1] };
3011 }
3012 
3013 static __inline__ vector unsigned int __ATTRS_o_ai
3014 vec_unsignede(vector double __a) {
3015 #ifdef __LITTLE_ENDIAN__
3016  vector unsigned int __ret = __builtin_vsx_xvcvdpuxws(__a);
3017  return vec_sld(__ret, __ret, 12);
3018 #else
3019  return __builtin_vsx_xvcvdpuxws(__a);
3020 #endif
3021 }
3022 
3023 static __inline__ vector unsigned int __ATTRS_o_ai
3024 vec_unsignedo(vector double __a) {
3025 #ifdef __LITTLE_ENDIAN__
3026  return __builtin_vsx_xvcvdpuxws(__a);
3027 #else
3028  vector unsigned int __ret = __builtin_vsx_xvcvdpuxws(__a);
3029  return vec_sld(__ret, __ret, 12);
3030 #endif
3031 }
3032 #endif
3033 
3034 /* vec_float */
3035 
3036 static __inline__ vector float __ATTRS_o_ai
3037 vec_sld(vector float, vector float, unsigned const int __c);
3038 
3039 static __inline__ vector float __ATTRS_o_ai
3040 vec_float(vector signed int __a) {
3041  return __builtin_convertvector(__a, vector float);
3042 }
3043 
3044 static __inline__ vector float __ATTRS_o_ai
3045 vec_float(vector unsigned int __a) {
3046  return __builtin_convertvector(__a, vector float);
3047 }
3048 
3049 #ifdef __VSX__
3050 static __inline__ vector float __ATTRS_o_ai
3051 vec_float2(vector signed long long __a, vector signed long long __b) {
3052  return (vector float) { __a[0], __a[1], __b[0], __b[1] };
3053 }
3054 
3055 static __inline__ vector float __ATTRS_o_ai
3056 vec_float2(vector unsigned long long __a, vector unsigned long long __b) {
3057  return (vector float) { __a[0], __a[1], __b[0], __b[1] };
3058 }
3059 
3060 static __inline__ vector float __ATTRS_o_ai
3061 vec_float2(vector double __a, vector double __b) {
3062  return (vector float) { __a[0], __a[1], __b[0], __b[1] };
3063 }
3064 
3065 static __inline__ vector float __ATTRS_o_ai
3066 vec_floate(vector signed long long __a) {
3067 #ifdef __LITTLE_ENDIAN__
3068  vector float __ret = __builtin_vsx_xvcvsxdsp(__a);
3069  return vec_sld(__ret, __ret, 12);
3070 #else
3071  return __builtin_vsx_xvcvsxdsp(__a);
3072 #endif
3073 }
3074 
3075 static __inline__ vector float __ATTRS_o_ai
3076 vec_floate(vector unsigned long long __a) {
3077 #ifdef __LITTLE_ENDIAN__
3078  vector float __ret = __builtin_vsx_xvcvuxdsp(__a);
3079  return vec_sld(__ret, __ret, 12);
3080 #else
3081  return __builtin_vsx_xvcvuxdsp(__a);
3082 #endif
3083 }
3084 
3085 static __inline__ vector float __ATTRS_o_ai
3086 vec_floate(vector double __a) {
3087 #ifdef __LITTLE_ENDIAN__
3088  vector float __ret = __builtin_vsx_xvcvdpsp(__a);
3089  return vec_sld(__ret, __ret, 12);
3090 #else
3091  return __builtin_vsx_xvcvdpsp(__a);
3092 #endif
3093 }
3094 
3095 static __inline__ vector float __ATTRS_o_ai
3096 vec_floato(vector signed long long __a) {
3097 #ifdef __LITTLE_ENDIAN__
3098  return __builtin_vsx_xvcvsxdsp(__a);
3099 #else
3100  vector float __ret = __builtin_vsx_xvcvsxdsp(__a);
3101  return vec_sld(__ret, __ret, 12);
3102 #endif
3103 }
3104 
3105 static __inline__ vector float __ATTRS_o_ai
3106 vec_floato(vector unsigned long long __a) {
3107 #ifdef __LITTLE_ENDIAN__
3108  return __builtin_vsx_xvcvuxdsp(__a);
3109 #else
3110  vector float __ret = __builtin_vsx_xvcvuxdsp(__a);
3111  return vec_sld(__ret, __ret, 12);
3112 #endif
3113 }
3114 
3115 static __inline__ vector float __ATTRS_o_ai
3116 vec_floato(vector double __a) {
3117 #ifdef __LITTLE_ENDIAN__
3118  return __builtin_vsx_xvcvdpsp(__a);
3119 #else
3120  vector float __ret = __builtin_vsx_xvcvdpsp(__a);
3121  return vec_sld(__ret, __ret, 12);
3122 #endif
3123 }
3124 #endif
3125 
3126 /* vec_double */
3127 
3128 #ifdef __VSX__
3129 static __inline__ vector double __ATTRS_o_ai
3130 vec_double(vector signed long long __a) {
3131  return __builtin_convertvector(__a, vector double);
3132 }
3133 
3134 static __inline__ vector double __ATTRS_o_ai
3135 vec_double(vector unsigned long long __a) {
3136  return __builtin_convertvector(__a, vector double);
3137 }
3138 
3139 static __inline__ vector double __ATTRS_o_ai
3140 vec_doublee(vector signed int __a) {
3141 #ifdef __LITTLE_ENDIAN__
3142  return __builtin_vsx_xvcvsxwdp(vec_sld(__a, __a, 4));
3143 #else
3144  return __builtin_vsx_xvcvsxwdp(__a);
3145 #endif
3146 }
3147 
3148 static __inline__ vector double __ATTRS_o_ai
3149 vec_doublee(vector unsigned int __a) {
3150 #ifdef __LITTLE_ENDIAN__
3151  return __builtin_vsx_xvcvuxwdp(vec_sld(__a, __a, 4));
3152 #else
3153  return __builtin_vsx_xvcvuxwdp(__a);
3154 #endif
3155 }
3156 
3157 static __inline__ vector double __ATTRS_o_ai
3158 vec_doublee(vector float __a) {
3159 #ifdef __LITTLE_ENDIAN__
3160  return __builtin_vsx_xvcvspdp(vec_sld(__a, __a, 4));
3161 #else
3162  return __builtin_vsx_xvcvspdp(__a);
3163 #endif
3164 }
3165 
3166 static __inline__ vector double __ATTRS_o_ai
3167 vec_doubleh(vector signed int __a) {
3168  vector double __ret = {__a[0], __a[1]};
3169  return __ret;
3170 }
3171 
3172 static __inline__ vector double __ATTRS_o_ai
3173 vec_doubleh(vector unsigned int __a) {
3174  vector double __ret = {__a[0], __a[1]};
3175  return __ret;
3176 }
3177 
3178 static __inline__ vector double __ATTRS_o_ai
3179 vec_doubleh(vector float __a) {
3180  vector double __ret = {__a[0], __a[1]};
3181  return __ret;
3182 }
3183 
3184 static __inline__ vector double __ATTRS_o_ai
3185 vec_doublel(vector signed int __a) {
3186  vector double __ret = {__a[2], __a[3]};
3187  return __ret;
3188 }
3189 
3190 static __inline__ vector double __ATTRS_o_ai
3191 vec_doublel(vector unsigned int __a) {
3192  vector double __ret = {__a[2], __a[3]};
3193  return __ret;
3194 }
3195 
3196 static __inline__ vector double __ATTRS_o_ai
3197 vec_doublel(vector float __a) {
3198  vector double __ret = {__a[2], __a[3]};
3199  return __ret;
3200 }
3201 
3202 static __inline__ vector double __ATTRS_o_ai
3203 vec_doubleo(vector signed int __a) {
3204 #ifdef __LITTLE_ENDIAN__
3205  return __builtin_vsx_xvcvsxwdp(__a);
3206 #else
3207  return __builtin_vsx_xvcvsxwdp(vec_sld(__a, __a, 4));
3208 #endif
3209 }
3210 
3211 static __inline__ vector double __ATTRS_o_ai
3212 vec_doubleo(vector unsigned int __a) {
3213 #ifdef __LITTLE_ENDIAN__
3214  return __builtin_vsx_xvcvuxwdp(__a);
3215 #else
3216  return __builtin_vsx_xvcvuxwdp(vec_sld(__a, __a, 4));
3217 #endif
3218 }
3219 
3220 static __inline__ vector double __ATTRS_o_ai
3221 vec_doubleo(vector float __a) {
3222 #ifdef __LITTLE_ENDIAN__
3223  return __builtin_vsx_xvcvspdp(__a);
3224 #else
3225  return __builtin_vsx_xvcvspdp(vec_sld(__a, __a, 4));
3226 #endif
3227 }
3228 #endif
3229 
3230 /* vec_div */
3231 
3232 /* Integer vector divides (vectors are scalarized, elements divided
3233  and the vectors reassembled).
3234 */
3235 static __inline__ vector signed char __ATTRS_o_ai
3236 vec_div(vector signed char __a, vector signed char __b) {
3237  return __a / __b;
3238 }
3239 
3240 static __inline__ vector unsigned char __ATTRS_o_ai
3241 vec_div(vector unsigned char __a, vector unsigned char __b) {
3242  return __a / __b;
3243 }
3244 
3245 static __inline__ vector signed short __ATTRS_o_ai
3246 vec_div(vector signed short __a, vector signed short __b) {
3247  return __a / __b;
3248 }
3249 
3250 static __inline__ vector unsigned short __ATTRS_o_ai
3251 vec_div(vector unsigned short __a, vector unsigned short __b) {
3252  return __a / __b;
3253 }
3254 
3255 static __inline__ vector signed int __ATTRS_o_ai
3256 vec_div(vector signed int __a, vector signed int __b) {
3257  return __a / __b;
3258 }
3259 
3260 static __inline__ vector unsigned int __ATTRS_o_ai
3261 vec_div(vector unsigned int __a, vector unsigned int __b) {
3262  return __a / __b;
3263 }
3264 
3265 #ifdef __VSX__
3266 static __inline__ vector signed long long __ATTRS_o_ai
3267 vec_div(vector signed long long __a, vector signed long long __b) {
3268  return __a / __b;
3269 }
3270 
3271 static __inline__ vector unsigned long long __ATTRS_o_ai
3272 vec_div(vector unsigned long long __a, vector unsigned long long __b) {
3273  return __a / __b;
3274 }
3275 
3276 static __inline__ vector float __ATTRS_o_ai vec_div(vector float __a,
3277  vector float __b) {
3278  return __a / __b;
3279 }
3280 
3281 static __inline__ vector double __ATTRS_o_ai vec_div(vector double __a,
3282  vector double __b) {
3283  return __a / __b;
3284 }
3285 #endif
3286 
3287 /* vec_dss */
3288 
3289 static __inline__ void __attribute__((__always_inline__)) vec_dss(int __a) {
3290  __builtin_altivec_dss(__a);
3291 }
3292 
3293 /* vec_dssall */
3294 
3295 static __inline__ void __attribute__((__always_inline__)) vec_dssall(void) {
3296  __builtin_altivec_dssall();
3297 }
3298 
3299 /* vec_dst */
3300 #define vec_dst(__PTR, __CW, __STR) \
3301  __extension__( \
3302  { __builtin_altivec_dst((const void *)(__PTR), (__CW), (__STR)); })
3303 
3304 /* vec_dstst */
3305 #define vec_dstst(__PTR, __CW, __STR) \
3306  __extension__( \
3307  { __builtin_altivec_dstst((const void *)(__PTR), (__CW), (__STR)); })
3308 
3309 /* vec_dststt */
3310 #define vec_dststt(__PTR, __CW, __STR) \
3311  __extension__( \
3312  { __builtin_altivec_dststt((const void *)(__PTR), (__CW), (__STR)); })
3313 
3314 /* vec_dstt */
3315 #define vec_dstt(__PTR, __CW, __STR) \
3316  __extension__( \
3317  { __builtin_altivec_dstt((const void *)(__PTR), (__CW), (__STR)); })
3318 
3319 /* vec_eqv */
3320 
3321 #ifdef __POWER8_VECTOR__
3322 static __inline__ vector signed char __ATTRS_o_ai
3323 vec_eqv(vector signed char __a, vector signed char __b) {
3324  return (vector signed char)__builtin_vsx_xxleqv((vector unsigned int)__a,
3325  (vector unsigned int)__b);
3326 }
3327 
3328 static __inline__ vector unsigned char __ATTRS_o_ai
3329 vec_eqv(vector unsigned char __a, vector unsigned char __b) {
3330  return (vector unsigned char)__builtin_vsx_xxleqv((vector unsigned int)__a,
3331  (vector unsigned int)__b);
3332 }
3333 
3334 static __inline__ vector bool char __ATTRS_o_ai vec_eqv(vector bool char __a,
3335  vector bool char __b) {
3336  return (vector bool char)__builtin_vsx_xxleqv((vector unsigned int)__a,
3337  (vector unsigned int)__b);
3338 }
3339 
3340 static __inline__ vector signed short __ATTRS_o_ai
3341 vec_eqv(vector signed short __a, vector signed short __b) {
3342  return (vector signed short)__builtin_vsx_xxleqv((vector unsigned int)__a,
3343  (vector unsigned int)__b);
3344 }
3345 
3346 static __inline__ vector unsigned short __ATTRS_o_ai
3347 vec_eqv(vector unsigned short __a, vector unsigned short __b) {
3348  return (vector unsigned short)__builtin_vsx_xxleqv((vector unsigned int)__a,
3349  (vector unsigned int)__b);
3350 }
3351 
3352 static __inline__ vector bool short __ATTRS_o_ai
3353 vec_eqv(vector bool short __a, vector bool short __b) {
3354  return (vector bool short)__builtin_vsx_xxleqv((vector unsigned int)__a,
3355  (vector unsigned int)__b);
3356 }
3357 
3358 static __inline__ vector signed int __ATTRS_o_ai
3359 vec_eqv(vector signed int __a, vector signed int __b) {
3360  return (vector signed int)__builtin_vsx_xxleqv((vector unsigned int)__a,
3361  (vector unsigned int)__b);
3362 }
3363 
3364 static __inline__ vector unsigned int __ATTRS_o_ai
3365 vec_eqv(vector unsigned int __a, vector unsigned int __b) {
3366  return __builtin_vsx_xxleqv(__a, __b);
3367 }
3368 
3369 static __inline__ vector bool int __ATTRS_o_ai vec_eqv(vector bool int __a,
3370  vector bool int __b) {
3371  return (vector bool int)__builtin_vsx_xxleqv((vector unsigned int)__a,
3372  (vector unsigned int)__b);
3373 }
3374 
3375 static __inline__ vector signed long long __ATTRS_o_ai
3376 vec_eqv(vector signed long long __a, vector signed long long __b) {
3377  return (vector signed long long)__builtin_vsx_xxleqv(
3378  (vector unsigned int)__a, (vector unsigned int)__b);
3379 }
3380 
3381 static __inline__ vector unsigned long long __ATTRS_o_ai
3382 vec_eqv(vector unsigned long long __a, vector unsigned long long __b) {
3383  return (vector unsigned long long)__builtin_vsx_xxleqv(
3384  (vector unsigned int)__a, (vector unsigned int)__b);
3385 }
3386 
3387 static __inline__ vector bool long long __ATTRS_o_ai
3388 vec_eqv(vector bool long long __a, vector bool long long __b) {
3389  return (vector bool long long)__builtin_vsx_xxleqv((vector unsigned int)__a,
3390  (vector unsigned int)__b);
3391 }
3392 
3393 static __inline__ vector float __ATTRS_o_ai vec_eqv(vector float __a,
3394  vector float __b) {
3395  return (vector float)__builtin_vsx_xxleqv((vector unsigned int)__a,
3396  (vector unsigned int)__b);
3397 }
3398 
3399 static __inline__ vector double __ATTRS_o_ai vec_eqv(vector double __a,
3400  vector double __b) {
3401  return (vector double)__builtin_vsx_xxleqv((vector unsigned int)__a,
3402  (vector unsigned int)__b);
3403 }
3404 #endif
3405 
3406 /* vec_expte */
3407 
3408 static __inline__ vector float __attribute__((__always_inline__))
3409 vec_expte(vector float __a) {
3410  return __builtin_altivec_vexptefp(__a);
3411 }
3412 
3413 /* vec_vexptefp */
3414 
3415 static __inline__ vector float __attribute__((__always_inline__))
3416 vec_vexptefp(vector float __a) {
3417  return __builtin_altivec_vexptefp(__a);
3418 }
3419 
3420 /* vec_floor */
3421 
3422 static __inline__ vector float __ATTRS_o_ai vec_floor(vector float __a) {
3423 #ifdef __VSX__
3424  return __builtin_vsx_xvrspim(__a);
3425 #else
3426  return __builtin_altivec_vrfim(__a);
3427 #endif
3428 }
3429 
3430 #ifdef __VSX__
3431 static __inline__ vector double __ATTRS_o_ai vec_floor(vector double __a) {
3432  return __builtin_vsx_xvrdpim(__a);
3433 }
3434 #endif
3435 
3436 /* vec_vrfim */
3437 
3438 static __inline__ vector float __attribute__((__always_inline__))
3439 vec_vrfim(vector float __a) {
3440  return __builtin_altivec_vrfim(__a);
3441 }
3442 
3443 /* vec_ld */
3444 
3445 static __inline__ vector signed char __ATTRS_o_ai
3446 vec_ld(int __a, const vector signed char *__b) {
3447  return (vector signed char)__builtin_altivec_lvx(__a, __b);
3448 }
3449 
3450 static __inline__ vector signed char __ATTRS_o_ai
3451 vec_ld(int __a, const signed char *__b) {
3452  return (vector signed char)__builtin_altivec_lvx(__a, __b);
3453 }
3454 
3455 static __inline__ vector unsigned char __ATTRS_o_ai
3456 vec_ld(int __a, const vector unsigned char *__b) {
3457  return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
3458 }
3459 
3460 static __inline__ vector unsigned char __ATTRS_o_ai
3461 vec_ld(int __a, const unsigned char *__b) {
3462  return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
3463 }
3464 
3465 static __inline__ vector bool char __ATTRS_o_ai
3466 vec_ld(int __a, const vector bool char *__b) {
3467  return (vector bool char)__builtin_altivec_lvx(__a, __b);
3468 }
3469 
3470 static __inline__ vector short __ATTRS_o_ai vec_ld(int __a,
3471  const vector short *__b) {
3472  return (vector short)__builtin_altivec_lvx(__a, __b);
3473 }
3474 
3475 static __inline__ vector short __ATTRS_o_ai vec_ld(int __a, const short *__b) {
3476  return (vector short)__builtin_altivec_lvx(__a, __b);
3477 }
3478 
3479 static __inline__ vector unsigned short __ATTRS_o_ai
3480 vec_ld(int __a, const vector unsigned short *__b) {
3481  return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
3482 }
3483 
3484 static __inline__ vector unsigned short __ATTRS_o_ai
3485 vec_ld(int __a, const unsigned short *__b) {
3486  return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
3487 }
3488 
3489 static __inline__ vector bool short __ATTRS_o_ai
3490 vec_ld(int __a, const vector bool short *__b) {
3491  return (vector bool short)__builtin_altivec_lvx(__a, __b);
3492 }
3493 
3494 static __inline__ vector pixel __ATTRS_o_ai vec_ld(int __a,
3495  const vector pixel *__b) {
3496  return (vector pixel)__builtin_altivec_lvx(__a, __b);
3497 }
3498 
3499 static __inline__ vector int __ATTRS_o_ai vec_ld(int __a,
3500  const vector int *__b) {
3501  return (vector int)__builtin_altivec_lvx(__a, __b);
3502 }
3503 
3504 static __inline__ vector int __ATTRS_o_ai vec_ld(int __a, const int *__b) {
3505  return (vector int)__builtin_altivec_lvx(__a, __b);
3506 }
3507 
3508 static __inline__ vector unsigned int __ATTRS_o_ai
3509 vec_ld(int __a, const vector unsigned int *__b) {
3510  return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
3511 }
3512 
3513 static __inline__ vector unsigned int __ATTRS_o_ai
3514 vec_ld(int __a, const unsigned int *__b) {
3515  return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
3516 }
3517 
3518 static __inline__ vector bool int __ATTRS_o_ai
3519 vec_ld(int __a, const vector bool int *__b) {
3520  return (vector bool int)__builtin_altivec_lvx(__a, __b);
3521 }
3522 
3523 static __inline__ vector float __ATTRS_o_ai vec_ld(int __a,
3524  const vector float *__b) {
3525  return (vector float)__builtin_altivec_lvx(__a, __b);
3526 }
3527 
3528 static __inline__ vector float __ATTRS_o_ai vec_ld(int __a, const float *__b) {
3529  return (vector float)__builtin_altivec_lvx(__a, __b);
3530 }
3531 
3532 /* vec_lvx */
3533 
3534 static __inline__ vector signed char __ATTRS_o_ai
3535 vec_lvx(int __a, const vector signed char *__b) {
3536  return (vector signed char)__builtin_altivec_lvx(__a, __b);
3537 }
3538 
3539 static __inline__ vector signed char __ATTRS_o_ai
3540 vec_lvx(int __a, const signed char *__b) {
3541  return (vector signed char)__builtin_altivec_lvx(__a, __b);
3542 }
3543 
3544 static __inline__ vector unsigned char __ATTRS_o_ai
3545 vec_lvx(int __a, const vector unsigned char *__b) {
3546  return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
3547 }
3548 
3549 static __inline__ vector unsigned char __ATTRS_o_ai
3550 vec_lvx(int __a, const unsigned char *__b) {
3551  return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
3552 }
3553 
3554 static __inline__ vector bool char __ATTRS_o_ai
3555 vec_lvx(int __a, const vector bool char *__b) {
3556  return (vector bool char)__builtin_altivec_lvx(__a, __b);
3557 }
3558 
3559 static __inline__ vector short __ATTRS_o_ai vec_lvx(int __a,
3560  const vector short *__b) {
3561  return (vector short)__builtin_altivec_lvx(__a, __b);
3562 }
3563 
3564 static __inline__ vector short __ATTRS_o_ai vec_lvx(int __a, const short *__b) {
3565  return (vector short)__builtin_altivec_lvx(__a, __b);
3566 }
3567 
3568 static __inline__ vector unsigned short __ATTRS_o_ai
3569 vec_lvx(int __a, const vector unsigned short *__b) {
3570  return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
3571 }
3572 
3573 static __inline__ vector unsigned short __ATTRS_o_ai
3574 vec_lvx(int __a, const unsigned short *__b) {
3575  return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
3576 }
3577 
3578 static __inline__ vector bool short __ATTRS_o_ai
3579 vec_lvx(int __a, const vector bool short *__b) {
3580  return (vector bool short)__builtin_altivec_lvx(__a, __b);
3581 }
3582 
3583 static __inline__ vector pixel __ATTRS_o_ai vec_lvx(int __a,
3584  const vector pixel *__b) {
3585  return (vector pixel)__builtin_altivec_lvx(__a, __b);
3586 }
3587 
3588 static __inline__ vector int __ATTRS_o_ai vec_lvx(int __a,
3589  const vector int *__b) {
3590  return (vector int)__builtin_altivec_lvx(__a, __b);
3591 }
3592 
3593 static __inline__ vector int __ATTRS_o_ai vec_lvx(int __a, const int *__b) {
3594  return (vector int)__builtin_altivec_lvx(__a, __b);
3595 }
3596 
3597 static __inline__ vector unsigned int __ATTRS_o_ai
3598 vec_lvx(int __a, const vector unsigned int *__b) {
3599  return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
3600 }
3601 
3602 static __inline__ vector unsigned int __ATTRS_o_ai
3603 vec_lvx(int __a, const unsigned int *__b) {
3604  return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
3605 }
3606 
3607 static __inline__ vector bool int __ATTRS_o_ai
3608 vec_lvx(int __a, const vector bool int *__b) {
3609  return (vector bool int)__builtin_altivec_lvx(__a, __b);
3610 }
3611 
3612 static __inline__ vector float __ATTRS_o_ai vec_lvx(int __a,
3613  const vector float *__b) {
3614  return (vector float)__builtin_altivec_lvx(__a, __b);
3615 }
3616 
3617 static __inline__ vector float __ATTRS_o_ai vec_lvx(int __a, const float *__b) {
3618  return (vector float)__builtin_altivec_lvx(__a, __b);
3619 }
3620 
3621 /* vec_lde */
3622 
3623 static __inline__ vector signed char __ATTRS_o_ai
3624 vec_lde(int __a, const signed char *__b) {
3625  return (vector signed char)__builtin_altivec_lvebx(__a, __b);
3626 }
3627 
3628 static __inline__ vector unsigned char __ATTRS_o_ai
3629 vec_lde(int __a, const unsigned char *__b) {
3630  return (vector unsigned char)__builtin_altivec_lvebx(__a, __b);
3631 }
3632 
3633 static __inline__ vector short __ATTRS_o_ai vec_lde(int __a, const short *__b) {
3634  return (vector short)__builtin_altivec_lvehx(__a, __b);
3635 }
3636 
3637 static __inline__ vector unsigned short __ATTRS_o_ai
3638 vec_lde(int __a, const unsigned short *__b) {
3639  return (vector unsigned short)__builtin_altivec_lvehx(__a, __b);
3640 }
3641 
3642 static __inline__ vector int __ATTRS_o_ai vec_lde(int __a, const int *__b) {
3643  return (vector int)__builtin_altivec_lvewx(__a, __b);
3644 }
3645 
3646 static __inline__ vector unsigned int __ATTRS_o_ai
3647 vec_lde(int __a, const unsigned int *__b) {
3648  return (vector unsigned int)__builtin_altivec_lvewx(__a, __b);
3649 }
3650 
3651 static __inline__ vector float __ATTRS_o_ai vec_lde(int __a, const float *__b) {
3652  return (vector float)__builtin_altivec_lvewx(__a, __b);
3653 }
3654 
3655 /* vec_lvebx */
3656 
3657 static __inline__ vector signed char __ATTRS_o_ai
3658 vec_lvebx(int __a, const signed char *__b) {
3659  return (vector signed char)__builtin_altivec_lvebx(__a, __b);
3660 }
3661 
3662 static __inline__ vector unsigned char __ATTRS_o_ai
3663 vec_lvebx(int __a, const unsigned char *__b) {
3664  return (vector unsigned char)__builtin_altivec_lvebx(__a, __b);
3665 }
3666 
3667 /* vec_lvehx */
3668 
3669 static __inline__ vector short __ATTRS_o_ai vec_lvehx(int __a,
3670  const short *__b) {
3671  return (vector short)__builtin_altivec_lvehx(__a, __b);
3672 }
3673 
3674 static __inline__ vector unsigned short __ATTRS_o_ai
3675 vec_lvehx(int __a, const unsigned short *__b) {
3676  return (vector unsigned short)__builtin_altivec_lvehx(__a, __b);
3677 }
3678 
3679 /* vec_lvewx */
3680 
3681 static __inline__ vector int __ATTRS_o_ai vec_lvewx(int __a, const int *__b) {
3682  return (vector int)__builtin_altivec_lvewx(__a, __b);
3683 }
3684 
3685 static __inline__ vector unsigned int __ATTRS_o_ai
3686 vec_lvewx(int __a, const unsigned int *__b) {
3687  return (vector unsigned int)__builtin_altivec_lvewx(__a, __b);
3688 }
3689 
3690 static __inline__ vector float __ATTRS_o_ai vec_lvewx(int __a,
3691  const float *__b) {
3692  return (vector float)__builtin_altivec_lvewx(__a, __b);
3693 }
3694 
3695 /* vec_ldl */
3696 
3697 static __inline__ vector signed char __ATTRS_o_ai
3698 vec_ldl(int __a, const vector signed char *__b) {
3699  return (vector signed char)__builtin_altivec_lvxl(__a, __b);
3700 }
3701 
3702 static __inline__ vector signed char __ATTRS_o_ai
3703 vec_ldl(int __a, const signed char *__b) {
3704  return (vector signed char)__builtin_altivec_lvxl(__a, __b);
3705 }
3706 
3707 static __inline__ vector unsigned char __ATTRS_o_ai
3708 vec_ldl(int __a, const vector unsigned char *__b) {
3709  return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
3710 }
3711 
3712 static __inline__ vector unsigned char __ATTRS_o_ai
3713 vec_ldl(int __a, const unsigned char *__b) {
3714  return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
3715 }
3716 
3717 static __inline__ vector bool char __ATTRS_o_ai
3718 vec_ldl(int __a, const vector bool char *__b) {
3719  return (vector bool char)__builtin_altivec_lvxl(__a, __b);
3720 }
3721 
3722 static __inline__ vector short __ATTRS_o_ai vec_ldl(int __a,
3723  const vector short *__b) {
3724  return (vector short)__builtin_altivec_lvxl(__a, __b);
3725 }
3726 
3727 static __inline__ vector short __ATTRS_o_ai vec_ldl(int __a, const short *__b) {
3728  return (vector short)__builtin_altivec_lvxl(__a, __b);
3729 }
3730 
3731 static __inline__ vector unsigned short __ATTRS_o_ai
3732 vec_ldl(int __a, const vector unsigned short *__b) {
3733  return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
3734 }
3735 
3736 static __inline__ vector unsigned short __ATTRS_o_ai
3737 vec_ldl(int __a, const unsigned short *__b) {
3738  return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
3739 }
3740 
3741 static __inline__ vector bool short __ATTRS_o_ai
3742 vec_ldl(int __a, const vector bool short *__b) {
3743  return (vector bool short)__builtin_altivec_lvxl(__a, __b);
3744 }
3745 
3746 static __inline__ vector pixel __ATTRS_o_ai vec_ldl(int __a,
3747  const vector pixel *__b) {
3748  return (vector pixel short)__builtin_altivec_lvxl(__a, __b);
3749 }
3750 
3751 static __inline__ vector int __ATTRS_o_ai vec_ldl(int __a,
3752  const vector int *__b) {
3753  return (vector int)__builtin_altivec_lvxl(__a, __b);
3754 }
3755 
3756 static __inline__ vector int __ATTRS_o_ai vec_ldl(int __a, const int *__b) {
3757  return (vector int)__builtin_altivec_lvxl(__a, __b);
3758 }
3759 
3760 static __inline__ vector unsigned int __ATTRS_o_ai
3761 vec_ldl(int __a, const vector unsigned int *__b) {
3762  return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
3763 }
3764 
3765 static __inline__ vector unsigned int __ATTRS_o_ai
3766 vec_ldl(int __a, const unsigned int *__b) {
3767  return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
3768 }
3769 
3770 static __inline__ vector bool int __ATTRS_o_ai
3771 vec_ldl(int __a, const vector bool int *__b) {
3772  return (vector bool int)__builtin_altivec_lvxl(__a, __b);
3773 }
3774 
3775 static __inline__ vector float __ATTRS_o_ai vec_ldl(int __a,
3776  const vector float *__b) {
3777  return (vector float)__builtin_altivec_lvxl(__a, __b);
3778 }
3779 
3780 static __inline__ vector float __ATTRS_o_ai vec_ldl(int __a, const float *__b) {
3781  return (vector float)__builtin_altivec_lvxl(__a, __b);
3782 }
3783 
3784 /* vec_lvxl */
3785 
3786 static __inline__ vector signed char __ATTRS_o_ai
3787 vec_lvxl(int __a, const vector signed char *__b) {
3788  return (vector signed char)__builtin_altivec_lvxl(__a, __b);
3789 }
3790 
3791 static __inline__ vector signed char __ATTRS_o_ai
3792 vec_lvxl(int __a, const signed char *__b) {
3793  return (vector signed char)__builtin_altivec_lvxl(__a, __b);
3794 }
3795 
3796 static __inline__ vector unsigned char __ATTRS_o_ai
3797 vec_lvxl(int __a, const vector unsigned char *__b) {
3798  return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
3799 }
3800 
3801 static __inline__ vector unsigned char __ATTRS_o_ai
3802 vec_lvxl(int __a, const unsigned char *__b) {
3803  return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
3804 }
3805 
3806 static __inline__ vector bool char __ATTRS_o_ai
3807 vec_lvxl(int __a, const vector bool char *__b) {
3808  return (vector bool char)__builtin_altivec_lvxl(__a, __b);
3809 }
3810 
3811 static __inline__ vector short __ATTRS_o_ai vec_lvxl(int __a,
3812  const vector short *__b) {
3813  return (vector short)__builtin_altivec_lvxl(__a, __b);
3814 }
3815 
3816 static __inline__ vector short __ATTRS_o_ai vec_lvxl(int __a,
3817  const short *__b) {
3818  return (vector short)__builtin_altivec_lvxl(__a, __b);
3819 }
3820 
3821 static __inline__ vector unsigned short __ATTRS_o_ai
3822 vec_lvxl(int __a, const vector unsigned short *__b) {
3823  return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
3824 }
3825 
3826 static __inline__ vector unsigned short __ATTRS_o_ai
3827 vec_lvxl(int __a, const unsigned short *__b) {
3828  return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
3829 }
3830 
3831 static __inline__ vector bool short __ATTRS_o_ai
3832 vec_lvxl(int __a, const vector bool short *__b) {
3833  return (vector bool short)__builtin_altivec_lvxl(__a, __b);
3834 }
3835 
3836 static __inline__ vector pixel __ATTRS_o_ai vec_lvxl(int __a,
3837  const vector pixel *__b) {
3838  return (vector pixel)__builtin_altivec_lvxl(__a, __b);
3839 }
3840 
3841 static __inline__ vector int __ATTRS_o_ai vec_lvxl(int __a,
3842  const vector int *__b) {
3843  return (vector int)__builtin_altivec_lvxl(__a, __b);
3844 }
3845 
3846 static __inline__ vector int __ATTRS_o_ai vec_lvxl(int __a, const int *__b) {
3847  return (vector int)__builtin_altivec_lvxl(__a, __b);
3848 }
3849 
3850 static __inline__ vector unsigned int __ATTRS_o_ai
3851 vec_lvxl(int __a, const vector unsigned int *__b) {
3852  return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
3853 }
3854 
3855 static __inline__ vector unsigned int __ATTRS_o_ai
3856 vec_lvxl(int __a, const unsigned int *__b) {
3857  return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
3858 }
3859 
3860 static __inline__ vector bool int __ATTRS_o_ai
3861 vec_lvxl(int __a, const vector bool int *__b) {
3862  return (vector bool int)__builtin_altivec_lvxl(__a, __b);
3863 }
3864 
3865 static __inline__ vector float __ATTRS_o_ai vec_lvxl(int __a,
3866  const vector float *__b) {
3867  return (vector float)__builtin_altivec_lvxl(__a, __b);
3868 }
3869 
3870 static __inline__ vector float __ATTRS_o_ai vec_lvxl(int __a,
3871  const float *__b) {
3872  return (vector float)__builtin_altivec_lvxl(__a, __b);
3873 }
3874 
3875 /* vec_loge */
3876 
3877 static __inline__ vector float __attribute__((__always_inline__))
3878 vec_loge(vector float __a) {
3879  return __builtin_altivec_vlogefp(__a);
3880 }
3881 
3882 /* vec_vlogefp */
3883 
3884 static __inline__ vector float __attribute__((__always_inline__))
3885 vec_vlogefp(vector float __a) {
3886  return __builtin_altivec_vlogefp(__a);
3887 }
3888 
3889 /* vec_lvsl */
3890 
3891 #ifdef __LITTLE_ENDIAN__
3892 static __inline__ vector unsigned char __ATTRS_o_ai
3893  __attribute__((__deprecated__("use assignment for unaligned little endian \
3894 loads/stores"))) vec_lvsl(int __a, const signed char *__b) {
3895  vector unsigned char mask =
3896  (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
3897  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
3898  7, 6, 5, 4, 3, 2, 1, 0};
3899  return vec_perm(mask, mask, reverse);
3900 }
3901 #else
3902 static __inline__ vector unsigned char __ATTRS_o_ai
3903 vec_lvsl(int __a, const signed char *__b) {
3904  return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
3905 }
3906 #endif
3907 
3908 #ifdef __LITTLE_ENDIAN__
3909 static __inline__ vector unsigned char __ATTRS_o_ai
3910  __attribute__((__deprecated__("use assignment for unaligned little endian \
3911 loads/stores"))) vec_lvsl(int __a, const unsigned char *__b) {
3912  vector unsigned char mask =
3913  (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
3914  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
3915  7, 6, 5, 4, 3, 2, 1, 0};
3916  return vec_perm(mask, mask, reverse);
3917 }
3918 #else
3919 static __inline__ vector unsigned char __ATTRS_o_ai
3920 vec_lvsl(int __a, const unsigned char *__b) {
3921  return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
3922 }
3923 #endif
3924 
3925 #ifdef __LITTLE_ENDIAN__
3926 static __inline__ vector unsigned char __ATTRS_o_ai
3927  __attribute__((__deprecated__("use assignment for unaligned little endian \
3928 loads/stores"))) vec_lvsl(int __a, const short *__b) {
3929  vector unsigned char mask =
3930  (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
3931  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
3932  7, 6, 5, 4, 3, 2, 1, 0};
3933  return vec_perm(mask, mask, reverse);
3934 }
3935 #else
3936 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsl(int __a,
3937  const short *__b) {
3938  return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
3939 }
3940 #endif
3941 
3942 #ifdef __LITTLE_ENDIAN__
3943 static __inline__ vector unsigned char __ATTRS_o_ai
3944  __attribute__((__deprecated__("use assignment for unaligned little endian \
3945 loads/stores"))) vec_lvsl(int __a, const unsigned short *__b) {
3946  vector unsigned char mask =
3947  (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
3948  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
3949  7, 6, 5, 4, 3, 2, 1, 0};
3950  return vec_perm(mask, mask, reverse);
3951 }
3952 #else
3953 static __inline__ vector unsigned char __ATTRS_o_ai
3954 vec_lvsl(int __a, const unsigned short *__b) {
3955  return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
3956 }
3957 #endif
3958 
3959 #ifdef __LITTLE_ENDIAN__
3960 static __inline__ vector unsigned char __ATTRS_o_ai
3961  __attribute__((__deprecated__("use assignment for unaligned little endian \
3962 loads/stores"))) vec_lvsl(int __a, const int *__b) {
3963  vector unsigned char mask =
3964  (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
3965  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
3966  7, 6, 5, 4, 3, 2, 1, 0};
3967  return vec_perm(mask, mask, reverse);
3968 }
3969 #else
3970 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsl(int __a,
3971  const int *__b) {
3972  return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
3973 }
3974 #endif
3975 
3976 #ifdef __LITTLE_ENDIAN__
3977 static __inline__ vector unsigned char __ATTRS_o_ai
3978  __attribute__((__deprecated__("use assignment for unaligned little endian \
3979 loads/stores"))) vec_lvsl(int __a, const unsigned int *__b) {
3980  vector unsigned char mask =
3981  (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
3982  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
3983  7, 6, 5, 4, 3, 2, 1, 0};
3984  return vec_perm(mask, mask, reverse);
3985 }
3986 #else
3987 static __inline__ vector unsigned char __ATTRS_o_ai
3988 vec_lvsl(int __a, const unsigned int *__b) {
3989  return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
3990 }
3991 #endif
3992 
3993 #ifdef __LITTLE_ENDIAN__
3994 static __inline__ vector unsigned char __ATTRS_o_ai
3995  __attribute__((__deprecated__("use assignment for unaligned little endian \
3996 loads/stores"))) vec_lvsl(int __a, const float *__b) {
3997  vector unsigned char mask =
3998  (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
3999  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4000  7, 6, 5, 4, 3, 2, 1, 0};
4001  return vec_perm(mask, mask, reverse);
4002 }
4003 #else
4004 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsl(int __a,
4005  const float *__b) {
4006  return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
4007 }
4008 #endif
4009 
4010 /* vec_lvsr */
4011 
4012 #ifdef __LITTLE_ENDIAN__
4013 static __inline__ vector unsigned char __ATTRS_o_ai
4014  __attribute__((__deprecated__("use assignment for unaligned little endian \
4015 loads/stores"))) vec_lvsr(int __a, const signed char *__b) {
4016  vector unsigned char mask =
4017  (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4018  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4019  7, 6, 5, 4, 3, 2, 1, 0};
4020  return vec_perm(mask, mask, reverse);
4021 }
4022 #else
4023 static __inline__ vector unsigned char __ATTRS_o_ai
4024 vec_lvsr(int __a, const signed char *__b) {
4025  return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4026 }
4027 #endif
4028 
4029 #ifdef __LITTLE_ENDIAN__
4030 static __inline__ vector unsigned char __ATTRS_o_ai
4031  __attribute__((__deprecated__("use assignment for unaligned little endian \
4032 loads/stores"))) vec_lvsr(int __a, const unsigned char *__b) {
4033  vector unsigned char mask =
4034  (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4035  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4036  7, 6, 5, 4, 3, 2, 1, 0};
4037  return vec_perm(mask, mask, reverse);
4038 }
4039 #else
4040 static __inline__ vector unsigned char __ATTRS_o_ai
4041 vec_lvsr(int __a, const unsigned char *__b) {
4042  return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4043 }
4044 #endif
4045 
4046 #ifdef __LITTLE_ENDIAN__
4047 static __inline__ vector unsigned char __ATTRS_o_ai
4048  __attribute__((__deprecated__("use assignment for unaligned little endian \
4049 loads/stores"))) vec_lvsr(int __a, const short *__b) {
4050  vector unsigned char mask =
4051  (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4052  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4053  7, 6, 5, 4, 3, 2, 1, 0};
4054  return vec_perm(mask, mask, reverse);
4055 }
4056 #else
4057 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsr(int __a,
4058  const short *__b) {
4059  return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4060 }
4061 #endif
4062 
4063 #ifdef __LITTLE_ENDIAN__
4064 static __inline__ vector unsigned char __ATTRS_o_ai
4065  __attribute__((__deprecated__("use assignment for unaligned little endian \
4066 loads/stores"))) vec_lvsr(int __a, const unsigned short *__b) {
4067  vector unsigned char mask =
4068  (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4069  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4070  7, 6, 5, 4, 3, 2, 1, 0};
4071  return vec_perm(mask, mask, reverse);
4072 }
4073 #else
4074 static __inline__ vector unsigned char __ATTRS_o_ai
4075 vec_lvsr(int __a, const unsigned short *__b) {
4076  return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4077 }
4078 #endif
4079 
4080 #ifdef __LITTLE_ENDIAN__
4081 static __inline__ vector unsigned char __ATTRS_o_ai
4082  __attribute__((__deprecated__("use assignment for unaligned little endian \
4083 loads/stores"))) vec_lvsr(int __a, const int *__b) {
4084  vector unsigned char mask =
4085  (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4086  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4087  7, 6, 5, 4, 3, 2, 1, 0};
4088  return vec_perm(mask, mask, reverse);
4089 }
4090 #else
4091 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsr(int __a,
4092  const int *__b) {
4093  return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4094 }
4095 #endif
4096 
4097 #ifdef __LITTLE_ENDIAN__
4098 static __inline__ vector unsigned char __ATTRS_o_ai
4099  __attribute__((__deprecated__("use assignment for unaligned little endian \
4100 loads/stores"))) vec_lvsr(int __a, const unsigned int *__b) {
4101  vector unsigned char mask =
4102  (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4103  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4104  7, 6, 5, 4, 3, 2, 1, 0};
4105  return vec_perm(mask, mask, reverse);
4106 }
4107 #else
4108 static __inline__ vector unsigned char __ATTRS_o_ai
4109 vec_lvsr(int __a, const unsigned int *__b) {
4110  return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4111 }
4112 #endif
4113 
4114 #ifdef __LITTLE_ENDIAN__
4115 static __inline__ vector unsigned char __ATTRS_o_ai
4116  __attribute__((__deprecated__("use assignment for unaligned little endian \
4117 loads/stores"))) vec_lvsr(int __a, const float *__b) {
4118  vector unsigned char mask =
4119  (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4120  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
4121  7, 6, 5, 4, 3, 2, 1, 0};
4122  return vec_perm(mask, mask, reverse);
4123 }
4124 #else
4125 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsr(int __a,
4126  const float *__b) {
4127  return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
4128 }
4129 #endif
4130 
4131 /* vec_madd */
4132 static __inline__ vector signed short __ATTRS_o_ai
4133 vec_mladd(vector signed short, vector signed short, vector signed short);
4134 static __inline__ vector signed short __ATTRS_o_ai
4135 vec_mladd(vector signed short, vector unsigned short, vector unsigned short);
4136 static __inline__ vector signed short __ATTRS_o_ai
4137 vec_mladd(vector unsigned short, vector signed short, vector signed short);
4138 static __inline__ vector unsigned short __ATTRS_o_ai
4139 vec_mladd(vector unsigned short, vector unsigned short, vector unsigned short);
4140 
4141 static __inline__ vector signed short __ATTRS_o_ai vec_madd(
4142  vector signed short __a, vector signed short __b, vector signed short __c) {
4143  return vec_mladd(__a, __b, __c);
4144 }
4145 
4146 static __inline__ vector signed short __ATTRS_o_ai
4147 vec_madd(vector signed short __a, vector unsigned short __b,
4148  vector unsigned short __c) {
4149  return vec_mladd(__a, __b, __c);
4150 }
4151 
4152 static __inline__ vector signed short __ATTRS_o_ai
4153 vec_madd(vector unsigned short __a, vector signed short __b,
4154  vector signed short __c) {
4155  return vec_mladd(__a, __b, __c);
4156 }
4157 
4158 static __inline__ vector unsigned short __ATTRS_o_ai
4159 vec_madd(vector unsigned short __a, vector unsigned short __b,
4160  vector unsigned short __c) {
4161  return vec_mladd(__a, __b, __c);
4162 }
4163 
4164 static __inline__ vector float __ATTRS_o_ai vec_madd(vector float __a,
4165  vector float __b,
4166  vector float __c) {
4167 #ifdef __VSX__
4168  return __builtin_vsx_xvmaddasp(__a, __b, __c);
4169 #else
4170  return __builtin_altivec_vmaddfp(__a, __b, __c);
4171 #endif
4172 }
4173 
4174 #ifdef __VSX__
4175 static __inline__ vector double __ATTRS_o_ai vec_madd(vector double __a,
4176  vector double __b,
4177  vector double __c) {
4178  return __builtin_vsx_xvmaddadp(__a, __b, __c);
4179 }
4180 #endif
4181 
4182 /* vec_vmaddfp */
4183 
4184 static __inline__ vector float __attribute__((__always_inline__))
4185 vec_vmaddfp(vector float __a, vector float __b, vector float __c) {
4186  return __builtin_altivec_vmaddfp(__a, __b, __c);
4187 }
4188 
4189 /* vec_madds */
4190 
4191 static __inline__ vector signed short __attribute__((__always_inline__))
4192 vec_madds(vector signed short __a, vector signed short __b,
4193  vector signed short __c) {
4194  return __builtin_altivec_vmhaddshs(__a, __b, __c);
4195 }
4196 
4197 /* vec_vmhaddshs */
4198 static __inline__ vector signed short __attribute__((__always_inline__))
4199 vec_vmhaddshs(vector signed short __a, vector signed short __b,
4200  vector signed short __c) {
4201  return __builtin_altivec_vmhaddshs(__a, __b, __c);
4202 }
4203 
4204 /* vec_msub */
4205 
4206 #ifdef __VSX__
4207 static __inline__ vector float __ATTRS_o_ai vec_msub(vector float __a,
4208  vector float __b,
4209  vector float __c) {
4210  return __builtin_vsx_xvmsubasp(__a, __b, __c);
4211 }
4212 
4213 static __inline__ vector double __ATTRS_o_ai vec_msub(vector double __a,
4214  vector double __b,
4215  vector double __c) {
4216  return __builtin_vsx_xvmsubadp(__a, __b, __c);
4217 }
4218 #endif
4219 
4220 /* vec_max */
4221 
4222 static __inline__ vector signed char __ATTRS_o_ai
4223 vec_max(vector signed char __a, vector signed char __b) {
4224  return __builtin_altivec_vmaxsb(__a, __b);
4225 }
4226 
4227 static __inline__ vector signed char __ATTRS_o_ai
4228 vec_max(vector bool char __a, vector signed char __b) {
4229  return __builtin_altivec_vmaxsb((vector signed char)__a, __b);
4230 }
4231 
4232 static __inline__ vector signed char __ATTRS_o_ai
4233 vec_max(vector signed char __a, vector bool char __b) {
4234  return __builtin_altivec_vmaxsb(__a, (vector signed char)__b);
4235 }
4236 
4237 static __inline__ vector unsigned char __ATTRS_o_ai
4238 vec_max(vector unsigned char __a, vector unsigned char __b) {
4239  return __builtin_altivec_vmaxub(__a, __b);
4240 }
4241 
4242 static __inline__ vector unsigned char __ATTRS_o_ai
4243 vec_max(vector bool char __a, vector unsigned char __b) {
4244  return __builtin_altivec_vmaxub((vector unsigned char)__a, __b);
4245 }
4246 
4247 static __inline__ vector unsigned char __ATTRS_o_ai
4248 vec_max(vector unsigned char __a, vector bool char __b) {
4249  return __builtin_altivec_vmaxub(__a, (vector unsigned char)__b);
4250 }
4251 
4252 static __inline__ vector short __ATTRS_o_ai vec_max(vector short __a,
4253  vector short __b) {
4254  return __builtin_altivec_vmaxsh(__a, __b);
4255 }
4256 
4257 static __inline__ vector short __ATTRS_o_ai vec_max(vector bool short __a,
4258  vector short __b) {
4259  return __builtin_altivec_vmaxsh((vector short)__a, __b);
4260 }
4261 
4262 static __inline__ vector short __ATTRS_o_ai vec_max(vector short __a,
4263  vector bool short __b) {
4264  return __builtin_altivec_vmaxsh(__a, (vector short)__b);
4265 }
4266 
4267 static __inline__ vector unsigned short __ATTRS_o_ai
4268 vec_max(vector unsigned short __a, vector unsigned short __b) {
4269  return __builtin_altivec_vmaxuh(__a, __b);
4270 }
4271 
4272 static __inline__ vector unsigned short __ATTRS_o_ai
4273 vec_max(vector bool short __a, vector unsigned short __b) {
4274  return __builtin_altivec_vmaxuh((vector unsigned short)__a, __b);
4275 }
4276 
4277 static __inline__ vector unsigned short __ATTRS_o_ai
4278 vec_max(vector unsigned short __a, vector bool short __b) {
4279  return __builtin_altivec_vmaxuh(__a, (vector unsigned short)__b);
4280 }
4281 
4282 static __inline__ vector int __ATTRS_o_ai vec_max(vector int __a,
4283  vector int __b) {
4284  return __builtin_altivec_vmaxsw(__a, __b);
4285 }
4286 
4287 static __inline__ vector int __ATTRS_o_ai vec_max(vector bool int __a,
4288  vector int __b) {
4289  return __builtin_altivec_vmaxsw((vector int)__a, __b);
4290 }
4291 
4292 static __inline__ vector int __ATTRS_o_ai vec_max(vector int __a,
4293  vector bool int __b) {
4294  return __builtin_altivec_vmaxsw(__a, (vector int)__b);
4295 }
4296 
4297 static __inline__ vector unsigned int __ATTRS_o_ai
4298 vec_max(vector unsigned int __a, vector unsigned int __b) {
4299  return __builtin_altivec_vmaxuw(__a, __b);
4300 }
4301 
4302 static __inline__ vector unsigned int __ATTRS_o_ai
4303 vec_max(vector bool int __a, vector unsigned int __b) {
4304  return __builtin_altivec_vmaxuw((vector unsigned int)__a, __b);
4305 }
4306 
4307 static __inline__ vector unsigned int __ATTRS_o_ai
4308 vec_max(vector unsigned int __a, vector bool int __b) {
4309  return __builtin_altivec_vmaxuw(__a, (vector unsigned int)__b);
4310 }
4311 
4312 #ifdef __POWER8_VECTOR__
4313 static __inline__ vector signed long long __ATTRS_o_ai
4314 vec_max(vector signed long long __a, vector signed long long __b) {
4315  return __builtin_altivec_vmaxsd(__a, __b);
4316 }
4317 
4318 static __inline__ vector signed long long __ATTRS_o_ai
4319 vec_max(vector bool long long __a, vector signed long long __b) {
4320  return __builtin_altivec_vmaxsd((vector signed long long)__a, __b);
4321 }
4322 
4323 static __inline__ vector signed long long __ATTRS_o_ai
4324 vec_max(vector signed long long __a, vector bool long long __b) {
4325  return __builtin_altivec_vmaxsd(__a, (vector signed long long)__b);
4326 }
4327 
4328 static __inline__ vector unsigned long long __ATTRS_o_ai
4329 vec_max(vector unsigned long long __a, vector unsigned long long __b) {
4330  return __builtin_altivec_vmaxud(__a, __b);
4331 }
4332 
4333 static __inline__ vector unsigned long long __ATTRS_o_ai
4334 vec_max(vector bool long long __a, vector unsigned long long __b) {
4335  return __builtin_altivec_vmaxud((vector unsigned long long)__a, __b);
4336 }
4337 
4338 static __inline__ vector unsigned long long __ATTRS_o_ai
4339 vec_max(vector unsigned long long __a, vector bool long long __b) {
4340  return __builtin_altivec_vmaxud(__a, (vector unsigned long long)__b);
4341 }
4342 #endif
4343 
4344 static __inline__ vector float __ATTRS_o_ai vec_max(vector float __a,
4345  vector float __b) {
4346 #ifdef __VSX__
4347  return __builtin_vsx_xvmaxsp(__a, __b);
4348 #else
4349  return __builtin_altivec_vmaxfp(__a, __b);
4350 #endif
4351 }
4352 
4353 #ifdef __VSX__
4354 static __inline__ vector double __ATTRS_o_ai vec_max(vector double __a,
4355  vector double __b) {
4356  return __builtin_vsx_xvmaxdp(__a, __b);
4357 }
4358 #endif
4359 
4360 /* vec_vmaxsb */
4361 
4362 static __inline__ vector signed char __ATTRS_o_ai
4363 vec_vmaxsb(vector signed char __a, vector signed char __b) {
4364  return __builtin_altivec_vmaxsb(__a, __b);
4365 }
4366 
4367 static __inline__ vector signed char __ATTRS_o_ai
4368 vec_vmaxsb(vector bool char __a, vector signed char __b) {
4369  return __builtin_altivec_vmaxsb((vector signed char)__a, __b);
4370 }
4371 
4372 static __inline__ vector signed char __ATTRS_o_ai
4373 vec_vmaxsb(vector signed char __a, vector bool char __b) {
4374  return __builtin_altivec_vmaxsb(__a, (vector signed char)__b);
4375 }
4376 
4377 /* vec_vmaxub */
4378 
4379 static __inline__ vector unsigned char __ATTRS_o_ai
4380 vec_vmaxub(vector unsigned char __a, vector unsigned char __b) {
4381  return __builtin_altivec_vmaxub(__a, __b);
4382 }
4383 
4384 static __inline__ vector unsigned char __ATTRS_o_ai
4385 vec_vmaxub(vector bool char __a, vector unsigned char __b) {
4386  return __builtin_altivec_vmaxub((vector unsigned char)__a, __b);
4387 }
4388 
4389 static __inline__ vector unsigned char __ATTRS_o_ai
4390 vec_vmaxub(vector unsigned char __a, vector bool char __b) {
4391  return __builtin_altivec_vmaxub(__a, (vector unsigned char)__b);
4392 }
4393 
4394 /* vec_vmaxsh */
4395 
4396 static __inline__ vector short __ATTRS_o_ai vec_vmaxsh(vector short __a,
4397  vector short __b) {
4398  return __builtin_altivec_vmaxsh(__a, __b);
4399 }
4400 
4401 static __inline__ vector short __ATTRS_o_ai vec_vmaxsh(vector bool short __a,
4402  vector short __b) {
4403  return __builtin_altivec_vmaxsh((vector short)__a, __b);
4404 }
4405 
4406 static __inline__ vector short __ATTRS_o_ai vec_vmaxsh(vector short __a,
4407  vector bool short __b) {
4408  return __builtin_altivec_vmaxsh(__a, (vector short)__b);
4409 }
4410 
4411 /* vec_vmaxuh */
4412 
4413 static __inline__ vector unsigned short __ATTRS_o_ai
4414 vec_vmaxuh(vector unsigned short __a, vector unsigned short __b) {
4415  return __builtin_altivec_vmaxuh(__a, __b);
4416 }
4417 
4418 static __inline__ vector unsigned short __ATTRS_o_ai
4419 vec_vmaxuh(vector bool short __a, vector unsigned short __b) {
4420  return __builtin_altivec_vmaxuh((vector unsigned short)__a, __b);
4421 }
4422 
4423 static __inline__ vector unsigned short __ATTRS_o_ai
4424 vec_vmaxuh(vector unsigned short __a, vector bool short __b) {
4425  return __builtin_altivec_vmaxuh(__a, (vector unsigned short)__b);
4426 }
4427 
4428 /* vec_vmaxsw */
4429 
4430 static __inline__ vector int __ATTRS_o_ai vec_vmaxsw(vector int __a,
4431  vector int __b) {
4432  return __builtin_altivec_vmaxsw(__a, __b);
4433 }
4434 
4435 static __inline__ vector int __ATTRS_o_ai vec_vmaxsw(vector bool int __a,
4436  vector int __b) {
4437  return __builtin_altivec_vmaxsw((vector int)__a, __b);
4438 }
4439 
4440 static __inline__ vector int __ATTRS_o_ai vec_vmaxsw(vector int __a,
4441  vector bool int __b) {
4442  return __builtin_altivec_vmaxsw(__a, (vector int)__b);
4443 }
4444 
4445 /* vec_vmaxuw */
4446 
4447 static __inline__ vector unsigned int __ATTRS_o_ai
4448 vec_vmaxuw(vector unsigned int __a, vector unsigned int __b) {
4449  return __builtin_altivec_vmaxuw(__a, __b);
4450 }
4451 
4452 static __inline__ vector unsigned int __ATTRS_o_ai
4453 vec_vmaxuw(vector bool int __a, vector unsigned int __b) {
4454  return __builtin_altivec_vmaxuw((vector unsigned int)__a, __b);
4455 }
4456 
4457 static __inline__ vector unsigned int __ATTRS_o_ai
4458 vec_vmaxuw(vector unsigned int __a, vector bool int __b) {
4459  return __builtin_altivec_vmaxuw(__a, (vector unsigned int)__b);
4460 }
4461 
4462 /* vec_vmaxfp */
4463 
4464 static __inline__ vector float __attribute__((__always_inline__))
4465 vec_vmaxfp(vector float __a, vector float __b) {
4466 #ifdef __VSX__
4467  return __builtin_vsx_xvmaxsp(__a, __b);
4468 #else
4469  return __builtin_altivec_vmaxfp(__a, __b);
4470 #endif
4471 }
4472 
4473 /* vec_mergeh */
4474 
4475 static __inline__ vector signed char __ATTRS_o_ai
4476 vec_mergeh(vector signed char __a, vector signed char __b) {
4477  return vec_perm(__a, __b,
4478  (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
4479  0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
4480  0x06, 0x16, 0x07, 0x17));
4481 }
4482 
4483 static __inline__ vector unsigned char __ATTRS_o_ai
4484 vec_mergeh(vector unsigned char __a, vector unsigned char __b) {
4485  return vec_perm(__a, __b,
4486  (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
4487  0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
4488  0x06, 0x16, 0x07, 0x17));
4489 }
4490 
4491 static __inline__ vector bool char __ATTRS_o_ai
4492 vec_mergeh(vector bool char __a, vector bool char __b) {
4493  return vec_perm(__a, __b,
4494  (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
4495  0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
4496  0x06, 0x16, 0x07, 0x17));
4497 }
4498 
4499 static __inline__ vector short __ATTRS_o_ai vec_mergeh(vector short __a,
4500  vector short __b) {
4501  return vec_perm(__a, __b,
4502  (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
4503  0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
4504  0x06, 0x07, 0x16, 0x17));
4505 }
4506 
4507 static __inline__ vector unsigned short __ATTRS_o_ai
4508 vec_mergeh(vector unsigned short __a, vector unsigned short __b) {
4509  return vec_perm(__a, __b,
4510  (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
4511  0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
4512  0x06, 0x07, 0x16, 0x17));
4513 }
4514 
4515 static __inline__ vector bool short __ATTRS_o_ai
4516 vec_mergeh(vector bool short __a, vector bool short __b) {
4517  return vec_perm(__a, __b,
4518  (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
4519  0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
4520  0x06, 0x07, 0x16, 0x17));
4521 }
4522 
4523 static __inline__ vector pixel __ATTRS_o_ai vec_mergeh(vector pixel __a,
4524  vector pixel __b) {
4525  return vec_perm(__a, __b,
4526  (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
4527  0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
4528  0x06, 0x07, 0x16, 0x17));
4529 }
4530 
4531 static __inline__ vector int __ATTRS_o_ai vec_mergeh(vector int __a,
4532  vector int __b) {
4533  return vec_perm(__a, __b,
4534  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
4535  0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
4536  0x14, 0x15, 0x16, 0x17));
4537 }
4538 
4539 static __inline__ vector unsigned int __ATTRS_o_ai
4540 vec_mergeh(vector unsigned int __a, vector unsigned int __b) {
4541  return vec_perm(__a, __b,
4542  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
4543  0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
4544  0x14, 0x15, 0x16, 0x17));
4545 }
4546 
4547 static __inline__ vector bool int __ATTRS_o_ai vec_mergeh(vector bool int __a,
4548  vector bool int __b) {
4549  return vec_perm(__a, __b,
4550  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
4551  0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
4552  0x14, 0x15, 0x16, 0x17));
4553 }
4554 
4555 static __inline__ vector float __ATTRS_o_ai vec_mergeh(vector float __a,
4556  vector float __b) {
4557  return vec_perm(__a, __b,
4558  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
4559  0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
4560  0x14, 0x15, 0x16, 0x17));
4561 }
4562 
4563 #ifdef __VSX__
4564 static __inline__ vector signed long long __ATTRS_o_ai
4565 vec_mergeh(vector signed long long __a, vector signed long long __b) {
4566  return vec_perm(__a, __b,
4567  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
4568  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
4569  0x14, 0x15, 0x16, 0x17));
4570 }
4571 
4572 static __inline__ vector signed long long __ATTRS_o_ai
4573 vec_mergeh(vector signed long long __a, vector bool long long __b) {
4574  return vec_perm(__a, (vector signed long long)__b,
4575  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
4576  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
4577  0x14, 0x15, 0x16, 0x17));
4578 }
4579 
4580 static __inline__ vector signed long long __ATTRS_o_ai
4581 vec_mergeh(vector bool long long __a, vector signed long long __b) {
4582  return vec_perm((vector signed long long)__a, __b,
4583  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
4584  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
4585  0x14, 0x15, 0x16, 0x17));
4586 }
4587 
4588 static __inline__ vector unsigned long long __ATTRS_o_ai
4589 vec_mergeh(vector unsigned long long __a, vector unsigned long long __b) {
4590  return vec_perm(__a, __b,
4591  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
4592  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
4593  0x14, 0x15, 0x16, 0x17));
4594 }
4595 
4596 static __inline__ vector unsigned long long __ATTRS_o_ai
4597 vec_mergeh(vector unsigned long long __a, vector bool long long __b) {
4598  return vec_perm(__a, (vector unsigned long long)__b,
4599  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
4600  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
4601  0x14, 0x15, 0x16, 0x17));
4602 }
4603 
4604 static __inline__ vector unsigned long long __ATTRS_o_ai
4605 vec_mergeh(vector bool long long __a, vector unsigned long long __b) {
4606  return vec_perm((vector unsigned long long)__a, __b,
4607  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
4608  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
4609  0x14, 0x15, 0x16, 0x17));
4610 }
4611 
4612 static __inline__ vector bool long long __ATTRS_o_ai
4613 vec_mergeh(vector bool long long __a, vector bool long long __b) {
4614  return vec_perm(__a, __b,
4615  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
4616  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
4617  0x14, 0x15, 0x16, 0x17));
4618 }
4619 
4620 static __inline__ vector double __ATTRS_o_ai vec_mergeh(vector double __a,
4621  vector double __b) {
4622  return vec_perm(__a, __b,
4623  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
4624  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
4625  0x14, 0x15, 0x16, 0x17));
4626 }
4627 static __inline__ vector double __ATTRS_o_ai
4628 vec_mergeh(vector double __a, vector bool long long __b) {
4629  return vec_perm(__a, (vector double)__b,
4630  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
4631  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
4632  0x14, 0x15, 0x16, 0x17));
4633 }
4634 static __inline__ vector double __ATTRS_o_ai
4635 vec_mergeh(vector bool long long __a, vector double __b) {
4636  return vec_perm((vector double)__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 #endif
4642 
4643 /* vec_vmrghb */
4644 
4645 #define __builtin_altivec_vmrghb vec_vmrghb
4646 
4647 static __inline__ vector signed char __ATTRS_o_ai
4648 vec_vmrghb(vector signed char __a, vector signed char __b) {
4649  return vec_perm(__a, __b,
4650  (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
4651  0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
4652  0x06, 0x16, 0x07, 0x17));
4653 }
4654 
4655 static __inline__ vector unsigned char __ATTRS_o_ai
4656 vec_vmrghb(vector unsigned char __a, vector unsigned char __b) {
4657  return vec_perm(__a, __b,
4658  (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
4659  0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
4660  0x06, 0x16, 0x07, 0x17));
4661 }
4662 
4663 static __inline__ vector bool char __ATTRS_o_ai
4664 vec_vmrghb(vector bool char __a, vector bool char __b) {
4665  return vec_perm(__a, __b,
4666  (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
4667  0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
4668  0x06, 0x16, 0x07, 0x17));
4669 }
4670 
4671 /* vec_vmrghh */
4672 
4673 #define __builtin_altivec_vmrghh vec_vmrghh
4674 
4675 static __inline__ vector short __ATTRS_o_ai vec_vmrghh(vector short __a,
4676  vector short __b) {
4677  return vec_perm(__a, __b,
4678  (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
4679  0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
4680  0x06, 0x07, 0x16, 0x17));
4681 }
4682 
4683 static __inline__ vector unsigned short __ATTRS_o_ai
4684 vec_vmrghh(vector unsigned short __a, vector unsigned short __b) {
4685  return vec_perm(__a, __b,
4686  (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
4687  0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
4688  0x06, 0x07, 0x16, 0x17));
4689 }
4690 
4691 static __inline__ vector bool short __ATTRS_o_ai
4692 vec_vmrghh(vector bool short __a, vector bool short __b) {
4693  return vec_perm(__a, __b,
4694  (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
4695  0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
4696  0x06, 0x07, 0x16, 0x17));
4697 }
4698 
4699 static __inline__ vector pixel __ATTRS_o_ai vec_vmrghh(vector pixel __a,
4700  vector pixel __b) {
4701  return vec_perm(__a, __b,
4702  (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
4703  0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
4704  0x06, 0x07, 0x16, 0x17));
4705 }
4706 
4707 /* vec_vmrghw */
4708 
4709 #define __builtin_altivec_vmrghw vec_vmrghw
4710 
4711 static __inline__ vector int __ATTRS_o_ai vec_vmrghw(vector int __a,
4712  vector int __b) {
4713  return vec_perm(__a, __b,
4714  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
4715  0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
4716  0x14, 0x15, 0x16, 0x17));
4717 }
4718 
4719 static __inline__ vector unsigned int __ATTRS_o_ai
4720 vec_vmrghw(vector unsigned int __a, vector unsigned int __b) {
4721  return vec_perm(__a, __b,
4722  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
4723  0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
4724  0x14, 0x15, 0x16, 0x17));
4725 }
4726 
4727 static __inline__ vector bool int __ATTRS_o_ai vec_vmrghw(vector bool int __a,
4728  vector bool int __b) {
4729  return vec_perm(__a, __b,
4730  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
4731  0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
4732  0x14, 0x15, 0x16, 0x17));
4733 }
4734 
4735 static __inline__ vector float __ATTRS_o_ai vec_vmrghw(vector float __a,
4736  vector float __b) {
4737  return vec_perm(__a, __b,
4738  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
4739  0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
4740  0x14, 0x15, 0x16, 0x17));
4741 }
4742 
4743 /* vec_mergel */
4744 
4745 static __inline__ vector signed char __ATTRS_o_ai
4746 vec_mergel(vector signed char __a, vector signed char __b) {
4747  return vec_perm(__a, __b,
4748  (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
4749  0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
4750  0x0E, 0x1E, 0x0F, 0x1F));
4751 }
4752 
4753 static __inline__ vector unsigned char __ATTRS_o_ai
4754 vec_mergel(vector unsigned char __a, vector unsigned char __b) {
4755  return vec_perm(__a, __b,
4756  (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
4757  0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
4758  0x0E, 0x1E, 0x0F, 0x1F));
4759 }
4760 
4761 static __inline__ vector bool char __ATTRS_o_ai
4762 vec_mergel(vector bool char __a, vector bool char __b) {
4763  return vec_perm(__a, __b,
4764  (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
4765  0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
4766  0x0E, 0x1E, 0x0F, 0x1F));
4767 }
4768 
4769 static __inline__ vector short __ATTRS_o_ai vec_mergel(vector short __a,
4770  vector short __b) {
4771  return vec_perm(__a, __b,
4772  (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
4773  0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
4774  0x0E, 0x0F, 0x1E, 0x1F));
4775 }
4776 
4777 static __inline__ vector unsigned short __ATTRS_o_ai
4778 vec_mergel(vector unsigned short __a, vector unsigned short __b) {
4779  return vec_perm(__a, __b,
4780  (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
4781  0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
4782  0x0E, 0x0F, 0x1E, 0x1F));
4783 }
4784 
4785 static __inline__ vector bool short __ATTRS_o_ai
4786 vec_mergel(vector bool short __a, vector bool short __b) {
4787  return vec_perm(__a, __b,
4788  (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
4789  0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
4790  0x0E, 0x0F, 0x1E, 0x1F));
4791 }
4792 
4793 static __inline__ vector pixel __ATTRS_o_ai vec_mergel(vector pixel __a,
4794  vector pixel __b) {
4795  return vec_perm(__a, __b,
4796  (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
4797  0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
4798  0x0E, 0x0F, 0x1E, 0x1F));
4799 }
4800 
4801 static __inline__ vector int __ATTRS_o_ai vec_mergel(vector int __a,
4802  vector int __b) {
4803  return vec_perm(__a, __b,
4804  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
4805  0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
4806  0x1C, 0x1D, 0x1E, 0x1F));
4807 }
4808 
4809 static __inline__ vector unsigned int __ATTRS_o_ai
4810 vec_mergel(vector unsigned int __a, vector unsigned int __b) {
4811  return vec_perm(__a, __b,
4812  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
4813  0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
4814  0x1C, 0x1D, 0x1E, 0x1F));
4815 }
4816 
4817 static __inline__ vector bool int __ATTRS_o_ai vec_mergel(vector bool int __a,
4818  vector bool int __b) {
4819  return vec_perm(__a, __b,
4820  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
4821  0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
4822  0x1C, 0x1D, 0x1E, 0x1F));
4823 }
4824 
4825 static __inline__ vector float __ATTRS_o_ai vec_mergel(vector float __a,
4826  vector float __b) {
4827  return vec_perm(__a, __b,
4828  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
4829  0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
4830  0x1C, 0x1D, 0x1E, 0x1F));
4831 }
4832 
4833 #ifdef __VSX__
4834 static __inline__ vector signed long long __ATTRS_o_ai
4835 vec_mergel(vector signed long long __a, vector signed long long __b) {
4836  return vec_perm(__a, __b,
4837  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
4838  0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
4839  0x1C, 0x1D, 0x1E, 0x1F));
4840 }
4841 static __inline__ vector signed long long __ATTRS_o_ai
4842 vec_mergel(vector signed long long __a, vector bool long long __b) {
4843  return vec_perm(__a, (vector signed long long)__b,
4844  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
4845  0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
4846  0x1C, 0x1D, 0x1E, 0x1F));
4847 }
4848 static __inline__ vector signed long long __ATTRS_o_ai
4849 vec_mergel(vector bool long long __a, vector signed long long __b) {
4850  return vec_perm((vector signed long long)__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 unsigned long long __ATTRS_o_ai
4856 vec_mergel(vector unsigned long long __a, vector unsigned long long __b) {
4857  return vec_perm(__a, __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 unsigned long long __ATTRS_o_ai
4863 vec_mergel(vector unsigned long long __a, vector bool long long __b) {
4864  return vec_perm(__a, (vector unsigned long long)__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 bool long long __a, vector unsigned long long __b) {
4871  return vec_perm((vector unsigned long long)__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 bool long long __ATTRS_o_ai
4877 vec_mergel(vector bool long long __a, vector bool long long __b) {
4878  return vec_perm(__a, __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 double __ATTRS_o_ai vec_mergel(vector double __a,
4884  vector double __b) {
4885  return vec_perm(__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 double __ATTRS_o_ai
4891 vec_mergel(vector double __a, vector bool long long __b) {
4892  return vec_perm(__a, (vector double)__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
4898 vec_mergel(vector bool long long __a, vector double __b) {
4899  return vec_perm((vector double)__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 #endif
4905 
4906 /* vec_vmrglb */
4907 
4908 #define __builtin_altivec_vmrglb vec_vmrglb
4909 
4910 static __inline__ vector signed char __ATTRS_o_ai
4911 vec_vmrglb(vector signed char __a, vector signed char __b) {
4912  return vec_perm(__a, __b,
4913  (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
4914  0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
4915  0x0E, 0x1E, 0x0F, 0x1F));
4916 }
4917 
4918 static __inline__ vector unsigned char __ATTRS_o_ai
4919 vec_vmrglb(vector unsigned char __a, vector unsigned char __b) {
4920  return vec_perm(__a, __b,
4921  (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
4922  0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
4923  0x0E, 0x1E, 0x0F, 0x1F));
4924 }
4925 
4926 static __inline__ vector bool char __ATTRS_o_ai
4927 vec_vmrglb(vector bool char __a, vector bool char __b) {
4928  return vec_perm(__a, __b,
4929  (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
4930  0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
4931  0x0E, 0x1E, 0x0F, 0x1F));
4932 }
4933 
4934 /* vec_vmrglh */
4935 
4936 #define __builtin_altivec_vmrglh vec_vmrglh
4937 
4938 static __inline__ vector short __ATTRS_o_ai vec_vmrglh(vector short __a,
4939  vector short __b) {
4940  return vec_perm(__a, __b,
4941  (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
4942  0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
4943  0x0E, 0x0F, 0x1E, 0x1F));
4944 }
4945 
4946 static __inline__ vector unsigned short __ATTRS_o_ai
4947 vec_vmrglh(vector unsigned short __a, vector unsigned short __b) {
4948  return vec_perm(__a, __b,
4949  (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
4950  0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
4951  0x0E, 0x0F, 0x1E, 0x1F));
4952 }
4953 
4954 static __inline__ vector bool short __ATTRS_o_ai
4955 vec_vmrglh(vector bool short __a, vector bool short __b) {
4956  return vec_perm(__a, __b,
4957  (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
4958  0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
4959  0x0E, 0x0F, 0x1E, 0x1F));
4960 }
4961 
4962 static __inline__ vector pixel __ATTRS_o_ai vec_vmrglh(vector pixel __a,
4963  vector pixel __b) {
4964  return vec_perm(__a, __b,
4965  (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
4966  0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
4967  0x0E, 0x0F, 0x1E, 0x1F));
4968 }
4969 
4970 /* vec_vmrglw */
4971 
4972 #define __builtin_altivec_vmrglw vec_vmrglw
4973 
4974 static __inline__ vector int __ATTRS_o_ai vec_vmrglw(vector int __a,
4975  vector int __b) {
4976  return vec_perm(__a, __b,
4977  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
4978  0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
4979  0x1C, 0x1D, 0x1E, 0x1F));
4980 }
4981 
4982 static __inline__ vector unsigned int __ATTRS_o_ai
4983 vec_vmrglw(vector unsigned int __a, vector unsigned int __b) {
4984  return vec_perm(__a, __b,
4985  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
4986  0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
4987  0x1C, 0x1D, 0x1E, 0x1F));
4988 }
4989 
4990 static __inline__ vector bool int __ATTRS_o_ai vec_vmrglw(vector bool int __a,
4991  vector bool int __b) {
4992  return vec_perm(__a, __b,
4993  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
4994  0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
4995  0x1C, 0x1D, 0x1E, 0x1F));
4996 }
4997 
4998 static __inline__ vector float __ATTRS_o_ai vec_vmrglw(vector float __a,
4999  vector float __b) {
5000  return vec_perm(__a, __b,
5001  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
5002  0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
5003  0x1C, 0x1D, 0x1E, 0x1F));
5004 }
5005 
5006 #ifdef __POWER8_VECTOR__
5007 /* vec_mergee */
5008 
5009 static __inline__ vector bool int __ATTRS_o_ai vec_mergee(vector bool int __a,
5010  vector bool int __b) {
5011  return vec_perm(__a, __b,
5012  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5013  0x12, 0x13, 0x08, 0x09, 0x0A, 0x0B,
5014  0x18, 0x19, 0x1A, 0x1B));
5015 }
5016 
5017 static __inline__ vector signed int __ATTRS_o_ai
5018 vec_mergee(vector signed int __a, vector signed int __b) {
5019  return vec_perm(__a, __b,
5020  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5021  0x12, 0x13, 0x08, 0x09, 0x0A, 0x0B,
5022  0x18, 0x19, 0x1A, 0x1B));
5023 }
5024 
5025 static __inline__ vector unsigned int __ATTRS_o_ai
5026 vec_mergee(vector unsigned int __a, vector unsigned int __b) {
5027  return vec_perm(__a, __b,
5028  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5029  0x12, 0x13, 0x08, 0x09, 0x0A, 0x0B,
5030  0x18, 0x19, 0x1A, 0x1B));
5031 }
5032 
5033 static __inline__ vector bool long long __ATTRS_o_ai
5034 vec_mergee(vector bool long long __a, vector bool long long __b) {
5035  return vec_mergeh(__a, __b);
5036 }
5037 
5038 static __inline__ vector signed long long __ATTRS_o_ai
5039 vec_mergee(vector signed long long __a, vector signed long long __b) {
5040  return vec_mergeh(__a, __b);
5041 }
5042 
5043 static __inline__ vector unsigned long long __ATTRS_o_ai
5044 vec_mergee(vector unsigned long long __a, vector unsigned long long __b) {
5045  return vec_mergeh(__a, __b);
5046 }
5047 
5048 static __inline__ vector float __ATTRS_o_ai
5049 vec_mergee(vector float __a, vector float __b) {
5050  return vec_perm(__a, __b,
5051  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
5052  0x12, 0x13, 0x08, 0x09, 0x0A, 0x0B,
5053  0x18, 0x19, 0x1A, 0x1B));
5054 }
5055 
5056 static __inline__ vector double __ATTRS_o_ai
5057 vec_mergee(vector double __a, vector double __b) {
5058  return vec_mergeh(__a, __b);
5059 }
5060 
5061 /* vec_mergeo */
5062 
5063 static __inline__ vector bool int __ATTRS_o_ai vec_mergeo(vector bool int __a,
5064  vector bool int __b) {
5065  return vec_perm(__a, __b,
5066  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x14, 0x15,
5067  0x16, 0x17, 0x0C, 0x0D, 0x0E, 0x0F,
5068  0x1C, 0x1D, 0x1E, 0x1F));
5069 }
5070 
5071 static __inline__ vector signed int __ATTRS_o_ai
5072 vec_mergeo(vector signed int __a, vector signed int __b) {
5073  return vec_perm(__a, __b,
5074  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x14, 0x15,
5075  0x16, 0x17, 0x0C, 0x0D, 0x0E, 0x0F,
5076  0x1C, 0x1D, 0x1E, 0x1F));
5077 }
5078 
5079 static __inline__ vector unsigned int __ATTRS_o_ai
5080 vec_mergeo(vector unsigned int __a, vector unsigned int __b) {
5081  return vec_perm(__a, __b,
5082  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x14, 0x15,
5083  0x16, 0x17, 0x0C, 0x0D, 0x0E, 0x0F,
5084  0x1C, 0x1D, 0x1E, 0x1F));
5085 }
5086 
5087 static __inline__ vector bool long long __ATTRS_o_ai
5088 vec_mergeo(vector bool long long __a, vector bool long long __b) {
5089  return vec_mergel(__a, __b);
5090 }
5091 
5092 static __inline__ vector signed long long __ATTRS_o_ai
5093 vec_mergeo(vector signed long long __a, vector signed long long __b) {
5094  return vec_mergel(__a, __b);
5095 }
5096 
5097 static __inline__ vector unsigned long long __ATTRS_o_ai
5098 vec_mergeo(vector unsigned long long __a, vector unsigned long long __b) {
5099  return vec_mergel(__a, __b);
5100 }
5101 
5102 static __inline__ vector float __ATTRS_o_ai
5103 vec_mergeo(vector float __a, vector float __b) {
5104  return vec_perm(__a, __b,
5105  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x14, 0x15,
5106  0x16, 0x17, 0x0C, 0x0D, 0x0E, 0x0F,
5107  0x1C, 0x1D, 0x1E, 0x1F));
5108 }
5109 
5110 static __inline__ vector double __ATTRS_o_ai
5111 vec_mergeo(vector double __a, vector double __b) {
5112  return vec_mergel(__a, __b);
5113 }
5114 
5115 #endif
5116 
5117 /* vec_mfvscr */
5118 
5119 static __inline__ vector unsigned short __attribute__((__always_inline__))
5120 vec_mfvscr(void) {
5121  return __builtin_altivec_mfvscr();
5122 }
5123 
5124 /* vec_min */
5125 
5126 static __inline__ vector signed char __ATTRS_o_ai
5127 vec_min(vector signed char __a, vector signed char __b) {
5128  return __builtin_altivec_vminsb(__a, __b);
5129 }
5130 
5131 static __inline__ vector signed char __ATTRS_o_ai
5132 vec_min(vector bool char __a, vector signed char __b) {
5133  return __builtin_altivec_vminsb((vector signed char)__a, __b);
5134 }
5135 
5136 static __inline__ vector signed char __ATTRS_o_ai
5137 vec_min(vector signed char __a, vector bool char __b) {
5138  return __builtin_altivec_vminsb(__a, (vector signed char)__b);
5139 }
5140 
5141 static __inline__ vector unsigned char __ATTRS_o_ai
5142 vec_min(vector unsigned char __a, vector unsigned char __b) {
5143  return __builtin_altivec_vminub(__a, __b);
5144 }
5145 
5146 static __inline__ vector unsigned char __ATTRS_o_ai
5147 vec_min(vector bool char __a, vector unsigned char __b) {
5148  return __builtin_altivec_vminub((vector unsigned char)__a, __b);
5149 }
5150 
5151 static __inline__ vector unsigned char __ATTRS_o_ai
5152 vec_min(vector unsigned char __a, vector bool char __b) {
5153  return __builtin_altivec_vminub(__a, (vector unsigned char)__b);
5154 }
5155 
5156 static __inline__ vector short __ATTRS_o_ai vec_min(vector short __a,
5157  vector short __b) {
5158  return __builtin_altivec_vminsh(__a, __b);
5159 }
5160 
5161 static __inline__ vector short __ATTRS_o_ai vec_min(vector bool short __a,
5162  vector short __b) {
5163  return __builtin_altivec_vminsh((vector short)__a, __b);
5164 }
5165 
5166 static __inline__ vector short __ATTRS_o_ai vec_min(vector short __a,
5167  vector bool short __b) {
5168  return __builtin_altivec_vminsh(__a, (vector short)__b);
5169 }
5170 
5171 static __inline__ vector unsigned short __ATTRS_o_ai
5172 vec_min(vector unsigned short __a, vector unsigned short __b) {
5173  return __builtin_altivec_vminuh(__a, __b);
5174 }
5175 
5176 static __inline__ vector unsigned short __ATTRS_o_ai
5177 vec_min(vector bool short __a, vector unsigned short __b) {
5178  return __builtin_altivec_vminuh((vector unsigned short)__a, __b);
5179 }
5180 
5181 static __inline__ vector unsigned short __ATTRS_o_ai
5182 vec_min(vector unsigned short __a, vector bool short __b) {
5183  return __builtin_altivec_vminuh(__a, (vector unsigned short)__b);
5184 }
5185 
5186 static __inline__ vector int __ATTRS_o_ai vec_min(vector int __a,
5187  vector int __b) {
5188  return __builtin_altivec_vminsw(__a, __b);
5189 }
5190 
5191 static __inline__ vector int __ATTRS_o_ai vec_min(vector bool int __a,
5192  vector int __b) {
5193  return __builtin_altivec_vminsw((vector int)__a, __b);
5194 }
5195 
5196 static __inline__ vector int __ATTRS_o_ai vec_min(vector int __a,
5197  vector bool int __b) {
5198  return __builtin_altivec_vminsw(__a, (vector int)__b);
5199 }
5200 
5201 static __inline__ vector unsigned int __ATTRS_o_ai
5202 vec_min(vector unsigned int __a, vector unsigned int __b) {
5203  return __builtin_altivec_vminuw(__a, __b);
5204 }
5205 
5206 static __inline__ vector unsigned int __ATTRS_o_ai
5207 vec_min(vector bool int __a, vector unsigned int __b) {
5208  return __builtin_altivec_vminuw((vector unsigned int)__a, __b);
5209 }
5210 
5211 static __inline__ vector unsigned int __ATTRS_o_ai
5212 vec_min(vector unsigned int __a, vector bool int __b) {
5213  return __builtin_altivec_vminuw(__a, (vector unsigned int)__b);
5214 }
5215 
5216 #ifdef __POWER8_VECTOR__
5217 static __inline__ vector signed long long __ATTRS_o_ai
5218 vec_min(vector signed long long __a, vector signed long long __b) {
5219  return __builtin_altivec_vminsd(__a, __b);
5220 }
5221 
5222 static __inline__ vector signed long long __ATTRS_o_ai
5223 vec_min(vector bool long long __a, vector signed long long __b) {
5224  return __builtin_altivec_vminsd((vector signed long long)__a, __b);
5225 }
5226 
5227 static __inline__ vector signed long long __ATTRS_o_ai
5228 vec_min(vector signed long long __a, vector bool long long __b) {
5229  return __builtin_altivec_vminsd(__a, (vector signed long long)__b);
5230 }
5231 
5232 static __inline__ vector unsigned long long __ATTRS_o_ai
5233 vec_min(vector unsigned long long __a, vector unsigned long long __b) {
5234  return __builtin_altivec_vminud(__a, __b);
5235 }
5236 
5237 static __inline__ vector unsigned long long __ATTRS_o_ai
5238 vec_min(vector bool long long __a, vector unsigned long long __b) {
5239  return __builtin_altivec_vminud((vector unsigned long long)__a, __b);
5240 }
5241 
5242 static __inline__ vector unsigned long long __ATTRS_o_ai
5243 vec_min(vector unsigned long long __a, vector bool long long __b) {
5244  return __builtin_altivec_vminud(__a, (vector unsigned long long)__b);
5245 }
5246 #endif
5247 
5248 static __inline__ vector float __ATTRS_o_ai vec_min(vector float __a,
5249  vector float __b) {
5250 #ifdef __VSX__
5251  return __builtin_vsx_xvminsp(__a, __b);
5252 #else
5253  return __builtin_altivec_vminfp(__a, __b);
5254 #endif
5255 }
5256 
5257 #ifdef __VSX__
5258 static __inline__ vector double __ATTRS_o_ai vec_min(vector double __a,
5259  vector double __b) {
5260  return __builtin_vsx_xvmindp(__a, __b);
5261 }
5262 #endif
5263 
5264 /* vec_vminsb */
5265 
5266 static __inline__ vector signed char __ATTRS_o_ai
5267 vec_vminsb(vector signed char __a, vector signed char __b) {
5268  return __builtin_altivec_vminsb(__a, __b);
5269 }
5270 
5271 static __inline__ vector signed char __ATTRS_o_ai
5272 vec_vminsb(vector bool char __a, vector signed char __b) {
5273  return __builtin_altivec_vminsb((vector signed char)__a, __b);
5274 }
5275 
5276 static __inline__ vector signed char __ATTRS_o_ai
5277 vec_vminsb(vector signed char __a, vector bool char __b) {
5278  return __builtin_altivec_vminsb(__a, (vector signed char)__b);
5279 }
5280 
5281 /* vec_vminub */
5282 
5283 static __inline__ vector unsigned char __ATTRS_o_ai
5284 vec_vminub(vector unsigned char __a, vector unsigned char __b) {
5285  return __builtin_altivec_vminub(__a, __b);
5286 }
5287 
5288 static __inline__ vector unsigned char __ATTRS_o_ai
5289 vec_vminub(vector bool char __a, vector unsigned char __b) {
5290  return __builtin_altivec_vminub((vector unsigned char)__a, __b);
5291 }
5292 
5293 static __inline__ vector unsigned char __ATTRS_o_ai
5294 vec_vminub(vector unsigned char __a, vector bool char __b) {
5295  return __builtin_altivec_vminub(__a, (vector unsigned char)__b);
5296 }
5297 
5298 /* vec_vminsh */
5299 
5300 static __inline__ vector short __ATTRS_o_ai vec_vminsh(vector short __a,
5301  vector short __b) {
5302  return __builtin_altivec_vminsh(__a, __b);
5303 }
5304 
5305 static __inline__ vector short __ATTRS_o_ai vec_vminsh(vector bool short __a,
5306  vector short __b) {
5307  return __builtin_altivec_vminsh((vector short)__a, __b);
5308 }
5309 
5310 static __inline__ vector short __ATTRS_o_ai vec_vminsh(vector short __a,
5311  vector bool short __b) {
5312  return __builtin_altivec_vminsh(__a, (vector short)__b);
5313 }
5314 
5315 /* vec_vminuh */
5316 
5317 static __inline__ vector unsigned short __ATTRS_o_ai
5318 vec_vminuh(vector unsigned short __a, vector unsigned short __b) {
5319  return __builtin_altivec_vminuh(__a, __b);
5320 }
5321 
5322 static __inline__ vector unsigned short __ATTRS_o_ai
5323 vec_vminuh(vector bool short __a, vector unsigned short __b) {
5324  return __builtin_altivec_vminuh((vector unsigned short)__a, __b);
5325 }
5326 
5327 static __inline__ vector unsigned short __ATTRS_o_ai
5328 vec_vminuh(vector unsigned short __a, vector bool short __b) {
5329  return __builtin_altivec_vminuh(__a, (vector unsigned short)__b);
5330 }
5331 
5332 /* vec_vminsw */
5333 
5334 static __inline__ vector int __ATTRS_o_ai vec_vminsw(vector int __a,
5335  vector int __b) {
5336  return __builtin_altivec_vminsw(__a, __b);
5337 }
5338 
5339 static __inline__ vector int __ATTRS_o_ai vec_vminsw(vector bool int __a,
5340  vector int __b) {
5341  return __builtin_altivec_vminsw((vector int)__a, __b);
5342 }
5343 
5344 static __inline__ vector int __ATTRS_o_ai vec_vminsw(vector int __a,
5345  vector bool int __b) {
5346  return __builtin_altivec_vminsw(__a, (vector int)__b);
5347 }
5348 
5349 /* vec_vminuw */
5350 
5351 static __inline__ vector unsigned int __ATTRS_o_ai
5352 vec_vminuw(vector unsigned int __a, vector unsigned int __b) {
5353  return __builtin_altivec_vminuw(__a, __b);
5354 }
5355 
5356 static __inline__ vector unsigned int __ATTRS_o_ai
5357 vec_vminuw(vector bool int __a, vector unsigned int __b) {
5358  return __builtin_altivec_vminuw((vector unsigned int)__a, __b);
5359 }
5360 
5361 static __inline__ vector unsigned int __ATTRS_o_ai
5362 vec_vminuw(vector unsigned int __a, vector bool int __b) {
5363  return __builtin_altivec_vminuw(__a, (vector unsigned int)__b);
5364 }
5365 
5366 /* vec_vminfp */
5367 
5368 static __inline__ vector float __attribute__((__always_inline__))
5369 vec_vminfp(vector float __a, vector float __b) {
5370 #ifdef __VSX__
5371  return __builtin_vsx_xvminsp(__a, __b);
5372 #else
5373  return __builtin_altivec_vminfp(__a, __b);
5374 #endif
5375 }
5376 
5377 /* vec_mladd */
5378 
5379 #define __builtin_altivec_vmladduhm vec_mladd
5380 
5381 static __inline__ vector short __ATTRS_o_ai vec_mladd(vector short __a,
5382  vector short __b,
5383  vector short __c) {
5384  return __a * __b + __c;
5385 }
5386 
5387 static __inline__ vector short __ATTRS_o_ai vec_mladd(
5388  vector short __a, vector unsigned short __b, vector unsigned short __c) {
5389  return __a * (vector short)__b + (vector short)__c;
5390 }
5391 
5392 static __inline__ vector short __ATTRS_o_ai vec_mladd(vector unsigned short __a,
5393  vector short __b,
5394  vector short __c) {
5395  return (vector short)__a * __b + __c;
5396 }
5397 
5398 static __inline__ vector unsigned short __ATTRS_o_ai
5399 vec_mladd(vector unsigned short __a, vector unsigned short __b,
5400  vector unsigned short __c) {
5401  return __a * __b + __c;
5402 }
5403 
5404 /* vec_vmladduhm */
5405 
5406 static __inline__ vector short __ATTRS_o_ai vec_vmladduhm(vector short __a,
5407  vector short __b,
5408  vector short __c) {
5409  return __a * __b + __c;
5410 }
5411 
5412 static __inline__ vector short __ATTRS_o_ai vec_vmladduhm(
5413  vector short __a, vector unsigned short __b, vector unsigned short __c) {
5414  return __a * (vector short)__b + (vector short)__c;
5415 }
5416 
5417 static __inline__ vector short __ATTRS_o_ai
5418 vec_vmladduhm(vector unsigned short __a, vector short __b, vector short __c) {
5419  return (vector short)__a * __b + __c;
5420 }
5421 
5422 static __inline__ vector unsigned short __ATTRS_o_ai
5423 vec_vmladduhm(vector unsigned short __a, vector unsigned short __b,
5424  vector unsigned short __c) {
5425  return __a * __b + __c;
5426 }
5427 
5428 /* vec_mradds */
5429 
5430 static __inline__ vector short __attribute__((__always_inline__))
5431 vec_mradds(vector short __a, vector short __b, vector short __c) {
5432  return __builtin_altivec_vmhraddshs(__a, __b, __c);
5433 }
5434 
5435 /* vec_vmhraddshs */
5436 
5437 static __inline__ vector short __attribute__((__always_inline__))
5438 vec_vmhraddshs(vector short __a, vector short __b, vector short __c) {
5439  return __builtin_altivec_vmhraddshs(__a, __b, __c);
5440 }
5441 
5442 /* vec_msum */
5443 
5444 static __inline__ vector int __ATTRS_o_ai vec_msum(vector signed char __a,
5445  vector unsigned char __b,
5446  vector int __c) {
5447  return __builtin_altivec_vmsummbm(__a, __b, __c);
5448 }
5449 
5450 static __inline__ vector unsigned int __ATTRS_o_ai
5451 vec_msum(vector unsigned char __a, vector unsigned char __b,
5452  vector unsigned int __c) {
5453  return __builtin_altivec_vmsumubm(__a, __b, __c);
5454 }
5455 
5456 static __inline__ vector int __ATTRS_o_ai vec_msum(vector short __a,
5457  vector short __b,
5458  vector int __c) {
5459  return __builtin_altivec_vmsumshm(__a, __b, __c);
5460 }
5461 
5462 static __inline__ vector unsigned int __ATTRS_o_ai
5463 vec_msum(vector unsigned short __a, vector unsigned short __b,
5464  vector unsigned int __c) {
5465  return __builtin_altivec_vmsumuhm(__a, __b, __c);
5466 }
5467 
5468 /* vec_vmsummbm */
5469 
5470 static __inline__ vector int __attribute__((__always_inline__))
5471 vec_vmsummbm(vector signed char __a, vector unsigned char __b, vector int __c) {
5472  return __builtin_altivec_vmsummbm(__a, __b, __c);
5473 }
5474 
5475 /* vec_vmsumubm */
5476 
5477 static __inline__ vector unsigned int __attribute__((__always_inline__))
5478 vec_vmsumubm(vector unsigned char __a, vector unsigned char __b,
5479  vector unsigned int __c) {
5480  return __builtin_altivec_vmsumubm(__a, __b, __c);
5481 }
5482 
5483 /* vec_vmsumshm */
5484 
5485 static __inline__ vector int __attribute__((__always_inline__))
5486 vec_vmsumshm(vector short __a, vector short __b, vector int __c) {
5487  return __builtin_altivec_vmsumshm(__a, __b, __c);
5488 }
5489 
5490 /* vec_vmsumuhm */
5491 
5492 static __inline__ vector unsigned int __attribute__((__always_inline__))
5493 vec_vmsumuhm(vector unsigned short __a, vector unsigned short __b,
5494  vector unsigned int __c) {
5495  return __builtin_altivec_vmsumuhm(__a, __b, __c);
5496 }
5497 
5498 /* vec_msums */
5499 
5500 static __inline__ vector int __ATTRS_o_ai vec_msums(vector short __a,
5501  vector short __b,
5502  vector int __c) {
5503  return __builtin_altivec_vmsumshs(__a, __b, __c);
5504 }
5505 
5506 static __inline__ vector unsigned int __ATTRS_o_ai
5507 vec_msums(vector unsigned short __a, vector unsigned short __b,
5508  vector unsigned int __c) {
5509  return __builtin_altivec_vmsumuhs(__a, __b, __c);
5510 }
5511 
5512 /* vec_vmsumshs */
5513 
5514 static __inline__ vector int __attribute__((__always_inline__))
5515 vec_vmsumshs(vector short __a, vector short __b, vector int __c) {
5516  return __builtin_altivec_vmsumshs(__a, __b, __c);
5517 }
5518 
5519 /* vec_vmsumuhs */
5520 
5521 static __inline__ vector unsigned int __attribute__((__always_inline__))
5522 vec_vmsumuhs(vector unsigned short __a, vector unsigned short __b,
5523  vector unsigned int __c) {
5524  return __builtin_altivec_vmsumuhs(__a, __b, __c);
5525 }
5526 
5527 /* vec_mtvscr */
5528 
5529 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector signed char __a) {
5530  __builtin_altivec_mtvscr((vector int)__a);
5531 }
5532 
5533 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector unsigned char __a) {
5534  __builtin_altivec_mtvscr((vector int)__a);
5535 }
5536 
5537 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector bool char __a) {
5538  __builtin_altivec_mtvscr((vector int)__a);
5539 }
5540 
5541 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector short __a) {
5542  __builtin_altivec_mtvscr((vector int)__a);
5543 }
5544 
5545 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector unsigned short __a) {
5546  __builtin_altivec_mtvscr((vector int)__a);
5547 }
5548 
5549 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector bool short __a) {
5550  __builtin_altivec_mtvscr((vector int)__a);
5551 }
5552 
5553 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector pixel __a) {
5554  __builtin_altivec_mtvscr((vector int)__a);
5555 }
5556 
5557 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector int __a) {
5558  __builtin_altivec_mtvscr((vector int)__a);
5559 }
5560 
5561 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector unsigned int __a) {
5562  __builtin_altivec_mtvscr((vector int)__a);
5563 }
5564 
5565 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector bool int __a) {
5566  __builtin_altivec_mtvscr((vector int)__a);
5567 }
5568 
5569 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector float __a) {
5570  __builtin_altivec_mtvscr((vector int)__a);
5571 }
5572 
5573 /* vec_mul */
5574 
5575 /* Integer vector multiplication will involve multiplication of the odd/even
5576  elements separately, then truncating the results and moving to the
5577  result vector.
5578 */
5579 static __inline__ vector signed char __ATTRS_o_ai
5580 vec_mul(vector signed char __a, vector signed char __b) {
5581  return __a * __b;
5582 }
5583 
5584 static __inline__ vector unsigned char __ATTRS_o_ai
5585 vec_mul(vector unsigned char __a, vector unsigned char __b) {
5586  return __a * __b;
5587 }
5588 
5589 static __inline__ vector signed short __ATTRS_o_ai
5590 vec_mul(vector signed short __a, vector signed short __b) {
5591  return __a * __b;
5592 }
5593 
5594 static __inline__ vector unsigned short __ATTRS_o_ai
5595 vec_mul(vector unsigned short __a, vector unsigned short __b) {
5596  return __a * __b;
5597 }
5598 
5599 static __inline__ vector signed int __ATTRS_o_ai
5600 vec_mul(vector signed int __a, vector signed int __b) {
5601  return __a * __b;
5602 }
5603 
5604 static __inline__ vector unsigned int __ATTRS_o_ai
5605 vec_mul(vector unsigned int __a, vector unsigned int __b) {
5606  return __a * __b;
5607 }
5608 
5609 #ifdef __VSX__
5610 static __inline__ vector signed long long __ATTRS_o_ai
5611 vec_mul(vector signed long long __a, vector signed long long __b) {
5612  return __a * __b;
5613 }
5614 
5615 static __inline__ vector unsigned long long __ATTRS_o_ai
5616 vec_mul(vector unsigned long long __a, vector unsigned long long __b) {
5617  return __a * __b;
5618 }
5619 #endif
5620 
5621 static __inline__ vector float __ATTRS_o_ai vec_mul(vector float __a,
5622  vector float __b) {
5623  return __a * __b;
5624 }
5625 
5626 #ifdef __VSX__
5627 static __inline__ vector double __ATTRS_o_ai vec_mul(vector double __a,
5628  vector double __b) {
5629  return __a * __b;
5630 }
5631 #endif
5632 
5633 /* The vmulos* and vmules* instructions have a big endian bias, so
5634  we must reverse the meaning of "even" and "odd" for little endian. */
5635 
5636 /* vec_mule */
5637 
5638 static __inline__ vector short __ATTRS_o_ai vec_mule(vector signed char __a,
5639  vector signed char __b) {
5640 #ifdef __LITTLE_ENDIAN__
5641  return __builtin_altivec_vmulosb(__a, __b);
5642 #else
5643  return __builtin_altivec_vmulesb(__a, __b);
5644 #endif
5645 }
5646 
5647 static __inline__ vector unsigned short __ATTRS_o_ai
5648 vec_mule(vector unsigned char __a, vector unsigned char __b) {
5649 #ifdef __LITTLE_ENDIAN__
5650  return __builtin_altivec_vmuloub(__a, __b);
5651 #else
5652  return __builtin_altivec_vmuleub(__a, __b);
5653 #endif
5654 }
5655 
5656 static __inline__ vector int __ATTRS_o_ai vec_mule(vector short __a,
5657  vector short __b) {
5658 #ifdef __LITTLE_ENDIAN__
5659  return __builtin_altivec_vmulosh(__a, __b);
5660 #else
5661  return __builtin_altivec_vmulesh(__a, __b);
5662 #endif
5663 }
5664 
5665 static __inline__ vector unsigned int __ATTRS_o_ai
5666 vec_mule(vector unsigned short __a, vector unsigned short __b) {
5667 #ifdef __LITTLE_ENDIAN__
5668  return __builtin_altivec_vmulouh(__a, __b);
5669 #else
5670  return __builtin_altivec_vmuleuh(__a, __b);
5671 #endif
5672 }
5673 
5674 #ifdef __POWER8_VECTOR__
5675 static __inline__ vector signed long long __ATTRS_o_ai
5676 vec_mule(vector signed int __a, vector signed int __b) {
5677 #ifdef __LITTLE_ENDIAN__
5678  return __builtin_altivec_vmulosw(__a, __b);
5679 #else
5680  return __builtin_altivec_vmulesw(__a, __b);
5681 #endif
5682 }
5683 
5684 static __inline__ vector unsigned long long __ATTRS_o_ai
5685 vec_mule(vector unsigned int __a, vector unsigned int __b) {
5686 #ifdef __LITTLE_ENDIAN__
5687  return __builtin_altivec_vmulouw(__a, __b);
5688 #else
5689  return __builtin_altivec_vmuleuw(__a, __b);
5690 #endif
5691 }
5692 #endif
5693 
5694 /* vec_vmulesb */
5695 
5696 static __inline__ vector short __attribute__((__always_inline__))
5697 vec_vmulesb(vector signed char __a, vector signed char __b) {
5698 #ifdef __LITTLE_ENDIAN__
5699  return __builtin_altivec_vmulosb(__a, __b);
5700 #else
5701  return __builtin_altivec_vmulesb(__a, __b);
5702 #endif
5703 }
5704 
5705 /* vec_vmuleub */
5706 
5707 static __inline__ vector unsigned short __attribute__((__always_inline__))
5708 vec_vmuleub(vector unsigned char __a, vector unsigned char __b) {
5709 #ifdef __LITTLE_ENDIAN__
5710  return __builtin_altivec_vmuloub(__a, __b);
5711 #else
5712  return __builtin_altivec_vmuleub(__a, __b);
5713 #endif
5714 }
5715 
5716 /* vec_vmulesh */
5717 
5718 static __inline__ vector int __attribute__((__always_inline__))
5719 vec_vmulesh(vector short __a, vector short __b) {
5720 #ifdef __LITTLE_ENDIAN__
5721  return __builtin_altivec_vmulosh(__a, __b);
5722 #else
5723  return __builtin_altivec_vmulesh(__a, __b);
5724 #endif
5725 }
5726 
5727 /* vec_vmuleuh */
5728 
5729 static __inline__ vector unsigned int __attribute__((__always_inline__))
5730 vec_vmuleuh(vector unsigned short __a, vector unsigned short __b) {
5731 #ifdef __LITTLE_ENDIAN__
5732  return __builtin_altivec_vmulouh(__a, __b);
5733 #else
5734  return __builtin_altivec_vmuleuh(__a, __b);
5735 #endif
5736 }
5737 
5738 /* vec_mulo */
5739 
5740 static __inline__ vector short __ATTRS_o_ai vec_mulo(vector signed char __a,
5741  vector signed char __b) {
5742 #ifdef __LITTLE_ENDIAN__
5743  return __builtin_altivec_vmulesb(__a, __b);
5744 #else
5745  return __builtin_altivec_vmulosb(__a, __b);
5746 #endif
5747 }
5748 
5749 static __inline__ vector unsigned short __ATTRS_o_ai
5750 vec_mulo(vector unsigned char __a, vector unsigned char __b) {
5751 #ifdef __LITTLE_ENDIAN__
5752  return __builtin_altivec_vmuleub(__a, __b);
5753 #else
5754  return __builtin_altivec_vmuloub(__a, __b);
5755 #endif
5756 }
5757 
5758 static __inline__ vector int __ATTRS_o_ai vec_mulo(vector short __a,
5759  vector short __b) {
5760 #ifdef __LITTLE_ENDIAN__
5761  return __builtin_altivec_vmulesh(__a, __b);
5762 #else
5763  return __builtin_altivec_vmulosh(__a, __b);
5764 #endif
5765 }
5766 
5767 static __inline__ vector unsigned int __ATTRS_o_ai
5768 vec_mulo(vector unsigned short __a, vector unsigned short __b) {
5769 #ifdef __LITTLE_ENDIAN__
5770  return __builtin_altivec_vmuleuh(__a, __b);
5771 #else
5772  return __builtin_altivec_vmulouh(__a, __b);
5773 #endif
5774 }
5775 
5776 #ifdef __POWER8_VECTOR__
5777 static __inline__ vector signed long long __ATTRS_o_ai
5778 vec_mulo(vector signed int __a, vector signed int __b) {
5779 #ifdef __LITTLE_ENDIAN__
5780  return __builtin_altivec_vmulesw(__a, __b);
5781 #else
5782  return __builtin_altivec_vmulosw(__a, __b);
5783 #endif
5784 }
5785 
5786 static __inline__ vector unsigned long long __ATTRS_o_ai
5787 vec_mulo(vector unsigned int __a, vector unsigned int __b) {
5788 #ifdef __LITTLE_ENDIAN__
5789  return __builtin_altivec_vmuleuw(__a, __b);
5790 #else
5791  return __builtin_altivec_vmulouw(__a, __b);
5792 #endif
5793 }
5794 #endif
5795 
5796 /* vec_vmulosb */
5797 
5798 static __inline__ vector short __attribute__((__always_inline__))
5799 vec_vmulosb(vector signed char __a, vector signed char __b) {
5800 #ifdef __LITTLE_ENDIAN__
5801  return __builtin_altivec_vmulesb(__a, __b);
5802 #else
5803  return __builtin_altivec_vmulosb(__a, __b);
5804 #endif
5805 }
5806 
5807 /* vec_vmuloub */
5808 
5809 static __inline__ vector unsigned short __attribute__((__always_inline__))
5810 vec_vmuloub(vector unsigned char __a, vector unsigned char __b) {
5811 #ifdef __LITTLE_ENDIAN__
5812  return __builtin_altivec_vmuleub(__a, __b);
5813 #else
5814  return __builtin_altivec_vmuloub(__a, __b);
5815 #endif
5816 }
5817 
5818 /* vec_vmulosh */
5819 
5820 static __inline__ vector int __attribute__((__always_inline__))
5821 vec_vmulosh(vector short __a, vector short __b) {
5822 #ifdef __LITTLE_ENDIAN__
5823  return __builtin_altivec_vmulesh(__a, __b);
5824 #else
5825  return __builtin_altivec_vmulosh(__a, __b);
5826 #endif
5827 }
5828 
5829 /* vec_vmulouh */
5830 
5831 static __inline__ vector unsigned int __attribute__((__always_inline__))
5832 vec_vmulouh(vector unsigned short __a, vector unsigned short __b) {
5833 #ifdef __LITTLE_ENDIAN__
5834  return __builtin_altivec_vmuleuh(__a, __b);
5835 #else
5836  return __builtin_altivec_vmulouh(__a, __b);
5837 #endif
5838 }
5839 
5840 /* vec_nand */
5841 
5842 #ifdef __POWER8_VECTOR__
5843 static __inline__ vector signed char __ATTRS_o_ai
5844 vec_nand(vector signed char __a, vector signed char __b) {
5845  return ~(__a & __b);
5846 }
5847 
5848 static __inline__ vector signed char __ATTRS_o_ai
5849 vec_nand(vector signed char __a, vector bool char __b) {
5850  return ~(__a & __b);
5851 }
5852 
5853 static __inline__ vector signed char __ATTRS_o_ai
5854 vec_nand(vector bool char __a, vector signed char __b) {
5855  return ~(__a & __b);
5856 }
5857 
5858 static __inline__ vector unsigned char __ATTRS_o_ai
5859 vec_nand(vector unsigned char __a, vector unsigned char __b) {
5860  return ~(__a & __b);
5861 }
5862 
5863 static __inline__ vector unsigned char __ATTRS_o_ai
5864 vec_nand(vector unsigned char __a, vector bool char __b) {
5865  return ~(__a & __b);
5866 }
5867 
5868 static __inline__ vector unsigned char __ATTRS_o_ai
5869 vec_nand(vector bool char __a, vector unsigned char __b) {
5870  return ~(__a & __b);
5871 }
5872 
5873 static __inline__ vector bool char __ATTRS_o_ai vec_nand(vector bool char __a,
5874  vector bool char __b) {
5875  return ~(__a & __b);
5876 }
5877 
5878 static __inline__ vector signed short __ATTRS_o_ai
5879 vec_nand(vector signed short __a, vector signed short __b) {
5880  return ~(__a & __b);
5881 }
5882 
5883 static __inline__ vector signed short __ATTRS_o_ai
5884 vec_nand(vector signed short __a, vector bool short __b) {
5885  return ~(__a & __b);
5886 }
5887 
5888 static __inline__ vector signed short __ATTRS_o_ai
5889 vec_nand(vector bool short __a, vector signed short __b) {
5890  return ~(__a & __b);
5891 }
5892 
5893 static __inline__ vector unsigned short __ATTRS_o_ai
5894 vec_nand(vector unsigned short __a, vector unsigned short __b) {
5895  return ~(__a & __b);
5896 }
5897 
5898 static __inline__ vector unsigned short __ATTRS_o_ai
5899 vec_nand(vector unsigned short __a, vector bool short __b) {
5900  return ~(__a & __b);
5901 }
5902 
5903 static __inline__ vector bool short __ATTRS_o_ai
5904 vec_nand(vector bool short __a, vector bool short __b) {
5905  return ~(__a & __b);
5906 }
5907 
5908 static __inline__ vector signed int __ATTRS_o_ai
5909 vec_nand(vector signed int __a, vector signed int __b) {
5910  return ~(__a & __b);
5911 }
5912 
5913 static __inline__ vector signed int __ATTRS_o_ai vec_nand(vector signed int __a,
5914  vector bool int __b) {
5915  return ~(__a & __b);
5916 }
5917 
5918 static __inline__ vector signed int __ATTRS_o_ai
5919 vec_nand(vector bool int __a, vector signed int __b) {
5920  return ~(__a & __b);
5921 }
5922 
5923 static __inline__ vector unsigned int __ATTRS_o_ai
5924 vec_nand(vector unsigned int __a, vector unsigned int __b) {
5925  return ~(__a & __b);
5926 }
5927 
5928 static __inline__ vector unsigned int __ATTRS_o_ai
5929 vec_nand(vector unsigned int __a, vector bool int __b) {
5930  return ~(__a & __b);
5931 }
5932 
5933 static __inline__ vector unsigned int __ATTRS_o_ai
5934 vec_nand(vector bool int __a, vector unsigned int __b) {
5935  return ~(__a & __b);
5936 }
5937 
5938 static __inline__ vector bool int __ATTRS_o_ai vec_nand(vector bool int __a,
5939  vector bool int __b) {
5940  return ~(__a & __b);
5941 }
5942 
5943 static __inline__ vector float __ATTRS_o_ai
5944 vec_nand(vector float __a, vector float __b) {
5945  return (vector float)(~((vector unsigned int)__a &
5946  (vector unsigned int)__b));
5947 }
5948 
5949 static __inline__ vector signed long long __ATTRS_o_ai
5950 vec_nand(vector signed long long __a, vector signed long long __b) {
5951  return ~(__a & __b);
5952 }
5953 
5954 static __inline__ vector signed long long __ATTRS_o_ai
5955 vec_nand(vector signed long long __a, vector bool long long __b) {
5956  return ~(__a & __b);
5957 }
5958 
5959 static __inline__ vector signed long long __ATTRS_o_ai
5960 vec_nand(vector bool long long __a, vector signed long long __b) {
5961  return ~(__a & __b);
5962 }
5963 
5964 static __inline__ vector unsigned long long __ATTRS_o_ai
5965 vec_nand(vector unsigned long long __a, vector unsigned long long __b) {
5966  return ~(__a & __b);
5967 }
5968 
5969 static __inline__ vector unsigned long long __ATTRS_o_ai
5970 vec_nand(vector unsigned long long __a, vector bool long long __b) {
5971  return ~(__a & __b);
5972 }
5973 
5974 static __inline__ vector unsigned long long __ATTRS_o_ai
5975 vec_nand(vector bool long long __a, vector unsigned long long __b) {
5976  return ~(__a & __b);
5977 }
5978 
5979 static __inline__ vector bool long long __ATTRS_o_ai
5980 vec_nand(vector bool long long __a, vector bool long long __b) {
5981  return ~(__a & __b);
5982 }
5983 
5984 static __inline__ vector double __ATTRS_o_ai
5985 vec_nand(vector double __a, vector double __b) {
5986  return (vector double)(~((vector unsigned long long)__a &
5987  (vector unsigned long long)__b));
5988 }
5989 
5990 #endif
5991 
5992 /* vec_nmadd */
5993 
5994 #ifdef __VSX__
5995 static __inline__ vector float __ATTRS_o_ai vec_nmadd(vector float __a,
5996  vector float __b,
5997  vector float __c) {
5998  return __builtin_vsx_xvnmaddasp(__a, __b, __c);
5999 }
6000 
6001 static __inline__ vector double __ATTRS_o_ai vec_nmadd(vector double __a,
6002  vector double __b,
6003  vector double __c) {
6004  return __builtin_vsx_xvnmaddadp(__a, __b, __c);
6005 }
6006 #endif
6007 
6008 /* vec_nmsub */
6009 
6010 static __inline__ vector float __ATTRS_o_ai vec_nmsub(vector float __a,
6011  vector float __b,
6012  vector float __c) {
6013 #ifdef __VSX__
6014  return __builtin_vsx_xvnmsubasp(__a, __b, __c);
6015 #else
6016  return __builtin_altivec_vnmsubfp(__a, __b, __c);
6017 #endif
6018 }
6019 
6020 #ifdef __VSX__
6021 static __inline__ vector double __ATTRS_o_ai vec_nmsub(vector double __a,
6022  vector double __b,
6023  vector double __c) {
6024  return __builtin_vsx_xvnmsubadp(__a, __b, __c);
6025 }
6026 #endif
6027 
6028 /* vec_vnmsubfp */
6029 
6030 static __inline__ vector float __attribute__((__always_inline__))
6031 vec_vnmsubfp(vector float __a, vector float __b, vector float __c) {
6032  return __builtin_altivec_vnmsubfp(__a, __b, __c);
6033 }
6034 
6035 /* vec_nor */
6036 
6037 #define __builtin_altivec_vnor vec_nor
6038 
6039 static __inline__ vector signed char __ATTRS_o_ai
6040 vec_nor(vector signed char __a, vector signed char __b) {
6041  return ~(__a | __b);
6042 }
6043 
6044 static __inline__ vector unsigned char __ATTRS_o_ai
6045 vec_nor(vector unsigned char __a, vector unsigned char __b) {
6046  return ~(__a | __b);
6047 }
6048 
6049 static __inline__ vector bool char __ATTRS_o_ai vec_nor(vector bool char __a,
6050  vector bool char __b) {
6051  return ~(__a | __b);
6052 }
6053 
6054 static __inline__ vector short __ATTRS_o_ai vec_nor(vector short __a,
6055  vector short __b) {
6056  return ~(__a | __b);
6057 }
6058 
6059 static __inline__ vector unsigned short __ATTRS_o_ai
6060 vec_nor(vector unsigned short __a, vector unsigned short __b) {
6061  return ~(__a | __b);
6062 }
6063 
6064 static __inline__ vector bool short __ATTRS_o_ai
6065 vec_nor(vector bool short __a, vector bool short __b) {
6066  return ~(__a | __b);
6067 }
6068 
6069 static __inline__ vector int __ATTRS_o_ai vec_nor(vector int __a,
6070  vector int __b) {
6071  return ~(__a | __b);
6072 }
6073 
6074 static __inline__ vector unsigned int __ATTRS_o_ai
6075 vec_nor(vector unsigned int __a, vector unsigned int __b) {
6076  return ~(__a | __b);
6077 }
6078 
6079 static __inline__ vector bool int __ATTRS_o_ai vec_nor(vector bool int __a,
6080  vector bool int __b) {
6081  return ~(__a | __b);
6082 }
6083 
6084 static __inline__ vector float __ATTRS_o_ai vec_nor(vector float __a,
6085  vector float __b) {
6086  vector unsigned int __res =
6087  ~((vector unsigned int)__a | (vector unsigned int)__b);
6088  return (vector float)__res;
6089 }
6090 
6091 #ifdef __VSX__
6092 static __inline__ vector double __ATTRS_o_ai vec_nor(vector double __a,
6093  vector double __b) {
6094  vector unsigned long long __res =
6095  ~((vector unsigned long long)__a | (vector unsigned long long)__b);
6096  return (vector double)__res;
6097 }
6098 #endif
6099 
6100 /* vec_vnor */
6101 
6102 static __inline__ vector signed char __ATTRS_o_ai
6103 vec_vnor(vector signed char __a, vector signed char __b) {
6104  return ~(__a | __b);
6105 }
6106 
6107 static __inline__ vector unsigned char __ATTRS_o_ai
6108 vec_vnor(vector unsigned char __a, vector unsigned char __b) {
6109  return ~(__a | __b);
6110 }
6111 
6112 static __inline__ vector bool char __ATTRS_o_ai vec_vnor(vector bool char __a,
6113  vector bool char __b) {
6114  return ~(__a | __b);
6115 }
6116 
6117 static __inline__ vector short __ATTRS_o_ai vec_vnor(vector short __a,
6118  vector short __b) {
6119  return ~(__a | __b);
6120 }
6121 
6122 static __inline__ vector unsigned short __ATTRS_o_ai
6123 vec_vnor(vector unsigned short __a, vector unsigned short __b) {
6124  return ~(__a | __b);
6125 }
6126 
6127 static __inline__ vector bool short __ATTRS_o_ai
6128 vec_vnor(vector bool short __a, vector bool short __b) {
6129  return ~(__a | __b);
6130 }
6131 
6132 static __inline__ vector int __ATTRS_o_ai vec_vnor(vector int __a,
6133  vector int __b) {
6134  return ~(__a | __b);
6135 }
6136 
6137 static __inline__ vector unsigned int __ATTRS_o_ai
6138 vec_vnor(vector unsigned int __a, vector unsigned int __b) {
6139  return ~(__a | __b);
6140 }
6141 
6142 static __inline__ vector bool int __ATTRS_o_ai vec_vnor(vector bool int __a,
6143  vector bool int __b) {
6144  return ~(__a | __b);
6145 }
6146 
6147 static __inline__ vector float __ATTRS_o_ai vec_vnor(vector float __a,
6148  vector float __b) {
6149  vector unsigned int __res =
6150  ~((vector unsigned int)__a | (vector unsigned int)__b);
6151  return (vector float)__res;
6152 }
6153 
6154 #ifdef __VSX__
6155 static __inline__ vector signed long long __ATTRS_o_ai
6156 vec_nor(vector signed long long __a, vector signed long long __b) {
6157  return ~(__a | __b);
6158 }
6159 
6160 static __inline__ vector unsigned long long __ATTRS_o_ai
6161 vec_nor(vector unsigned long long __a, vector unsigned long long __b) {
6162  return ~(__a | __b);
6163 }
6164 
6165 static __inline__ vector bool long long __ATTRS_o_ai
6166 vec_nor(vector bool long long __a, vector bool long long __b) {
6167  return ~(__a | __b);
6168 }
6169 #endif
6170 
6171 /* vec_or */
6172 
6173 #define __builtin_altivec_vor vec_or
6174 
6175 static __inline__ vector signed char __ATTRS_o_ai
6176 vec_or(vector signed char __a, vector signed char __b) {
6177  return __a | __b;
6178 }
6179 
6180 static __inline__ vector signed char __ATTRS_o_ai
6181 vec_or(vector bool char __a, vector signed char __b) {
6182  return (vector signed char)__a | __b;
6183 }
6184 
6185 static __inline__ vector signed char __ATTRS_o_ai vec_or(vector signed char __a,
6186  vector bool char __b) {
6187  return __a | (vector signed char)__b;
6188 }
6189 
6190 static __inline__ vector unsigned char __ATTRS_o_ai
6191 vec_or(vector unsigned char __a, vector unsigned char __b) {
6192  return __a | __b;
6193 }
6194 
6195 static __inline__ vector unsigned char __ATTRS_o_ai
6196 vec_or(vector bool char __a, vector unsigned char __b) {
6197  return (vector unsigned char)__a | __b;
6198 }
6199 
6200 static __inline__ vector unsigned char __ATTRS_o_ai
6201 vec_or(vector unsigned char __a, vector bool char __b) {
6202  return __a | (vector unsigned char)__b;
6203 }
6204 
6205 static __inline__ vector bool char __ATTRS_o_ai vec_or(vector bool char __a,
6206  vector bool char __b) {
6207  return __a | __b;
6208 }
6209 
6210 static __inline__ vector short __ATTRS_o_ai vec_or(vector short __a,
6211  vector short __b) {
6212  return __a | __b;
6213 }
6214 
6215 static __inline__ vector short __ATTRS_o_ai vec_or(vector bool short __a,
6216  vector short __b) {
6217  return (vector short)__a | __b;
6218 }
6219 
6220 static __inline__ vector short __ATTRS_o_ai vec_or(vector short __a,
6221  vector bool short __b) {
6222  return __a | (vector short)__b;
6223 }
6224 
6225 static __inline__ vector unsigned short __ATTRS_o_ai
6226 vec_or(vector unsigned short __a, vector unsigned short __b) {
6227  return __a | __b;
6228 }
6229 
6230 static __inline__ vector unsigned short __ATTRS_o_ai
6231 vec_or(vector bool short __a, vector unsigned short __b) {
6232  return (vector unsigned short)__a | __b;
6233 }
6234 
6235 static __inline__ vector unsigned short __ATTRS_o_ai
6236 vec_or(vector unsigned short __a, vector bool short __b) {
6237  return __a | (vector unsigned short)__b;
6238 }
6239 
6240 static __inline__ vector bool short __ATTRS_o_ai vec_or(vector bool short __a,
6241  vector bool short __b) {
6242  return __a | __b;
6243 }
6244 
6245 static __inline__ vector int __ATTRS_o_ai vec_or(vector int __a,
6246  vector int __b) {
6247  return __a | __b;
6248 }
6249 
6250 static __inline__ vector int __ATTRS_o_ai vec_or(vector bool int __a,
6251  vector int __b) {
6252  return (vector int)__a | __b;
6253 }
6254 
6255 static __inline__ vector int __ATTRS_o_ai vec_or(vector int __a,
6256  vector bool int __b) {
6257  return __a | (vector int)__b;
6258 }
6259 
6260 static __inline__ vector unsigned int __ATTRS_o_ai
6261 vec_or(vector unsigned int __a, vector unsigned int __b) {
6262  return __a | __b;
6263 }
6264 
6265 static __inline__ vector unsigned int __ATTRS_o_ai
6266 vec_or(vector bool int __a, vector unsigned int __b) {
6267  return (vector unsigned int)__a | __b;
6268 }
6269 
6270 static __inline__ vector unsigned int __ATTRS_o_ai
6271 vec_or(vector unsigned int __a, vector bool int __b) {
6272  return __a | (vector unsigned int)__b;
6273 }
6274 
6275 static __inline__ vector bool int __ATTRS_o_ai vec_or(vector bool int __a,
6276  vector bool int __b) {
6277  return __a | __b;
6278 }
6279 
6280 static __inline__ vector float __ATTRS_o_ai vec_or(vector float __a,
6281  vector float __b) {
6282  vector unsigned int __res =
6283  (vector unsigned int)__a | (vector unsigned int)__b;
6284  return (vector float)__res;
6285 }
6286 
6287 static __inline__ vector float __ATTRS_o_ai vec_or(vector bool int __a,
6288  vector float __b) {
6289  vector unsigned int __res =
6290  (vector unsigned int)__a | (vector unsigned int)__b;
6291  return (vector float)__res;
6292 }
6293 
6294 static __inline__ vector float __ATTRS_o_ai vec_or(vector float __a,
6295  vector bool int __b) {
6296  vector unsigned int __res =
6297  (vector unsigned int)__a | (vector unsigned int)__b;
6298  return (vector float)__res;
6299 }
6300 
6301 #ifdef __VSX__
6302 static __inline__ vector double __ATTRS_o_ai vec_or(vector bool long long __a,
6303  vector double __b) {
6304  return (vector unsigned long long)__a | (vector unsigned long long)__b;
6305 }
6306 
6307 static __inline__ vector double __ATTRS_o_ai vec_or(vector double __a,
6308  vector bool long long __b) {
6309  return (vector unsigned long long)__a | (vector unsigned long long)__b;
6310 }
6311 
6312 static __inline__ vector double __ATTRS_o_ai vec_or(vector double __a,
6313  vector double __b) {
6314  vector unsigned long long __res =
6315  (vector unsigned long long)__a | (vector unsigned long long)__b;
6316  return (vector double)__res;
6317 }
6318 
6319 static __inline__ vector signed long long __ATTRS_o_ai
6320 vec_or(vector signed long long __a, vector signed long long __b) {
6321  return __a | __b;
6322 }
6323 
6324 static __inline__ vector signed long long __ATTRS_o_ai
6325 vec_or(vector bool long long __a, vector signed long long __b) {
6326  return (vector signed long long)__a | __b;
6327 }
6328 
6329 static __inline__ vector signed long long __ATTRS_o_ai
6330 vec_or(vector signed long long __a, vector bool long long __b) {
6331  return __a | (vector signed long long)__b;
6332 }
6333 
6334 static __inline__ vector unsigned long long __ATTRS_o_ai
6335 vec_or(vector unsigned long long __a, vector unsigned long long __b) {
6336  return __a | __b;
6337 }
6338 
6339 static __inline__ vector unsigned long long __ATTRS_o_ai
6340 vec_or(vector bool long long __a, vector unsigned long long __b) {
6341  return (vector unsigned long long)__a | __b;
6342 }
6343 
6344 static __inline__ vector unsigned long long __ATTRS_o_ai
6345 vec_or(vector unsigned long long __a, vector bool long long __b) {
6346  return __a | (vector unsigned long long)__b;
6347 }
6348 
6349 static __inline__ vector bool long long __ATTRS_o_ai
6350 vec_or(vector bool long long __a, vector bool long long __b) {
6351  return __a | __b;
6352 }
6353 #endif
6354 
6355 #ifdef __POWER8_VECTOR__
6356 static __inline__ vector signed char __ATTRS_o_ai
6357 vec_orc(vector signed char __a, vector signed char __b) {
6358  return __a | ~__b;
6359 }
6360 
6361 static __inline__ vector signed char __ATTRS_o_ai
6362 vec_orc(vector signed char __a, vector bool char __b) {
6363  return __a | ~__b;
6364 }
6365 
6366 static __inline__ vector signed char __ATTRS_o_ai
6367 vec_orc(vector bool char __a, vector signed char __b) {
6368  return __a | ~__b;
6369 }
6370 
6371 static __inline__ vector unsigned char __ATTRS_o_ai
6372 vec_orc(vector unsigned char __a, vector unsigned char __b) {
6373  return __a | ~__b;
6374 }
6375 
6376 static __inline__ vector unsigned char __ATTRS_o_ai
6377 vec_orc(vector unsigned char __a, vector bool char __b) {
6378  return __a | ~__b;
6379 }
6380 
6381 static __inline__ vector unsigned char __ATTRS_o_ai
6382 vec_orc(vector bool char __a, vector unsigned char __b) {
6383  return __a | ~__b;
6384 }
6385 
6386 static __inline__ vector bool char __ATTRS_o_ai vec_orc(vector bool char __a,
6387  vector bool char __b) {
6388  return __a | ~__b;
6389 }
6390 
6391 static __inline__ vector signed short __ATTRS_o_ai
6392 vec_orc(vector signed short __a, vector signed short __b) {
6393  return __a | ~__b;
6394 }
6395 
6396 static __inline__ vector signed short __ATTRS_o_ai
6397 vec_orc(vector signed short __a, vector bool short __b) {
6398  return __a | ~__b;
6399 }
6400 
6401 static __inline__ vector signed short __ATTRS_o_ai
6402 vec_orc(vector bool short __a, vector signed short __b) {
6403  return __a | ~__b;
6404 }
6405 
6406 static __inline__ vector unsigned short __ATTRS_o_ai
6407 vec_orc(vector unsigned short __a, vector unsigned short __b) {
6408  return __a | ~__b;
6409 }
6410 
6411 static __inline__ vector unsigned short __ATTRS_o_ai
6412 vec_orc(vector unsigned short __a, vector bool short __b) {
6413  return __a | ~__b;
6414 }
6415 
6416 static __inline__ vector unsigned short __ATTRS_o_ai
6417 vec_orc(vector bool short __a, vector unsigned short __b) {
6418  return __a | ~__b;
6419 }
6420 
6421 static __inline__ vector bool short __ATTRS_o_ai
6422 vec_orc(vector bool short __a, vector bool short __b) {
6423  return __a | ~__b;
6424 }
6425 
6426 static __inline__ vector signed int __ATTRS_o_ai
6427 vec_orc(vector signed int __a, vector signed int __b) {
6428  return __a | ~__b;
6429 }
6430 
6431 static __inline__ vector signed int __ATTRS_o_ai vec_orc(vector signed int __a,
6432  vector bool int __b) {
6433  return __a | ~__b;
6434 }
6435 
6436 static __inline__ vector signed int __ATTRS_o_ai
6437 vec_orc(vector bool int __a, vector signed int __b) {
6438  return __a | ~__b;
6439 }
6440 
6441 static __inline__ vector unsigned int __ATTRS_o_ai
6442 vec_orc(vector unsigned int __a, vector unsigned int __b) {
6443  return __a | ~__b;
6444 }
6445 
6446 static __inline__ vector unsigned int __ATTRS_o_ai
6447 vec_orc(vector unsigned int __a, vector bool int __b) {
6448  return __a | ~__b;
6449 }
6450 
6451 static __inline__ vector unsigned int __ATTRS_o_ai
6452 vec_orc(vector bool int __a, vector unsigned int __b) {
6453  return __a | ~__b;
6454 }
6455 
6456 static __inline__ vector bool int __ATTRS_o_ai vec_orc(vector bool int __a,
6457  vector bool int __b) {
6458  return __a | ~__b;
6459 }
6460 
6461 static __inline__ vector float __ATTRS_o_ai
6462 vec_orc(vector bool int __a, vector float __b) {
6463  return (vector float)(__a | ~(vector unsigned int)__b);
6464 }
6465 
6466 static __inline__ vector float __ATTRS_o_ai
6467 vec_orc(vector float __a, vector bool int __b) {
6468  return (vector float)((vector unsigned int)__a | ~__b);
6469 }
6470 
6471 static __inline__ vector signed long long __ATTRS_o_ai
6472 vec_orc(vector signed long long __a, vector signed long long __b) {
6473  return __a | ~__b;
6474 }
6475 
6476 static __inline__ vector signed long long __ATTRS_o_ai
6477 vec_orc(vector signed long long __a, vector bool long long __b) {
6478  return __a | ~__b;
6479 }
6480 
6481 static __inline__ vector signed long long __ATTRS_o_ai
6482 vec_orc(vector bool long long __a, vector signed long long __b) {
6483  return __a | ~__b;
6484 }
6485 
6486 static __inline__ vector unsigned long long __ATTRS_o_ai
6487 vec_orc(vector unsigned long long __a, vector unsigned long long __b) {
6488  return __a | ~__b;
6489 }
6490 
6491 static __inline__ vector unsigned long long __ATTRS_o_ai
6492 vec_orc(vector unsigned long long __a, vector bool long long __b) {
6493  return __a | ~__b;
6494 }
6495 
6496 static __inline__ vector unsigned long long __ATTRS_o_ai
6497 vec_orc(vector bool long long __a, vector unsigned long long __b) {
6498  return __a | ~__b;
6499 }
6500 
6501 static __inline__ vector bool long long __ATTRS_o_ai
6502 vec_orc(vector bool long long __a, vector bool long long __b) {
6503  return __a | ~__b;
6504 }
6505 
6506 static __inline__ vector double __ATTRS_o_ai
6507 vec_orc(vector double __a, vector bool long long __b) {
6508  return (vector double)((vector unsigned long long)__a | ~__b);
6509 }
6510 
6511 static __inline__ vector double __ATTRS_o_ai
6512 vec_orc(vector bool long long __a, vector double __b) {
6513  return (vector double)(__a | ~(vector unsigned long long)__b);
6514 }
6515 #endif
6516 
6517 /* vec_vor */
6518 
6519 static __inline__ vector signed char __ATTRS_o_ai
6520 vec_vor(vector signed char __a, vector signed char __b) {
6521  return __a | __b;
6522 }
6523 
6524 static __inline__ vector signed char __ATTRS_o_ai
6525 vec_vor(vector bool char __a, vector signed char __b) {
6526  return (vector signed char)__a | __b;
6527 }
6528 
6529 static __inline__ vector signed char __ATTRS_o_ai
6530 vec_vor(vector signed char __a, vector bool char __b) {
6531  return __a | (vector signed char)__b;
6532 }
6533 
6534 static __inline__ vector unsigned char __ATTRS_o_ai
6535 vec_vor(vector unsigned char __a, vector unsigned char __b) {
6536  return __a | __b;
6537 }
6538 
6539 static __inline__ vector unsigned char __ATTRS_o_ai
6540 vec_vor(vector bool char __a, vector unsigned char __b) {
6541  return (vector unsigned char)__a | __b;
6542 }
6543 
6544 static __inline__ vector unsigned char __ATTRS_o_ai
6545 vec_vor(vector unsigned char __a, vector bool char __b) {
6546  return __a | (vector unsigned char)__b;
6547 }
6548 
6549 static __inline__ vector bool char __ATTRS_o_ai vec_vor(vector bool char __a,
6550  vector bool char __b) {
6551  return __a | __b;
6552 }
6553 
6554 static __inline__ vector short __ATTRS_o_ai vec_vor(vector short __a,
6555  vector short __b) {
6556  return __a | __b;
6557 }
6558 
6559 static __inline__ vector short __ATTRS_o_ai vec_vor(vector bool short __a,
6560  vector short __b) {
6561  return (vector short)__a | __b;
6562 }
6563 
6564 static __inline__ vector short __ATTRS_o_ai vec_vor(vector short __a,
6565  vector bool short __b) {
6566  return __a | (vector short)__b;
6567 }
6568 
6569 static __inline__ vector unsigned short __ATTRS_o_ai
6570 vec_vor(vector unsigned short __a, vector unsigned short __b) {
6571  return __a | __b;
6572 }
6573 
6574 static __inline__ vector unsigned short __ATTRS_o_ai
6575 vec_vor(vector bool short __a, vector unsigned short __b) {
6576  return (vector unsigned short)__a | __b;
6577 }
6578 
6579 static __inline__ vector unsigned short __ATTRS_o_ai
6580 vec_vor(vector unsigned short __a, vector bool short __b) {
6581  return __a | (vector unsigned short)__b;
6582 }
6583 
6584 static __inline__ vector bool short __ATTRS_o_ai
6585 vec_vor(vector bool short __a, vector bool short __b) {
6586  return __a | __b;
6587 }
6588 
6589 static __inline__ vector int __ATTRS_o_ai vec_vor(vector int __a,
6590  vector int __b) {
6591  return __a | __b;
6592 }
6593 
6594 static __inline__ vector int __ATTRS_o_ai vec_vor(vector bool int __a,
6595  vector int __b) {
6596  return (vector int)__a | __b;
6597 }
6598 
6599 static __inline__ vector int __ATTRS_o_ai vec_vor(vector int __a,
6600  vector bool int __b) {
6601  return __a | (vector int)__b;
6602 }
6603 
6604 static __inline__ vector unsigned int __ATTRS_o_ai
6605 vec_vor(vector unsigned int __a, vector unsigned int __b) {
6606  return __a | __b;
6607 }
6608 
6609 static __inline__ vector unsigned int __ATTRS_o_ai
6610 vec_vor(vector bool int __a, vector unsigned int __b) {
6611  return (vector unsigned int)__a | __b;
6612 }
6613 
6614 static __inline__ vector unsigned int __ATTRS_o_ai
6615 vec_vor(vector unsigned int __a, vector bool int __b) {
6616  return __a | (vector unsigned int)__b;
6617 }
6618 
6619 static __inline__ vector bool int __ATTRS_o_ai vec_vor(vector bool int __a,
6620  vector bool int __b) {
6621  return __a | __b;
6622 }
6623 
6624 static __inline__ vector float __ATTRS_o_ai vec_vor(vector float __a,
6625  vector float __b) {
6626  vector unsigned int __res =
6627  (vector unsigned int)__a | (vector unsigned int)__b;
6628  return (vector float)__res;
6629 }
6630 
6631 static __inline__ vector float __ATTRS_o_ai vec_vor(vector bool int __a,
6632  vector float __b) {
6633  vector unsigned int __res =
6634  (vector unsigned int)__a | (vector unsigned int)__b;
6635  return (vector float)__res;
6636 }
6637 
6638 static __inline__ vector float __ATTRS_o_ai vec_vor(vector float __a,
6639  vector bool int __b) {
6640  vector unsigned int __res =
6641  (vector unsigned int)__a | (vector unsigned int)__b;
6642  return (vector float)__res;
6643 }
6644 
6645 #ifdef __VSX__
6646 static __inline__ vector signed long long __ATTRS_o_ai
6647 vec_vor(vector signed long long __a, vector signed long long __b) {
6648  return __a | __b;
6649 }
6650 
6651 static __inline__ vector signed long long __ATTRS_o_ai
6652 vec_vor(vector bool long long __a, vector signed long long __b) {
6653  return (vector signed long long)__a | __b;
6654 }
6655 
6656 static __inline__ vector signed long long __ATTRS_o_ai
6657 vec_vor(vector signed long long __a, vector bool long long __b) {
6658  return __a | (vector signed long long)__b;
6659 }
6660 
6661 static __inline__ vector unsigned long long __ATTRS_o_ai
6662 vec_vor(vector unsigned long long __a, vector unsigned long long __b) {
6663  return __a | __b;
6664 }
6665 
6666 static __inline__ vector unsigned long long __ATTRS_o_ai
6667 vec_vor(vector bool long long __a, vector unsigned long long __b) {
6668  return (vector unsigned long long)__a | __b;
6669 }
6670 
6671 static __inline__ vector unsigned long long __ATTRS_o_ai
6672 vec_vor(vector unsigned long long __a, vector bool long long __b) {
6673  return __a | (vector unsigned long long)__b;
6674 }
6675 
6676 static __inline__ vector bool long long __ATTRS_o_ai
6677 vec_vor(vector bool long long __a, vector bool long long __b) {
6678  return __a | __b;
6679 }
6680 #endif
6681 
6682 /* vec_pack */
6683 
6684 /* The various vector pack instructions have a big-endian bias, so for
6685  little endian we must handle reversed element numbering. */
6686 
6687 static __inline__ vector signed char __ATTRS_o_ai
6688 vec_pack(vector signed short __a, vector signed short __b) {
6689 #ifdef __LITTLE_ENDIAN__
6690  return (vector signed char)vec_perm(
6691  __a, __b,
6692  (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
6693  0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
6694 #else
6695  return (vector signed char)vec_perm(
6696  __a, __b,
6697  (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
6698  0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
6699 #endif
6700 }
6701 
6702 static __inline__ vector unsigned char __ATTRS_o_ai
6703 vec_pack(vector unsigned short __a, vector unsigned short __b) {
6704 #ifdef __LITTLE_ENDIAN__
6705  return (vector unsigned char)vec_perm(
6706  __a, __b,
6707  (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
6708  0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
6709 #else
6710  return (vector unsigned char)vec_perm(
6711  __a, __b,
6712  (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
6713  0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
6714 #endif
6715 }
6716 
6717 static __inline__ vector bool char __ATTRS_o_ai
6718 vec_pack(vector bool short __a, vector bool short __b) {
6719 #ifdef __LITTLE_ENDIAN__
6720  return (vector bool char)vec_perm(
6721  __a, __b,
6722  (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
6723  0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
6724 #else
6725  return (vector bool char)vec_perm(
6726  __a, __b,
6727  (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
6728  0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
6729 #endif
6730 }
6731 
6732 static __inline__ vector short __ATTRS_o_ai vec_pack(vector int __a,
6733  vector int __b) {
6734 #ifdef __LITTLE_ENDIAN__
6735  return (vector short)vec_perm(
6736  __a, __b,
6737  (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
6738  0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
6739 #else
6740  return (vector short)vec_perm(
6741  __a, __b,
6742  (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
6743  0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
6744 #endif
6745 }
6746 
6747 static __inline__ vector unsigned short __ATTRS_o_ai
6748 vec_pack(vector unsigned int __a, vector unsigned int __b) {
6749 #ifdef __LITTLE_ENDIAN__
6750  return (vector unsigned short)vec_perm(
6751  __a, __b,
6752  (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
6753  0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
6754 #else
6755  return (vector unsigned short)vec_perm(
6756  __a, __b,
6757  (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
6758  0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
6759 #endif
6760 }
6761 
6762 static __inline__ vector bool short __ATTRS_o_ai vec_pack(vector bool int __a,
6763  vector bool int __b) {
6764 #ifdef __LITTLE_ENDIAN__
6765  return (vector bool short)vec_perm(
6766  __a, __b,
6767  (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
6768  0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
6769 #else
6770  return (vector bool short)vec_perm(
6771  __a, __b,
6772  (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
6773  0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
6774 #endif
6775 }
6776 
6777 #ifdef __VSX__
6778 static __inline__ vector signed int __ATTRS_o_ai
6779 vec_pack(vector signed long long __a, vector signed long long __b) {
6780 #ifdef __LITTLE_ENDIAN__
6781  return (vector signed int)vec_perm(
6782  __a, __b,
6783  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
6784  0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
6785 #else
6786  return (vector signed int)vec_perm(
6787  __a, __b,
6788  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
6789  0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
6790 #endif
6791 }
6792 static __inline__ vector unsigned int __ATTRS_o_ai
6793 vec_pack(vector unsigned long long __a, vector unsigned long long __b) {
6794 #ifdef __LITTLE_ENDIAN__
6795  return (vector unsigned 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 unsigned 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 
6807 static __inline__ vector bool int __ATTRS_o_ai
6808 vec_pack(vector bool long long __a, vector bool long long __b) {
6809 #ifdef __LITTLE_ENDIAN__
6810  return (vector bool int)vec_perm(
6811  __a, __b,
6812  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
6813  0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
6814 #else
6815  return (vector bool int)vec_perm(
6816  __a, __b,
6817  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
6818  0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
6819 #endif
6820 }
6821 
6822 static __inline__ vector float __ATTRS_o_ai
6823 vec_pack(vector double __a, vector double __b) {
6824  return (vector float) (__a[0], __a[1], __b[0], __b[1]);
6825 }
6826 #endif
6827 
6828 #ifdef __POWER9_VECTOR__
6829 static __inline__ vector unsigned short __ATTRS_o_ai
6830 vec_pack_to_short_fp32(vector float __a, vector float __b) {
6831  vector float __resa = __builtin_vsx_xvcvsphp(__a);
6832  vector float __resb = __builtin_vsx_xvcvsphp(__b);
6833 #ifdef __LITTLE_ENDIAN__
6834  return (vector unsigned short)vec_mergee(__resa, __resb);
6835 #else
6836  return (vector unsigned short)vec_mergeo(__resa, __resb);
6837 #endif
6838 }
6839 
6840 #endif
6841 /* vec_vpkuhum */
6842 
6843 #define __builtin_altivec_vpkuhum vec_vpkuhum
6844 
6845 static __inline__ vector signed char __ATTRS_o_ai
6846 vec_vpkuhum(vector signed short __a, vector signed short __b) {
6847 #ifdef __LITTLE_ENDIAN__
6848  return (vector signed char)vec_perm(
6849  __a, __b,
6850  (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
6851  0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
6852 #else
6853  return (vector signed char)vec_perm(
6854  __a, __b,
6855  (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
6856  0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
6857 #endif
6858 }
6859 
6860 static __inline__ vector unsigned char __ATTRS_o_ai
6861 vec_vpkuhum(vector unsigned short __a, vector unsigned short __b) {
6862 #ifdef __LITTLE_ENDIAN__
6863  return (vector unsigned char)vec_perm(
6864  __a, __b,
6865  (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
6866  0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
6867 #else
6868  return (vector unsigned char)vec_perm(
6869  __a, __b,
6870  (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
6871  0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
6872 #endif
6873 }
6874 
6875 static __inline__ vector bool char __ATTRS_o_ai
6876 vec_vpkuhum(vector bool short __a, vector bool short __b) {
6877 #ifdef __LITTLE_ENDIAN__
6878  return (vector bool char)vec_perm(
6879  __a, __b,
6880  (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
6881  0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
6882 #else
6883  return (vector bool char)vec_perm(
6884  __a, __b,
6885  (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
6886  0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
6887 #endif
6888 }
6889 
6890 /* vec_vpkuwum */
6891 
6892 #define __builtin_altivec_vpkuwum vec_vpkuwum
6893 
6894 static __inline__ vector short __ATTRS_o_ai vec_vpkuwum(vector int __a,
6895  vector int __b) {
6896 #ifdef __LITTLE_ENDIAN__
6897  return (vector short)vec_perm(
6898  __a, __b,
6899  (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
6900  0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
6901 #else
6902  return (vector short)vec_perm(
6903  __a, __b,
6904  (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
6905  0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
6906 #endif
6907 }
6908 
6909 static __inline__ vector unsigned short __ATTRS_o_ai
6910 vec_vpkuwum(vector unsigned int __a, vector unsigned int __b) {
6911 #ifdef __LITTLE_ENDIAN__
6912  return (vector unsigned short)vec_perm(
6913  __a, __b,
6914  (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
6915  0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
6916 #else
6917  return (vector unsigned short)vec_perm(
6918  __a, __b,
6919  (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
6920  0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
6921 #endif
6922 }
6923 
6924 static __inline__ vector bool short __ATTRS_o_ai
6925 vec_vpkuwum(vector bool int __a, vector bool int __b) {
6926 #ifdef __LITTLE_ENDIAN__
6927  return (vector bool short)vec_perm(
6928  __a, __b,
6929  (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
6930  0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
6931 #else
6932  return (vector bool short)vec_perm(
6933  __a, __b,
6934  (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
6935  0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
6936 #endif
6937 }
6938 
6939 /* vec_vpkudum */
6940 
6941 #ifdef __POWER8_VECTOR__
6942 #define __builtin_altivec_vpkudum vec_vpkudum
6943 
6944 static __inline__ vector int __ATTRS_o_ai vec_vpkudum(vector long long __a,
6945  vector long long __b) {
6946 #ifdef __LITTLE_ENDIAN__
6947  return (vector int)vec_perm(
6948  __a, __b,
6949  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
6950  0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
6951 #else
6952  return (vector int)vec_perm(
6953  __a, __b,
6954  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
6955  0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
6956 #endif
6957 }
6958 
6959 static __inline__ vector unsigned int __ATTRS_o_ai
6960 vec_vpkudum(vector unsigned long long __a, vector unsigned long long __b) {
6961 #ifdef __LITTLE_ENDIAN__
6962  return (vector unsigned int)vec_perm(
6963  __a, __b,
6964  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
6965  0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
6966 #else
6967  return (vector unsigned int)vec_perm(
6968  __a, __b,
6969  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
6970  0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
6971 #endif
6972 }
6973 
6974 static __inline__ vector bool int __ATTRS_o_ai
6975 vec_vpkudum(vector bool long long __a, vector bool long long __b) {
6976 #ifdef __LITTLE_ENDIAN__
6977  return (vector bool int)vec_perm(
6978  (vector long long)__a, (vector long long)__b,
6979  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
6980  0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
6981 #else
6982  return (vector bool int)vec_perm(
6983  (vector long long)__a, (vector long long)__b,
6984  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
6985  0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
6986 #endif
6987 }
6988 #endif
6989 
6990 /* vec_packpx */
6991 
6992 static __inline__ vector pixel __attribute__((__always_inline__))
6993 vec_packpx(vector unsigned int __a, vector unsigned int __b) {
6994 #ifdef __LITTLE_ENDIAN__
6995  return (vector pixel)__builtin_altivec_vpkpx(__b, __a);
6996 #else
6997  return (vector pixel)__builtin_altivec_vpkpx(__a, __b);
6998 #endif
6999 }
7000 
7001 /* vec_vpkpx */
7002 
7003 static __inline__ vector pixel __attribute__((__always_inline__))
7004 vec_vpkpx(vector unsigned int __a, vector unsigned int __b) {
7005 #ifdef __LITTLE_ENDIAN__
7006  return (vector pixel)__builtin_altivec_vpkpx(__b, __a);
7007 #else
7008  return (vector pixel)__builtin_altivec_vpkpx(__a, __b);
7009 #endif
7010 }
7011 
7012 /* vec_packs */
7013 
7014 static __inline__ vector signed char __ATTRS_o_ai vec_packs(vector short __a,
7015  vector short __b) {
7016 #ifdef __LITTLE_ENDIAN__
7017  return __builtin_altivec_vpkshss(__b, __a);
7018 #else
7019  return __builtin_altivec_vpkshss(__a, __b);
7020 #endif
7021 }
7022 
7023 static __inline__ vector unsigned char __ATTRS_o_ai
7024 vec_packs(vector unsigned short __a, vector unsigned short __b) {
7025 #ifdef __LITTLE_ENDIAN__
7026  return __builtin_altivec_vpkuhus(__b, __a);
7027 #else
7028  return __builtin_altivec_vpkuhus(__a, __b);
7029 #endif
7030 }
7031 
7032 static __inline__ vector signed short __ATTRS_o_ai vec_packs(vector int __a,
7033  vector int __b) {
7034 #ifdef __LITTLE_ENDIAN__
7035  return __builtin_altivec_vpkswss(__b, __a);
7036 #else
7037  return __builtin_altivec_vpkswss(__a, __b);
7038 #endif
7039 }
7040 
7041 static __inline__ vector unsigned short __ATTRS_o_ai
7042 vec_packs(vector unsigned int __a, vector unsigned int __b) {
7043 #ifdef __LITTLE_ENDIAN__
7044  return __builtin_altivec_vpkuwus(__b, __a);
7045 #else
7046  return __builtin_altivec_vpkuwus(__a, __b);
7047 #endif
7048 }
7049 
7050 #ifdef __POWER8_VECTOR__
7051 static __inline__ vector int __ATTRS_o_ai vec_packs(vector long long __a,
7052  vector long long __b) {
7053 #ifdef __LITTLE_ENDIAN__
7054  return __builtin_altivec_vpksdss(__b, __a);
7055 #else
7056  return __builtin_altivec_vpksdss(__a, __b);
7057 #endif
7058 }
7059 
7060 static __inline__ vector unsigned int __ATTRS_o_ai
7061 vec_packs(vector unsigned long long __a, vector unsigned long long __b) {
7062 #ifdef __LITTLE_ENDIAN__
7063  return __builtin_altivec_vpkudus(__b, __a);
7064 #else
7065  return __builtin_altivec_vpkudus(__a, __b);
7066 #endif
7067 }
7068 #endif
7069 
7070 /* vec_vpkshss */
7071 
7072 static __inline__ vector signed char __attribute__((__always_inline__))
7073 vec_vpkshss(vector short __a, vector short __b) {
7074 #ifdef __LITTLE_ENDIAN__
7075  return __builtin_altivec_vpkshss(__b, __a);
7076 #else
7077  return __builtin_altivec_vpkshss(__a, __b);
7078 #endif
7079 }
7080 
7081 /* vec_vpksdss */
7082 
7083 #ifdef __POWER8_VECTOR__
7084 static __inline__ vector int __ATTRS_o_ai vec_vpksdss(vector long long __a,
7085  vector long long __b) {
7086 #ifdef __LITTLE_ENDIAN__
7087  return __builtin_altivec_vpksdss(__b, __a);
7088 #else
7089  return __builtin_altivec_vpksdss(__a, __b);
7090 #endif
7091 }
7092 #endif
7093 
7094 /* vec_vpkuhus */
7095 
7096 static __inline__ vector unsigned char __attribute__((__always_inline__))
7097 vec_vpkuhus(vector unsigned short __a, vector unsigned short __b) {
7098 #ifdef __LITTLE_ENDIAN__
7099  return __builtin_altivec_vpkuhus(__b, __a);
7100 #else
7101  return __builtin_altivec_vpkuhus(__a, __b);
7102 #endif
7103 }
7104 
7105 /* vec_vpkudus */
7106 
7107 #ifdef __POWER8_VECTOR__
7108 static __inline__ vector unsigned int __attribute__((__always_inline__))
7109 vec_vpkudus(vector unsigned long long __a, vector unsigned long long __b) {
7110 #ifdef __LITTLE_ENDIAN__
7111  return __builtin_altivec_vpkudus(__b, __a);
7112 #else
7113  return __builtin_altivec_vpkudus(__a, __b);
7114 #endif
7115 }
7116 #endif
7117 
7118 /* vec_vpkswss */
7119 
7120 static __inline__ vector signed short __attribute__((__always_inline__))
7121 vec_vpkswss(vector int __a, vector int __b) {
7122 #ifdef __LITTLE_ENDIAN__
7123  return __builtin_altivec_vpkswss(__b, __a);
7124 #else
7125  return __builtin_altivec_vpkswss(__a, __b);
7126 #endif
7127 }
7128 
7129 /* vec_vpkuwus */
7130 
7131 static __inline__ vector unsigned short __attribute__((__always_inline__))
7132 vec_vpkuwus(vector unsigned int __a, vector unsigned int __b) {
7133 #ifdef __LITTLE_ENDIAN__
7134  return __builtin_altivec_vpkuwus(__b, __a);
7135 #else
7136  return __builtin_altivec_vpkuwus(__a, __b);
7137 #endif
7138 }
7139 
7140 /* vec_packsu */
7141 
7142 static __inline__ vector unsigned char __ATTRS_o_ai
7143 vec_packsu(vector short __a, vector short __b) {
7144 #ifdef __LITTLE_ENDIAN__
7145  return __builtin_altivec_vpkshus(__b, __a);
7146 #else
7147  return __builtin_altivec_vpkshus(__a, __b);
7148 #endif
7149 }
7150 
7151 static __inline__ vector unsigned char __ATTRS_o_ai
7152 vec_packsu(vector unsigned short __a, vector unsigned short __b) {
7153 #ifdef __LITTLE_ENDIAN__
7154  return __builtin_altivec_vpkuhus(__b, __a);
7155 #else
7156  return __builtin_altivec_vpkuhus(__a, __b);
7157 #endif
7158 }
7159 
7160 static __inline__ vector unsigned short __ATTRS_o_ai
7161 vec_packsu(vector int __a, vector int __b) {
7162 #ifdef __LITTLE_ENDIAN__
7163  return __builtin_altivec_vpkswus(__b, __a);
7164 #else
7165  return __builtin_altivec_vpkswus(__a, __b);
7166 #endif
7167 }
7168 
7169 static __inline__ vector unsigned short __ATTRS_o_ai
7170 vec_packsu(vector unsigned int __a, vector unsigned int __b) {
7171 #ifdef __LITTLE_ENDIAN__
7172  return __builtin_altivec_vpkuwus(__b, __a);
7173 #else
7174  return __builtin_altivec_vpkuwus(__a, __b);
7175 #endif
7176 }
7177 
7178 #ifdef __POWER8_VECTOR__
7179 static __inline__ vector unsigned int __ATTRS_o_ai
7180 vec_packsu(vector long long __a, vector long long __b) {
7181 #ifdef __LITTLE_ENDIAN__
7182  return __builtin_altivec_vpksdus(__b, __a);
7183 #else
7184  return __builtin_altivec_vpksdus(__a, __b);
7185 #endif
7186 }
7187 
7188 static __inline__ vector unsigned int __ATTRS_o_ai
7189 vec_packsu(vector unsigned long long __a, vector unsigned long long __b) {
7190 #ifdef __LITTLE_ENDIAN__
7191  return __builtin_altivec_vpkudus(__b, __a);
7192 #else
7193  return __builtin_altivec_vpkudus(__a, __b);
7194 #endif
7195 }
7196 #endif
7197 
7198 /* vec_vpkshus */
7199 
7200 static __inline__ vector unsigned char __ATTRS_o_ai
7201 vec_vpkshus(vector short __a, vector short __b) {
7202 #ifdef __LITTLE_ENDIAN__
7203  return __builtin_altivec_vpkshus(__b, __a);
7204 #else
7205  return __builtin_altivec_vpkshus(__a, __b);
7206 #endif
7207 }
7208 
7209 static __inline__ vector unsigned char __ATTRS_o_ai
7210 vec_vpkshus(vector unsigned short __a, vector unsigned short __b) {
7211 #ifdef __LITTLE_ENDIAN__
7212  return __builtin_altivec_vpkuhus(__b, __a);
7213 #else
7214  return __builtin_altivec_vpkuhus(__a, __b);
7215 #endif
7216 }
7217 
7218 /* vec_vpkswus */
7219 
7220 static __inline__ vector unsigned short __ATTRS_o_ai
7221 vec_vpkswus(vector int __a, vector int __b) {
7222 #ifdef __LITTLE_ENDIAN__
7223  return __builtin_altivec_vpkswus(__b, __a);
7224 #else
7225  return __builtin_altivec_vpkswus(__a, __b);
7226 #endif
7227 }
7228 
7229 static __inline__ vector unsigned short __ATTRS_o_ai
7230 vec_vpkswus(vector unsigned int __a, vector unsigned int __b) {
7231 #ifdef __LITTLE_ENDIAN__
7232  return __builtin_altivec_vpkuwus(__b, __a);
7233 #else
7234  return __builtin_altivec_vpkuwus(__a, __b);
7235 #endif
7236 }
7237 
7238 /* vec_vpksdus */
7239 
7240 #ifdef __POWER8_VECTOR__
7241 static __inline__ vector unsigned int __ATTRS_o_ai
7242 vec_vpksdus(vector long long __a, vector long long __b) {
7243 #ifdef __LITTLE_ENDIAN__
7244  return __builtin_altivec_vpksdus(__b, __a);
7245 #else
7246  return __builtin_altivec_vpksdus(__a, __b);
7247 #endif
7248 }
7249 #endif
7250 
7251 /* vec_perm */
7252 
7253 // The vperm instruction is defined architecturally with a big-endian bias.
7254 // For little endian, we swap the input operands and invert the permute
7255 // control vector. Only the rightmost 5 bits matter, so we could use
7256 // a vector of all 31s instead of all 255s to perform the inversion.
7257 // However, when the PCV is not a constant, using 255 has an advantage
7258 // in that the vec_xor can be recognized as a vec_nor (and for P8 and
7259 // later, possibly a vec_nand).
7260 
7261 static __inline__ vector signed char __ATTRS_o_ai vec_perm(
7262  vector signed char __a, vector signed char __b, vector unsigned char __c) {
7263 #ifdef __LITTLE_ENDIAN__
7264  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7265  255, 255, 255, 255, 255, 255, 255, 255};
7266  __d = vec_xor(__c, __d);
7267  return (vector signed char)__builtin_altivec_vperm_4si((vector int)__b,
7268  (vector int)__a, __d);
7269 #else
7270  return (vector signed char)__builtin_altivec_vperm_4si((vector int)__a,
7271  (vector int)__b, __c);
7272 #endif
7273 }
7274 
7275 static __inline__ vector unsigned char __ATTRS_o_ai
7276 vec_perm(vector unsigned char __a, vector unsigned char __b,
7277  vector unsigned char __c) {
7278 #ifdef __LITTLE_ENDIAN__
7279  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7280  255, 255, 255, 255, 255, 255, 255, 255};
7281  __d = vec_xor(__c, __d);
7282  return (vector unsigned char)__builtin_altivec_vperm_4si(
7283  (vector int)__b, (vector int)__a, __d);
7284 #else
7285  return (vector unsigned char)__builtin_altivec_vperm_4si(
7286  (vector int)__a, (vector int)__b, __c);
7287 #endif
7288 }
7289 
7290 static __inline__ vector bool char __ATTRS_o_ai
7291 vec_perm(vector bool char __a, vector bool char __b, 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 bool char)__builtin_altivec_vperm_4si((vector int)__b,
7297  (vector int)__a, __d);
7298 #else
7299  return (vector bool char)__builtin_altivec_vperm_4si((vector int)__a,
7300  (vector int)__b, __c);
7301 #endif
7302 }
7303 
7304 static __inline__ vector short __ATTRS_o_ai vec_perm(vector signed short __a,
7305  vector signed short __b,
7306  vector unsigned char __c) {
7307 #ifdef __LITTLE_ENDIAN__
7308  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7309  255, 255, 255, 255, 255, 255, 255, 255};
7310  __d = vec_xor(__c, __d);
7311  return (vector signed short)__builtin_altivec_vperm_4si((vector int)__b,
7312  (vector int)__a, __d);
7313 #else
7314  return (vector signed short)__builtin_altivec_vperm_4si((vector int)__a,
7315  (vector int)__b, __c);
7316 #endif
7317 }
7318 
7319 static __inline__ vector unsigned short __ATTRS_o_ai
7320 vec_perm(vector unsigned short __a, vector unsigned short __b,
7321  vector unsigned char __c) {
7322 #ifdef __LITTLE_ENDIAN__
7323  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7324  255, 255, 255, 255, 255, 255, 255, 255};
7325  __d = vec_xor(__c, __d);
7326  return (vector unsigned short)__builtin_altivec_vperm_4si(
7327  (vector int)__b, (vector int)__a, __d);
7328 #else
7329  return (vector unsigned short)__builtin_altivec_vperm_4si(
7330  (vector int)__a, (vector int)__b, __c);
7331 #endif
7332 }
7333 
7334 static __inline__ vector bool short __ATTRS_o_ai vec_perm(
7335  vector bool short __a, vector bool short __b, 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 bool short)__builtin_altivec_vperm_4si((vector int)__b,
7341  (vector int)__a, __d);
7342 #else
7343  return (vector bool short)__builtin_altivec_vperm_4si((vector int)__a,
7344  (vector int)__b, __c);
7345 #endif
7346 }
7347 
7348 static __inline__ vector pixel __ATTRS_o_ai vec_perm(vector pixel __a,
7349  vector pixel __b,
7350  vector unsigned char __c) {
7351 #ifdef __LITTLE_ENDIAN__
7352  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7353  255, 255, 255, 255, 255, 255, 255, 255};
7354  __d = vec_xor(__c, __d);
7355  return (vector pixel)__builtin_altivec_vperm_4si((vector int)__b,
7356  (vector int)__a, __d);
7357 #else
7358  return (vector pixel)__builtin_altivec_vperm_4si((vector int)__a,
7359  (vector int)__b, __c);
7360 #endif
7361 }
7362 
7363 static __inline__ vector int __ATTRS_o_ai vec_perm(vector signed int __a,
7364  vector signed int __b,
7365  vector unsigned char __c) {
7366 #ifdef __LITTLE_ENDIAN__
7367  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7368  255, 255, 255, 255, 255, 255, 255, 255};
7369  __d = vec_xor(__c, __d);
7370  return (vector signed int)__builtin_altivec_vperm_4si(__b, __a, __d);
7371 #else
7372  return (vector signed int)__builtin_altivec_vperm_4si(__a, __b, __c);
7373 #endif
7374 }
7375 
7376 static __inline__ vector unsigned int __ATTRS_o_ai
7377 vec_perm(vector unsigned int __a, vector unsigned int __b,
7378  vector unsigned char __c) {
7379 #ifdef __LITTLE_ENDIAN__
7380  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7381  255, 255, 255, 255, 255, 255, 255, 255};
7382  __d = vec_xor(__c, __d);
7383  return (vector unsigned int)__builtin_altivec_vperm_4si((vector int)__b,
7384  (vector int)__a, __d);
7385 #else
7386  return (vector unsigned int)__builtin_altivec_vperm_4si((vector int)__a,
7387  (vector int)__b, __c);
7388 #endif
7389 }
7390 
7391 static __inline__ vector bool int __ATTRS_o_ai
7392 vec_perm(vector bool int __a, vector bool int __b, 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 bool int)__builtin_altivec_vperm_4si((vector int)__b,
7398  (vector int)__a, __d);
7399 #else
7400  return (vector bool int)__builtin_altivec_vperm_4si((vector int)__a,
7401  (vector int)__b, __c);
7402 #endif
7403 }
7404 
7405 static __inline__ vector float __ATTRS_o_ai vec_perm(vector float __a,
7406  vector float __b,
7407  vector unsigned char __c) {
7408 #ifdef __LITTLE_ENDIAN__
7409  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7410  255, 255, 255, 255, 255, 255, 255, 255};
7411  __d = vec_xor(__c, __d);
7412  return (vector float)__builtin_altivec_vperm_4si((vector int)__b,
7413  (vector int)__a, __d);
7414 #else
7415  return (vector float)__builtin_altivec_vperm_4si((vector int)__a,
7416  (vector int)__b, __c);
7417 #endif
7418 }
7419 
7420 #ifdef __VSX__
7421 static __inline__ vector long long __ATTRS_o_ai
7422 vec_perm(vector signed long long __a, vector signed long long __b,
7423  vector unsigned char __c) {
7424 #ifdef __LITTLE_ENDIAN__
7425  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7426  255, 255, 255, 255, 255, 255, 255, 255};
7427  __d = vec_xor(__c, __d);
7428  return (vector signed long long)__builtin_altivec_vperm_4si(
7429  (vector int)__b, (vector int)__a, __d);
7430 #else
7431  return (vector signed long long)__builtin_altivec_vperm_4si(
7432  (vector int)__a, (vector int)__b, __c);
7433 #endif
7434 }
7435 
7436 static __inline__ vector unsigned long long __ATTRS_o_ai
7437 vec_perm(vector unsigned long long __a, vector unsigned long long __b,
7438  vector unsigned char __c) {
7439 #ifdef __LITTLE_ENDIAN__
7440  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7441  255, 255, 255, 255, 255, 255, 255, 255};
7442  __d = vec_xor(__c, __d);
7443  return (vector unsigned long long)__builtin_altivec_vperm_4si(
7444  (vector int)__b, (vector int)__a, __d);
7445 #else
7446  return (vector unsigned long long)__builtin_altivec_vperm_4si(
7447  (vector int)__a, (vector int)__b, __c);
7448 #endif
7449 }
7450 
7451 static __inline__ vector bool long long __ATTRS_o_ai
7452 vec_perm(vector bool long long __a, vector bool long long __b,
7453  vector unsigned char __c) {
7454 #ifdef __LITTLE_ENDIAN__
7455  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
7456  255, 255, 255, 255, 255, 255, 255, 255};
7457  __d = vec_xor(__c, __d);
7458  return (vector bool long long)__builtin_altivec_vperm_4si(
7459  (vector int)__b, (vector int)__a, __d);
7460 #else
7461  return (vector bool long long)__builtin_altivec_vperm_4si(
7462  (vector int)__a, (vector int)__b, __c);
7463 #endif
7464 }
7465 
7466 static __inline__ vector double __ATTRS_o_ai
7467 vec_perm(vector double __a, vector double __b, 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 double)__builtin_altivec_vperm_4si((vector int)__b,
7473  (vector int)__a, __d);
7474 #else
7475  return (vector double)__builtin_altivec_vperm_4si((vector int)__a,
7476  (vector int)__b, __c);
7477 #endif
7478 }
7479 #endif
7480 
7481 /* vec_vperm */
7482 
7483 static __inline__ vector signed char __ATTRS_o_ai vec_vperm(
7484  vector signed char __a, vector signed char __b, vector unsigned char __c) {
7485  return vec_perm(__a, __b, __c);
7486 }
7487 
7488 static __inline__ vector unsigned char __ATTRS_o_ai
7489 vec_vperm(vector unsigned char __a, vector unsigned char __b,
7490  vector unsigned char __c) {
7491  return vec_perm(__a, __b, __c);
7492 }
7493 
7494 static __inline__ vector bool char __ATTRS_o_ai vec_vperm(
7495  vector bool char __a, vector bool char __b, vector unsigned char __c) {
7496  return vec_perm(__a, __b, __c);
7497 }
7498 
7499 static __inline__ vector short __ATTRS_o_ai
7500 vec_vperm(vector short __a, vector short __b, vector unsigned char __c) {
7501  return vec_perm(__a, __b, __c);
7502 }
7503 
7504 static __inline__ vector unsigned short __ATTRS_o_ai
7505 vec_vperm(vector unsigned short __a, vector unsigned short __b,
7506  vector unsigned char __c) {
7507  return vec_perm(__a, __b, __c);
7508 }
7509 
7510 static __inline__ vector bool short __ATTRS_o_ai vec_vperm(
7511  vector bool short __a, vector bool short __b, vector unsigned char __c) {
7512  return vec_perm(__a, __b, __c);
7513 }
7514 
7515 static __inline__ vector pixel __ATTRS_o_ai
7516 vec_vperm(vector pixel __a, vector pixel __b, vector unsigned char __c) {
7517  return vec_perm(__a, __b, __c);
7518 }
7519 
7520 static __inline__ vector int __ATTRS_o_ai vec_vperm(vector int __a,
7521  vector int __b,
7522  vector unsigned char __c) {
7523  return vec_perm(__a, __b, __c);
7524 }
7525 
7526 static __inline__ vector unsigned int __ATTRS_o_ai
7527 vec_vperm(vector unsigned int __a, vector unsigned int __b,
7528  vector unsigned char __c) {
7529  return vec_perm(__a, __b, __c);
7530 }
7531 
7532 static __inline__ vector bool int __ATTRS_o_ai
7533 vec_vperm(vector bool int __a, vector bool int __b, vector unsigned char __c) {
7534  return vec_perm(__a, __b, __c);
7535 }
7536 
7537 static __inline__ vector float __ATTRS_o_ai
7538 vec_vperm(vector float __a, vector float __b, vector unsigned char __c) {
7539  return vec_perm(__a, __b, __c);
7540 }
7541 
7542 #ifdef __VSX__
7543 static __inline__ vector long long __ATTRS_o_ai vec_vperm(
7544  vector long long __a, vector long long __b, vector unsigned char __c) {
7545  return vec_perm(__a, __b, __c);
7546 }
7547 
7548 static __inline__ vector unsigned long long __ATTRS_o_ai
7549 vec_vperm(vector unsigned long long __a, vector unsigned long long __b,
7550  vector unsigned char __c) {
7551  return vec_perm(__a, __b, __c);
7552 }
7553 
7554 static __inline__ vector double __ATTRS_o_ai
7555 vec_vperm(vector double __a, vector double __b, vector unsigned char __c) {
7556  return vec_perm(__a, __b, __c);
7557 }
7558 #endif
7559 
7560 /* vec_re */
7561 
7562 static __inline__ vector float __ATTRS_o_ai vec_re(vector float __a) {
7563 #ifdef __VSX__
7564  return __builtin_vsx_xvresp(__a);
7565 #else
7566  return __builtin_altivec_vrefp(__a);
7567 #endif
7568 }
7569 
7570 #ifdef __VSX__
7571 static __inline__ vector double __ATTRS_o_ai vec_re(vector double __a) {
7572  return __builtin_vsx_xvredp(__a);
7573 }
7574 #endif
7575 
7576 /* vec_vrefp */
7577 
7578 static __inline__ vector float __attribute__((__always_inline__))
7579 vec_vrefp(vector float __a) {
7580  return __builtin_altivec_vrefp(__a);
7581 }
7582 
7583 /* vec_rl */
7584 
7585 static __inline__ vector signed char __ATTRS_o_ai
7586 vec_rl(vector signed char __a, vector unsigned char __b) {
7587  return (vector signed char)__builtin_altivec_vrlb((vector char)__a, __b);
7588 }
7589 
7590 static __inline__ vector unsigned char __ATTRS_o_ai
7591 vec_rl(vector unsigned char __a, vector unsigned char __b) {
7592  return (vector unsigned char)__builtin_altivec_vrlb((vector char)__a, __b);
7593 }
7594 
7595 static __inline__ vector short __ATTRS_o_ai vec_rl(vector short __a,
7596  vector unsigned short __b) {
7597  return __builtin_altivec_vrlh(__a, __b);
7598 }
7599 
7600 static __inline__ vector unsigned short __ATTRS_o_ai
7601 vec_rl(vector unsigned short __a, vector unsigned short __b) {
7602  return (vector unsigned short)__builtin_altivec_vrlh((vector short)__a, __b);
7603 }
7604 
7605 static __inline__ vector int __ATTRS_o_ai vec_rl(vector int __a,
7606  vector unsigned int __b) {
7607  return __builtin_altivec_vrlw(__a, __b);
7608 }
7609 
7610 static __inline__ vector unsigned int __ATTRS_o_ai
7611 vec_rl(vector unsigned int __a, vector unsigned int __b) {
7612  return (vector unsigned int)__builtin_altivec_vrlw((vector int)__a, __b);
7613 }
7614 
7615 #ifdef __POWER8_VECTOR__
7616 static __inline__ vector signed long long __ATTRS_o_ai
7617 vec_rl(vector signed long long __a, vector unsigned long long __b) {
7618  return __builtin_altivec_vrld(__a, __b);
7619 }
7620 
7621 static __inline__ vector unsigned long long __ATTRS_o_ai
7622 vec_rl(vector unsigned long long __a, vector unsigned long long __b) {
7623  return __builtin_altivec_vrld(__a, __b);
7624 }
7625 #endif
7626 
7627 /* vec_rlmi */
7628 #ifdef __POWER9_VECTOR__
7629 static __inline__ vector unsigned int __ATTRS_o_ai
7630 vec_rlmi(vector unsigned int __a, vector unsigned int __b,
7631  vector unsigned int __c) {
7632  return __builtin_altivec_vrlwmi(__a, __c, __b);
7633 }
7634 
7635 static __inline__ vector unsigned long long __ATTRS_o_ai
7636 vec_rlmi(vector unsigned long long __a, vector unsigned long long __b,
7637  vector unsigned long long __c) {
7638  return __builtin_altivec_vrldmi(__a, __c, __b);
7639 }
7640 
7641 /* vec_rlnm */
7642 static __inline__ vector unsigned int __ATTRS_o_ai
7643 vec_rlnm(vector unsigned int __a, vector unsigned int __b,
7644  vector unsigned int __c) {
7645  vector unsigned int OneByte = { 0x8, 0x8, 0x8, 0x8 };
7646  return __builtin_altivec_vrlwnm(__a, ((__c << OneByte) | __b));
7647 }
7648 
7649 static __inline__ vector unsigned long long __ATTRS_o_ai
7650 vec_rlnm(vector unsigned long long __a, vector unsigned long long __b,
7651  vector unsigned long long __c) {
7652  vector unsigned long long OneByte = { 0x8, 0x8 };
7653  return __builtin_altivec_vrldnm(__a, ((__c << OneByte) | __b));
7654 }
7655 #endif
7656 
7657 /* vec_vrlb */
7658 
7659 static __inline__ vector signed char __ATTRS_o_ai
7660 vec_vrlb(vector signed char __a, vector unsigned char __b) {
7661  return (vector signed char)__builtin_altivec_vrlb((vector char)__a, __b);
7662 }
7663 
7664 static __inline__ vector unsigned char __ATTRS_o_ai
7665 vec_vrlb(vector unsigned char __a, vector unsigned char __b) {
7666  return (vector unsigned char)__builtin_altivec_vrlb((vector char)__a, __b);
7667 }
7668 
7669 /* vec_vrlh */
7670 
7671 static __inline__ vector short __ATTRS_o_ai
7672 vec_vrlh(vector short __a, vector unsigned short __b) {
7673  return __builtin_altivec_vrlh(__a, __b);
7674 }
7675 
7676 static __inline__ vector unsigned short __ATTRS_o_ai
7677 vec_vrlh(vector unsigned short __a, vector unsigned short __b) {
7678  return (vector unsigned short)__builtin_altivec_vrlh((vector short)__a, __b);
7679 }
7680 
7681 /* vec_vrlw */
7682 
7683 static __inline__ vector int __ATTRS_o_ai vec_vrlw(vector int __a,
7684  vector unsigned int __b) {
7685  return __builtin_altivec_vrlw(__a, __b);
7686 }
7687 
7688 static __inline__ vector unsigned int __ATTRS_o_ai
7689 vec_vrlw(vector unsigned int __a, vector unsigned int __b) {
7690  return (vector unsigned int)__builtin_altivec_vrlw((vector int)__a, __b);
7691 }
7692 
7693 /* vec_round */
7694 
7695 static __inline__ vector float __ATTRS_o_ai vec_round(vector float __a) {
7696 #ifdef __VSX__
7697  return __builtin_vsx_xvrspi(__a);
7698 #else
7699  return __builtin_altivec_vrfin(__a);
7700 #endif
7701 }
7702 
7703 #ifdef __VSX__
7704 static __inline__ vector double __ATTRS_o_ai vec_round(vector double __a) {
7705  return __builtin_vsx_xvrdpi(__a);
7706 }
7707 
7708 /* vec_rint */
7709 
7710 static __inline__ vector float __ATTRS_o_ai vec_rint(vector float __a) {
7711  return __builtin_vsx_xvrspic(__a);
7712 }
7713 
7714 static __inline__ vector double __ATTRS_o_ai vec_rint(vector double __a) {
7715  return __builtin_vsx_xvrdpic(__a);
7716 }
7717 
7718 /* vec_nearbyint */
7719 
7720 static __inline__ vector float __ATTRS_o_ai vec_nearbyint(vector float __a) {
7721  return __builtin_vsx_xvrspi(__a);
7722 }
7723 
7724 static __inline__ vector double __ATTRS_o_ai vec_nearbyint(vector double __a) {
7725  return __builtin_vsx_xvrdpi(__a);
7726 }
7727 #endif
7728 
7729 /* vec_vrfin */
7730 
7731 static __inline__ vector float __attribute__((__always_inline__))
7732 vec_vrfin(vector float __a) {
7733  return __builtin_altivec_vrfin(__a);
7734 }
7735 
7736 /* vec_sqrt */
7737 
7738 #ifdef __VSX__
7739 static __inline__ vector float __ATTRS_o_ai vec_sqrt(vector float __a) {
7740  return __builtin_vsx_xvsqrtsp(__a);
7741 }
7742 
7743 static __inline__ vector double __ATTRS_o_ai vec_sqrt(vector double __a) {
7744  return __builtin_vsx_xvsqrtdp(__a);
7745 }
7746 #endif
7747 
7748 /* vec_rsqrte */
7749 
7750 static __inline__ vector float __ATTRS_o_ai vec_rsqrte(vector float __a) {
7751 #ifdef __VSX__
7752  return __builtin_vsx_xvrsqrtesp(__a);
7753 #else
7754  return __builtin_altivec_vrsqrtefp(__a);
7755 #endif
7756 }
7757 
7758 #ifdef __VSX__
7759 static __inline__ vector double __ATTRS_o_ai vec_rsqrte(vector double __a) {
7760  return __builtin_vsx_xvrsqrtedp(__a);
7761 }
7762 #endif
7763 
7764 /* vec_vrsqrtefp */
7765 
7766 static __inline__ __vector float __attribute__((__always_inline__))
7767 vec_vrsqrtefp(vector float __a) {
7768  return __builtin_altivec_vrsqrtefp(__a);
7769 }
7770 
7771 /* vec_sel */
7772 
7773 #define __builtin_altivec_vsel_4si vec_sel
7774 
7775 static __inline__ vector signed char __ATTRS_o_ai vec_sel(
7776  vector signed char __a, vector signed char __b, vector unsigned char __c) {
7777  return (__a & ~(vector signed char)__c) | (__b & (vector signed char)__c);
7778 }
7779 
7780 static __inline__ vector signed char __ATTRS_o_ai
7781 vec_sel(vector signed char __a, vector signed char __b, vector bool char __c) {
7782  return (__a & ~(vector signed char)__c) | (__b & (vector signed char)__c);
7783 }
7784 
7785 static __inline__ vector unsigned char __ATTRS_o_ai
7786 vec_sel(vector unsigned char __a, vector unsigned char __b,
7787  vector unsigned char __c) {
7788  return (__a & ~__c) | (__b & __c);
7789 }
7790 
7791 static __inline__ vector unsigned char __ATTRS_o_ai vec_sel(
7792  vector unsigned char __a, vector unsigned char __b, vector bool char __c) {
7793  return (__a & ~(vector unsigned char)__c) | (__b & (vector unsigned char)__c);
7794 }
7795 
7796 static __inline__ vector bool char __ATTRS_o_ai
7797 vec_sel(vector bool char __a, vector bool char __b, vector unsigned char __c) {
7798  return (__a & ~(vector bool char)__c) | (__b & (vector bool char)__c);
7799 }
7800 
7801 static __inline__ vector bool char __ATTRS_o_ai vec_sel(vector bool char __a,
7802  vector bool char __b,
7803  vector bool char __c) {
7804  return (__a & ~__c) | (__b & __c);
7805 }
7806 
7807 static __inline__ vector short __ATTRS_o_ai vec_sel(vector short __a,
7808  vector short __b,
7809  vector unsigned short __c) {
7810  return (__a & ~(vector short)__c) | (__b & (vector short)__c);
7811 }
7812 
7813 static __inline__ vector short __ATTRS_o_ai vec_sel(vector short __a,
7814  vector short __b,
7815  vector bool short __c) {
7816  return (__a & ~(vector short)__c) | (__b & (vector short)__c);
7817 }
7818 
7819 static __inline__ vector unsigned short __ATTRS_o_ai
7820 vec_sel(vector unsigned short __a, vector unsigned short __b,
7821  vector unsigned short __c) {
7822  return (__a & ~__c) | (__b & __c);
7823 }
7824 
7825 static __inline__ vector unsigned short __ATTRS_o_ai
7826 vec_sel(vector unsigned short __a, vector unsigned short __b,
7827  vector bool short __c) {
7828  return (__a & ~(vector unsigned short)__c) |
7829  (__b & (vector unsigned short)__c);
7830 }
7831 
7832 static __inline__ vector bool short __ATTRS_o_ai vec_sel(
7833  vector bool short __a, vector bool short __b, vector unsigned short __c) {
7834  return (__a & ~(vector bool short)__c) | (__b & (vector bool short)__c);
7835 }
7836 
7837 static __inline__ vector bool short __ATTRS_o_ai
7838 vec_sel(vector bool short __a, vector bool short __b, vector bool short __c) {
7839  return (__a & ~__c) | (__b & __c);
7840 }
7841 
7842 static __inline__ vector int __ATTRS_o_ai vec_sel(vector int __a,
7843  vector int __b,
7844  vector unsigned int __c) {
7845  return (__a & ~(vector int)__c) | (__b & (vector int)__c);
7846 }
7847 
7848 static __inline__ vector int __ATTRS_o_ai vec_sel(vector int __a,
7849  vector int __b,
7850  vector bool int __c) {
7851  return (__a & ~(vector int)__c) | (__b & (vector int)__c);
7852 }
7853 
7854 static __inline__ vector unsigned int __ATTRS_o_ai vec_sel(
7855  vector unsigned int __a, vector unsigned int __b, vector unsigned int __c) {
7856  return (__a & ~__c) | (__b & __c);
7857 }
7858 
7859 static __inline__ vector unsigned int __ATTRS_o_ai
7860 vec_sel(vector unsigned int __a, vector unsigned int __b, vector bool int __c) {
7861  return (__a & ~(vector unsigned int)__c) | (__b & (vector unsigned int)__c);
7862 }
7863 
7864 static __inline__ vector bool int __ATTRS_o_ai
7865 vec_sel(vector bool int __a, vector bool int __b, vector unsigned int __c) {
7866  return (__a & ~(vector bool int)__c) | (__b & (vector bool int)__c);
7867 }
7868 
7869 static __inline__ vector bool int __ATTRS_o_ai vec_sel(vector bool int __a,
7870  vector bool int __b,
7871  vector bool int __c) {
7872  return (__a & ~__c) | (__b & __c);
7873 }
7874 
7875 static __inline__ vector float __ATTRS_o_ai vec_sel(vector float __a,
7876  vector float __b,
7877  vector unsigned int __c) {
7878  vector int __res = ((vector int)__a & ~(vector int)__c) |
7879  ((vector int)__b & (vector int)__c);
7880  return (vector float)__res;
7881 }
7882 
7883 static __inline__ vector float __ATTRS_o_ai vec_sel(vector float __a,
7884  vector float __b,
7885  vector bool int __c) {
7886  vector int __res = ((vector int)__a & ~(vector int)__c) |
7887  ((vector int)__b & (vector int)__c);
7888  return (vector float)__res;
7889 }
7890 
7891 #ifdef __VSX__
7892 static __inline__ vector double __ATTRS_o_ai
7893 vec_sel(vector double __a, vector double __b, vector bool long long __c) {
7894  vector long long __res = ((vector long long)__a & ~(vector long long)__c) |
7895  ((vector long long)__b & (vector long long)__c);
7896  return (vector double)__res;
7897 }
7898 
7899 static __inline__ vector double __ATTRS_o_ai
7900 vec_sel(vector double __a, vector double __b, vector unsigned long long __c) {
7901  vector long long __res = ((vector long long)__a & ~(vector long long)__c) |
7902  ((vector long long)__b & (vector long long)__c);
7903  return (vector double)__res;
7904 }
7905 #endif
7906 
7907 /* vec_vsel */
7908 
7909 static __inline__ vector signed char __ATTRS_o_ai vec_vsel(
7910  vector signed char __a, vector signed char __b, vector unsigned char __c) {
7911  return (__a & ~(vector signed char)__c) | (__b & (vector signed char)__c);
7912 }
7913 
7914 static __inline__ vector signed char __ATTRS_o_ai
7915 vec_vsel(vector signed char __a, vector signed char __b, vector bool char __c) {
7916  return (__a & ~(vector signed char)__c) | (__b & (vector signed char)__c);
7917 }
7918 
7919 static __inline__ vector unsigned char __ATTRS_o_ai
7920 vec_vsel(vector unsigned char __a, vector unsigned char __b,
7921  vector unsigned char __c) {
7922  return (__a & ~__c) | (__b & __c);
7923 }
7924 
7925 static __inline__ vector unsigned char __ATTRS_o_ai vec_vsel(
7926  vector unsigned char __a, vector unsigned char __b, vector bool char __c) {
7927  return (__a & ~(vector unsigned char)__c) | (__b & (vector unsigned char)__c);
7928 }
7929 
7930 static __inline__ vector bool char __ATTRS_o_ai
7931 vec_vsel(vector bool char __a, vector bool char __b, vector unsigned char __c) {
7932  return (__a & ~(vector bool char)__c) | (__b & (vector bool char)__c);
7933 }
7934 
7935 static __inline__ vector bool char __ATTRS_o_ai vec_vsel(vector bool char __a,
7936  vector bool char __b,
7937  vector bool char __c) {
7938  return (__a & ~__c) | (__b & __c);
7939 }
7940 
7941 static __inline__ vector short __ATTRS_o_ai
7942 vec_vsel(vector short __a, vector short __b, vector unsigned short __c) {
7943  return (__a & ~(vector short)__c) | (__b & (vector short)__c);
7944 }
7945 
7946 static __inline__ vector short __ATTRS_o_ai vec_vsel(vector short __a,
7947  vector short __b,
7948  vector bool short __c) {
7949  return (__a & ~(vector short)__c) | (__b & (vector short)__c);
7950 }
7951 
7952 static __inline__ vector unsigned short __ATTRS_o_ai
7953 vec_vsel(vector unsigned short __a, vector unsigned short __b,
7954  vector unsigned short __c) {
7955  return (__a & ~__c) | (__b & __c);
7956 }
7957 
7958 static __inline__ vector unsigned short __ATTRS_o_ai
7959 vec_vsel(vector unsigned short __a, vector unsigned short __b,
7960  vector bool short __c) {
7961  return (__a & ~(vector unsigned short)__c) |
7962  (__b & (vector unsigned short)__c);
7963 }
7964 
7965 static __inline__ vector bool short __ATTRS_o_ai vec_vsel(
7966  vector bool short __a, vector bool short __b, vector unsigned short __c) {
7967  return (__a & ~(vector bool short)__c) | (__b & (vector bool short)__c);
7968 }
7969 
7970 static __inline__ vector bool short __ATTRS_o_ai
7971 vec_vsel(vector bool short __a, vector bool short __b, vector bool short __c) {
7972  return (__a & ~__c) | (__b & __c);
7973 }
7974 
7975 static __inline__ vector int __ATTRS_o_ai vec_vsel(vector int __a,
7976  vector int __b,
7977  vector unsigned int __c) {
7978  return (__a & ~(vector int)__c) | (__b & (vector int)__c);
7979 }
7980 
7981 static __inline__ vector int __ATTRS_o_ai vec_vsel(vector int __a,
7982  vector int __b,
7983  vector bool int __c) {
7984  return (__a & ~(vector int)__c) | (__b & (vector int)__c);
7985 }
7986 
7987 static __inline__ vector unsigned int __ATTRS_o_ai vec_vsel(
7988  vector unsigned int __a, vector unsigned int __b, vector unsigned int __c) {
7989  return (__a & ~__c) | (__b & __c);
7990 }
7991 
7992 static __inline__ vector unsigned int __ATTRS_o_ai vec_vsel(
7993  vector unsigned int __a, vector unsigned int __b, vector bool int __c) {
7994  return (__a & ~(vector unsigned int)__c) | (__b & (vector unsigned int)__c);
7995 }
7996 
7997 static __inline__ vector bool int __ATTRS_o_ai
7998 vec_vsel(vector bool int __a, vector bool int __b, vector unsigned int __c) {
7999  return (__a & ~(vector bool int)__c) | (__b & (vector bool int)__c);
8000 }
8001 
8002 static __inline__ vector bool int __ATTRS_o_ai vec_vsel(vector bool int __a,
8003  vector bool int __b,
8004  vector bool int __c) {
8005  return (__a & ~__c) | (__b & __c);
8006 }
8007 
8008 static __inline__ vector float __ATTRS_o_ai vec_vsel(vector float __a,
8009  vector float __b,
8010  vector unsigned int __c) {
8011  vector int __res = ((vector int)__a & ~(vector int)__c) |
8012  ((vector int)__b & (vector int)__c);
8013  return (vector float)__res;
8014 }
8015 
8016 static __inline__ vector float __ATTRS_o_ai vec_vsel(vector float __a,
8017  vector float __b,
8018  vector bool int __c) {
8019  vector int __res = ((vector int)__a & ~(vector int)__c) |
8020  ((vector int)__b & (vector int)__c);
8021  return (vector float)__res;
8022 }
8023 
8024 /* vec_sl */
8025 
8026 // vec_sl does modulo arithmetic on __b first, so __b is allowed to be more
8027 // than the length of __a.
8028 static __inline__ vector unsigned char __ATTRS_o_ai
8029 vec_sl(vector unsigned char __a, vector unsigned char __b) {
8030  return __a << (__b %
8031  (vector unsigned char)(sizeof(unsigned char) * __CHAR_BIT__));
8032 }
8033 
8034 static __inline__ vector signed char __ATTRS_o_ai
8035 vec_sl(vector signed char __a, vector unsigned char __b) {
8036  return (vector signed char)vec_sl((vector unsigned char)__a, __b);
8037 }
8038 
8039 static __inline__ vector unsigned short __ATTRS_o_ai
8040 vec_sl(vector unsigned short __a, vector unsigned short __b) {
8041  return __a << (__b % (vector unsigned short)(sizeof(unsigned short) *
8042  __CHAR_BIT__));
8043 }
8044 
8045 static __inline__ vector short __ATTRS_o_ai vec_sl(vector short __a,
8046  vector unsigned short __b) {
8047  return (vector short)vec_sl((vector unsigned short)__a, __b);
8048 }
8049 
8050 static __inline__ vector unsigned int __ATTRS_o_ai
8051 vec_sl(vector unsigned int __a, vector unsigned int __b) {
8052  return __a << (__b %
8053  (vector unsigned int)(sizeof(unsigned int) * __CHAR_BIT__));
8054 }
8055 
8056 static __inline__ vector int __ATTRS_o_ai vec_sl(vector int __a,
8057  vector unsigned int __b) {
8058  return (vector int)vec_sl((vector unsigned int)__a, __b);
8059 }
8060 
8061 #ifdef __POWER8_VECTOR__
8062 static __inline__ vector unsigned long long __ATTRS_o_ai
8063 vec_sl(vector unsigned long long __a, vector unsigned long long __b) {
8064  return __a << (__b % (vector unsigned long long)(sizeof(unsigned long long) *
8065  __CHAR_BIT__));
8066 }
8067 
8068 static __inline__ vector long long __ATTRS_o_ai
8069 vec_sl(vector long long __a, vector unsigned long long __b) {
8070  return (vector long long)vec_sl((vector unsigned long long)__a, __b);
8071 }
8072 #endif
8073 
8074 /* vec_vslb */
8075 
8076 #define __builtin_altivec_vslb vec_vslb
8077 
8078 static __inline__ vector signed char __ATTRS_o_ai
8079 vec_vslb(vector signed char __a, vector unsigned char __b) {
8080  return vec_sl(__a, __b);
8081 }
8082 
8083 static __inline__ vector unsigned char __ATTRS_o_ai
8084 vec_vslb(vector unsigned char __a, vector unsigned char __b) {
8085  return vec_sl(__a, __b);
8086 }
8087 
8088 /* vec_vslh */
8089 
8090 #define __builtin_altivec_vslh vec_vslh
8091 
8092 static __inline__ vector short __ATTRS_o_ai
8093 vec_vslh(vector short __a, vector unsigned short __b) {
8094  return vec_sl(__a, __b);
8095 }
8096 
8097 static __inline__ vector unsigned short __ATTRS_o_ai
8098 vec_vslh(vector unsigned short __a, vector unsigned short __b) {
8099  return vec_sl(__a, __b);
8100 }
8101 
8102 /* vec_vslw */
8103 
8104 #define __builtin_altivec_vslw vec_vslw
8105 
8106 static __inline__ vector int __ATTRS_o_ai vec_vslw(vector int __a,
8107  vector unsigned int __b) {
8108  return vec_sl(__a, __b);
8109 }
8110 
8111 static __inline__ vector unsigned int __ATTRS_o_ai
8112 vec_vslw(vector unsigned int __a, vector unsigned int __b) {
8113  return vec_sl(__a, __b);
8114 }
8115 
8116 /* vec_sld */
8117 
8118 #define __builtin_altivec_vsldoi_4si vec_sld
8119 
8120 static __inline__ vector signed char __ATTRS_o_ai vec_sld(
8121  vector signed char __a, vector signed char __b, unsigned const int __c) {
8122  unsigned char __d = __c & 0x0F;
8123 #ifdef __LITTLE_ENDIAN__
8124  return vec_perm(
8125  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8126  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8127  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8128  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8129 #else
8130  return vec_perm(
8131  __a, __b,
8132  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8133  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8134  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8135 #endif
8136 }
8137 
8138 static __inline__ vector unsigned char __ATTRS_o_ai
8139 vec_sld(vector unsigned char __a, vector unsigned char __b,
8140  unsigned const int __c) {
8141  unsigned char __d = __c & 0x0F;
8142 #ifdef __LITTLE_ENDIAN__
8143  return vec_perm(
8144  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8145  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8146  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8147  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8148 #else
8149  return vec_perm(
8150  __a, __b,
8151  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8152  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8153  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8154 #endif
8155 }
8156 
8157 static __inline__ vector bool char __ATTRS_o_ai
8158 vec_sld(vector bool char __a, vector bool char __b, unsigned const int __c) {
8159  unsigned char __d = __c & 0x0F;
8160 #ifdef __LITTLE_ENDIAN__
8161  return vec_perm(
8162  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8163  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8164  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8165  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8166 #else
8167  return vec_perm(
8168  __a, __b,
8169  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8170  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8171  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8172 #endif
8173 }
8174 
8175 static __inline__ vector signed short __ATTRS_o_ai vec_sld(
8176  vector signed short __a, vector signed short __b, unsigned const int __c) {
8177  unsigned char __d = __c & 0x0F;
8178 #ifdef __LITTLE_ENDIAN__
8179  return vec_perm(
8180  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8181  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8182  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8183  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8184 #else
8185  return vec_perm(
8186  __a, __b,
8187  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8188  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8189  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8190 #endif
8191 }
8192 
8193 static __inline__ vector unsigned short __ATTRS_o_ai
8194 vec_sld(vector unsigned short __a, vector unsigned short __b,
8195  unsigned const int __c) {
8196  unsigned char __d = __c & 0x0F;
8197 #ifdef __LITTLE_ENDIAN__
8198  return vec_perm(
8199  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8200  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8201  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8202  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8203 #else
8204  return vec_perm(
8205  __a, __b,
8206  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8207  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8208  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8209 #endif
8210 }
8211 
8212 static __inline__ vector bool short __ATTRS_o_ai
8213 vec_sld(vector bool short __a, vector bool short __b, unsigned const int __c) {
8214  unsigned char __d = __c & 0x0F;
8215 #ifdef __LITTLE_ENDIAN__
8216  return vec_perm(
8217  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8218  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8219  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8220  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8221 #else
8222  return vec_perm(
8223  __a, __b,
8224  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8225  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8226  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8227 #endif
8228 }
8229 
8230 static __inline__ vector pixel __ATTRS_o_ai vec_sld(vector pixel __a,
8231  vector pixel __b,
8232  unsigned const int __c) {
8233  unsigned char __d = __c & 0x0F;
8234 #ifdef __LITTLE_ENDIAN__
8235  return vec_perm(
8236  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8237  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8238  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8239  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8240 #else
8241  return vec_perm(
8242  __a, __b,
8243  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8244  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8245  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8246 #endif
8247 }
8248 
8249 static __inline__ vector signed int __ATTRS_o_ai
8250 vec_sld(vector signed int __a, vector signed int __b, unsigned const int __c) {
8251  unsigned char __d = __c & 0x0F;
8252 #ifdef __LITTLE_ENDIAN__
8253  return vec_perm(
8254  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8255  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8256  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8257  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8258 #else
8259  return vec_perm(
8260  __a, __b,
8261  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8262  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8263  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8264 #endif
8265 }
8266 
8267 static __inline__ vector unsigned int __ATTRS_o_ai vec_sld(
8268  vector unsigned int __a, vector unsigned int __b, unsigned const int __c) {
8269  unsigned char __d = __c & 0x0F;
8270 #ifdef __LITTLE_ENDIAN__
8271  return vec_perm(
8272  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8273  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8274  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8275  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8276 #else
8277  return vec_perm(
8278  __a, __b,
8279  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8280  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8281  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8282 #endif
8283 }
8284 
8285 static __inline__ vector bool int __ATTRS_o_ai vec_sld(vector bool int __a,
8286  vector bool int __b,
8287  unsigned const int __c) {
8288  unsigned char __d = __c & 0x0F;
8289 #ifdef __LITTLE_ENDIAN__
8290  return vec_perm(
8291  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8292  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8293  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8294  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8295 #else
8296  return vec_perm(
8297  __a, __b,
8298  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8299  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8300  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8301 #endif
8302 }
8303 
8304 static __inline__ vector float __ATTRS_o_ai vec_sld(vector float __a,
8305  vector float __b,
8306  unsigned const int __c) {
8307  unsigned char __d = __c & 0x0F;
8308 #ifdef __LITTLE_ENDIAN__
8309  return vec_perm(
8310  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8311  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8312  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8313  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8314 #else
8315  return vec_perm(
8316  __a, __b,
8317  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8318  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8319  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8320 #endif
8321 }
8322 
8323 #ifdef __VSX__
8324 static __inline__ vector bool long long __ATTRS_o_ai
8325 vec_sld(vector bool long long __a, vector bool long long __b,
8326  unsigned const int __c) {
8327  unsigned char __d = __c & 0x0F;
8328 #ifdef __LITTLE_ENDIAN__
8329  return vec_perm(
8330  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8331  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8332  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8333  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8334 #else
8335  return vec_perm(
8336  __a, __b,
8337  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8338  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8339  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8340 #endif
8341 }
8342 
8343 static __inline__ vector signed long long __ATTRS_o_ai
8344 vec_sld(vector signed long long __a, vector signed long long __b,
8345  unsigned const int __c) {
8346  unsigned char __d = __c & 0x0F;
8347 #ifdef __LITTLE_ENDIAN__
8348  return vec_perm(
8349  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8350  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8351  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8352  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8353 #else
8354  return vec_perm(
8355  __a, __b,
8356  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8357  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8358  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8359 #endif
8360 }
8361 
8362 static __inline__ vector unsigned long long __ATTRS_o_ai
8363 vec_sld(vector unsigned long long __a, vector unsigned long long __b,
8364  unsigned const int __c) {
8365  unsigned char __d = __c & 0x0F;
8366 #ifdef __LITTLE_ENDIAN__
8367  return vec_perm(
8368  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8369  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8370  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8371  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8372 #else
8373  return vec_perm(
8374  __a, __b,
8375  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8376  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8377  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8378 #endif
8379 }
8380 
8381 static __inline__ vector double __ATTRS_o_ai vec_sld(vector double __a,
8382  vector double __b,
8383  unsigned const int __c) {
8384  unsigned char __d = __c & 0x0F;
8385 #ifdef __LITTLE_ENDIAN__
8386  return vec_perm(
8387  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8388  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8389  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8390  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8391 #else
8392  return vec_perm(
8393  __a, __b,
8394  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8395  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8396  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8397 #endif
8398 }
8399 #endif
8400 
8401 /* vec_sldw */
8402 static __inline__ vector signed char __ATTRS_o_ai vec_sldw(
8403  vector signed char __a, vector signed char __b, unsigned const int __c) {
8404  return vec_sld(__a, __b, ((__c << 2) & 0x0F));
8405 }
8406 
8407 static __inline__ vector unsigned char __ATTRS_o_ai
8408 vec_sldw(vector unsigned char __a, vector unsigned char __b,
8409  unsigned const int __c) {
8410  return vec_sld(__a, __b, ((__c << 2) & 0x0F));
8411 }
8412 
8413 static __inline__ vector signed short __ATTRS_o_ai vec_sldw(
8414  vector signed short __a, vector signed short __b, unsigned const int __c) {
8415  return vec_sld(__a, __b, ((__c << 2) & 0x0F));
8416 }
8417 
8418 static __inline__ vector unsigned short __ATTRS_o_ai
8419 vec_sldw(vector unsigned short __a, vector unsigned short __b,
8420  unsigned const int __c) {
8421  return vec_sld(__a, __b, ((__c << 2) & 0x0F));
8422 }
8423 
8424 static __inline__ vector signed int __ATTRS_o_ai
8425 vec_sldw(vector signed int __a, vector signed int __b, unsigned const int __c) {
8426  return vec_sld(__a, __b, ((__c << 2) & 0x0F));
8427 }
8428 
8429 static __inline__ vector unsigned int __ATTRS_o_ai vec_sldw(
8430  vector unsigned int __a, vector unsigned int __b, unsigned const int __c) {
8431  return vec_sld(__a, __b, ((__c << 2) & 0x0F));
8432 }
8433 
8434 #ifdef __VSX__
8435 static __inline__ vector signed long long __ATTRS_o_ai
8436 vec_sldw(vector signed long long __a, vector signed long long __b,
8437  unsigned const int __c) {
8438  return vec_sld(__a, __b, ((__c << 2) & 0x0F));
8439 }
8440 
8441 static __inline__ vector unsigned long long __ATTRS_o_ai
8442 vec_sldw(vector unsigned long long __a, vector unsigned long long __b,
8443  unsigned const int __c) {
8444  return vec_sld(__a, __b, ((__c << 2) & 0x0F));
8445 }
8446 #endif
8447 
8448 #ifdef __POWER9_VECTOR__
8449 /* vec_slv */
8450 static __inline__ vector unsigned char __ATTRS_o_ai
8451 vec_slv(vector unsigned char __a, vector unsigned char __b) {
8452  return __builtin_altivec_vslv(__a, __b);
8453 }
8454 
8455 /* vec_srv */
8456 static __inline__ vector unsigned char __ATTRS_o_ai
8457 vec_srv(vector unsigned char __a, vector unsigned char __b) {
8458  return __builtin_altivec_vsrv(__a, __b);
8459 }
8460 #endif
8461 
8462 /* vec_vsldoi */
8463 
8464 static __inline__ vector signed char __ATTRS_o_ai
8465 vec_vsldoi(vector signed char __a, vector signed char __b, unsigned char __c) {
8466  unsigned char __d = __c & 0x0F;
8467 #ifdef __LITTLE_ENDIAN__
8468  return vec_perm(
8469  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8470  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8471  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8472  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8473 #else
8474  return vec_perm(
8475  __a, __b,
8476  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8477  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8478  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8479 #endif
8480 }
8481 
8482 static __inline__ vector unsigned char __ATTRS_o_ai vec_vsldoi(
8483  vector unsigned char __a, vector unsigned char __b, unsigned char __c) {
8484  unsigned char __d = __c & 0x0F;
8485 #ifdef __LITTLE_ENDIAN__
8486  return vec_perm(
8487  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8488  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8489  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8490  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8491 #else
8492  return vec_perm(
8493  __a, __b,
8494  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8495  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8496  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8497 #endif
8498 }
8499 
8500 static __inline__ vector short __ATTRS_o_ai vec_vsldoi(vector short __a,
8501  vector short __b,
8502  unsigned char __c) {
8503  unsigned char __d = __c & 0x0F;
8504 #ifdef __LITTLE_ENDIAN__
8505  return vec_perm(
8506  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8507  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8508  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8509  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8510 #else
8511  return vec_perm(
8512  __a, __b,
8513  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8514  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8515  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8516 #endif
8517 }
8518 
8519 static __inline__ vector unsigned short __ATTRS_o_ai vec_vsldoi(
8520  vector unsigned short __a, vector unsigned short __b, unsigned char __c) {
8521  unsigned char __d = __c & 0x0F;
8522 #ifdef __LITTLE_ENDIAN__
8523  return vec_perm(
8524  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8525  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8526  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8527  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8528 #else
8529  return vec_perm(
8530  __a, __b,
8531  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8532  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8533  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8534 #endif
8535 }
8536 
8537 static __inline__ vector pixel __ATTRS_o_ai vec_vsldoi(vector pixel __a,
8538  vector pixel __b,
8539  unsigned char __c) {
8540  unsigned char __d = __c & 0x0F;
8541 #ifdef __LITTLE_ENDIAN__
8542  return vec_perm(
8543  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8544  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8545  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8546  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8547 #else
8548  return vec_perm(
8549  __a, __b,
8550  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8551  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8552  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8553 #endif
8554 }
8555 
8556 static __inline__ vector int __ATTRS_o_ai vec_vsldoi(vector int __a,
8557  vector int __b,
8558  unsigned char __c) {
8559  unsigned char __d = __c & 0x0F;
8560 #ifdef __LITTLE_ENDIAN__
8561  return vec_perm(
8562  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8563  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8564  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8565  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8566 #else
8567  return vec_perm(
8568  __a, __b,
8569  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8570  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8571  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8572 #endif
8573 }
8574 
8575 static __inline__ vector unsigned int __ATTRS_o_ai vec_vsldoi(
8576  vector unsigned int __a, vector unsigned int __b, unsigned char __c) {
8577  unsigned char __d = __c & 0x0F;
8578 #ifdef __LITTLE_ENDIAN__
8579  return vec_perm(
8580  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8581  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8582  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8583  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8584 #else
8585  return vec_perm(
8586  __a, __b,
8587  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8588  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8589  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8590 #endif
8591 }
8592 
8593 static __inline__ vector float __ATTRS_o_ai vec_vsldoi(vector float __a,
8594  vector float __b,
8595  unsigned char __c) {
8596  unsigned char __d = __c & 0x0F;
8597 #ifdef __LITTLE_ENDIAN__
8598  return vec_perm(
8599  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
8600  20 - __d, 21 - __d, 22 - __d, 23 - __d,
8601  24 - __d, 25 - __d, 26 - __d, 27 - __d,
8602  28 - __d, 29 - __d, 30 - __d, 31 - __d));
8603 #else
8604  return vec_perm(
8605  __a, __b,
8606  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
8607  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
8608  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
8609 #endif
8610 }
8611 
8612 /* vec_sll */
8613 
8614 static __inline__ vector signed char __ATTRS_o_ai
8615 vec_sll(vector signed char __a, vector unsigned char __b) {
8616  return (vector signed char)__builtin_altivec_vsl((vector int)__a,
8617  (vector int)__b);
8618 }
8619 
8620 static __inline__ vector signed char __ATTRS_o_ai
8621 vec_sll(vector signed char __a, vector unsigned short __b) {
8622  return (vector signed char)__builtin_altivec_vsl((vector int)__a,
8623  (vector int)__b);
8624 }
8625 
8626 static __inline__ vector signed char __ATTRS_o_ai
8627 vec_sll(vector signed char __a, vector unsigned int __b) {
8628  return (vector signed char)__builtin_altivec_vsl((vector int)__a,
8629  (vector int)__b);
8630 }
8631 
8632 static __inline__ vector unsigned char __ATTRS_o_ai
8633 vec_sll(vector unsigned char __a, vector unsigned char __b) {
8634  return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
8635  (vector int)__b);
8636 }
8637 
8638 static __inline__ vector unsigned char __ATTRS_o_ai
8639 vec_sll(vector unsigned char __a, vector unsigned short __b) {
8640  return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
8641  (vector int)__b);
8642 }
8643 
8644 static __inline__ vector unsigned char __ATTRS_o_ai
8645 vec_sll(vector unsigned char __a, vector unsigned int __b) {
8646  return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
8647  (vector int)__b);
8648 }
8649 
8650 static __inline__ vector bool char __ATTRS_o_ai
8651 vec_sll(vector bool char __a, vector unsigned char __b) {
8652  return (vector bool char)__builtin_altivec_vsl((vector int)__a,
8653  (vector int)__b);
8654 }
8655 
8656 static __inline__ vector bool char __ATTRS_o_ai
8657 vec_sll(vector bool char __a, vector unsigned short __b) {
8658  return (vector bool char)__builtin_altivec_vsl((vector int)__a,
8659  (vector int)__b);
8660 }
8661 
8662 static __inline__ vector bool char __ATTRS_o_ai
8663 vec_sll(vector bool char __a, vector unsigned int __b) {
8664  return (vector bool char)__builtin_altivec_vsl((vector int)__a,
8665  (vector int)__b);
8666 }
8667 
8668 static __inline__ vector short __ATTRS_o_ai vec_sll(vector short __a,
8669  vector unsigned char __b) {
8670  return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
8671 }
8672 
8673 static __inline__ vector short __ATTRS_o_ai vec_sll(vector short __a,
8674  vector unsigned short __b) {
8675  return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
8676 }
8677 
8678 static __inline__ vector short __ATTRS_o_ai vec_sll(vector short __a,
8679  vector unsigned int __b) {
8680  return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
8681 }
8682 
8683 static __inline__ vector unsigned short __ATTRS_o_ai
8684 vec_sll(vector unsigned short __a, vector unsigned char __b) {
8685  return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
8686  (vector int)__b);
8687 }
8688 
8689 static __inline__ vector unsigned short __ATTRS_o_ai
8690 vec_sll(vector unsigned short __a, vector unsigned short __b) {
8691  return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
8692  (vector int)__b);
8693 }
8694 
8695 static __inline__ vector unsigned short __ATTRS_o_ai
8696 vec_sll(vector unsigned short __a, vector unsigned int __b) {
8697  return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
8698  (vector int)__b);
8699 }
8700 
8701 static __inline__ vector bool short __ATTRS_o_ai
8702 vec_sll(vector bool short __a, vector unsigned char __b) {
8703  return (vector bool short)__builtin_altivec_vsl((vector int)__a,
8704  (vector int)__b);
8705 }
8706 
8707 static __inline__ vector bool short __ATTRS_o_ai
8708 vec_sll(vector bool short __a, vector unsigned short __b) {
8709  return (vector bool short)__builtin_altivec_vsl((vector int)__a,
8710  (vector int)__b);
8711 }
8712 
8713 static __inline__ vector bool short __ATTRS_o_ai
8714 vec_sll(vector bool short __a, vector unsigned int __b) {
8715  return (vector bool short)__builtin_altivec_vsl((vector int)__a,
8716  (vector int)__b);
8717 }
8718 
8719 static __inline__ vector pixel __ATTRS_o_ai vec_sll(vector pixel __a,
8720  vector unsigned char __b) {
8721  return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
8722 }
8723 
8724 static __inline__ vector pixel __ATTRS_o_ai vec_sll(vector pixel __a,
8725  vector unsigned short __b) {
8726  return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
8727 }
8728 
8729 static __inline__ vector pixel __ATTRS_o_ai vec_sll(vector pixel __a,
8730  vector unsigned int __b) {
8731  return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
8732 }
8733 
8734 static __inline__ vector int __ATTRS_o_ai vec_sll(vector int __a,
8735  vector unsigned char __b) {
8736  return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
8737 }
8738 
8739 static __inline__ vector int __ATTRS_o_ai vec_sll(vector int __a,
8740  vector unsigned short __b) {
8741  return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
8742 }
8743 
8744 static __inline__ vector int __ATTRS_o_ai vec_sll(vector int __a,
8745  vector unsigned int __b) {
8746  return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
8747 }
8748 
8749 static __inline__ vector unsigned int __ATTRS_o_ai
8750 vec_sll(vector unsigned int __a, vector unsigned char __b) {
8751  return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
8752  (vector int)__b);
8753 }
8754 
8755 static __inline__ vector unsigned int __ATTRS_o_ai
8756 vec_sll(vector unsigned int __a, vector unsigned short __b) {
8757  return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
8758  (vector int)__b);
8759 }
8760 
8761 static __inline__ vector unsigned int __ATTRS_o_ai
8762 vec_sll(vector unsigned int __a, vector unsigned int __b) {
8763  return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
8764  (vector int)__b);
8765 }
8766 
8767 static __inline__ vector bool int __ATTRS_o_ai
8768 vec_sll(vector bool int __a, vector unsigned char __b) {
8769  return (vector bool int)__builtin_altivec_vsl((vector int)__a,
8770  (vector int)__b);
8771 }
8772 
8773 static __inline__ vector bool int __ATTRS_o_ai
8774 vec_sll(vector bool int __a, vector unsigned short __b) {
8775  return (vector bool int)__builtin_altivec_vsl((vector int)__a,
8776  (vector int)__b);
8777 }
8778 
8779 static __inline__ vector bool int __ATTRS_o_ai
8780 vec_sll(vector bool int __a, vector unsigned int __b) {
8781  return (vector bool int)__builtin_altivec_vsl((vector int)__a,
8782  (vector int)__b);
8783 }
8784 
8785 #ifdef __VSX__
8786 static __inline__ vector signed long long __ATTRS_o_ai
8787 vec_sll(vector signed long long __a, vector unsigned char __b) {
8788  return (vector signed long long)__builtin_altivec_vsl((vector int)__a,
8789  (vector int)__b);
8790 }
8791 
8792 static __inline__ vector unsigned long long __ATTRS_o_ai
8793 vec_sll(vector unsigned long long __a, vector unsigned char __b) {
8794  return (vector unsigned long long)__builtin_altivec_vsl((vector int)__a,
8795  (vector int)__b);
8796 }
8797 #endif
8798 
8799 /* vec_vsl */
8800 
8801 static __inline__ vector signed char __ATTRS_o_ai
8802 vec_vsl(vector signed char __a, vector unsigned char __b) {
8803  return (vector signed char)__builtin_altivec_vsl((vector int)__a,
8804  (vector int)__b);
8805 }
8806 
8807 static __inline__ vector signed char __ATTRS_o_ai
8808 vec_vsl(vector signed char __a, vector unsigned short __b) {
8809  return (vector signed char)__builtin_altivec_vsl((vector int)__a,
8810  (vector int)__b);
8811 }
8812 
8813 static __inline__ vector signed char __ATTRS_o_ai
8814 vec_vsl(vector signed char __a, vector unsigned int __b) {
8815  return (vector signed char)__builtin_altivec_vsl((vector int)__a,
8816  (vector int)__b);
8817 }
8818 
8819 static __inline__ vector unsigned char __ATTRS_o_ai
8820 vec_vsl(vector unsigned char __a, vector unsigned char __b) {
8821  return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
8822  (vector int)__b);
8823 }
8824 
8825 static __inline__ vector unsigned char __ATTRS_o_ai
8826 vec_vsl(vector unsigned char __a, vector unsigned short __b) {
8827  return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
8828  (vector int)__b);
8829 }
8830 
8831 static __inline__ vector unsigned char __ATTRS_o_ai
8832 vec_vsl(vector unsigned char __a, vector unsigned int __b) {
8833  return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
8834  (vector int)__b);
8835 }
8836 
8837 static __inline__ vector bool char __ATTRS_o_ai
8838 vec_vsl(vector bool char __a, vector unsigned char __b) {
8839  return (vector bool char)__builtin_altivec_vsl((vector int)__a,
8840  (vector int)__b);
8841 }
8842 
8843 static __inline__ vector bool char __ATTRS_o_ai
8844 vec_vsl(vector bool char __a, vector unsigned short __b) {
8845  return (vector bool char)__builtin_altivec_vsl((vector int)__a,
8846  (vector int)__b);
8847 }
8848 
8849 static __inline__ vector bool char __ATTRS_o_ai
8850 vec_vsl(vector bool char __a, vector unsigned int __b) {
8851  return (vector bool char)__builtin_altivec_vsl((vector int)__a,
8852  (vector int)__b);
8853 }
8854 
8855 static __inline__ vector short __ATTRS_o_ai vec_vsl(vector short __a,
8856  vector unsigned char __b) {
8857  return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
8858 }
8859 
8860 static __inline__ vector short __ATTRS_o_ai vec_vsl(vector short __a,
8861  vector unsigned short __b) {
8862  return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
8863 }
8864 
8865 static __inline__ vector short __ATTRS_o_ai vec_vsl(vector short __a,
8866  vector unsigned int __b) {
8867  return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
8868 }
8869 
8870 static __inline__ vector unsigned short __ATTRS_o_ai
8871 vec_vsl(vector unsigned short __a, vector unsigned char __b) {
8872  return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
8873  (vector int)__b);
8874 }
8875 
8876 static __inline__ vector unsigned short __ATTRS_o_ai
8877 vec_vsl(vector unsigned short __a, vector unsigned short __b) {
8878  return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
8879  (vector int)__b);
8880 }
8881 
8882 static __inline__ vector unsigned short __ATTRS_o_ai
8883 vec_vsl(vector unsigned short __a, vector unsigned int __b) {
8884  return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
8885  (vector int)__b);
8886 }
8887 
8888 static __inline__ vector bool short __ATTRS_o_ai
8889 vec_vsl(vector bool short __a, vector unsigned char __b) {
8890  return (vector bool short)__builtin_altivec_vsl((vector int)__a,
8891  (vector int)__b);
8892 }
8893 
8894 static __inline__ vector bool short __ATTRS_o_ai
8895 vec_vsl(vector bool short __a, vector unsigned short __b) {
8896  return (vector bool short)__builtin_altivec_vsl((vector int)__a,
8897  (vector int)__b);
8898 }
8899 
8900 static __inline__ vector bool short __ATTRS_o_ai
8901 vec_vsl(vector bool short __a, vector unsigned int __b) {
8902  return (vector bool short)__builtin_altivec_vsl((vector int)__a,
8903  (vector int)__b);
8904 }
8905 
8906 static __inline__ vector pixel __ATTRS_o_ai vec_vsl(vector pixel __a,
8907  vector unsigned char __b) {
8908  return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
8909 }
8910 
8911 static __inline__ vector pixel __ATTRS_o_ai vec_vsl(vector pixel __a,
8912  vector unsigned short __b) {
8913  return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
8914 }
8915 
8916 static __inline__ vector pixel __ATTRS_o_ai vec_vsl(vector pixel __a,
8917  vector unsigned int __b) {
8918  return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
8919 }
8920 
8921 static __inline__ vector int __ATTRS_o_ai vec_vsl(vector int __a,
8922  vector unsigned char __b) {
8923  return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
8924 }
8925 
8926 static __inline__ vector int __ATTRS_o_ai vec_vsl(vector int __a,
8927  vector unsigned short __b) {
8928  return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
8929 }
8930 
8931 static __inline__ vector int __ATTRS_o_ai vec_vsl(vector int __a,
8932  vector unsigned int __b) {
8933  return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
8934 }
8935 
8936 static __inline__ vector unsigned int __ATTRS_o_ai
8937 vec_vsl(vector unsigned int __a, vector unsigned char __b) {
8938  return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
8939  (vector int)__b);
8940 }
8941 
8942 static __inline__ vector unsigned int __ATTRS_o_ai
8943 vec_vsl(vector unsigned int __a, vector unsigned short __b) {
8944  return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
8945  (vector int)__b);
8946 }
8947 
8948 static __inline__ vector unsigned int __ATTRS_o_ai
8949 vec_vsl(vector unsigned int __a, vector unsigned int __b) {
8950  return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
8951  (vector int)__b);
8952 }
8953 
8954 static __inline__ vector bool int __ATTRS_o_ai
8955 vec_vsl(vector bool int __a, vector unsigned char __b) {
8956  return (vector bool int)__builtin_altivec_vsl((vector int)__a,
8957  (vector int)__b);
8958 }
8959 
8960 static __inline__ vector bool int __ATTRS_o_ai
8961 vec_vsl(vector bool int __a, vector unsigned short __b) {
8962  return (vector bool int)__builtin_altivec_vsl((vector int)__a,
8963  (vector int)__b);
8964 }
8965 
8966 static __inline__ vector bool int __ATTRS_o_ai
8967 vec_vsl(vector bool int __a, vector unsigned int __b) {
8968  return (vector bool int)__builtin_altivec_vsl((vector int)__a,
8969  (vector int)__b);
8970 }
8971 
8972 /* vec_slo */
8973 
8974 static __inline__ vector signed char __ATTRS_o_ai
8975 vec_slo(vector signed char __a, vector signed char __b) {
8976  return (vector signed char)__builtin_altivec_vslo((vector int)__a,
8977  (vector int)__b);
8978 }
8979 
8980 static __inline__ vector signed char __ATTRS_o_ai
8981 vec_slo(vector signed char __a, vector unsigned char __b) {
8982  return (vector signed char)__builtin_altivec_vslo((vector int)__a,
8983  (vector int)__b);
8984 }
8985 
8986 static __inline__ vector unsigned char __ATTRS_o_ai
8987 vec_slo(vector unsigned char __a, vector signed char __b) {
8988  return (vector unsigned char)__builtin_altivec_vslo((vector int)__a,
8989  (vector int)__b);
8990 }
8991 
8992 static __inline__ vector unsigned char __ATTRS_o_ai
8993 vec_slo(vector unsigned char __a, vector unsigned char __b) {
8994  return (vector unsigned char)__builtin_altivec_vslo((vector int)__a,
8995  (vector int)__b);
8996 }
8997 
8998 static __inline__ vector short __ATTRS_o_ai vec_slo(vector short __a,
8999  vector signed char __b) {
9000  return (vector short)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9001 }
9002 
9003 static __inline__ vector short __ATTRS_o_ai vec_slo(vector short __a,
9004  vector unsigned char __b) {
9005  return (vector short)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9006 }
9007 
9008 static __inline__ vector unsigned short __ATTRS_o_ai
9009 vec_slo(vector unsigned short __a, vector signed char __b) {
9010  return (vector unsigned short)__builtin_altivec_vslo((vector int)__a,
9011  (vector int)__b);
9012 }
9013 
9014 static __inline__ vector unsigned short __ATTRS_o_ai
9015 vec_slo(vector unsigned short __a, vector unsigned char __b) {
9016  return (vector unsigned short)__builtin_altivec_vslo((vector int)__a,
9017  (vector int)__b);
9018 }
9019 
9020 static __inline__ vector pixel __ATTRS_o_ai vec_slo(vector pixel __a,
9021  vector signed char __b) {
9022  return (vector pixel)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9023 }
9024 
9025 static __inline__ vector pixel __ATTRS_o_ai vec_slo(vector pixel __a,
9026  vector unsigned char __b) {
9027  return (vector pixel)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9028 }
9029 
9030 static __inline__ vector int __ATTRS_o_ai vec_slo(vector int __a,
9031  vector signed char __b) {
9032  return (vector int)__builtin_altivec_vslo(__a, (vector int)__b);
9033 }
9034 
9035 static __inline__ vector int __ATTRS_o_ai vec_slo(vector int __a,
9036  vector unsigned char __b) {
9037  return (vector int)__builtin_altivec_vslo(__a, (vector int)__b);
9038 }
9039 
9040 static __inline__ vector unsigned int __ATTRS_o_ai
9041 vec_slo(vector unsigned int __a, vector signed char __b) {
9042  return (vector unsigned int)__builtin_altivec_vslo((vector int)__a,
9043  (vector int)__b);
9044 }
9045 
9046 static __inline__ vector unsigned int __ATTRS_o_ai
9047 vec_slo(vector unsigned int __a, vector unsigned char __b) {
9048  return (vector unsigned int)__builtin_altivec_vslo((vector int)__a,
9049  (vector int)__b);
9050 }
9051 
9052 static __inline__ vector float __ATTRS_o_ai vec_slo(vector float __a,
9053  vector signed char __b) {
9054  return (vector float)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9055 }
9056 
9057 static __inline__ vector float __ATTRS_o_ai vec_slo(vector float __a,
9058  vector unsigned char __b) {
9059  return (vector float)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9060 }
9061 
9062 #ifdef __VSX__
9063 static __inline__ vector signed long long __ATTRS_o_ai
9064 vec_slo(vector signed long long __a, vector signed char __b) {
9065  return (vector signed long long)__builtin_altivec_vslo((vector int)__a,
9066  (vector int)__b);
9067 }
9068 
9069 static __inline__ vector signed long long __ATTRS_o_ai
9070 vec_slo(vector signed long long __a, vector unsigned char __b) {
9071  return (vector signed long long)__builtin_altivec_vslo((vector int)__a,
9072  (vector int)__b);
9073 }
9074 
9075 static __inline__ vector unsigned long long __ATTRS_o_ai
9076 vec_slo(vector unsigned long long __a, vector signed char __b) {
9077  return (vector unsigned long long)__builtin_altivec_vslo((vector int)__a,
9078  (vector int)__b);
9079 }
9080 
9081 static __inline__ vector unsigned long long __ATTRS_o_ai
9082 vec_slo(vector unsigned long long __a, vector unsigned char __b) {
9083  return (vector unsigned long long)__builtin_altivec_vslo((vector int)__a,
9084  (vector int)__b);
9085 }
9086 #endif
9087 
9088 /* vec_vslo */
9089 
9090 static __inline__ vector signed char __ATTRS_o_ai
9091 vec_vslo(vector signed char __a, vector signed char __b) {
9092  return (vector signed char)__builtin_altivec_vslo((vector int)__a,
9093  (vector int)__b);
9094 }
9095 
9096 static __inline__ vector signed char __ATTRS_o_ai
9097 vec_vslo(vector signed char __a, vector unsigned char __b) {
9098  return (vector signed char)__builtin_altivec_vslo((vector int)__a,
9099  (vector int)__b);
9100 }
9101 
9102 static __inline__ vector unsigned char __ATTRS_o_ai
9103 vec_vslo(vector unsigned char __a, vector signed char __b) {
9104  return (vector unsigned char)__builtin_altivec_vslo((vector int)__a,
9105  (vector int)__b);
9106 }
9107 
9108 static __inline__ vector unsigned char __ATTRS_o_ai
9109 vec_vslo(vector unsigned char __a, vector unsigned char __b) {
9110  return (vector unsigned char)__builtin_altivec_vslo((vector int)__a,
9111  (vector int)__b);
9112 }
9113 
9114 static __inline__ vector short __ATTRS_o_ai vec_vslo(vector short __a,
9115  vector signed char __b) {
9116  return (vector short)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9117 }
9118 
9119 static __inline__ vector short __ATTRS_o_ai vec_vslo(vector short __a,
9120  vector unsigned char __b) {
9121  return (vector short)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9122 }
9123 
9124 static __inline__ vector unsigned short __ATTRS_o_ai
9125 vec_vslo(vector unsigned short __a, vector signed char __b) {
9126  return (vector unsigned short)__builtin_altivec_vslo((vector int)__a,
9127  (vector int)__b);
9128 }
9129 
9130 static __inline__ vector unsigned short __ATTRS_o_ai
9131 vec_vslo(vector unsigned short __a, vector unsigned char __b) {
9132  return (vector unsigned short)__builtin_altivec_vslo((vector int)__a,
9133  (vector int)__b);
9134 }
9135 
9136 static __inline__ vector pixel __ATTRS_o_ai vec_vslo(vector pixel __a,
9137  vector signed char __b) {
9138  return (vector pixel)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9139 }
9140 
9141 static __inline__ vector pixel __ATTRS_o_ai vec_vslo(vector pixel __a,
9142  vector unsigned char __b) {
9143  return (vector pixel)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9144 }
9145 
9146 static __inline__ vector int __ATTRS_o_ai vec_vslo(vector int __a,
9147  vector signed char __b) {
9148  return (vector int)__builtin_altivec_vslo(__a, (vector int)__b);
9149 }
9150 
9151 static __inline__ vector int __ATTRS_o_ai vec_vslo(vector int __a,
9152  vector unsigned char __b) {
9153  return (vector int)__builtin_altivec_vslo(__a, (vector int)__b);
9154 }
9155 
9156 static __inline__ vector unsigned int __ATTRS_o_ai
9157 vec_vslo(vector unsigned int __a, vector signed char __b) {
9158  return (vector unsigned int)__builtin_altivec_vslo((vector int)__a,
9159  (vector int)__b);
9160 }
9161 
9162 static __inline__ vector unsigned int __ATTRS_o_ai
9163 vec_vslo(vector unsigned int __a, vector unsigned char __b) {
9164  return (vector unsigned int)__builtin_altivec_vslo((vector int)__a,
9165  (vector int)__b);
9166 }
9167 
9168 static __inline__ vector float __ATTRS_o_ai vec_vslo(vector float __a,
9169  vector signed char __b) {
9170  return (vector float)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9171 }
9172 
9173 static __inline__ vector float __ATTRS_o_ai vec_vslo(vector float __a,
9174  vector unsigned char __b) {
9175  return (vector float)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
9176 }
9177 
9178 /* vec_splat */
9179 
9180 static __inline__ vector signed char __ATTRS_o_ai
9181 vec_splat(vector signed char __a, unsigned const int __b) {
9182  return vec_perm(__a, __a, (vector unsigned char)(__b & 0x0F));
9183 }
9184 
9185 static __inline__ vector unsigned char __ATTRS_o_ai
9186 vec_splat(vector unsigned char __a, unsigned const int __b) {
9187  return vec_perm(__a, __a, (vector unsigned char)(__b & 0x0F));
9188 }
9189 
9190 static __inline__ vector bool char __ATTRS_o_ai
9191 vec_splat(vector bool char __a, unsigned const int __b) {
9192  return vec_perm(__a, __a, (vector unsigned char)(__b & 0x0F));
9193 }
9194 
9195 static __inline__ vector signed short __ATTRS_o_ai
9196 vec_splat(vector signed short __a, unsigned const int __b) {
9197  unsigned char b0 = (__b & 0x07) * 2;
9198  unsigned char b1 = b0 + 1;
9199  return vec_perm(__a, __a,
9200  (vector unsigned char)(b0, b1, b0, b1, b0, b1, b0, b1, b0, b1,
9201  b0, b1, b0, b1, b0, b1));
9202 }
9203 
9204 static __inline__ vector unsigned short __ATTRS_o_ai
9205 vec_splat(vector unsigned short __a, unsigned const int __b) {
9206  unsigned char b0 = (__b & 0x07) * 2;
9207  unsigned char b1 = b0 + 1;
9208  return vec_perm(__a, __a,
9209  (vector unsigned char)(b0, b1, b0, b1, b0, b1, b0, b1, b0, b1,
9210  b0, b1, b0, b1, b0, b1));
9211 }
9212 
9213 static __inline__ vector bool short __ATTRS_o_ai
9214 vec_splat(vector bool short __a, unsigned const int __b) {
9215  unsigned char b0 = (__b & 0x07) * 2;
9216  unsigned char b1 = b0 + 1;
9217  return vec_perm(__a, __a,
9218  (vector unsigned char)(b0, b1, b0, b1, b0, b1, b0, b1, b0, b1,
9219  b0, b1, b0, b1, b0, b1));
9220 }
9221 
9222 static __inline__ vector pixel __ATTRS_o_ai vec_splat(vector pixel __a,
9223  unsigned const int __b) {
9224  unsigned char b0 = (__b & 0x07) * 2;
9225  unsigned char b1 = b0 + 1;
9226  return vec_perm(__a, __a,
9227  (vector unsigned char)(b0, b1, b0, b1, b0, b1, b0, b1, b0, b1,
9228  b0, b1, b0, b1, b0, b1));
9229 }
9230 
9231 static __inline__ vector signed int __ATTRS_o_ai
9232 vec_splat(vector signed int __a, unsigned const int __b) {
9233  unsigned char b0 = (__b & 0x03) * 4;
9234  unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3;
9235  return vec_perm(__a, __a,
9236  (vector unsigned char)(b0, b1, b2, b3, b0, b1, b2, b3, b0, b1,
9237  b2, b3, b0, b1, b2, b3));
9238 }
9239 
9240 static __inline__ vector unsigned int __ATTRS_o_ai
9241 vec_splat(vector unsigned int __a, unsigned const int __b) {
9242  unsigned char b0 = (__b & 0x03) * 4;
9243  unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3;
9244  return vec_perm(__a, __a,
9245  (vector unsigned char)(b0, b1, b2, b3, b0, b1, b2, b3, b0, b1,
9246  b2, b3, b0, b1, b2, b3));
9247 }
9248 
9249 static __inline__ vector bool int __ATTRS_o_ai
9250 vec_splat(vector bool int __a, unsigned const int __b) {
9251  unsigned char b0 = (__b & 0x03) * 4;
9252  unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3;
9253  return vec_perm(__a, __a,
9254  (vector unsigned char)(b0, b1, b2, b3, b0, b1, b2, b3, b0, b1,
9255  b2, b3, b0, b1, b2, b3));
9256 }
9257 
9258 static __inline__ vector float __ATTRS_o_ai vec_splat(vector float __a,
9259  unsigned const int __b) {
9260  unsigned char b0 = (__b & 0x03) * 4;
9261  unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3;
9262  return vec_perm(__a, __a,
9263  (vector unsigned char)(b0, b1, b2, b3, b0, b1, b2, b3, b0, b1,
9264  b2, b3, b0, b1, b2, b3));
9265 }
9266 
9267 #ifdef __VSX__
9268 static __inline__ vector double __ATTRS_o_ai vec_splat(vector double __a,
9269  unsigned const int __b) {
9270  unsigned char b0 = (__b & 0x01) * 8;
9271  unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3, b4 = b0 + 4, b5 = b0 + 5,
9272  b6 = b0 + 6, b7 = b0 + 7;
9273  return vec_perm(__a, __a,
9274  (vector unsigned char)(b0, b1, b2, b3, b4, b5, b6, b7, b0, b1,
9275  b2, b3, b4, b5, b6, b7));
9276 }
9277 static __inline__ vector bool long long __ATTRS_o_ai
9278 vec_splat(vector bool long long __a, unsigned const int __b) {
9279  unsigned char b0 = (__b & 0x01) * 8;
9280  unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3, b4 = b0 + 4, b5 = b0 + 5,
9281  b6 = b0 + 6, b7 = b0 + 7;
9282  return vec_perm(__a, __a,
9283  (vector unsigned char)(b0, b1, b2, b3, b4, b5, b6, b7, b0, b1,
9284  b2, b3, b4, b5, b6, b7));
9285 }
9286 static __inline__ vector signed long long __ATTRS_o_ai
9287 vec_splat(vector signed long long __a, unsigned const int __b) {
9288  unsigned char b0 = (__b & 0x01) * 8;
9289  unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3, b4 = b0 + 4, b5 = b0 + 5,
9290  b6 = b0 + 6, b7 = b0 + 7;
9291  return vec_perm(__a, __a,
9292  (vector unsigned char)(b0, b1, b2, b3, b4, b5, b6, b7, b0, b1,
9293  b2, b3, b4, b5, b6, b7));
9294 }
9295 static __inline__ vector unsigned long long __ATTRS_o_ai
9296 vec_splat(vector unsigned long long __a, unsigned const int __b) {
9297  unsigned char b0 = (__b & 0x01) * 8;
9298  unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3, b4 = b0 + 4, b5 = b0 + 5,
9299  b6 = b0 + 6, b7 = b0 + 7;
9300  return vec_perm(__a, __a,
9301  (vector unsigned char)(b0, b1, b2, b3, b4, b5, b6, b7, b0, b1,
9302  b2, b3, b4, b5, b6, b7));
9303 }
9304 #endif
9305 
9306 /* vec_vspltb */
9307 
9308 #define __builtin_altivec_vspltb vec_vspltb
9309 
9310 static __inline__ vector signed char __ATTRS_o_ai
9311 vec_vspltb(vector signed char __a, unsigned char __b) {
9312  return vec_perm(__a, __a, (vector unsigned char)(__b));
9313 }
9314 
9315 static __inline__ vector unsigned char __ATTRS_o_ai
9316 vec_vspltb(vector unsigned char __a, unsigned char __b) {
9317  return vec_perm(__a, __a, (vector unsigned char)(__b));
9318 }
9319 
9320 static __inline__ vector bool char __ATTRS_o_ai vec_vspltb(vector bool char __a,
9321  unsigned char __b) {
9322  return vec_perm(__a, __a, (vector unsigned char)(__b));
9323 }
9324 
9325 /* vec_vsplth */
9326 
9327 #define __builtin_altivec_vsplth vec_vsplth
9328 
9329 static __inline__ vector short __ATTRS_o_ai vec_vsplth(vector short __a,
9330  unsigned char __b) {
9331  __b *= 2;
9332  unsigned char b1 = __b + 1;
9333  return vec_perm(__a, __a,
9334  (vector unsigned char)(__b, b1, __b, b1, __b, b1, __b, b1,
9335  __b, b1, __b, b1, __b, b1, __b, b1));
9336 }
9337 
9338 static __inline__ vector unsigned short __ATTRS_o_ai
9339 vec_vsplth(vector unsigned short __a, unsigned char __b) {
9340  __b *= 2;
9341  unsigned char b1 = __b + 1;
9342  return vec_perm(__a, __a,
9343  (vector unsigned char)(__b, b1, __b, b1, __b, b1, __b, b1,
9344  __b, b1, __b, b1, __b, b1, __b, b1));
9345 }
9346 
9347 static __inline__ vector bool short __ATTRS_o_ai
9348 vec_vsplth(vector bool short __a, unsigned char __b) {
9349  __b *= 2;
9350  unsigned char b1 = __b + 1;
9351  return vec_perm(__a, __a,
9352  (vector unsigned char)(__b, b1, __b, b1, __b, b1, __b, b1,
9353  __b, b1, __b, b1, __b, b1, __b, b1));
9354 }
9355 
9356 static __inline__ vector pixel __ATTRS_o_ai vec_vsplth(vector pixel __a,
9357  unsigned char __b) {
9358  __b *= 2;
9359  unsigned char b1 = __b + 1;
9360  return vec_perm(__a, __a,
9361  (vector unsigned char)(__b, b1, __b, b1, __b, b1, __b, b1,
9362  __b, b1, __b, b1, __b, b1, __b, b1));
9363 }
9364 
9365 /* vec_vspltw */
9366 
9367 #define __builtin_altivec_vspltw vec_vspltw
9368 
9369 static __inline__ vector int __ATTRS_o_ai vec_vspltw(vector int __a,
9370  unsigned char __b) {
9371  __b *= 4;
9372  unsigned char b1 = __b + 1, b2 = __b + 2, b3 = __b + 3;
9373  return vec_perm(__a, __a,
9374  (vector unsigned char)(__b, b1, b2, b3, __b, b1, b2, b3, __b,
9375  b1, b2, b3, __b, b1, b2, b3));
9376 }
9377 
9378 static __inline__ vector unsigned int __ATTRS_o_ai
9379 vec_vspltw(vector unsigned int __a, unsigned char __b) {
9380  __b *= 4;
9381  unsigned char b1 = __b + 1, b2 = __b + 2, b3 = __b + 3;
9382  return vec_perm(__a, __a,
9383  (vector unsigned char)(__b, b1, b2, b3, __b, b1, b2, b3, __b,
9384  b1, b2, b3, __b, b1, b2, b3));
9385 }
9386 
9387 static __inline__ vector bool int __ATTRS_o_ai vec_vspltw(vector bool int __a,
9388  unsigned char __b) {
9389  __b *= 4;
9390  unsigned char b1 = __b + 1, b2 = __b + 2, b3 = __b + 3;
9391  return vec_perm(__a, __a,
9392  (vector unsigned char)(__b, b1, b2, b3, __b, b1, b2, b3, __b,
9393  b1, b2, b3, __b, b1, b2, b3));
9394 }
9395 
9396 static __inline__ vector float __ATTRS_o_ai vec_vspltw(vector float __a,
9397  unsigned char __b) {
9398  __b *= 4;
9399  unsigned char b1 = __b + 1, b2 = __b + 2, b3 = __b + 3;
9400  return vec_perm(__a, __a,
9401  (vector unsigned char)(__b, b1, b2, b3, __b, b1, b2, b3, __b,
9402  b1, b2, b3, __b, b1, b2, b3));
9403 }
9404 
9405 /* vec_splat_s8 */
9406 
9407 #define __builtin_altivec_vspltisb vec_splat_s8
9408 
9409 // FIXME: parameter should be treated as 5-bit signed literal
9410 static __inline__ vector signed char __ATTRS_o_ai
9411 vec_splat_s8(signed char __a) {
9412  return (vector signed char)(__a);
9413 }
9414 
9415 /* vec_vspltisb */
9416 
9417 // FIXME: parameter should be treated as 5-bit signed literal
9418 static __inline__ vector signed char __ATTRS_o_ai
9419 vec_vspltisb(signed char __a) {
9420  return (vector signed char)(__a);
9421 }
9422 
9423 /* vec_splat_s16 */
9424 
9425 #define __builtin_altivec_vspltish vec_splat_s16
9426 
9427 // FIXME: parameter should be treated as 5-bit signed literal
9428 static __inline__ vector short __ATTRS_o_ai vec_splat_s16(signed char __a) {
9429  return (vector short)(__a);
9430 }
9431 
9432 /* vec_vspltish */
9433 
9434 // FIXME: parameter should be treated as 5-bit signed literal
9435 static __inline__ vector short __ATTRS_o_ai vec_vspltish(signed char __a) {
9436  return (vector short)(__a);
9437 }
9438 
9439 /* vec_splat_s32 */
9440 
9441 #define __builtin_altivec_vspltisw vec_splat_s32
9442 
9443 // FIXME: parameter should be treated as 5-bit signed literal
9444 static __inline__ vector int __ATTRS_o_ai vec_splat_s32(signed char __a) {
9445  return (vector int)(__a);
9446 }
9447 
9448 /* vec_vspltisw */
9449 
9450 // FIXME: parameter should be treated as 5-bit signed literal
9451 static __inline__ vector int __ATTRS_o_ai vec_vspltisw(signed char __a) {
9452  return (vector int)(__a);
9453 }
9454 
9455 /* vec_splat_u8 */
9456 
9457 // FIXME: parameter should be treated as 5-bit signed literal
9458 static __inline__ vector unsigned char __ATTRS_o_ai
9459 vec_splat_u8(unsigned char __a) {
9460  return (vector unsigned char)(__a);
9461 }
9462 
9463 /* vec_splat_u16 */
9464 
9465 // FIXME: parameter should be treated as 5-bit signed literal
9466 static __inline__ vector unsigned short __ATTRS_o_ai
9467 vec_splat_u16(signed char __a) {
9468  return (vector unsigned short)(__a);
9469 }
9470 
9471 /* vec_splat_u32 */
9472 
9473 // FIXME: parameter should be treated as 5-bit signed literal
9474 static __inline__ vector unsigned int __ATTRS_o_ai
9475 vec_splat_u32(signed char __a) {
9476  return (vector unsigned int)(__a);
9477 }
9478 
9479 /* vec_sr */
9480 
9481 // vec_sr does modulo arithmetic on __b first, so __b is allowed to be more
9482 // than the length of __a.
9483 static __inline__ vector unsigned char __ATTRS_o_ai
9484 vec_sr(vector unsigned char __a, vector unsigned char __b) {
9485  return __a >>
9486  (__b % (vector unsigned char)(sizeof(unsigned char) * __CHAR_BIT__));
9487 }
9488 
9489 static __inline__ vector signed char __ATTRS_o_ai
9490 vec_sr(vector signed char __a, vector unsigned char __b) {
9491  return (vector signed char)vec_sr((vector unsigned char)__a, __b);
9492 }
9493 
9494 static __inline__ vector unsigned short __ATTRS_o_ai
9495 vec_sr(vector unsigned short __a, vector unsigned short __b) {
9496  return __a >>
9497  (__b % (vector unsigned short)(sizeof(unsigned short) * __CHAR_BIT__));
9498 }
9499 
9500 static __inline__ vector short __ATTRS_o_ai vec_sr(vector short __a,
9501  vector unsigned short __b) {
9502  return (vector short)vec_sr((vector unsigned short)__a, __b);
9503 }
9504 
9505 static __inline__ vector unsigned int __ATTRS_o_ai
9506 vec_sr(vector unsigned int __a, vector unsigned int __b) {
9507  return __a >>
9508  (__b % (vector unsigned int)(sizeof(unsigned int) * __CHAR_BIT__));
9509 }
9510 
9511 static __inline__ vector int __ATTRS_o_ai vec_sr(vector int __a,
9512  vector unsigned int __b) {
9513  return (vector int)vec_sr((vector unsigned int)__a, __b);
9514 }
9515 
9516 #ifdef __POWER8_VECTOR__
9517 static __inline__ vector unsigned long long __ATTRS_o_ai
9518 vec_sr(vector unsigned long long __a, vector unsigned long long __b) {
9519  return __a >> (__b % (vector unsigned long long)(sizeof(unsigned long long) *
9520  __CHAR_BIT__));
9521 }
9522 
9523 static __inline__ vector long long __ATTRS_o_ai
9524 vec_sr(vector long long __a, vector unsigned long long __b) {
9525  return (vector long long)vec_sr((vector unsigned long long)__a, __b);
9526 }
9527 #endif
9528 
9529 /* vec_vsrb */
9530 
9531 #define __builtin_altivec_vsrb vec_vsrb
9532 
9533 static __inline__ vector signed char __ATTRS_o_ai
9534 vec_vsrb(vector signed char __a, vector unsigned char __b) {
9535  return vec_sr(__a, __b);
9536 }
9537 
9538 static __inline__ vector unsigned char __ATTRS_o_ai
9539 vec_vsrb(vector unsigned char __a, vector unsigned char __b) {
9540  return vec_sr(__a, __b);
9541 }
9542 
9543 /* vec_vsrh */
9544 
9545 #define __builtin_altivec_vsrh vec_vsrh
9546 
9547 static __inline__ vector short __ATTRS_o_ai
9548 vec_vsrh(vector short __a, vector unsigned short __b) {
9549  return vec_sr(__a, __b);
9550 }
9551 
9552 static __inline__ vector unsigned short __ATTRS_o_ai
9553 vec_vsrh(vector unsigned short __a, vector unsigned short __b) {
9554  return vec_sr(__a, __b);
9555 }
9556 
9557 /* vec_vsrw */
9558 
9559 #define __builtin_altivec_vsrw vec_vsrw
9560 
9561 static __inline__ vector int __ATTRS_o_ai vec_vsrw(vector int __a,
9562  vector unsigned int __b) {
9563  return vec_sr(__a, __b);
9564 }
9565 
9566 static __inline__ vector unsigned int __ATTRS_o_ai
9567 vec_vsrw(vector unsigned int __a, vector unsigned int __b) {
9568  return vec_sr(__a, __b);
9569 }
9570 
9571 /* vec_sra */
9572 
9573 static __inline__ vector signed char __ATTRS_o_ai
9574 vec_sra(vector signed char __a, vector unsigned char __b) {
9575  return (vector signed char)__builtin_altivec_vsrab((vector char)__a, __b);
9576 }
9577 
9578 static __inline__ vector unsigned char __ATTRS_o_ai
9579 vec_sra(vector unsigned char __a, vector unsigned char __b) {
9580  return (vector unsigned char)__builtin_altivec_vsrab((vector char)__a, __b);
9581 }
9582 
9583 static __inline__ vector short __ATTRS_o_ai vec_sra(vector short __a,
9584  vector unsigned short __b) {
9585  return __builtin_altivec_vsrah(__a, (vector unsigned short)__b);
9586 }
9587 
9588 static __inline__ vector unsigned short __ATTRS_o_ai
9589 vec_sra(vector unsigned short __a, vector unsigned short __b) {
9590  return (vector unsigned short)__builtin_altivec_vsrah((vector short)__a, __b);
9591 }
9592 
9593 static __inline__ vector int __ATTRS_o_ai vec_sra(vector int __a,
9594  vector unsigned int __b) {
9595  return __builtin_altivec_vsraw(__a, __b);
9596 }
9597 
9598 static __inline__ vector unsigned int __ATTRS_o_ai
9599 vec_sra(vector unsigned int __a, vector unsigned int __b) {
9600  return (vector unsigned int)__builtin_altivec_vsraw((vector int)__a, __b);
9601 }
9602 
9603 #ifdef __POWER8_VECTOR__
9604 static __inline__ vector signed long long __ATTRS_o_ai
9605 vec_sra(vector signed long long __a, vector unsigned long long __b) {
9606  return __a >> __b;
9607 }
9608 
9609 static __inline__ vector unsigned long long __ATTRS_o_ai
9610 vec_sra(vector unsigned long long __a, vector unsigned long long __b) {
9611  return (vector unsigned long long)((vector signed long long)__a >> __b);
9612 }
9613 #endif
9614 
9615 /* vec_vsrab */
9616 
9617 static __inline__ vector signed char __ATTRS_o_ai
9618 vec_vsrab(vector signed char __a, vector unsigned char __b) {
9619  return (vector signed char)__builtin_altivec_vsrab((vector char)__a, __b);
9620 }
9621 
9622 static __inline__ vector unsigned char __ATTRS_o_ai
9623 vec_vsrab(vector unsigned char __a, vector unsigned char __b) {
9624  return (vector unsigned char)__builtin_altivec_vsrab((vector char)__a, __b);
9625 }
9626 
9627 /* vec_vsrah */
9628 
9629 static __inline__ vector short __ATTRS_o_ai
9630 vec_vsrah(vector short __a, vector unsigned short __b) {
9631  return __builtin_altivec_vsrah(__a, (vector unsigned short)__b);
9632 }
9633 
9634 static __inline__ vector unsigned short __ATTRS_o_ai
9635 vec_vsrah(vector unsigned short __a, vector unsigned short __b) {
9636  return (vector unsigned short)__builtin_altivec_vsrah((vector short)__a, __b);
9637 }
9638 
9639 /* vec_vsraw */
9640 
9641 static __inline__ vector int __ATTRS_o_ai vec_vsraw(vector int __a,
9642  vector unsigned int __b) {
9643  return __builtin_altivec_vsraw(__a, __b);
9644 }
9645 
9646 static __inline__ vector unsigned int __ATTRS_o_ai
9647 vec_vsraw(vector unsigned int __a, vector unsigned int __b) {
9648  return (vector unsigned int)__builtin_altivec_vsraw((vector int)__a, __b);
9649 }
9650 
9651 /* vec_srl */
9652 
9653 static __inline__ vector signed char __ATTRS_o_ai
9654 vec_srl(vector signed char __a, vector unsigned char __b) {
9655  return (vector signed char)__builtin_altivec_vsr((vector int)__a,
9656  (vector int)__b);
9657 }
9658 
9659 static __inline__ vector signed char __ATTRS_o_ai
9660 vec_srl(vector signed char __a, vector unsigned short __b) {
9661  return (vector signed char)__builtin_altivec_vsr((vector int)__a,
9662  (vector int)__b);
9663 }
9664 
9665 static __inline__ vector signed char __ATTRS_o_ai
9666 vec_srl(vector signed char __a, vector unsigned int __b) {
9667  return (vector signed char)__builtin_altivec_vsr((vector int)__a,
9668  (vector int)__b);
9669 }
9670 
9671 static __inline__ vector unsigned char __ATTRS_o_ai
9672 vec_srl(vector unsigned char __a, vector unsigned char __b) {
9673  return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
9674  (vector int)__b);
9675 }
9676 
9677 static __inline__ vector unsigned char __ATTRS_o_ai
9678 vec_srl(vector unsigned char __a, vector unsigned short __b) {
9679  return (vector unsigned 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 int __b) {
9685  return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
9686  (vector int)__b);
9687 }
9688 
9689 static __inline__ vector bool char __ATTRS_o_ai
9690 vec_srl(vector bool char __a, vector unsigned char __b) {
9691  return (vector bool char)__builtin_altivec_vsr((vector int)__a,
9692  (vector int)__b);
9693 }
9694 
9695 static __inline__ vector bool char __ATTRS_o_ai
9696 vec_srl(vector bool char __a, vector unsigned short __b) {
9697  return (vector bool 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 int __b) {
9703  return (vector bool char)__builtin_altivec_vsr((vector int)__a,
9704  (vector int)__b);
9705 }
9706 
9707 static __inline__ vector short __ATTRS_o_ai vec_srl(vector short __a,
9708  vector unsigned char __b) {
9709  return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9710 }
9711 
9712 static __inline__ vector short __ATTRS_o_ai vec_srl(vector short __a,
9713  vector unsigned short __b) {
9714  return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9715 }
9716 
9717 static __inline__ vector short __ATTRS_o_ai vec_srl(vector short __a,
9718  vector unsigned int __b) {
9719  return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9720 }
9721 
9722 static __inline__ vector unsigned short __ATTRS_o_ai
9723 vec_srl(vector unsigned short __a, vector unsigned char __b) {
9724  return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
9725  (vector int)__b);
9726 }
9727 
9728 static __inline__ vector unsigned short __ATTRS_o_ai
9729 vec_srl(vector unsigned short __a, vector unsigned short __b) {
9730  return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
9731  (vector int)__b);
9732 }
9733 
9734 static __inline__ vector unsigned short __ATTRS_o_ai
9735 vec_srl(vector unsigned short __a, vector unsigned int __b) {
9736  return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
9737  (vector int)__b);
9738 }
9739 
9740 static __inline__ vector bool short __ATTRS_o_ai
9741 vec_srl(vector bool short __a, vector unsigned char __b) {
9742  return (vector bool short)__builtin_altivec_vsr((vector int)__a,
9743  (vector int)__b);
9744 }
9745 
9746 static __inline__ vector bool short __ATTRS_o_ai
9747 vec_srl(vector bool short __a, vector unsigned short __b) {
9748  return (vector bool 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 int __b) {
9754  return (vector bool short)__builtin_altivec_vsr((vector int)__a,
9755  (vector int)__b);
9756 }
9757 
9758 static __inline__ vector pixel __ATTRS_o_ai vec_srl(vector pixel __a,
9759  vector unsigned char __b) {
9760  return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9761 }
9762 
9763 static __inline__ vector pixel __ATTRS_o_ai vec_srl(vector pixel __a,
9764  vector unsigned short __b) {
9765  return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9766 }
9767 
9768 static __inline__ vector pixel __ATTRS_o_ai vec_srl(vector pixel __a,
9769  vector unsigned int __b) {
9770  return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9771 }
9772 
9773 static __inline__ vector int __ATTRS_o_ai vec_srl(vector int __a,
9774  vector unsigned char __b) {
9775  return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
9776 }
9777 
9778 static __inline__ vector int __ATTRS_o_ai vec_srl(vector int __a,
9779  vector unsigned short __b) {
9780  return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
9781 }
9782 
9783 static __inline__ vector int __ATTRS_o_ai vec_srl(vector int __a,
9784  vector unsigned int __b) {
9785  return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
9786 }
9787 
9788 static __inline__ vector unsigned int __ATTRS_o_ai
9789 vec_srl(vector unsigned int __a, vector unsigned char __b) {
9790  return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
9791  (vector int)__b);
9792 }
9793 
9794 static __inline__ vector unsigned int __ATTRS_o_ai
9795 vec_srl(vector unsigned int __a, vector unsigned short __b) {
9796  return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
9797  (vector int)__b);
9798 }
9799 
9800 static __inline__ vector unsigned int __ATTRS_o_ai
9801 vec_srl(vector unsigned int __a, vector unsigned int __b) {
9802  return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
9803  (vector int)__b);
9804 }
9805 
9806 static __inline__ vector bool int __ATTRS_o_ai
9807 vec_srl(vector bool int __a, vector unsigned char __b) {
9808  return (vector bool int)__builtin_altivec_vsr((vector int)__a,
9809  (vector int)__b);
9810 }
9811 
9812 static __inline__ vector bool int __ATTRS_o_ai
9813 vec_srl(vector bool int __a, vector unsigned short __b) {
9814  return (vector bool 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 int __b) {
9820  return (vector bool int)__builtin_altivec_vsr((vector int)__a,
9821  (vector int)__b);
9822 }
9823 
9824 #ifdef __VSX__
9825 static __inline__ vector signed long long __ATTRS_o_ai
9826 vec_srl(vector signed long long __a, vector unsigned char __b) {
9827  return (vector signed long long)__builtin_altivec_vsr((vector int)__a,
9828  (vector int)__b);
9829 }
9830 
9831 static __inline__ vector unsigned long long __ATTRS_o_ai
9832 vec_srl(vector unsigned long long __a, vector unsigned char __b) {
9833  return (vector unsigned long long)__builtin_altivec_vsr((vector int)__a,
9834  (vector int)__b);
9835 }
9836 #endif
9837 
9838 /* vec_vsr */
9839 
9840 static __inline__ vector signed char __ATTRS_o_ai
9841 vec_vsr(vector signed char __a, vector unsigned char __b) {
9842  return (vector signed char)__builtin_altivec_vsr((vector int)__a,
9843  (vector int)__b);
9844 }
9845 
9846 static __inline__ vector signed char __ATTRS_o_ai
9847 vec_vsr(vector signed char __a, vector unsigned short __b) {
9848  return (vector signed char)__builtin_altivec_vsr((vector int)__a,
9849  (vector int)__b);
9850 }
9851 
9852 static __inline__ vector signed char __ATTRS_o_ai
9853 vec_vsr(vector signed char __a, vector unsigned int __b) {
9854  return (vector signed char)__builtin_altivec_vsr((vector int)__a,
9855  (vector int)__b);
9856 }
9857 
9858 static __inline__ vector unsigned char __ATTRS_o_ai
9859 vec_vsr(vector unsigned char __a, vector unsigned char __b) {
9860  return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
9861  (vector int)__b);
9862 }
9863 
9864 static __inline__ vector unsigned char __ATTRS_o_ai
9865 vec_vsr(vector unsigned char __a, vector unsigned short __b) {
9866  return (vector unsigned 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 int __b) {
9872  return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
9873  (vector int)__b);
9874 }
9875 
9876 static __inline__ vector bool char __ATTRS_o_ai
9877 vec_vsr(vector bool char __a, vector unsigned char __b) {
9878  return (vector bool char)__builtin_altivec_vsr((vector int)__a,
9879  (vector int)__b);
9880 }
9881 
9882 static __inline__ vector bool char __ATTRS_o_ai
9883 vec_vsr(vector bool char __a, vector unsigned short __b) {
9884  return (vector bool 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 int __b) {
9890  return (vector bool char)__builtin_altivec_vsr((vector int)__a,
9891  (vector int)__b);
9892 }
9893 
9894 static __inline__ vector short __ATTRS_o_ai vec_vsr(vector short __a,
9895  vector unsigned char __b) {
9896  return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9897 }
9898 
9899 static __inline__ vector short __ATTRS_o_ai vec_vsr(vector short __a,
9900  vector unsigned short __b) {
9901  return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9902 }
9903 
9904 static __inline__ vector short __ATTRS_o_ai vec_vsr(vector short __a,
9905  vector unsigned int __b) {
9906  return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9907 }
9908 
9909 static __inline__ vector unsigned short __ATTRS_o_ai
9910 vec_vsr(vector unsigned short __a, vector unsigned char __b) {
9911  return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
9912  (vector int)__b);
9913 }
9914 
9915 static __inline__ vector unsigned short __ATTRS_o_ai
9916 vec_vsr(vector unsigned short __a, vector unsigned short __b) {
9917  return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
9918  (vector int)__b);
9919 }
9920 
9921 static __inline__ vector unsigned short __ATTRS_o_ai
9922 vec_vsr(vector unsigned short __a, vector unsigned int __b) {
9923  return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
9924  (vector int)__b);
9925 }
9926 
9927 static __inline__ vector bool short __ATTRS_o_ai
9928 vec_vsr(vector bool short __a, vector unsigned char __b) {
9929  return (vector bool short)__builtin_altivec_vsr((vector int)__a,
9930  (vector int)__b);
9931 }
9932 
9933 static __inline__ vector bool short __ATTRS_o_ai
9934 vec_vsr(vector bool short __a, vector unsigned short __b) {
9935  return (vector bool 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 int __b) {
9941  return (vector bool short)__builtin_altivec_vsr((vector int)__a,
9942  (vector int)__b);
9943 }
9944 
9945 static __inline__ vector pixel __ATTRS_o_ai vec_vsr(vector pixel __a,
9946  vector unsigned char __b) {
9947  return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9948 }
9949 
9950 static __inline__ vector pixel __ATTRS_o_ai vec_vsr(vector pixel __a,
9951  vector unsigned short __b) {
9952  return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9953 }
9954 
9955 static __inline__ vector pixel __ATTRS_o_ai vec_vsr(vector pixel __a,
9956  vector unsigned int __b) {
9957  return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
9958 }
9959 
9960 static __inline__ vector int __ATTRS_o_ai vec_vsr(vector int __a,
9961  vector unsigned char __b) {
9962  return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
9963 }
9964 
9965 static __inline__ vector int __ATTRS_o_ai vec_vsr(vector int __a,
9966  vector unsigned short __b) {
9967  return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
9968 }
9969 
9970 static __inline__ vector int __ATTRS_o_ai vec_vsr(vector int __a,
9971  vector unsigned int __b) {
9972  return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
9973 }
9974 
9975 static __inline__ vector unsigned int __ATTRS_o_ai
9976 vec_vsr(vector unsigned int __a, vector unsigned char __b) {
9977  return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
9978  (vector int)__b);
9979 }
9980 
9981 static __inline__ vector unsigned int __ATTRS_o_ai
9982 vec_vsr(vector unsigned int __a, vector unsigned short __b) {
9983  return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
9984  (vector int)__b);
9985 }
9986 
9987 static __inline__ vector unsigned int __ATTRS_o_ai
9988 vec_vsr(vector unsigned int __a, vector unsigned int __b) {
9989  return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
9990  (vector int)__b);
9991 }
9992 
9993 static __inline__ vector bool int __ATTRS_o_ai
9994 vec_vsr(vector bool int __a, vector unsigned char __b) {
9995  return (vector bool int)__builtin_altivec_vsr((vector int)__a,
9996  (vector int)__b);
9997 }
9998 
9999 static __inline__ vector bool int __ATTRS_o_ai
10000 vec_vsr(vector bool int __a, vector unsigned short __b) {
10001  return (vector bool 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 int __b) {
10007  return (vector bool int)__builtin_altivec_vsr((vector int)__a,
10008  (vector int)__b);
10009 }
10010 
10011 /* vec_sro */
10012 
10013 static __inline__ vector signed char __ATTRS_o_ai
10014 vec_sro(vector signed char __a, vector signed char __b) {
10015  return (vector signed char)__builtin_altivec_vsro((vector int)__a,
10016  (vector int)__b);
10017 }
10018 
10019 static __inline__ vector signed char __ATTRS_o_ai
10020 vec_sro(vector signed char __a, vector unsigned char __b) {
10021  return (vector signed char)__builtin_altivec_vsro((vector int)__a,
10022  (vector int)__b);
10023 }
10024 
10025 static __inline__ vector unsigned char __ATTRS_o_ai
10026 vec_sro(vector unsigned char __a, vector signed char __b) {
10027  return (vector unsigned char)__builtin_altivec_vsro((vector int)__a,
10028  (vector int)__b);
10029 }
10030 
10031 static __inline__ vector unsigned char __ATTRS_o_ai
10032 vec_sro(vector unsigned char __a, vector unsigned char __b) {
10033  return (vector unsigned char)__builtin_altivec_vsro((vector int)__a,
10034  (vector int)__b);
10035 }
10036 
10037 static __inline__ vector short __ATTRS_o_ai vec_sro(vector short __a,
10038  vector signed char __b) {
10039  return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10040 }
10041 
10042 static __inline__ vector short __ATTRS_o_ai vec_sro(vector short __a,
10043  vector unsigned char __b) {
10044  return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10045 }
10046 
10047 static __inline__ vector unsigned short __ATTRS_o_ai
10048 vec_sro(vector unsigned short __a, vector signed char __b) {
10049  return (vector unsigned short)__builtin_altivec_vsro((vector int)__a,
10050  (vector int)__b);
10051 }
10052 
10053 static __inline__ vector unsigned short __ATTRS_o_ai
10054 vec_sro(vector unsigned short __a, vector unsigned char __b) {
10055  return (vector unsigned short)__builtin_altivec_vsro((vector int)__a,
10056  (vector int)__b);
10057 }
10058 
10059 static __inline__ vector pixel __ATTRS_o_ai vec_sro(vector pixel __a,
10060  vector signed char __b) {
10061  return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10062 }
10063 
10064 static __inline__ vector pixel __ATTRS_o_ai vec_sro(vector pixel __a,
10065  vector unsigned char __b) {
10066  return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10067 }
10068 
10069 static __inline__ vector int __ATTRS_o_ai vec_sro(vector int __a,
10070  vector signed char __b) {
10071  return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
10072 }
10073 
10074 static __inline__ vector int __ATTRS_o_ai vec_sro(vector int __a,
10075  vector unsigned char __b) {
10076  return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
10077 }
10078 
10079 static __inline__ vector unsigned int __ATTRS_o_ai
10080 vec_sro(vector unsigned int __a, vector signed char __b) {
10081  return (vector unsigned int)__builtin_altivec_vsro((vector int)__a,
10082  (vector int)__b);
10083 }
10084 
10085 static __inline__ vector unsigned int __ATTRS_o_ai
10086 vec_sro(vector unsigned int __a, vector unsigned char __b) {
10087  return (vector unsigned int)__builtin_altivec_vsro((vector int)__a,
10088  (vector int)__b);
10089 }
10090 
10091 static __inline__ vector float __ATTRS_o_ai vec_sro(vector float __a,
10092  vector signed char __b) {
10093  return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10094 }
10095 
10096 static __inline__ vector float __ATTRS_o_ai vec_sro(vector float __a,
10097  vector unsigned char __b) {
10098  return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10099 }
10100 
10101 #ifdef __VSX__
10102 static __inline__ vector signed long long __ATTRS_o_ai
10103 vec_sro(vector signed long long __a, vector signed char __b) {
10104  return (vector signed long long)__builtin_altivec_vsro((vector int)__a,
10105  (vector int)__b);
10106 }
10107 
10108 static __inline__ vector signed long long __ATTRS_o_ai
10109 vec_sro(vector signed long long __a, vector unsigned char __b) {
10110  return (vector signed long long)__builtin_altivec_vsro((vector int)__a,
10111  (vector int)__b);
10112 }
10113 
10114 static __inline__ vector unsigned long long __ATTRS_o_ai
10115 vec_sro(vector unsigned long long __a, vector signed char __b) {
10116  return (vector unsigned long long)__builtin_altivec_vsro((vector int)__a,
10117  (vector int)__b);
10118 }
10119 
10120 static __inline__ vector unsigned long long __ATTRS_o_ai
10121 vec_sro(vector unsigned long long __a, vector unsigned char __b) {
10122  return (vector unsigned long long)__builtin_altivec_vsro((vector int)__a,
10123  (vector int)__b);
10124 }
10125 #endif
10126 
10127 /* vec_vsro */
10128 
10129 static __inline__ vector signed char __ATTRS_o_ai
10130 vec_vsro(vector signed char __a, vector signed char __b) {
10131  return (vector signed char)__builtin_altivec_vsro((vector int)__a,
10132  (vector int)__b);
10133 }
10134 
10135 static __inline__ vector signed char __ATTRS_o_ai
10136 vec_vsro(vector signed char __a, vector unsigned char __b) {
10137  return (vector signed char)__builtin_altivec_vsro((vector int)__a,
10138  (vector int)__b);
10139 }
10140 
10141 static __inline__ vector unsigned char __ATTRS_o_ai
10142 vec_vsro(vector unsigned char __a, vector signed char __b) {
10143  return (vector unsigned char)__builtin_altivec_vsro((vector int)__a,
10144  (vector int)__b);
10145 }
10146 
10147 static __inline__ vector unsigned char __ATTRS_o_ai
10148 vec_vsro(vector unsigned char __a, vector unsigned char __b) {
10149  return (vector unsigned char)__builtin_altivec_vsro((vector int)__a,
10150  (vector int)__b);
10151 }
10152 
10153 static __inline__ vector short __ATTRS_o_ai vec_vsro(vector short __a,
10154  vector signed char __b) {
10155  return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10156 }
10157 
10158 static __inline__ vector short __ATTRS_o_ai vec_vsro(vector short __a,
10159  vector unsigned char __b) {
10160  return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10161 }
10162 
10163 static __inline__ vector unsigned short __ATTRS_o_ai
10164 vec_vsro(vector unsigned short __a, vector signed char __b) {
10165  return (vector unsigned short)__builtin_altivec_vsro((vector int)__a,
10166  (vector int)__b);
10167 }
10168 
10169 static __inline__ vector unsigned short __ATTRS_o_ai
10170 vec_vsro(vector unsigned short __a, vector unsigned char __b) {
10171  return (vector unsigned short)__builtin_altivec_vsro((vector int)__a,
10172  (vector int)__b);
10173 }
10174 
10175 static __inline__ vector pixel __ATTRS_o_ai vec_vsro(vector pixel __a,
10176  vector signed char __b) {
10177  return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10178 }
10179 
10180 static __inline__ vector pixel __ATTRS_o_ai vec_vsro(vector pixel __a,
10181  vector unsigned char __b) {
10182  return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10183 }
10184 
10185 static __inline__ vector int __ATTRS_o_ai vec_vsro(vector int __a,
10186  vector signed char __b) {
10187  return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
10188 }
10189 
10190 static __inline__ vector int __ATTRS_o_ai vec_vsro(vector int __a,
10191  vector unsigned char __b) {
10192  return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
10193 }
10194 
10195 static __inline__ vector unsigned int __ATTRS_o_ai
10196 vec_vsro(vector unsigned int __a, vector signed char __b) {
10197  return (vector unsigned int)__builtin_altivec_vsro((vector int)__a,
10198  (vector int)__b);
10199 }
10200 
10201 static __inline__ vector unsigned int __ATTRS_o_ai
10202 vec_vsro(vector unsigned int __a, vector unsigned char __b) {
10203  return (vector unsigned int)__builtin_altivec_vsro((vector int)__a,
10204  (vector int)__b);
10205 }
10206 
10207 static __inline__ vector float __ATTRS_o_ai vec_vsro(vector float __a,
10208  vector signed char __b) {
10209  return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10210 }
10211 
10212 static __inline__ vector float __ATTRS_o_ai vec_vsro(vector float __a,
10213  vector unsigned char __b) {
10214  return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
10215 }
10216 
10217 /* vec_st */
10218 
10219 static __inline__ void __ATTRS_o_ai vec_st(vector signed char __a, int __b,
10220  vector signed char *__c) {
10221  __builtin_altivec_stvx((vector int)__a, __b, __c);
10222 }
10223 
10224 static __inline__ void __ATTRS_o_ai vec_st(vector signed char __a, int __b,
10225  signed char *__c) {
10226  __builtin_altivec_stvx((vector int)__a, __b, __c);
10227 }
10228 
10229 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned char __a, int __b,
10230  vector unsigned char *__c) {
10231  __builtin_altivec_stvx((vector int)__a, __b, __c);
10232 }
10233 
10234 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned char __a, int __b,
10235  unsigned char *__c) {
10236  __builtin_altivec_stvx((vector int)__a, __b, __c);
10237 }
10238 
10239 static __inline__ void __ATTRS_o_ai vec_st(vector bool char __a, int __b,
10240  signed char *__c) {
10241  __builtin_altivec_stvx((vector int)__a, __b, __c);
10242 }
10243 
10244 static __inline__ void __ATTRS_o_ai vec_st(vector bool char __a, int __b,
10245  unsigned char *__c) {
10246  __builtin_altivec_stvx((vector int)__a, __b, __c);
10247 }
10248 
10249 static __inline__ void __ATTRS_o_ai vec_st(vector bool char __a, int __b,
10250  vector bool char *__c) {
10251  __builtin_altivec_stvx((vector int)__a, __b, __c);
10252 }
10253 
10254 static __inline__ void __ATTRS_o_ai vec_st(vector short __a, int __b,
10255  vector short *__c) {
10256  __builtin_altivec_stvx((vector int)__a, __b, __c);
10257 }
10258 
10259 static __inline__ void __ATTRS_o_ai vec_st(vector short __a, int __b,
10260  short *__c) {
10261  __builtin_altivec_stvx((vector int)__a, __b, __c);
10262 }
10263 
10264 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned short __a, int __b,
10265  vector unsigned short *__c) {
10266  __builtin_altivec_stvx((vector int)__a, __b, __c);
10267 }
10268 
10269 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned short __a, int __b,
10270  unsigned short *__c) {
10271  __builtin_altivec_stvx((vector int)__a, __b, __c);
10272 }
10273 
10274 static __inline__ void __ATTRS_o_ai vec_st(vector bool short __a, int __b,
10275  short *__c) {
10276  __builtin_altivec_stvx((vector int)__a, __b, __c);
10277 }
10278 
10279 static __inline__ void __ATTRS_o_ai vec_st(vector bool short __a, int __b,
10280  unsigned short *__c) {
10281  __builtin_altivec_stvx((vector int)__a, __b, __c);
10282 }
10283 
10284 static __inline__ void __ATTRS_o_ai vec_st(vector bool short __a, int __b,
10285  vector bool short *__c) {
10286  __builtin_altivec_stvx((vector int)__a, __b, __c);
10287 }
10288 
10289 static __inline__ void __ATTRS_o_ai vec_st(vector pixel __a, int __b,
10290  short *__c) {
10291  __builtin_altivec_stvx((vector int)__a, __b, __c);
10292 }
10293 
10294 static __inline__ void __ATTRS_o_ai vec_st(vector pixel __a, int __b,
10295  unsigned short *__c) {
10296  __builtin_altivec_stvx((vector int)__a, __b, __c);
10297 }
10298 
10299 static __inline__ void __ATTRS_o_ai vec_st(vector pixel __a, int __b,
10300  vector pixel *__c) {
10301  __builtin_altivec_stvx((vector int)__a, __b, __c);
10302 }
10303 
10304 static __inline__ void __ATTRS_o_ai vec_st(vector int __a, int __b,
10305  vector int *__c) {
10306  __builtin_altivec_stvx(__a, __b, __c);
10307 }
10308 
10309 static __inline__ void __ATTRS_o_ai vec_st(vector int __a, int __b, int *__c) {
10310  __builtin_altivec_stvx(__a, __b, __c);
10311 }
10312 
10313 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned int __a, int __b,
10314  vector unsigned int *__c) {
10315  __builtin_altivec_stvx((vector int)__a, __b, __c);
10316 }
10317 
10318 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned int __a, int __b,
10319  unsigned int *__c) {
10320  __builtin_altivec_stvx((vector int)__a, __b, __c);
10321 }
10322 
10323 static __inline__ void __ATTRS_o_ai vec_st(vector bool int __a, int __b,
10324  int *__c) {
10325  __builtin_altivec_stvx((vector int)__a, __b, __c);
10326 }
10327 
10328 static __inline__ void __ATTRS_o_ai vec_st(vector bool int __a, int __b,
10329  unsigned int *__c) {
10330  __builtin_altivec_stvx((vector int)__a, __b, __c);
10331 }
10332 
10333 static __inline__ void __ATTRS_o_ai vec_st(vector bool int __a, int __b,
10334  vector bool int *__c) {
10335  __builtin_altivec_stvx((vector int)__a, __b, __c);
10336 }
10337 
10338 static __inline__ void __ATTRS_o_ai vec_st(vector float __a, int __b,
10339  vector float *__c) {
10340  __builtin_altivec_stvx((vector int)__a, __b, __c);
10341 }
10342 
10343 static __inline__ void __ATTRS_o_ai vec_st(vector float __a, int __b,
10344  float *__c) {
10345  __builtin_altivec_stvx((vector int)__a, __b, __c);
10346 }
10347 
10348 /* vec_stvx */
10349 
10350 static __inline__ void __ATTRS_o_ai vec_stvx(vector signed char __a, int __b,
10351  vector signed char *__c) {
10352  __builtin_altivec_stvx((vector int)__a, __b, __c);
10353 }
10354 
10355 static __inline__ void __ATTRS_o_ai vec_stvx(vector signed char __a, int __b,
10356  signed char *__c) {
10357  __builtin_altivec_stvx((vector int)__a, __b, __c);
10358 }
10359 
10360 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned char __a, int __b,
10361  vector unsigned char *__c) {
10362  __builtin_altivec_stvx((vector int)__a, __b, __c);
10363 }
10364 
10365 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned char __a, int __b,
10366  unsigned char *__c) {
10367  __builtin_altivec_stvx((vector int)__a, __b, __c);
10368 }
10369 
10370 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool char __a, int __b,
10371  signed char *__c) {
10372  __builtin_altivec_stvx((vector int)__a, __b, __c);
10373 }
10374 
10375 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool char __a, int __b,
10376  unsigned char *__c) {
10377  __builtin_altivec_stvx((vector int)__a, __b, __c);
10378 }
10379 
10380 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool char __a, int __b,
10381  vector bool char *__c) {
10382  __builtin_altivec_stvx((vector int)__a, __b, __c);
10383 }
10384 
10385 static __inline__ void __ATTRS_o_ai vec_stvx(vector short __a, int __b,
10386  vector short *__c) {
10387  __builtin_altivec_stvx((vector int)__a, __b, __c);
10388 }
10389 
10390 static __inline__ void __ATTRS_o_ai vec_stvx(vector short __a, int __b,
10391  short *__c) {
10392  __builtin_altivec_stvx((vector int)__a, __b, __c);
10393 }
10394 
10395 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned short __a, int __b,
10396  vector unsigned short *__c) {
10397  __builtin_altivec_stvx((vector int)__a, __b, __c);
10398 }
10399 
10400 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned short __a, int __b,
10401  unsigned short *__c) {
10402  __builtin_altivec_stvx((vector int)__a, __b, __c);
10403 }
10404 
10405 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool short __a, int __b,
10406  short *__c) {
10407  __builtin_altivec_stvx((vector int)__a, __b, __c);
10408 }
10409 
10410 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool short __a, int __b,
10411  unsigned short *__c) {
10412  __builtin_altivec_stvx((vector int)__a, __b, __c);
10413 }
10414 
10415 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool short __a, int __b,
10416  vector bool short *__c) {
10417  __builtin_altivec_stvx((vector int)__a, __b, __c);
10418 }
10419 
10420 static __inline__ void __ATTRS_o_ai vec_stvx(vector pixel __a, int __b,
10421  short *__c) {
10422  __builtin_altivec_stvx((vector int)__a, __b, __c);
10423 }
10424 
10425 static __inline__ void __ATTRS_o_ai vec_stvx(vector pixel __a, int __b,
10426  unsigned short *__c) {
10427  __builtin_altivec_stvx((vector int)__a, __b, __c);
10428 }
10429 
10430 static __inline__ void __ATTRS_o_ai vec_stvx(vector pixel __a, int __b,
10431  vector pixel *__c) {
10432  __builtin_altivec_stvx((vector int)__a, __b, __c);
10433 }
10434 
10435 static __inline__ void __ATTRS_o_ai vec_stvx(vector int __a, int __b,
10436  vector int *__c) {
10437  __builtin_altivec_stvx(__a, __b, __c);
10438 }
10439 
10440 static __inline__ void __ATTRS_o_ai vec_stvx(vector int __a, int __b,
10441  int *__c) {
10442  __builtin_altivec_stvx(__a, __b, __c);
10443 }
10444 
10445 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned int __a, int __b,
10446  vector unsigned int *__c) {
10447  __builtin_altivec_stvx((vector int)__a, __b, __c);
10448 }
10449 
10450 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned int __a, int __b,
10451  unsigned int *__c) {
10452  __builtin_altivec_stvx((vector int)__a, __b, __c);
10453 }
10454 
10455 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool int __a, int __b,
10456  int *__c) {
10457  __builtin_altivec_stvx((vector int)__a, __b, __c);
10458 }
10459 
10460 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool int __a, int __b,
10461  unsigned int *__c) {
10462  __builtin_altivec_stvx((vector int)__a, __b, __c);
10463 }
10464 
10465 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool int __a, int __b,
10466  vector bool int *__c) {
10467  __builtin_altivec_stvx((vector int)__a, __b, __c);
10468 }
10469 
10470 static __inline__ void __ATTRS_o_ai vec_stvx(vector float __a, int __b,
10471  vector float *__c) {
10472  __builtin_altivec_stvx((vector int)__a, __b, __c);
10473 }
10474 
10475 static __inline__ void __ATTRS_o_ai vec_stvx(vector float __a, int __b,
10476  float *__c) {
10477  __builtin_altivec_stvx((vector int)__a, __b, __c);
10478 }
10479 
10480 /* vec_ste */
10481 
10482 static __inline__ void __ATTRS_o_ai vec_ste(vector signed char __a, int __b,
10483  signed char *__c) {
10484  __builtin_altivec_stvebx((vector char)__a, __b, __c);
10485 }
10486 
10487 static __inline__ void __ATTRS_o_ai vec_ste(vector unsigned char __a, int __b,
10488  unsigned char *__c) {
10489  __builtin_altivec_stvebx((vector char)__a, __b, __c);
10490 }
10491 
10492 static __inline__ void __ATTRS_o_ai vec_ste(vector bool char __a, int __b,
10493  signed char *__c) {
10494  __builtin_altivec_stvebx((vector char)__a, __b, __c);
10495 }
10496 
10497 static __inline__ void __ATTRS_o_ai vec_ste(vector bool char __a, int __b,
10498  unsigned char *__c) {
10499  __builtin_altivec_stvebx((vector char)__a, __b, __c);
10500 }
10501 
10502 static __inline__ void __ATTRS_o_ai vec_ste(vector short __a, int __b,
10503  short *__c) {
10504  __builtin_altivec_stvehx(__a, __b, __c);
10505 }
10506 
10507 static __inline__ void __ATTRS_o_ai vec_ste(vector unsigned short __a, int __b,
10508  unsigned short *__c) {
10509  __builtin_altivec_stvehx((vector short)__a, __b, __c);
10510 }
10511 
10512 static __inline__ void __ATTRS_o_ai vec_ste(vector bool short __a, int __b,
10513  short *__c) {
10514  __builtin_altivec_stvehx((vector short)__a, __b, __c);
10515 }
10516 
10517 static __inline__ void __ATTRS_o_ai vec_ste(vector bool short __a, int __b,
10518  unsigned short *__c) {
10519  __builtin_altivec_stvehx((vector short)__a, __b, __c);
10520 }
10521 
10522 static __inline__ void __ATTRS_o_ai vec_ste(vector pixel __a, int __b,
10523  short *__c) {
10524  __builtin_altivec_stvehx((vector short)__a, __b, __c);
10525 }
10526 
10527 static __inline__ void __ATTRS_o_ai vec_ste(vector pixel __a, int __b,
10528  unsigned short *__c) {
10529  __builtin_altivec_stvehx((vector short)__a, __b, __c);
10530 }
10531 
10532 static __inline__ void __ATTRS_o_ai vec_ste(vector int __a, int __b, int *__c) {
10533  __builtin_altivec_stvewx(__a, __b, __c);
10534 }
10535 
10536 static __inline__ void __ATTRS_o_ai vec_ste(vector unsigned int __a, int __b,
10537  unsigned int *__c) {
10538  __builtin_altivec_stvewx((vector int)__a, __b, __c);
10539 }
10540 
10541 static __inline__ void __ATTRS_o_ai vec_ste(vector bool int __a, int __b,
10542  int *__c) {
10543  __builtin_altivec_stvewx((vector int)__a, __b, __c);
10544 }
10545 
10546 static __inline__ void __ATTRS_o_ai vec_ste(vector bool int __a, int __b,
10547  unsigned int *__c) {
10548  __builtin_altivec_stvewx((vector int)__a, __b, __c);
10549 }
10550 
10551 static __inline__ void __ATTRS_o_ai vec_ste(vector float __a, int __b,
10552  float *__c) {
10553  __builtin_altivec_stvewx((vector int)__a, __b, __c);
10554 }
10555 
10556 /* vec_stvebx */
10557 
10558 static __inline__ void __ATTRS_o_ai vec_stvebx(vector signed char __a, int __b,
10559  signed char *__c) {
10560  __builtin_altivec_stvebx((vector char)__a, __b, __c);
10561 }
10562 
10563 static __inline__ void __ATTRS_o_ai vec_stvebx(vector unsigned char __a,
10564  int __b, unsigned char *__c) {
10565  __builtin_altivec_stvebx((vector char)__a, __b, __c);
10566 }
10567 
10568 static __inline__ void __ATTRS_o_ai vec_stvebx(vector bool char __a, int __b,
10569  signed char *__c) {
10570  __builtin_altivec_stvebx((vector char)__a, __b, __c);
10571 }
10572 
10573 static __inline__ void __ATTRS_o_ai vec_stvebx(vector bool char __a, int __b,
10574  unsigned char *__c) {
10575  __builtin_altivec_stvebx((vector char)__a, __b, __c);
10576 }
10577 
10578 /* vec_stvehx */
10579 
10580 static __inline__ void __ATTRS_o_ai vec_stvehx(vector short __a, int __b,
10581  short *__c) {
10582  __builtin_altivec_stvehx(__a, __b, __c);
10583 }
10584 
10585 static __inline__ void __ATTRS_o_ai vec_stvehx(vector unsigned short __a,
10586  int __b, unsigned short *__c) {
10587  __builtin_altivec_stvehx((vector short)__a, __b, __c);
10588 }
10589 
10590 static __inline__ void __ATTRS_o_ai vec_stvehx(vector bool short __a, int __b,
10591  short *__c) {
10592  __builtin_altivec_stvehx((vector short)__a, __b, __c);
10593 }
10594 
10595 static __inline__ void __ATTRS_o_ai vec_stvehx(vector bool short __a, int __b,
10596  unsigned short *__c) {
10597  __builtin_altivec_stvehx((vector short)__a, __b, __c);
10598 }
10599 
10600 static __inline__ void __ATTRS_o_ai vec_stvehx(vector pixel __a, int __b,
10601  short *__c) {
10602  __builtin_altivec_stvehx((vector short)__a, __b, __c);
10603 }
10604 
10605 static __inline__ void __ATTRS_o_ai vec_stvehx(vector pixel __a, int __b,
10606  unsigned short *__c) {
10607  __builtin_altivec_stvehx((vector short)__a, __b, __c);
10608 }
10609 
10610 /* vec_stvewx */
10611 
10612 static __inline__ void __ATTRS_o_ai vec_stvewx(vector int __a, int __b,
10613  int *__c) {
10614  __builtin_altivec_stvewx(__a, __b, __c);
10615 }
10616 
10617 static __inline__ void __ATTRS_o_ai vec_stvewx(vector unsigned int __a, int __b,
10618  unsigned int *__c) {
10619  __builtin_altivec_stvewx((vector int)__a, __b, __c);
10620 }
10621 
10622 static __inline__ void __ATTRS_o_ai vec_stvewx(vector bool int __a, int __b,
10623  int *__c) {
10624  __builtin_altivec_stvewx((vector int)__a, __b, __c);
10625 }
10626 
10627 static __inline__ void __ATTRS_o_ai vec_stvewx(vector bool int __a, int __b,
10628  unsigned int *__c) {
10629  __builtin_altivec_stvewx((vector int)__a, __b, __c);
10630 }
10631 
10632 static __inline__ void __ATTRS_o_ai vec_stvewx(vector float __a, int __b,
10633  float *__c) {
10634  __builtin_altivec_stvewx((vector int)__a, __b, __c);
10635 }
10636 
10637 /* vec_stl */
10638 
10639 static __inline__ void __ATTRS_o_ai vec_stl(vector signed char __a, int __b,
10640  vector signed char *__c) {
10641  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10642 }
10643 
10644 static __inline__ void __ATTRS_o_ai vec_stl(vector signed char __a, int __b,
10645  signed char *__c) {
10646  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10647 }
10648 
10649 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned char __a, int __b,
10650  vector unsigned char *__c) {
10651  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10652 }
10653 
10654 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned char __a, int __b,
10655  unsigned char *__c) {
10656  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10657 }
10658 
10659 static __inline__ void __ATTRS_o_ai vec_stl(vector bool char __a, int __b,
10660  signed char *__c) {
10661  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10662 }
10663 
10664 static __inline__ void __ATTRS_o_ai vec_stl(vector bool char __a, int __b,
10665  unsigned char *__c) {
10666  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10667 }
10668 
10669 static __inline__ void __ATTRS_o_ai vec_stl(vector bool char __a, int __b,
10670  vector bool char *__c) {
10671  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10672 }
10673 
10674 static __inline__ void __ATTRS_o_ai vec_stl(vector short __a, int __b,
10675  vector short *__c) {
10676  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10677 }
10678 
10679 static __inline__ void __ATTRS_o_ai vec_stl(vector short __a, int __b,
10680  short *__c) {
10681  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10682 }
10683 
10684 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned short __a, int __b,
10685  vector unsigned short *__c) {
10686  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10687 }
10688 
10689 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned short __a, int __b,
10690  unsigned short *__c) {
10691  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10692 }
10693 
10694 static __inline__ void __ATTRS_o_ai vec_stl(vector bool short __a, int __b,
10695  short *__c) {
10696  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10697 }
10698 
10699 static __inline__ void __ATTRS_o_ai vec_stl(vector bool short __a, int __b,
10700  unsigned short *__c) {
10701  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10702 }
10703 
10704 static __inline__ void __ATTRS_o_ai vec_stl(vector bool short __a, int __b,
10705  vector bool short *__c) {
10706  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10707 }
10708 
10709 static __inline__ void __ATTRS_o_ai vec_stl(vector pixel __a, int __b,
10710  short *__c) {
10711  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10712 }
10713 
10714 static __inline__ void __ATTRS_o_ai vec_stl(vector pixel __a, int __b,
10715  unsigned short *__c) {
10716  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10717 }
10718 
10719 static __inline__ void __ATTRS_o_ai vec_stl(vector pixel __a, int __b,
10720  vector pixel *__c) {
10721  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10722 }
10723 
10724 static __inline__ void __ATTRS_o_ai vec_stl(vector int __a, int __b,
10725  vector int *__c) {
10726  __builtin_altivec_stvxl(__a, __b, __c);
10727 }
10728 
10729 static __inline__ void __ATTRS_o_ai vec_stl(vector int __a, int __b, int *__c) {
10730  __builtin_altivec_stvxl(__a, __b, __c);
10731 }
10732 
10733 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned int __a, int __b,
10734  vector unsigned int *__c) {
10735  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10736 }
10737 
10738 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned int __a, int __b,
10739  unsigned int *__c) {
10740  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10741 }
10742 
10743 static __inline__ void __ATTRS_o_ai vec_stl(vector bool int __a, int __b,
10744  int *__c) {
10745  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10746 }
10747 
10748 static __inline__ void __ATTRS_o_ai vec_stl(vector bool int __a, int __b,
10749  unsigned int *__c) {
10750  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10751 }
10752 
10753 static __inline__ void __ATTRS_o_ai vec_stl(vector bool int __a, int __b,
10754  vector bool int *__c) {
10755  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10756 }
10757 
10758 static __inline__ void __ATTRS_o_ai vec_stl(vector float __a, int __b,
10759  vector float *__c) {
10760  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10761 }
10762 
10763 static __inline__ void __ATTRS_o_ai vec_stl(vector float __a, int __b,
10764  float *__c) {
10765  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10766 }
10767 
10768 /* vec_stvxl */
10769 
10770 static __inline__ void __ATTRS_o_ai vec_stvxl(vector signed char __a, int __b,
10771  vector signed char *__c) {
10772  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10773 }
10774 
10775 static __inline__ void __ATTRS_o_ai vec_stvxl(vector signed char __a, int __b,
10776  signed char *__c) {
10777  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10778 }
10779 
10780 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned char __a, int __b,
10781  vector unsigned char *__c) {
10782  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10783 }
10784 
10785 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned char __a, int __b,
10786  unsigned char *__c) {
10787  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10788 }
10789 
10790 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool char __a, int __b,
10791  signed char *__c) {
10792  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10793 }
10794 
10795 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool char __a, int __b,
10796  unsigned char *__c) {
10797  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10798 }
10799 
10800 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool char __a, int __b,
10801  vector bool char *__c) {
10802  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10803 }
10804 
10805 static __inline__ void __ATTRS_o_ai vec_stvxl(vector short __a, int __b,
10806  vector short *__c) {
10807  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10808 }
10809 
10810 static __inline__ void __ATTRS_o_ai vec_stvxl(vector short __a, int __b,
10811  short *__c) {
10812  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10813 }
10814 
10815 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned short __a,
10816  int __b,
10817  vector unsigned short *__c) {
10818  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10819 }
10820 
10821 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned short __a,
10822  int __b, unsigned short *__c) {
10823  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10824 }
10825 
10826 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool short __a, int __b,
10827  short *__c) {
10828  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10829 }
10830 
10831 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool short __a, int __b,
10832  unsigned short *__c) {
10833  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10834 }
10835 
10836 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool short __a, int __b,
10837  vector bool short *__c) {
10838  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10839 }
10840 
10841 static __inline__ void __ATTRS_o_ai vec_stvxl(vector pixel __a, int __b,
10842  short *__c) {
10843  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10844 }
10845 
10846 static __inline__ void __ATTRS_o_ai vec_stvxl(vector pixel __a, int __b,
10847  unsigned short *__c) {
10848  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10849 }
10850 
10851 static __inline__ void __ATTRS_o_ai vec_stvxl(vector pixel __a, int __b,
10852  vector pixel *__c) {
10853  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10854 }
10855 
10856 static __inline__ void __ATTRS_o_ai vec_stvxl(vector int __a, int __b,
10857  vector int *__c) {
10858  __builtin_altivec_stvxl(__a, __b, __c);
10859 }
10860 
10861 static __inline__ void __ATTRS_o_ai vec_stvxl(vector int __a, int __b,
10862  int *__c) {
10863  __builtin_altivec_stvxl(__a, __b, __c);
10864 }
10865 
10866 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned int __a, int __b,
10867  vector unsigned int *__c) {
10868  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10869 }
10870 
10871 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned int __a, int __b,
10872  unsigned int *__c) {
10873  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10874 }
10875 
10876 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool int __a, int __b,
10877  int *__c) {
10878  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10879 }
10880 
10881 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool int __a, int __b,
10882  unsigned int *__c) {
10883  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10884 }
10885 
10886 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool int __a, int __b,
10887  vector bool int *__c) {
10888  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10889 }
10890 
10891 static __inline__ void __ATTRS_o_ai vec_stvxl(vector float __a, int __b,
10892  vector float *__c) {
10893  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10894 }
10895 
10896 static __inline__ void __ATTRS_o_ai vec_stvxl(vector float __a, int __b,
10897  float *__c) {
10898  __builtin_altivec_stvxl((vector int)__a, __b, __c);
10899 }
10900 
10901 /* vec_sub */
10902 
10903 static __inline__ vector signed char __ATTRS_o_ai
10904 vec_sub(vector signed char __a, vector signed char __b) {
10905  return __a - __b;
10906 }
10907 
10908 static __inline__ vector signed char __ATTRS_o_ai
10909 vec_sub(vector bool char __a, vector signed char __b) {
10910  return (vector signed char)__a - __b;
10911 }
10912 
10913 static __inline__ vector signed char __ATTRS_o_ai
10914 vec_sub(vector signed char __a, vector bool char __b) {
10915  return __a - (vector signed char)__b;
10916 }
10917 
10918 static __inline__ vector unsigned char __ATTRS_o_ai
10919 vec_sub(vector unsigned char __a, vector unsigned char __b) {
10920  return __a - __b;
10921 }
10922 
10923 static __inline__ vector unsigned char __ATTRS_o_ai
10924 vec_sub(vector bool char __a, vector unsigned char __b) {
10925  return (vector unsigned char)__a - __b;
10926 }
10927 
10928 static __inline__ vector unsigned char __ATTRS_o_ai
10929 vec_sub(vector unsigned char __a, vector bool char __b) {
10930  return __a - (vector unsigned char)__b;
10931 }
10932 
10933 static __inline__ vector short __ATTRS_o_ai vec_sub(vector short __a,
10934  vector short __b) {
10935  return __a - __b;
10936 }
10937 
10938 static __inline__ vector short __ATTRS_o_ai vec_sub(vector bool short __a,
10939  vector short __b) {
10940  return (vector short)__a - __b;
10941 }
10942 
10943 static __inline__ vector short __ATTRS_o_ai vec_sub(vector short __a,
10944  vector bool short __b) {
10945  return __a - (vector short)__b;
10946 }
10947 
10948 static __inline__ vector unsigned short __ATTRS_o_ai
10949 vec_sub(vector unsigned short __a, vector unsigned short __b) {
10950  return __a - __b;
10951 }
10952 
10953 static __inline__ vector unsigned short __ATTRS_o_ai
10954 vec_sub(vector bool short __a, vector unsigned short __b) {
10955  return (vector unsigned short)__a - __b;
10956 }
10957 
10958 static __inline__ vector unsigned short __ATTRS_o_ai
10959 vec_sub(vector unsigned short __a, vector bool short __b) {
10960  return __a - (vector unsigned short)__b;
10961 }
10962 
10963 static __inline__ vector int __ATTRS_o_ai vec_sub(vector int __a,
10964  vector int __b) {
10965  return __a - __b;
10966 }
10967 
10968 static __inline__ vector int __ATTRS_o_ai vec_sub(vector bool int __a,
10969  vector int __b) {
10970  return (vector int)__a - __b;
10971 }
10972 
10973 static __inline__ vector int __ATTRS_o_ai vec_sub(vector int __a,
10974  vector bool int __b) {
10975  return __a - (vector int)__b;
10976 }
10977 
10978 static __inline__ vector unsigned int __ATTRS_o_ai
10979 vec_sub(vector unsigned int __a, vector unsigned int __b) {
10980  return __a - __b;
10981 }
10982 
10983 static __inline__ vector unsigned int __ATTRS_o_ai
10984 vec_sub(vector bool int __a, vector unsigned int __b) {
10985  return (vector unsigned int)__a - __b;
10986 }
10987 
10988 static __inline__ vector unsigned int __ATTRS_o_ai
10989 vec_sub(vector unsigned int __a, vector bool int __b) {
10990  return __a - (vector unsigned int)__b;
10991 }
10992 
10993 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
10994 static __inline__ vector signed __int128 __ATTRS_o_ai
10995 vec_sub(vector signed __int128 __a, vector signed __int128 __b) {
10996  return __a - __b;
10997 }
10998 
10999 static __inline__ vector unsigned __int128 __ATTRS_o_ai
11000 vec_sub(vector unsigned __int128 __a, vector unsigned __int128 __b) {
11001  return __a - __b;
11002 }
11003 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
11004 
11005 #ifdef __VSX__
11006 static __inline__ vector signed long long __ATTRS_o_ai
11007 vec_sub(vector signed long long __a, vector signed long long __b) {
11008  return __a - __b;
11009 }
11010 
11011 static __inline__ vector unsigned long long __ATTRS_o_ai
11012 vec_sub(vector unsigned long long __a, vector unsigned long long __b) {
11013  return __a - __b;
11014 }
11015 
11016 static __inline__ vector double __ATTRS_o_ai vec_sub(vector double __a,
11017  vector double __b) {
11018  return __a - __b;
11019 }
11020 #endif
11021 
11022 static __inline__ vector float __ATTRS_o_ai vec_sub(vector float __a,
11023  vector float __b) {
11024  return __a - __b;
11025 }
11026 
11027 /* vec_vsububm */
11028 
11029 #define __builtin_altivec_vsububm vec_vsububm
11030 
11031 static __inline__ vector signed char __ATTRS_o_ai
11032 vec_vsububm(vector signed char __a, vector signed char __b) {
11033  return __a - __b;
11034 }
11035 
11036 static __inline__ vector signed char __ATTRS_o_ai
11037 vec_vsububm(vector bool char __a, vector signed char __b) {
11038  return (vector signed char)__a - __b;
11039 }
11040 
11041 static __inline__ vector signed char __ATTRS_o_ai
11042 vec_vsububm(vector signed char __a, vector bool char __b) {
11043  return __a - (vector signed char)__b;
11044 }
11045 
11046 static __inline__ vector unsigned char __ATTRS_o_ai
11047 vec_vsububm(vector unsigned char __a, vector unsigned char __b) {
11048  return __a - __b;
11049 }
11050 
11051 static __inline__ vector unsigned char __ATTRS_o_ai
11052 vec_vsububm(vector bool char __a, vector unsigned char __b) {
11053  return (vector unsigned char)__a - __b;
11054 }
11055 
11056 static __inline__ vector unsigned char __ATTRS_o_ai
11057 vec_vsububm(vector unsigned char __a, vector bool char __b) {
11058  return __a - (vector unsigned char)__b;
11059 }
11060 
11061 /* vec_vsubuhm */
11062 
11063 #define __builtin_altivec_vsubuhm vec_vsubuhm
11064 
11065 static __inline__ vector short __ATTRS_o_ai vec_vsubuhm(vector short __a,
11066  vector short __b) {
11067  return __a - __b;
11068 }
11069 
11070 static __inline__ vector short __ATTRS_o_ai vec_vsubuhm(vector bool short __a,
11071  vector short __b) {
11072  return (vector short)__a - __b;
11073 }
11074 
11075 static __inline__ vector short __ATTRS_o_ai vec_vsubuhm(vector short __a,
11076  vector bool short __b) {
11077  return __a - (vector short)__b;
11078 }
11079 
11080 static __inline__ vector unsigned short __ATTRS_o_ai
11081 vec_vsubuhm(vector unsigned short __a, vector unsigned short __b) {
11082  return __a - __b;
11083 }
11084 
11085 static __inline__ vector unsigned short __ATTRS_o_ai
11086 vec_vsubuhm(vector bool short __a, vector unsigned short __b) {
11087  return (vector unsigned short)__a - __b;
11088 }
11089 
11090 static __inline__ vector unsigned short __ATTRS_o_ai
11091 vec_vsubuhm(vector unsigned short __a, vector bool short __b) {
11092  return __a - (vector unsigned short)__b;
11093 }
11094 
11095 /* vec_vsubuwm */
11096 
11097 #define __builtin_altivec_vsubuwm vec_vsubuwm
11098 
11099 static __inline__ vector int __ATTRS_o_ai vec_vsubuwm(vector int __a,
11100  vector int __b) {
11101  return __a - __b;
11102 }
11103 
11104 static __inline__ vector int __ATTRS_o_ai vec_vsubuwm(vector bool int __a,
11105  vector int __b) {
11106  return (vector int)__a - __b;
11107 }
11108 
11109 static __inline__ vector int __ATTRS_o_ai vec_vsubuwm(vector int __a,
11110  vector bool int __b) {
11111  return __a - (vector int)__b;
11112 }
11113 
11114 static __inline__ vector unsigned int __ATTRS_o_ai
11115 vec_vsubuwm(vector unsigned int __a, vector unsigned int __b) {
11116  return __a - __b;
11117 }
11118 
11119 static __inline__ vector unsigned int __ATTRS_o_ai
11120 vec_vsubuwm(vector bool int __a, vector unsigned int __b) {
11121  return (vector unsigned int)__a - __b;
11122 }
11123 
11124 static __inline__ vector unsigned int __ATTRS_o_ai
11125 vec_vsubuwm(vector unsigned int __a, vector bool int __b) {
11126  return __a - (vector unsigned int)__b;
11127 }
11128 
11129 /* vec_vsubfp */
11130 
11131 #define __builtin_altivec_vsubfp vec_vsubfp
11132 
11133 static __inline__ vector float __attribute__((__always_inline__))
11134 vec_vsubfp(vector float __a, vector float __b) {
11135  return __a - __b;
11136 }
11137 
11138 /* vec_subc */
11139 
11140 static __inline__ vector signed int __ATTRS_o_ai
11141 vec_subc(vector signed int __a, vector signed int __b) {
11142  return (vector signed int)__builtin_altivec_vsubcuw((vector unsigned int)__a,
11143  (vector unsigned int) __b);
11144 }
11145 
11146 static __inline__ vector unsigned int __ATTRS_o_ai
11147 vec_subc(vector unsigned int __a, vector unsigned int __b) {
11148  return __builtin_altivec_vsubcuw(__a, __b);
11149 }
11150 
11151 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
11152 static __inline__ vector unsigned __int128 __ATTRS_o_ai
11153 vec_subc(vector unsigned __int128 __a, vector unsigned __int128 __b) {
11154  return __builtin_altivec_vsubcuq(__a, __b);
11155 }
11156 
11157 static __inline__ vector signed __int128 __ATTRS_o_ai
11158 vec_subc(vector signed __int128 __a, vector signed __int128 __b) {
11159  return __builtin_altivec_vsubcuq(__a, __b);
11160 }
11161 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
11162 
11163 /* vec_vsubcuw */
11164 
11165 static __inline__ vector unsigned int __attribute__((__always_inline__))
11166 vec_vsubcuw(vector unsigned int __a, vector unsigned int __b) {
11167  return __builtin_altivec_vsubcuw(__a, __b);
11168 }
11169 
11170 /* vec_subs */
11171 
11172 static __inline__ vector signed char __ATTRS_o_ai
11173 vec_subs(vector signed char __a, vector signed char __b) {
11174  return __builtin_altivec_vsubsbs(__a, __b);
11175 }
11176 
11177 static __inline__ vector signed char __ATTRS_o_ai
11178 vec_subs(vector bool char __a, vector signed char __b) {
11179  return __builtin_altivec_vsubsbs((vector signed char)__a, __b);
11180 }
11181 
11182 static __inline__ vector signed char __ATTRS_o_ai
11183 vec_subs(vector signed char __a, vector bool char __b) {
11184  return __builtin_altivec_vsubsbs(__a, (vector signed char)__b);
11185 }
11186 
11187 static __inline__ vector unsigned char __ATTRS_o_ai
11188 vec_subs(vector unsigned char __a, vector unsigned char __b) {
11189  return __builtin_altivec_vsububs(__a, __b);
11190 }
11191 
11192 static __inline__ vector unsigned char __ATTRS_o_ai
11193 vec_subs(vector bool char __a, vector unsigned char __b) {
11194  return __builtin_altivec_vsububs((vector unsigned char)__a, __b);
11195 }
11196 
11197 static __inline__ vector unsigned char __ATTRS_o_ai
11198 vec_subs(vector unsigned char __a, vector bool char __b) {
11199  return __builtin_altivec_vsububs(__a, (vector unsigned char)__b);
11200 }
11201 
11202 static __inline__ vector short __ATTRS_o_ai vec_subs(vector short __a,
11203  vector short __b) {
11204  return __builtin_altivec_vsubshs(__a, __b);
11205 }
11206 
11207 static __inline__ vector short __ATTRS_o_ai vec_subs(vector bool short __a,
11208  vector short __b) {
11209  return __builtin_altivec_vsubshs((vector short)__a, __b);
11210 }
11211 
11212 static __inline__ vector short __ATTRS_o_ai vec_subs(vector short __a,
11213  vector bool short __b) {
11214  return __builtin_altivec_vsubshs(__a, (vector short)__b);
11215 }
11216 
11217 static __inline__ vector unsigned short __ATTRS_o_ai
11218 vec_subs(vector unsigned short __a, vector unsigned short __b) {
11219  return __builtin_altivec_vsubuhs(__a, __b);
11220 }
11221 
11222 static __inline__ vector unsigned short __ATTRS_o_ai
11223 vec_subs(vector bool short __a, vector unsigned short __b) {
11224  return __builtin_altivec_vsubuhs((vector unsigned short)__a, __b);
11225 }
11226 
11227 static __inline__ vector unsigned short __ATTRS_o_ai
11228 vec_subs(vector unsigned short __a, vector bool short __b) {
11229  return __builtin_altivec_vsubuhs(__a, (vector unsigned short)__b);
11230 }
11231 
11232 static __inline__ vector int __ATTRS_o_ai vec_subs(vector int __a,
11233  vector int __b) {
11234  return __builtin_altivec_vsubsws(__a, __b);
11235 }
11236 
11237 static __inline__ vector int __ATTRS_o_ai vec_subs(vector bool int __a,
11238  vector int __b) {
11239  return __builtin_altivec_vsubsws((vector int)__a, __b);
11240 }
11241 
11242 static __inline__ vector int __ATTRS_o_ai vec_subs(vector int __a,
11243  vector bool int __b) {
11244  return __builtin_altivec_vsubsws(__a, (vector int)__b);
11245 }
11246 
11247 static __inline__ vector unsigned int __ATTRS_o_ai
11248 vec_subs(vector unsigned int __a, vector unsigned int __b) {
11249  return __builtin_altivec_vsubuws(__a, __b);
11250 }
11251 
11252 static __inline__ vector unsigned int __ATTRS_o_ai
11253 vec_subs(vector bool int __a, vector unsigned int __b) {
11254  return __builtin_altivec_vsubuws((vector unsigned int)__a, __b);
11255 }
11256 
11257 static __inline__ vector unsigned int __ATTRS_o_ai
11258 vec_subs(vector unsigned int __a, vector bool int __b) {
11259  return __builtin_altivec_vsubuws(__a, (vector unsigned int)__b);
11260 }
11261 
11262 /* vec_vsubsbs */
11263 
11264 static __inline__ vector signed char __ATTRS_o_ai
11265 vec_vsubsbs(vector signed char __a, vector signed char __b) {
11266  return __builtin_altivec_vsubsbs(__a, __b);
11267 }
11268 
11269 static __inline__ vector signed char __ATTRS_o_ai
11270 vec_vsubsbs(vector bool char __a, vector signed char __b) {
11271  return __builtin_altivec_vsubsbs((vector signed char)__a, __b);
11272 }
11273 
11274 static __inline__ vector signed char __ATTRS_o_ai
11275 vec_vsubsbs(vector signed char __a, vector bool char __b) {
11276  return __builtin_altivec_vsubsbs(__a, (vector signed char)__b);
11277 }
11278 
11279 /* vec_vsububs */
11280 
11281 static __inline__ vector unsigned char __ATTRS_o_ai
11282 vec_vsububs(vector unsigned char __a, vector unsigned char __b) {
11283  return __builtin_altivec_vsububs(__a, __b);
11284 }
11285 
11286 static __inline__ vector unsigned char __ATTRS_o_ai
11287 vec_vsububs(vector bool char __a, vector unsigned char __b) {
11288  return __builtin_altivec_vsububs((vector unsigned char)__a, __b);
11289 }
11290 
11291 static __inline__ vector unsigned char __ATTRS_o_ai
11292 vec_vsububs(vector unsigned char __a, vector bool char __b) {
11293  return __builtin_altivec_vsububs(__a, (vector unsigned char)__b);
11294 }
11295 
11296 /* vec_vsubshs */
11297 
11298 static __inline__ vector short __ATTRS_o_ai vec_vsubshs(vector short __a,
11299  vector short __b) {
11300  return __builtin_altivec_vsubshs(__a, __b);
11301 }
11302 
11303 static __inline__ vector short __ATTRS_o_ai vec_vsubshs(vector bool short __a,
11304  vector short __b) {
11305  return __builtin_altivec_vsubshs((vector short)__a, __b);
11306 }
11307 
11308 static __inline__ vector short __ATTRS_o_ai vec_vsubshs(vector short __a,
11309  vector bool short __b) {
11310  return __builtin_altivec_vsubshs(__a, (vector short)__b);
11311 }
11312 
11313 /* vec_vsubuhs */
11314 
11315 static __inline__ vector unsigned short __ATTRS_o_ai
11316 vec_vsubuhs(vector unsigned short __a, vector unsigned short __b) {
11317  return __builtin_altivec_vsubuhs(__a, __b);
11318 }
11319 
11320 static __inline__ vector unsigned short __ATTRS_o_ai
11321 vec_vsubuhs(vector bool short __a, vector unsigned short __b) {
11322  return __builtin_altivec_vsubuhs((vector unsigned short)__a, __b);
11323 }
11324 
11325 static __inline__ vector unsigned short __ATTRS_o_ai
11326 vec_vsubuhs(vector unsigned short __a, vector bool short __b) {
11327  return __builtin_altivec_vsubuhs(__a, (vector unsigned short)__b);
11328 }
11329 
11330 /* vec_vsubsws */
11331 
11332 static __inline__ vector int __ATTRS_o_ai vec_vsubsws(vector int __a,
11333  vector int __b) {
11334  return __builtin_altivec_vsubsws(__a, __b);
11335 }
11336 
11337 static __inline__ vector int __ATTRS_o_ai vec_vsubsws(vector bool int __a,
11338  vector int __b) {
11339  return __builtin_altivec_vsubsws((vector int)__a, __b);
11340 }
11341 
11342 static __inline__ vector int __ATTRS_o_ai vec_vsubsws(vector int __a,
11343  vector bool int __b) {
11344  return __builtin_altivec_vsubsws(__a, (vector int)__b);
11345 }
11346 
11347 /* vec_vsubuws */
11348 
11349 static __inline__ vector unsigned int __ATTRS_o_ai
11350 vec_vsubuws(vector unsigned int __a, vector unsigned int __b) {
11351  return __builtin_altivec_vsubuws(__a, __b);
11352 }
11353 
11354 static __inline__ vector unsigned int __ATTRS_o_ai
11355 vec_vsubuws(vector bool int __a, vector unsigned int __b) {
11356  return __builtin_altivec_vsubuws((vector unsigned int)__a, __b);
11357 }
11358 
11359 static __inline__ vector unsigned int __ATTRS_o_ai
11360 vec_vsubuws(vector unsigned int __a, vector bool int __b) {
11361  return __builtin_altivec_vsubuws(__a, (vector unsigned int)__b);
11362 }
11363 
11364 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
11365 /* vec_vsubuqm */
11366 
11367 static __inline__ vector signed __int128 __ATTRS_o_ai
11368 vec_vsubuqm(vector signed __int128 __a, vector signed __int128 __b) {
11369  return __a - __b;
11370 }
11371 
11372 static __inline__ vector unsigned __int128 __ATTRS_o_ai
11373 vec_vsubuqm(vector unsigned __int128 __a, vector unsigned __int128 __b) {
11374  return __a - __b;
11375 }
11376 
11377 /* vec_vsubeuqm */
11378 
11379 
11380 static __inline__ vector signed __int128 __ATTRS_o_ai
11381 vec_vsubeuqm(vector signed __int128 __a, vector signed __int128 __b,
11382  vector signed __int128 __c) {
11383  return __builtin_altivec_vsubeuqm(__a, __b, __c);
11384 }
11385 
11386 static __inline__ vector unsigned __int128 __ATTRS_o_ai
11387 vec_vsubeuqm(vector unsigned __int128 __a, vector unsigned __int128 __b,
11388  vector unsigned __int128 __c) {
11389  return __builtin_altivec_vsubeuqm(__a, __b, __c);
11390 }
11391 
11392 static __inline__ vector signed __int128 __ATTRS_o_ai
11393 vec_sube(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_sube(vector unsigned __int128 __a, vector unsigned __int128 __b,
11400  vector unsigned __int128 __c) {
11401  return __builtin_altivec_vsubeuqm(__a, __b, __c);
11402 }
11403 
11404 /* vec_vsubcuq */
11405 
11406 static __inline__ vector signed __int128 __ATTRS_o_ai
11407 vec_vsubcuq(vector signed __int128 __a, vector signed __int128 __b) {
11408  return __builtin_altivec_vsubcuq(__a, __b);
11409 }
11410 
11411 static __inline__ vector unsigned __int128 __ATTRS_o_ai
11412 vec_vsubcuq(vector unsigned __int128 __a, vector unsigned __int128 __b) {
11413  return __builtin_altivec_vsubcuq(__a, __b);
11414 }
11415 
11416 /* vec_vsubecuq */
11417 
11418 static __inline__ vector signed __int128 __ATTRS_o_ai
11419 vec_vsubecuq(vector signed __int128 __a, vector signed __int128 __b,
11420  vector signed __int128 __c) {
11421  return __builtin_altivec_vsubecuq(__a, __b, __c);
11422 }
11423 
11424 static __inline__ vector unsigned __int128 __ATTRS_o_ai
11425 vec_vsubecuq(vector unsigned __int128 __a, vector unsigned __int128 __b,
11426  vector unsigned __int128 __c) {
11427  return __builtin_altivec_vsubecuq(__a, __b, __c);
11428 }
11429 
11430 static __inline__ vector signed int __ATTRS_o_ai
11431 vec_subec(vector signed int __a, vector signed int __b,
11432  vector signed int __c) {
11433  return vec_addec(__a, ~__b, __c);
11434 }
11435 
11436 static __inline__ vector unsigned int __ATTRS_o_ai
11437 vec_subec(vector unsigned int __a, vector unsigned int __b,
11438  vector unsigned int __c) {
11439  return vec_addec(__a, ~__b, __c);
11440 }
11441 
11442 static __inline__ vector signed __int128 __ATTRS_o_ai
11443 vec_subec(vector signed __int128 __a, vector signed __int128 __b,
11444  vector signed __int128 __c) {
11445  return __builtin_altivec_vsubecuq(__a, __b, __c);
11446 }
11447 
11448 static __inline__ vector unsigned __int128 __ATTRS_o_ai
11449 vec_subec(vector unsigned __int128 __a, vector unsigned __int128 __b,
11450  vector unsigned __int128 __c) {
11451  return __builtin_altivec_vsubecuq(__a, __b, __c);
11452 }
11453 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
11454 
11455 static __inline__ vector signed int __ATTRS_o_ai
11456 vec_sube(vector signed int __a, vector signed int __b,
11457  vector signed int __c) {
11458  vector signed int __mask = {1, 1, 1, 1};
11459  vector signed int __carry = __c & __mask;
11460  return vec_adde(__a, ~__b, __carry);
11461 }
11462 
11463 static __inline__ vector unsigned int __ATTRS_o_ai
11464 vec_sube(vector unsigned int __a, vector unsigned int __b,
11465  vector unsigned int __c) {
11466  vector unsigned int __mask = {1, 1, 1, 1};
11467  vector unsigned int __carry = __c & __mask;
11468  return vec_adde(__a, ~__b, __carry);
11469 }
11470 /* vec_sum4s */
11471 
11472 static __inline__ vector int __ATTRS_o_ai vec_sum4s(vector signed char __a,
11473  vector int __b) {
11474  return __builtin_altivec_vsum4sbs(__a, __b);
11475 }
11476 
11477 static __inline__ vector unsigned int __ATTRS_o_ai
11478 vec_sum4s(vector unsigned char __a, vector unsigned int __b) {
11479  return __builtin_altivec_vsum4ubs(__a, __b);
11480 }
11481 
11482 static __inline__ vector int __ATTRS_o_ai vec_sum4s(vector signed short __a,
11483  vector int __b) {
11484  return __builtin_altivec_vsum4shs(__a, __b);
11485 }
11486 
11487 /* vec_vsum4sbs */
11488 
11489 static __inline__ vector int __attribute__((__always_inline__))
11490 vec_vsum4sbs(vector signed char __a, vector int __b) {
11491  return __builtin_altivec_vsum4sbs(__a, __b);
11492 }
11493 
11494 /* vec_vsum4ubs */
11495 
11496 static __inline__ vector unsigned int __attribute__((__always_inline__))
11497 vec_vsum4ubs(vector unsigned char __a, vector unsigned int __b) {
11498  return __builtin_altivec_vsum4ubs(__a, __b);
11499 }
11500 
11501 /* vec_vsum4shs */
11502 
11503 static __inline__ vector int __attribute__((__always_inline__))
11504 vec_vsum4shs(vector signed short __a, vector int __b) {
11505  return __builtin_altivec_vsum4shs(__a, __b);
11506 }
11507 
11508 /* vec_sum2s */
11509 
11510 /* The vsum2sws instruction has a big-endian bias, so that the second
11511  input vector and the result always reference big-endian elements
11512  1 and 3 (little-endian element 0 and 2). For ease of porting the
11513  programmer wants elements 1 and 3 in both cases, so for little
11514  endian we must perform some permutes. */
11515 
11516 static __inline__ vector signed int __attribute__((__always_inline__))
11517 vec_sum2s(vector int __a, vector int __b) {
11518 #ifdef __LITTLE_ENDIAN__
11519  vector int __c = (vector signed int)vec_perm(
11520  __b, __b, (vector unsigned char)(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15,
11521  8, 9, 10, 11));
11522  __c = __builtin_altivec_vsum2sws(__a, __c);
11523  return (vector signed int)vec_perm(
11524  __c, __c, (vector unsigned char)(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15,
11525  8, 9, 10, 11));
11526 #else
11527  return __builtin_altivec_vsum2sws(__a, __b);
11528 #endif
11529 }
11530 
11531 /* vec_vsum2sws */
11532 
11533 static __inline__ vector signed int __attribute__((__always_inline__))
11534 vec_vsum2sws(vector int __a, vector int __b) {
11535 #ifdef __LITTLE_ENDIAN__
11536  vector int __c = (vector signed int)vec_perm(
11537  __b, __b, (vector unsigned char)(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15,
11538  8, 9, 10, 11));
11539  __c = __builtin_altivec_vsum2sws(__a, __c);
11540  return (vector signed int)vec_perm(
11541  __c, __c, (vector unsigned char)(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15,
11542  8, 9, 10, 11));
11543 #else
11544  return __builtin_altivec_vsum2sws(__a, __b);
11545 #endif
11546 }
11547 
11548 /* vec_sums */
11549 
11550 /* The vsumsws instruction has a big-endian bias, so that the second
11551  input vector and the result always reference big-endian element 3
11552  (little-endian element 0). For ease of porting the programmer
11553  wants element 3 in both cases, so for little endian we must perform
11554  some permutes. */
11555 
11556 static __inline__ vector signed int __attribute__((__always_inline__))
11557 vec_sums(vector signed int __a, vector signed int __b) {
11558 #ifdef __LITTLE_ENDIAN__
11559  __b = (vector signed int)vec_splat(__b, 3);
11560  __b = __builtin_altivec_vsumsws(__a, __b);
11561  return (vector signed int)(0, 0, 0, __b[0]);
11562 #else
11563  return __builtin_altivec_vsumsws(__a, __b);
11564 #endif
11565 }
11566 
11567 /* vec_vsumsws */
11568 
11569 static __inline__ vector signed int __attribute__((__always_inline__))
11570 vec_vsumsws(vector signed int __a, vector signed int __b) {
11571 #ifdef __LITTLE_ENDIAN__
11572  __b = (vector signed int)vec_splat(__b, 3);
11573  __b = __builtin_altivec_vsumsws(__a, __b);
11574  return (vector signed int)(0, 0, 0, __b[0]);
11575 #else
11576  return __builtin_altivec_vsumsws(__a, __b);
11577 #endif
11578 }
11579 
11580 /* vec_trunc */
11581 
11582 static __inline__ vector float __ATTRS_o_ai vec_trunc(vector float __a) {
11583 #ifdef __VSX__
11584  return __builtin_vsx_xvrspiz(__a);
11585 #else
11586  return __builtin_altivec_vrfiz(__a);
11587 #endif
11588 }
11589 
11590 #ifdef __VSX__
11591 static __inline__ vector double __ATTRS_o_ai vec_trunc(vector double __a) {
11592  return __builtin_vsx_xvrdpiz(__a);
11593 }
11594 #endif
11595 
11596 /* vec_vrfiz */
11597 
11598 static __inline__ vector float __attribute__((__always_inline__))
11599 vec_vrfiz(vector float __a) {
11600  return __builtin_altivec_vrfiz(__a);
11601 }
11602 
11603 /* vec_unpackh */
11604 
11605 /* The vector unpack instructions all have a big-endian bias, so for
11606  little endian we must reverse the meanings of "high" and "low." */
11607 
11608 static __inline__ vector short __ATTRS_o_ai
11609 vec_unpackh(vector signed char __a) {
11610 #ifdef __LITTLE_ENDIAN__
11611  return __builtin_altivec_vupklsb((vector char)__a);
11612 #else
11613  return __builtin_altivec_vupkhsb((vector char)__a);
11614 #endif
11615 }
11616 
11617 static __inline__ vector bool short __ATTRS_o_ai
11618 vec_unpackh(vector bool char __a) {
11619 #ifdef __LITTLE_ENDIAN__
11620  return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
11621 #else
11622  return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
11623 #endif
11624 }
11625 
11626 static __inline__ vector int __ATTRS_o_ai vec_unpackh(vector short __a) {
11627 #ifdef __LITTLE_ENDIAN__
11628  return __builtin_altivec_vupklsh(__a);
11629 #else
11630  return __builtin_altivec_vupkhsh(__a);
11631 #endif
11632 }
11633 
11634 static __inline__ vector bool int __ATTRS_o_ai
11635 vec_unpackh(vector bool short __a) {
11636 #ifdef __LITTLE_ENDIAN__
11637  return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
11638 #else
11639  return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
11640 #endif
11641 }
11642 
11643 static __inline__ vector unsigned int __ATTRS_o_ai
11644 vec_unpackh(vector pixel __a) {
11645 #ifdef __LITTLE_ENDIAN__
11646  return (vector unsigned int)__builtin_altivec_vupklpx((vector short)__a);
11647 #else
11648  return (vector unsigned int)__builtin_altivec_vupkhpx((vector short)__a);
11649 #endif
11650 }
11651 
11652 #ifdef __POWER8_VECTOR__
11653 static __inline__ vector long long __ATTRS_o_ai vec_unpackh(vector int __a) {
11654 #ifdef __LITTLE_ENDIAN__
11655  return __builtin_altivec_vupklsw(__a);
11656 #else
11657  return __builtin_altivec_vupkhsw(__a);
11658 #endif
11659 }
11660 
11661 static __inline__ vector bool long long __ATTRS_o_ai
11662 vec_unpackh(vector bool int __a) {
11663 #ifdef __LITTLE_ENDIAN__
11664  return (vector bool long long)__builtin_altivec_vupklsw((vector int)__a);
11665 #else
11666  return (vector bool long long)__builtin_altivec_vupkhsw((vector int)__a);
11667 #endif
11668 }
11669 
11670 static __inline__ vector double __ATTRS_o_ai
11671 vec_unpackh(vector float __a) {
11672  return (vector double)(__a[0], __a[1]);
11673 }
11674 #endif
11675 
11676 /* vec_vupkhsb */
11677 
11678 static __inline__ vector short __ATTRS_o_ai
11679 vec_vupkhsb(vector signed char __a) {
11680 #ifdef __LITTLE_ENDIAN__
11681  return __builtin_altivec_vupklsb((vector char)__a);
11682 #else
11683  return __builtin_altivec_vupkhsb((vector char)__a);
11684 #endif
11685 }
11686 
11687 static __inline__ vector bool short __ATTRS_o_ai
11688 vec_vupkhsb(vector bool char __a) {
11689 #ifdef __LITTLE_ENDIAN__
11690  return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
11691 #else
11692  return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
11693 #endif
11694 }
11695 
11696 /* vec_vupkhsh */
11697 
11698 static __inline__ vector int __ATTRS_o_ai vec_vupkhsh(vector short __a) {
11699 #ifdef __LITTLE_ENDIAN__
11700  return __builtin_altivec_vupklsh(__a);
11701 #else
11702  return __builtin_altivec_vupkhsh(__a);
11703 #endif
11704 }
11705 
11706 static __inline__ vector bool int __ATTRS_o_ai
11707 vec_vupkhsh(vector bool short __a) {
11708 #ifdef __LITTLE_ENDIAN__
11709  return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
11710 #else
11711  return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
11712 #endif
11713 }
11714 
11715 static __inline__ vector unsigned int __ATTRS_o_ai
11716 vec_vupkhsh(vector pixel __a) {
11717 #ifdef __LITTLE_ENDIAN__
11718  return (vector unsigned int)__builtin_altivec_vupklpx((vector short)__a);
11719 #else
11720  return (vector unsigned int)__builtin_altivec_vupkhpx((vector short)__a);
11721 #endif
11722 }
11723 
11724 /* vec_vupkhsw */
11725 
11726 #ifdef __POWER8_VECTOR__
11727 static __inline__ vector long long __ATTRS_o_ai vec_vupkhsw(vector int __a) {
11728 #ifdef __LITTLE_ENDIAN__
11729  return __builtin_altivec_vupklsw(__a);
11730 #else
11731  return __builtin_altivec_vupkhsw(__a);
11732 #endif
11733 }
11734 
11735 static __inline__ vector bool long long __ATTRS_o_ai
11736 vec_vupkhsw(vector bool int __a) {
11737 #ifdef __LITTLE_ENDIAN__
11738  return (vector bool long long)__builtin_altivec_vupklsw((vector int)__a);
11739 #else
11740  return (vector bool long long)__builtin_altivec_vupkhsw((vector int)__a);
11741 #endif
11742 }
11743 #endif
11744 
11745 /* vec_unpackl */
11746 
11747 static __inline__ vector short __ATTRS_o_ai
11748 vec_unpackl(vector signed char __a) {
11749 #ifdef __LITTLE_ENDIAN__
11750  return __builtin_altivec_vupkhsb((vector char)__a);
11751 #else
11752  return __builtin_altivec_vupklsb((vector char)__a);
11753 #endif
11754 }
11755 
11756 static __inline__ vector bool short __ATTRS_o_ai
11757 vec_unpackl(vector bool char __a) {
11758 #ifdef __LITTLE_ENDIAN__
11759  return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
11760 #else
11761  return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
11762 #endif
11763 }
11764 
11765 static __inline__ vector int __ATTRS_o_ai vec_unpackl(vector short __a) {
11766 #ifdef __LITTLE_ENDIAN__
11767  return __builtin_altivec_vupkhsh(__a);
11768 #else
11769  return __builtin_altivec_vupklsh(__a);
11770 #endif
11771 }
11772 
11773 static __inline__ vector bool int __ATTRS_o_ai
11774 vec_unpackl(vector bool short __a) {
11775 #ifdef __LITTLE_ENDIAN__
11776  return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
11777 #else
11778  return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
11779 #endif
11780 }
11781 
11782 static __inline__ vector unsigned int __ATTRS_o_ai
11783 vec_unpackl(vector pixel __a) {
11784 #ifdef __LITTLE_ENDIAN__
11785  return (vector unsigned int)__builtin_altivec_vupkhpx((vector short)__a);
11786 #else
11787  return (vector unsigned int)__builtin_altivec_vupklpx((vector short)__a);
11788 #endif
11789 }
11790 
11791 #ifdef __POWER8_VECTOR__
11792 static __inline__ vector long long __ATTRS_o_ai vec_unpackl(vector int __a) {
11793 #ifdef __LITTLE_ENDIAN__
11794  return __builtin_altivec_vupkhsw(__a);
11795 #else
11796  return __builtin_altivec_vupklsw(__a);
11797 #endif
11798 }
11799 
11800 static __inline__ vector bool long long __ATTRS_o_ai
11801 vec_unpackl(vector bool int __a) {
11802 #ifdef __LITTLE_ENDIAN__
11803  return (vector bool long long)__builtin_altivec_vupkhsw((vector int)__a);
11804 #else
11805  return (vector bool long long)__builtin_altivec_vupklsw((vector int)__a);
11806 #endif
11807 }
11808 
11809 static __inline__ vector double __ATTRS_o_ai
11810 vec_unpackl(vector float __a) {
11811  return (vector double)(__a[2], __a[3]);
11812 }
11813 #endif
11814 
11815 /* vec_vupklsb */
11816 
11817 static __inline__ vector short __ATTRS_o_ai
11818 vec_vupklsb(vector signed char __a) {
11819 #ifdef __LITTLE_ENDIAN__
11820  return __builtin_altivec_vupkhsb((vector char)__a);
11821 #else
11822  return __builtin_altivec_vupklsb((vector char)__a);
11823 #endif
11824 }
11825 
11826 static __inline__ vector bool short __ATTRS_o_ai
11827 vec_vupklsb(vector bool char __a) {
11828 #ifdef __LITTLE_ENDIAN__
11829  return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
11830 #else
11831  return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
11832 #endif
11833 }
11834 
11835 /* vec_vupklsh */
11836 
11837 static __inline__ vector int __ATTRS_o_ai vec_vupklsh(vector short __a) {
11838 #ifdef __LITTLE_ENDIAN__
11839  return __builtin_altivec_vupkhsh(__a);
11840 #else
11841  return __builtin_altivec_vupklsh(__a);
11842 #endif
11843 }
11844 
11845 static __inline__ vector bool int __ATTRS_o_ai
11846 vec_vupklsh(vector bool short __a) {
11847 #ifdef __LITTLE_ENDIAN__
11848  return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
11849 #else
11850  return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
11851 #endif
11852 }
11853 
11854 static __inline__ vector unsigned int __ATTRS_o_ai
11855 vec_vupklsh(vector pixel __a) {
11856 #ifdef __LITTLE_ENDIAN__
11857  return (vector unsigned int)__builtin_altivec_vupkhpx((vector short)__a);
11858 #else
11859  return (vector unsigned int)__builtin_altivec_vupklpx((vector short)__a);
11860 #endif
11861 }
11862 
11863 /* vec_vupklsw */
11864 
11865 #ifdef __POWER8_VECTOR__
11866 static __inline__ vector long long __ATTRS_o_ai vec_vupklsw(vector int __a) {
11867 #ifdef __LITTLE_ENDIAN__
11868  return __builtin_altivec_vupkhsw(__a);
11869 #else
11870  return __builtin_altivec_vupklsw(__a);
11871 #endif
11872 }
11873 
11874 static __inline__ vector bool long long __ATTRS_o_ai
11875 vec_vupklsw(vector bool int __a) {
11876 #ifdef __LITTLE_ENDIAN__
11877  return (vector bool long long)__builtin_altivec_vupkhsw((vector int)__a);
11878 #else
11879  return (vector bool long long)__builtin_altivec_vupklsw((vector int)__a);
11880 #endif
11881 }
11882 #endif
11883 
11884 /* vec_vsx_ld */
11885 
11886 #ifdef __VSX__
11887 
11888 static __inline__ vector bool int __ATTRS_o_ai
11889 vec_vsx_ld(int __a, const vector bool int *__b) {
11890  return (vector bool int)__builtin_vsx_lxvw4x(__a, __b);
11891 }
11892 
11893 static __inline__ vector signed int __ATTRS_o_ai
11894 vec_vsx_ld(int __a, const vector signed int *__b) {
11895  return (vector signed int)__builtin_vsx_lxvw4x(__a, __b);
11896 }
11897 
11898 static __inline__ vector signed int __ATTRS_o_ai
11899 vec_vsx_ld(int __a, const signed int *__b) {
11900  return (vector signed int)__builtin_vsx_lxvw4x(__a, __b);
11901 }
11902 
11903 static __inline__ vector unsigned int __ATTRS_o_ai
11904 vec_vsx_ld(int __a, const vector unsigned int *__b) {
11905  return (vector unsigned int)__builtin_vsx_lxvw4x(__a, __b);
11906 }
11907 
11908 static __inline__ vector unsigned int __ATTRS_o_ai
11909 vec_vsx_ld(int __a, const unsigned int *__b) {
11910  return (vector unsigned int)__builtin_vsx_lxvw4x(__a, __b);
11911 }
11912 
11913 static __inline__ vector float __ATTRS_o_ai
11914 vec_vsx_ld(int __a, const vector float *__b) {
11915  return (vector float)__builtin_vsx_lxvw4x(__a, __b);
11916 }
11917 
11918 static __inline__ vector float __ATTRS_o_ai vec_vsx_ld(int __a,
11919  const float *__b) {
11920  return (vector float)__builtin_vsx_lxvw4x(__a, __b);
11921 }
11922 
11923 static __inline__ vector signed long long __ATTRS_o_ai
11924 vec_vsx_ld(int __a, const vector signed long long *__b) {
11925  return (vector signed long long)__builtin_vsx_lxvd2x(__a, __b);
11926 }
11927 
11928 static __inline__ vector unsigned long long __ATTRS_o_ai
11929 vec_vsx_ld(int __a, const vector unsigned long long *__b) {
11930  return (vector unsigned long long)__builtin_vsx_lxvd2x(__a, __b);
11931 }
11932 
11933 static __inline__ vector double __ATTRS_o_ai
11934 vec_vsx_ld(int __a, const vector double *__b) {
11935  return (vector double)__builtin_vsx_lxvd2x(__a, __b);
11936 }
11937 
11938 static __inline__ vector double __ATTRS_o_ai
11939 vec_vsx_ld(int __a, const double *__b) {
11940  return (vector double)__builtin_vsx_lxvd2x(__a, __b);
11941 }
11942 
11943 static __inline__ vector bool short __ATTRS_o_ai
11944 vec_vsx_ld(int __a, const vector bool short *__b) {
11945  return (vector bool short)__builtin_vsx_lxvw4x(__a, __b);
11946 }
11947 
11948 static __inline__ vector signed short __ATTRS_o_ai
11949 vec_vsx_ld(int __a, const vector signed short *__b) {
11950  return (vector signed short)__builtin_vsx_lxvw4x(__a, __b);
11951 }
11952 
11953 static __inline__ vector signed short __ATTRS_o_ai
11954 vec_vsx_ld(int __a, const signed short *__b) {
11955  return (vector signed short)__builtin_vsx_lxvw4x(__a, __b);
11956 }
11957 
11958 static __inline__ vector unsigned short __ATTRS_o_ai
11959 vec_vsx_ld(int __a, const vector unsigned short *__b) {
11960  return (vector unsigned short)__builtin_vsx_lxvw4x(__a, __b);
11961 }
11962 
11963 static __inline__ vector unsigned short __ATTRS_o_ai
11964 vec_vsx_ld(int __a, const unsigned short *__b) {
11965  return (vector unsigned short)__builtin_vsx_lxvw4x(__a, __b);
11966 }
11967 
11968 static __inline__ vector bool char __ATTRS_o_ai
11969 vec_vsx_ld(int __a, const vector bool char *__b) {
11970  return (vector bool char)__builtin_vsx_lxvw4x(__a, __b);
11971 }
11972 
11973 static __inline__ vector signed char __ATTRS_o_ai
11974 vec_vsx_ld(int __a, const vector signed char *__b) {
11975  return (vector signed char)__builtin_vsx_lxvw4x(__a, __b);
11976 }
11977 
11978 static __inline__ vector signed char __ATTRS_o_ai
11979 vec_vsx_ld(int __a, const signed char *__b) {
11980  return (vector signed char)__builtin_vsx_lxvw4x(__a, __b);
11981 }
11982 
11983 static __inline__ vector unsigned char __ATTRS_o_ai
11984 vec_vsx_ld(int __a, const vector unsigned char *__b) {
11985  return (vector unsigned char)__builtin_vsx_lxvw4x(__a, __b);
11986 }
11987 
11988 static __inline__ vector unsigned char __ATTRS_o_ai
11989 vec_vsx_ld(int __a, const unsigned char *__b) {
11990  return (vector unsigned char)__builtin_vsx_lxvw4x(__a, __b);
11991 }
11992 
11993 #endif
11994 
11995 /* vec_vsx_st */
11996 
11997 #ifdef __VSX__
11998 
11999 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool int __a, int __b,
12000  vector bool int *__c) {
12001  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12002 }
12003 
12004 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool int __a, int __b,
12005  signed int *__c) {
12006  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12007 }
12008 
12009 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool int __a, int __b,
12010  unsigned int *__c) {
12011  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12012 }
12013 
12014 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed int __a, int __b,
12015  vector signed int *__c) {
12016  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12017 }
12018 
12019 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed int __a, int __b,
12020  signed int *__c) {
12021  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12022 }
12023 
12024 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned int __a, int __b,
12025  vector unsigned int *__c) {
12026  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12027 }
12028 
12029 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned int __a, int __b,
12030  unsigned int *__c) {
12031  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12032 }
12033 
12034 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector float __a, int __b,
12035  vector float *__c) {
12036  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12037 }
12038 
12039 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector float __a, int __b,
12040  float *__c) {
12041  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12042 }
12043 
12044 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed long long __a,
12045  int __b,
12046  vector signed long long *__c) {
12047  __builtin_vsx_stxvd2x((vector double)__a, __b, __c);
12048 }
12049 
12050 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned long long __a,
12051  int __b,
12052  vector unsigned long long *__c) {
12053  __builtin_vsx_stxvd2x((vector double)__a, __b, __c);
12054 }
12055 
12056 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector double __a, int __b,
12057  vector double *__c) {
12058  __builtin_vsx_stxvd2x((vector double)__a, __b, __c);
12059 }
12060 
12061 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector double __a, int __b,
12062  double *__c) {
12063  __builtin_vsx_stxvd2x((vector double)__a, __b, __c);
12064 }
12065 
12066 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool short __a, int __b,
12067  vector bool short *__c) {
12068  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12069 }
12070 
12071 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool short __a, int __b,
12072  signed short *__c) {
12073  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12074 }
12075 
12076 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool short __a, int __b,
12077  unsigned short *__c) {
12078  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12079 }
12080 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed short __a, int __b,
12081  vector signed short *__c) {
12082  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12083 }
12084 
12085 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed short __a, int __b,
12086  signed short *__c) {
12087  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12088 }
12089 
12090 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned short __a,
12091  int __b,
12092  vector unsigned short *__c) {
12093  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12094 }
12095 
12096 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned short __a,
12097  int __b, unsigned short *__c) {
12098  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12099 }
12100 
12101 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool char __a, int __b,
12102  vector bool char *__c) {
12103  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12104 }
12105 
12106 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool char __a, int __b,
12107  signed char *__c) {
12108  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12109 }
12110 
12111 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool char __a, int __b,
12112  unsigned char *__c) {
12113  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12114 }
12115 
12116 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed char __a, int __b,
12117  vector signed char *__c) {
12118  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12119 }
12120 
12121 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed char __a, int __b,
12122  signed char *__c) {
12123  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12124 }
12125 
12126 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned char __a,
12127  int __b,
12128  vector unsigned char *__c) {
12129  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12130 }
12131 
12132 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned char __a,
12133  int __b, unsigned char *__c) {
12134  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
12135 }
12136 
12137 #endif
12138 
12139 #ifdef __VSX__
12140 #define vec_xxpermdi __builtin_vsx_xxpermdi
12141 #define vec_xxsldwi __builtin_vsx_xxsldwi
12142 #endif
12143 
12144 /* vec_xor */
12145 
12146 #define __builtin_altivec_vxor vec_xor
12147 
12148 static __inline__ vector signed char __ATTRS_o_ai
12149 vec_xor(vector signed char __a, vector signed char __b) {
12150  return __a ^ __b;
12151 }
12152 
12153 static __inline__ vector signed char __ATTRS_o_ai
12154 vec_xor(vector bool char __a, vector signed char __b) {
12155  return (vector signed char)__a ^ __b;
12156 }
12157 
12158 static __inline__ vector signed char __ATTRS_o_ai
12159 vec_xor(vector signed char __a, vector bool char __b) {
12160  return __a ^ (vector signed char)__b;
12161 }
12162 
12163 static __inline__ vector unsigned char __ATTRS_o_ai
12164 vec_xor(vector unsigned char __a, vector unsigned char __b) {
12165  return __a ^ __b;
12166 }
12167 
12168 static __inline__ vector unsigned char __ATTRS_o_ai
12169 vec_xor(vector bool char __a, vector unsigned char __b) {
12170  return (vector unsigned char)__a ^ __b;
12171 }
12172 
12173 static __inline__ vector unsigned char __ATTRS_o_ai
12174 vec_xor(vector unsigned char __a, vector bool char __b) {
12175  return __a ^ (vector unsigned char)__b;
12176 }
12177 
12178 static __inline__ vector bool char __ATTRS_o_ai vec_xor(vector bool char __a,
12179  vector bool char __b) {
12180  return __a ^ __b;
12181 }
12182 
12183 static __inline__ vector short __ATTRS_o_ai vec_xor(vector short __a,
12184  vector short __b) {
12185  return __a ^ __b;
12186 }
12187 
12188 static __inline__ vector short __ATTRS_o_ai vec_xor(vector bool short __a,
12189  vector short __b) {
12190  return (vector short)__a ^ __b;
12191 }
12192 
12193 static __inline__ vector short __ATTRS_o_ai vec_xor(vector short __a,
12194  vector bool short __b) {
12195  return __a ^ (vector short)__b;
12196 }
12197 
12198 static __inline__ vector unsigned short __ATTRS_o_ai
12199 vec_xor(vector unsigned short __a, vector unsigned short __b) {
12200  return __a ^ __b;
12201 }
12202 
12203 static __inline__ vector unsigned short __ATTRS_o_ai
12204 vec_xor(vector bool short __a, vector unsigned short __b) {
12205  return (vector unsigned short)__a ^ __b;
12206 }
12207 
12208 static __inline__ vector unsigned short __ATTRS_o_ai
12209 vec_xor(vector unsigned short __a, vector bool short __b) {
12210  return __a ^ (vector unsigned short)__b;
12211 }
12212 
12213 static __inline__ vector bool short __ATTRS_o_ai
12214 vec_xor(vector bool short __a, vector bool short __b) {
12215  return __a ^ __b;
12216 }
12217 
12218 static __inline__ vector int __ATTRS_o_ai vec_xor(vector int __a,
12219  vector int __b) {
12220  return __a ^ __b;
12221 }
12222 
12223 static __inline__ vector int __ATTRS_o_ai vec_xor(vector bool int __a,
12224  vector int __b) {
12225  return (vector int)__a ^ __b;
12226 }
12227 
12228 static __inline__ vector int __ATTRS_o_ai vec_xor(vector int __a,
12229  vector bool int __b) {
12230  return __a ^ (vector int)__b;
12231 }
12232 
12233 static __inline__ vector unsigned int __ATTRS_o_ai
12234 vec_xor(vector unsigned int __a, vector unsigned int __b) {
12235  return __a ^ __b;
12236 }
12237 
12238 static __inline__ vector unsigned int __ATTRS_o_ai
12239 vec_xor(vector bool int __a, vector unsigned int __b) {
12240  return (vector unsigned int)__a ^ __b;
12241 }
12242 
12243 static __inline__ vector unsigned int __ATTRS_o_ai
12244 vec_xor(vector unsigned int __a, vector bool int __b) {
12245  return __a ^ (vector unsigned int)__b;
12246 }
12247 
12248 static __inline__ vector bool int __ATTRS_o_ai vec_xor(vector bool int __a,
12249  vector bool int __b) {
12250  return __a ^ __b;
12251 }
12252 
12253 static __inline__ vector float __ATTRS_o_ai vec_xor(vector float __a,
12254  vector float __b) {
12255  vector unsigned int __res =
12256  (vector unsigned int)__a ^ (vector unsigned int)__b;
12257  return (vector float)__res;
12258 }
12259 
12260 static __inline__ vector float __ATTRS_o_ai vec_xor(vector bool int __a,
12261  vector float __b) {
12262  vector unsigned int __res =
12263  (vector unsigned int)__a ^ (vector unsigned int)__b;
12264  return (vector float)__res;
12265 }
12266 
12267 static __inline__ vector float __ATTRS_o_ai vec_xor(vector float __a,
12268  vector bool int __b) {
12269  vector unsigned int __res =
12270  (vector unsigned int)__a ^ (vector unsigned int)__b;
12271  return (vector float)__res;
12272 }
12273 
12274 #ifdef __VSX__
12275 static __inline__ vector signed long long __ATTRS_o_ai
12276 vec_xor(vector signed long long __a, vector signed long long __b) {
12277  return __a ^ __b;
12278 }
12279 
12280 static __inline__ vector signed long long __ATTRS_o_ai
12281 vec_xor(vector bool long long __a, vector signed long long __b) {
12282  return (vector signed long long)__a ^ __b;
12283 }
12284 
12285 static __inline__ vector signed long long __ATTRS_o_ai
12286 vec_xor(vector signed long long __a, vector bool long long __b) {
12287  return __a ^ (vector signed long long)__b;
12288 }
12289 
12290 static __inline__ vector unsigned long long __ATTRS_o_ai
12291 vec_xor(vector unsigned long long __a, vector unsigned long long __b) {
12292  return __a ^ __b;
12293 }
12294 
12295 static __inline__ vector unsigned long long __ATTRS_o_ai
12296 vec_xor(vector bool long long __a, vector unsigned long long __b) {
12297  return (vector unsigned long long)__a ^ __b;
12298 }
12299 
12300 static __inline__ vector unsigned long long __ATTRS_o_ai
12301 vec_xor(vector unsigned long long __a, vector bool long long __b) {
12302  return __a ^ (vector unsigned long long)__b;
12303 }
12304 
12305 static __inline__ vector bool long long __ATTRS_o_ai
12306 vec_xor(vector bool long long __a, vector bool long long __b) {
12307  return __a ^ __b;
12308 }
12309 
12310 static __inline__ vector double __ATTRS_o_ai vec_xor(vector double __a,
12311  vector double __b) {
12312  return (vector double)((vector unsigned long long)__a ^
12313  (vector unsigned long long)__b);
12314 }
12315 
12316 static __inline__ vector double __ATTRS_o_ai
12317 vec_xor(vector double __a, vector bool long long __b) {
12318  return (vector double)((vector unsigned long long)__a ^
12319  (vector unsigned long long)__b);
12320 }
12321 
12322 static __inline__ vector double __ATTRS_o_ai vec_xor(vector bool long long __a,
12323  vector double __b) {
12324  return (vector double)((vector unsigned long long)__a ^
12325  (vector unsigned long long)__b);
12326 }
12327 #endif
12328 
12329 /* vec_vxor */
12330 
12331 static __inline__ vector signed char __ATTRS_o_ai
12332 vec_vxor(vector signed char __a, vector signed char __b) {
12333  return __a ^ __b;
12334 }
12335 
12336 static __inline__ vector signed char __ATTRS_o_ai
12337 vec_vxor(vector bool char __a, vector signed char __b) {
12338  return (vector signed char)__a ^ __b;
12339 }
12340 
12341 static __inline__ vector signed char __ATTRS_o_ai
12342 vec_vxor(vector signed char __a, vector bool char __b) {
12343  return __a ^ (vector signed char)__b;
12344 }
12345 
12346 static __inline__ vector unsigned char __ATTRS_o_ai
12347 vec_vxor(vector unsigned char __a, vector unsigned char __b) {
12348  return __a ^ __b;
12349 }
12350 
12351 static __inline__ vector unsigned char __ATTRS_o_ai
12352 vec_vxor(vector bool char __a, vector unsigned char __b) {
12353  return (vector unsigned char)__a ^ __b;
12354 }
12355 
12356 static __inline__ vector unsigned char __ATTRS_o_ai
12357 vec_vxor(vector unsigned char __a, vector bool char __b) {
12358  return __a ^ (vector unsigned char)__b;
12359 }
12360 
12361 static __inline__ vector bool char __ATTRS_o_ai vec_vxor(vector bool char __a,
12362  vector bool char __b) {
12363  return __a ^ __b;
12364 }
12365 
12366 static __inline__ vector short __ATTRS_o_ai vec_vxor(vector short __a,
12367  vector short __b) {
12368  return __a ^ __b;
12369 }
12370 
12371 static __inline__ vector short __ATTRS_o_ai vec_vxor(vector bool short __a,
12372  vector short __b) {
12373  return (vector short)__a ^ __b;
12374 }
12375 
12376 static __inline__ vector short __ATTRS_o_ai vec_vxor(vector short __a,
12377  vector bool short __b) {
12378  return __a ^ (vector short)__b;
12379 }
12380 
12381 static __inline__ vector unsigned short __ATTRS_o_ai
12382 vec_vxor(vector unsigned short __a, vector unsigned short __b) {
12383  return __a ^ __b;
12384 }
12385 
12386 static __inline__ vector unsigned short __ATTRS_o_ai
12387 vec_vxor(vector bool short __a, vector unsigned short __b) {
12388  return (vector unsigned short)__a ^ __b;
12389 }
12390 
12391 static __inline__ vector unsigned short __ATTRS_o_ai
12392 vec_vxor(vector unsigned short __a, vector bool short __b) {
12393  return __a ^ (vector unsigned short)__b;
12394 }
12395 
12396 static __inline__ vector bool short __ATTRS_o_ai
12397 vec_vxor(vector bool short __a, vector bool short __b) {
12398  return __a ^ __b;
12399 }
12400 
12401 static __inline__ vector int __ATTRS_o_ai vec_vxor(vector int __a,
12402  vector int __b) {
12403  return __a ^ __b;
12404 }
12405 
12406 static __inline__ vector int __ATTRS_o_ai vec_vxor(vector bool int __a,
12407  vector int __b) {
12408  return (vector int)__a ^ __b;
12409 }
12410 
12411 static __inline__ vector int __ATTRS_o_ai vec_vxor(vector int __a,
12412  vector bool int __b) {
12413  return __a ^ (vector int)__b;
12414 }
12415 
12416 static __inline__ vector unsigned int __ATTRS_o_ai
12417 vec_vxor(vector unsigned int __a, vector unsigned int __b) {
12418  return __a ^ __b;
12419 }
12420 
12421 static __inline__ vector unsigned int __ATTRS_o_ai
12422 vec_vxor(vector bool int __a, vector unsigned int __b) {
12423  return (vector unsigned int)__a ^ __b;
12424 }
12425 
12426 static __inline__ vector unsigned int __ATTRS_o_ai
12427 vec_vxor(vector unsigned int __a, vector bool int __b) {
12428  return __a ^ (vector unsigned int)__b;
12429 }
12430 
12431 static __inline__ vector bool int __ATTRS_o_ai vec_vxor(vector bool int __a,
12432  vector bool int __b) {
12433  return __a ^ __b;
12434 }
12435 
12436 static __inline__ vector float __ATTRS_o_ai vec_vxor(vector float __a,
12437  vector float __b) {
12438  vector unsigned int __res =
12439  (vector unsigned int)__a ^ (vector unsigned int)__b;
12440  return (vector float)__res;
12441 }
12442 
12443 static __inline__ vector float __ATTRS_o_ai vec_vxor(vector bool int __a,
12444  vector float __b) {
12445  vector unsigned int __res =
12446  (vector unsigned int)__a ^ (vector unsigned int)__b;
12447  return (vector float)__res;
12448 }
12449 
12450 static __inline__ vector float __ATTRS_o_ai vec_vxor(vector float __a,
12451  vector bool int __b) {
12452  vector unsigned int __res =
12453  (vector unsigned int)__a ^ (vector unsigned int)__b;
12454  return (vector float)__res;
12455 }
12456 
12457 #ifdef __VSX__
12458 static __inline__ vector signed long long __ATTRS_o_ai
12459 vec_vxor(vector signed long long __a, vector signed long long __b) {
12460  return __a ^ __b;
12461 }
12462 
12463 static __inline__ vector signed long long __ATTRS_o_ai
12464 vec_vxor(vector bool long long __a, vector signed long long __b) {
12465  return (vector signed long long)__a ^ __b;
12466 }
12467 
12468 static __inline__ vector signed long long __ATTRS_o_ai
12469 vec_vxor(vector signed long long __a, vector bool long long __b) {
12470  return __a ^ (vector signed long long)__b;
12471 }
12472 
12473 static __inline__ vector unsigned long long __ATTRS_o_ai
12474 vec_vxor(vector unsigned long long __a, vector unsigned long long __b) {
12475  return __a ^ __b;
12476 }
12477 
12478 static __inline__ vector unsigned long long __ATTRS_o_ai
12479 vec_vxor(vector bool long long __a, vector unsigned long long __b) {
12480  return (vector unsigned long long)__a ^ __b;
12481 }
12482 
12483 static __inline__ vector unsigned long long __ATTRS_o_ai
12484 vec_vxor(vector unsigned long long __a, vector bool long long __b) {
12485  return __a ^ (vector unsigned long long)__b;
12486 }
12487 
12488 static __inline__ vector bool long long __ATTRS_o_ai
12489 vec_vxor(vector bool long long __a, vector bool long long __b) {
12490  return __a ^ __b;
12491 }
12492 #endif
12493 
12494 /* ------------------------ extensions for CBEA ----------------------------- */
12495 
12496 /* vec_extract */
12497 
12498 static __inline__ signed char __ATTRS_o_ai vec_extract(vector signed char __a,
12499  int __b) {
12500  return __a[__b];
12501 }
12502 
12503 static __inline__ unsigned char __ATTRS_o_ai
12504 vec_extract(vector unsigned char __a, int __b) {
12505  return __a[__b];
12506 }
12507 
12508 static __inline__ unsigned char __ATTRS_o_ai vec_extract(vector bool char __a,
12509  int __b) {
12510  return __a[__b];
12511 }
12512 
12513 static __inline__ signed short __ATTRS_o_ai vec_extract(vector signed short __a,
12514  int __b) {
12515  return __a[__b];
12516 }
12517 
12518 static __inline__ unsigned short __ATTRS_o_ai
12519 vec_extract(vector unsigned short __a, int __b) {
12520  return __a[__b];
12521 }
12522 
12523 static __inline__ unsigned short __ATTRS_o_ai vec_extract(vector bool short __a,
12524  int __b) {
12525  return __a[__b];
12526 }
12527 
12528 static __inline__ signed int __ATTRS_o_ai vec_extract(vector signed int __a,
12529  int __b) {
12530  return __a[__b];
12531 }
12532 
12533 static __inline__ unsigned int __ATTRS_o_ai vec_extract(vector unsigned int __a,
12534  int __b) {
12535  return __a[__b];
12536 }
12537 
12538 static __inline__ unsigned int __ATTRS_o_ai vec_extract(vector bool int __a,
12539  int __b) {
12540  return __a[__b];
12541 }
12542 
12543 #ifdef __VSX__
12544 static __inline__ signed long long __ATTRS_o_ai
12545 vec_extract(vector signed long long __a, int __b) {
12546  return __a[__b];
12547 }
12548 
12549 static __inline__ unsigned long long __ATTRS_o_ai
12550 vec_extract(vector unsigned long long __a, int __b) {
12551  return __a[__b];
12552 }
12553 
12554 static __inline__ unsigned long long __ATTRS_o_ai
12555 vec_extract(vector bool long long __a, int __b) {
12556  return __a[__b];
12557 }
12558 
12559 static __inline__ double __ATTRS_o_ai vec_extract(vector double __a, int __b) {
12560  return __a[__b];
12561 }
12562 #endif
12563 
12564 static __inline__ float __ATTRS_o_ai vec_extract(vector float __a, int __b) {
12565  return __a[__b];
12566 }
12567 
12568 #ifdef __POWER9_VECTOR__
12569 
12570 #define vec_insert4b __builtin_vsx_insertword
12571 #define vec_extract4b __builtin_vsx_extractuword
12572 
12573 /* vec_extract_exp */
12574 
12575 static __inline__ vector unsigned int __ATTRS_o_ai
12576 vec_extract_exp(vector float __a) {
12577  return __builtin_vsx_xvxexpsp(__a);
12578 }
12579 
12580 static __inline__ vector unsigned long long __ATTRS_o_ai
12581 vec_extract_exp(vector double __a) {
12582  return __builtin_vsx_xvxexpdp(__a);
12583 }
12584 
12585 /* vec_extract_sig */
12586 
12587 static __inline__ vector unsigned int __ATTRS_o_ai
12588 vec_extract_sig(vector float __a) {
12589  return __builtin_vsx_xvxsigsp(__a);
12590 }
12591 
12592 static __inline__ vector unsigned long long __ATTRS_o_ai
12593 vec_extract_sig (vector double __a) {
12594  return __builtin_vsx_xvxsigdp(__a);
12595 }
12596 
12597 static __inline__ vector float __ATTRS_o_ai
12598 vec_extract_fp32_from_shorth(vector unsigned short __a) {
12599  vector unsigned short __b =
12600 #ifdef __LITTLE_ENDIAN__
12601  __builtin_shufflevector(__a, __a, 0, -1, 1, -1, 2, -1, 3, -1);
12602 #else
12603  __builtin_shufflevector(__a, __a, -1, 0, -1, 1, -1, 2, -1, 3);
12604 #endif
12605  return __builtin_vsx_xvcvhpsp(__b);
12606 }
12607 
12608 static __inline__ vector float __ATTRS_o_ai
12609 vec_extract_fp32_from_shortl(vector unsigned short __a) {
12610  vector unsigned short __b =
12611 #ifdef __LITTLE_ENDIAN__
12612  __builtin_shufflevector(__a, __a, 4, -1, 5, -1, 6, -1, 7, -1);
12613 #else
12614  __builtin_shufflevector(__a, __a, -1, 4, -1, 5, -1, 6, -1, 7);
12615 #endif
12616  return __builtin_vsx_xvcvhpsp(__b);
12617 }
12618 #endif /* __POWER9_VECTOR__ */
12619 
12620 /* vec_insert */
12621 
12622 static __inline__ vector signed char __ATTRS_o_ai
12623 vec_insert(signed char __a, vector signed char __b, int __c) {
12624  __b[__c] = __a;
12625  return __b;
12626 }
12627 
12628 static __inline__ vector unsigned char __ATTRS_o_ai
12629 vec_insert(unsigned char __a, vector unsigned char __b, int __c) {
12630  __b[__c] = __a;
12631  return __b;
12632 }
12633 
12634 static __inline__ vector bool char __ATTRS_o_ai vec_insert(unsigned char __a,
12635  vector bool char __b,
12636  int __c) {
12637  __b[__c] = __a;
12638  return __b;
12639 }
12640 
12641 static __inline__ vector signed short __ATTRS_o_ai
12642 vec_insert(signed short __a, vector signed short __b, int __c) {
12643  __b[__c] = __a;
12644  return __b;
12645 }
12646 
12647 static __inline__ vector unsigned short __ATTRS_o_ai
12648 vec_insert(unsigned short __a, vector unsigned short __b, int __c) {
12649  __b[__c] = __a;
12650  return __b;
12651 }
12652 
12653 static __inline__ vector bool short __ATTRS_o_ai
12654 vec_insert(unsigned short __a, vector bool short __b, int __c) {
12655  __b[__c] = __a;
12656  return __b;
12657 }
12658 
12659 static __inline__ vector signed int __ATTRS_o_ai
12660 vec_insert(signed int __a, vector signed int __b, int __c) {
12661  __b[__c] = __a;
12662  return __b;
12663 }
12664 
12665 static __inline__ vector unsigned int __ATTRS_o_ai
12666 vec_insert(unsigned int __a, vector unsigned int __b, int __c) {
12667  __b[__c] = __a;
12668  return __b;
12669 }
12670 
12671 static __inline__ vector bool int __ATTRS_o_ai vec_insert(unsigned int __a,
12672  vector bool int __b,
12673  int __c) {
12674  __b[__c] = __a;
12675  return __b;
12676 }
12677 
12678 #ifdef __VSX__
12679 static __inline__ vector signed long long __ATTRS_o_ai
12680 vec_insert(signed long long __a, vector signed long long __b, int __c) {
12681  __b[__c] = __a;
12682  return __b;
12683 }
12684 
12685 static __inline__ vector unsigned long long __ATTRS_o_ai
12686 vec_insert(unsigned long long __a, vector unsigned long long __b, int __c) {
12687  __b[__c] = __a;
12688  return __b;
12689 }
12690 
12691 static __inline__ vector bool long long __ATTRS_o_ai
12692 vec_insert(unsigned long long __a, vector bool long long __b, int __c) {
12693  __b[__c] = __a;
12694  return __b;
12695 }
12696 static __inline__ vector double __ATTRS_o_ai vec_insert(double __a,
12697  vector double __b,
12698  int __c) {
12699  __b[__c] = __a;
12700  return __b;
12701 }
12702 #endif
12703 
12704 static __inline__ vector float __ATTRS_o_ai vec_insert(float __a,
12705  vector float __b,
12706  int __c) {
12707  __b[__c] = __a;
12708  return __b;
12709 }
12710 
12711 /* vec_lvlx */
12712 
12713 static __inline__ vector signed char __ATTRS_o_ai
12714 vec_lvlx(int __a, const signed char *__b) {
12715  return vec_perm(vec_ld(__a, __b), (vector signed char)(0),
12716  vec_lvsl(__a, __b));
12717 }
12718 
12719 static __inline__ vector signed char __ATTRS_o_ai
12720 vec_lvlx(int __a, const vector signed char *__b) {
12721  return vec_perm(vec_ld(__a, __b), (vector signed char)(0),
12722  vec_lvsl(__a, (unsigned char *)__b));
12723 }
12724 
12725 static __inline__ vector unsigned char __ATTRS_o_ai
12726 vec_lvlx(int __a, const unsigned char *__b) {
12727  return vec_perm(vec_ld(__a, __b), (vector unsigned char)(0),
12728  vec_lvsl(__a, __b));
12729 }
12730 
12731 static __inline__ vector unsigned char __ATTRS_o_ai
12732 vec_lvlx(int __a, const vector unsigned char *__b) {
12733  return vec_perm(vec_ld(__a, __b), (vector unsigned char)(0),
12734  vec_lvsl(__a, (unsigned char *)__b));
12735 }
12736 
12737 static __inline__ vector bool char __ATTRS_o_ai
12738 vec_lvlx(int __a, const vector bool char *__b) {
12739  return vec_perm(vec_ld(__a, __b), (vector bool char)(0),
12740  vec_lvsl(__a, (unsigned char *)__b));
12741 }
12742 
12743 static __inline__ vector short __ATTRS_o_ai vec_lvlx(int __a,
12744  const short *__b) {
12745  return vec_perm(vec_ld(__a, __b), (vector short)(0), vec_lvsl(__a, __b));
12746 }
12747 
12748 static __inline__ vector short __ATTRS_o_ai vec_lvlx(int __a,
12749  const vector short *__b) {
12750  return vec_perm(vec_ld(__a, __b), (vector short)(0),
12751  vec_lvsl(__a, (unsigned char *)__b));
12752 }
12753 
12754 static __inline__ vector unsigned short __ATTRS_o_ai
12755 vec_lvlx(int __a, const unsigned short *__b) {
12756  return vec_perm(vec_ld(__a, __b), (vector unsigned short)(0),
12757  vec_lvsl(__a, __b));
12758 }
12759 
12760 static __inline__ vector unsigned short __ATTRS_o_ai
12761 vec_lvlx(int __a, const vector unsigned short *__b) {
12762  return vec_perm(vec_ld(__a, __b), (vector unsigned short)(0),
12763  vec_lvsl(__a, (unsigned char *)__b));
12764 }
12765 
12766 static __inline__ vector bool short __ATTRS_o_ai
12767 vec_lvlx(int __a, const vector bool short *__b) {
12768  return vec_perm(vec_ld(__a, __b), (vector bool short)(0),
12769  vec_lvsl(__a, (unsigned char *)__b));
12770 }
12771 
12772 static __inline__ vector pixel __ATTRS_o_ai vec_lvlx(int __a,
12773  const vector pixel *__b) {
12774  return vec_perm(vec_ld(__a, __b), (vector pixel)(0),
12775  vec_lvsl(__a, (unsigned char *)__b));
12776 }
12777 
12778 static __inline__ vector int __ATTRS_o_ai vec_lvlx(int __a, const int *__b) {
12779  return vec_perm(vec_ld(__a, __b), (vector int)(0), vec_lvsl(__a, __b));
12780 }
12781 
12782 static __inline__ vector int __ATTRS_o_ai vec_lvlx(int __a,
12783  const vector int *__b) {
12784  return vec_perm(vec_ld(__a, __b), (vector int)(0),
12785  vec_lvsl(__a, (unsigned char *)__b));
12786 }
12787 
12788 static __inline__ vector unsigned int __ATTRS_o_ai
12789 vec_lvlx(int __a, const unsigned int *__b) {
12790  return vec_perm(vec_ld(__a, __b), (vector unsigned int)(0),
12791  vec_lvsl(__a, __b));
12792 }
12793 
12794 static __inline__ vector unsigned int __ATTRS_o_ai
12795 vec_lvlx(int __a, const vector unsigned int *__b) {
12796  return vec_perm(vec_ld(__a, __b), (vector unsigned int)(0),
12797  vec_lvsl(__a, (unsigned char *)__b));
12798 }
12799 
12800 static __inline__ vector bool int __ATTRS_o_ai
12801 vec_lvlx(int __a, const vector bool int *__b) {
12802  return vec_perm(vec_ld(__a, __b), (vector bool int)(0),
12803  vec_lvsl(__a, (unsigned char *)__b));
12804 }
12805 
12806 static __inline__ vector float __ATTRS_o_ai vec_lvlx(int __a,
12807  const float *__b) {
12808  return vec_perm(vec_ld(__a, __b), (vector float)(0), vec_lvsl(__a, __b));
12809 }
12810 
12811 static __inline__ vector float __ATTRS_o_ai vec_lvlx(int __a,
12812  const vector float *__b) {
12813  return vec_perm(vec_ld(__a, __b), (vector float)(0),
12814  vec_lvsl(__a, (unsigned char *)__b));
12815 }
12816 
12817 /* vec_lvlxl */
12818 
12819 static __inline__ vector signed char __ATTRS_o_ai
12820 vec_lvlxl(int __a, const signed char *__b) {
12821  return vec_perm(vec_ldl(__a, __b), (vector signed char)(0),
12822  vec_lvsl(__a, __b));
12823 }
12824 
12825 static __inline__ vector signed char __ATTRS_o_ai
12826 vec_lvlxl(int __a, const vector signed char *__b) {
12827  return vec_perm(vec_ldl(__a, __b), (vector signed char)(0),
12828  vec_lvsl(__a, (unsigned char *)__b));
12829 }
12830 
12831 static __inline__ vector unsigned char __ATTRS_o_ai
12832 vec_lvlxl(int __a, const unsigned char *__b) {
12833  return vec_perm(vec_ldl(__a, __b), (vector unsigned char)(0),
12834  vec_lvsl(__a, __b));
12835 }
12836 
12837 static __inline__ vector unsigned char __ATTRS_o_ai
12838 vec_lvlxl(int __a, const vector unsigned char *__b) {
12839  return vec_perm(vec_ldl(__a, __b), (vector unsigned char)(0),
12840  vec_lvsl(__a, (unsigned char *)__b));
12841 }
12842 
12843 static __inline__ vector bool char __ATTRS_o_ai
12844 vec_lvlxl(int __a, const vector bool char *__b) {
12845  return vec_perm(vec_ldl(__a, __b), (vector bool char)(0),
12846  vec_lvsl(__a, (unsigned char *)__b));
12847 }
12848 
12849 static __inline__ vector short __ATTRS_o_ai vec_lvlxl(int __a,
12850  const short *__b) {
12851  return vec_perm(vec_ldl(__a, __b), (vector short)(0), vec_lvsl(__a, __b));
12852 }
12853 
12854 static __inline__ vector short __ATTRS_o_ai vec_lvlxl(int __a,
12855  const vector short *__b) {
12856  return vec_perm(vec_ldl(__a, __b), (vector short)(0),
12857  vec_lvsl(__a, (unsigned char *)__b));
12858 }
12859 
12860 static __inline__ vector unsigned short __ATTRS_o_ai
12861 vec_lvlxl(int __a, const unsigned short *__b) {
12862  return vec_perm(vec_ldl(__a, __b), (vector unsigned short)(0),
12863  vec_lvsl(__a, __b));
12864 }
12865 
12866 static __inline__ vector unsigned short __ATTRS_o_ai
12867 vec_lvlxl(int __a, const vector unsigned short *__b) {
12868  return vec_perm(vec_ldl(__a, __b), (vector unsigned short)(0),
12869  vec_lvsl(__a, (unsigned char *)__b));
12870 }
12871 
12872 static __inline__ vector bool short __ATTRS_o_ai
12873 vec_lvlxl(int __a, const vector bool short *__b) {
12874  return vec_perm(vec_ldl(__a, __b), (vector bool short)(0),
12875  vec_lvsl(__a, (unsigned char *)__b));
12876 }
12877 
12878 static __inline__ vector pixel __ATTRS_o_ai vec_lvlxl(int __a,
12879  const vector pixel *__b) {
12880  return vec_perm(vec_ldl(__a, __b), (vector pixel)(0),
12881  vec_lvsl(__a, (unsigned char *)__b));
12882 }
12883 
12884 static __inline__ vector int __ATTRS_o_ai vec_lvlxl(int __a, const int *__b) {
12885  return vec_perm(vec_ldl(__a, __b), (vector int)(0), vec_lvsl(__a, __b));
12886 }
12887 
12888 static __inline__ vector int __ATTRS_o_ai vec_lvlxl(int __a,
12889  const vector int *__b) {
12890  return vec_perm(vec_ldl(__a, __b), (vector int)(0),
12891  vec_lvsl(__a, (unsigned char *)__b));
12892 }
12893 
12894 static __inline__ vector unsigned int __ATTRS_o_ai
12895 vec_lvlxl(int __a, const unsigned int *__b) {
12896  return vec_perm(vec_ldl(__a, __b), (vector unsigned int)(0),
12897  vec_lvsl(__a, __b));
12898 }
12899 
12900 static __inline__ vector unsigned int __ATTRS_o_ai
12901 vec_lvlxl(int __a, const vector unsigned int *__b) {
12902  return vec_perm(vec_ldl(__a, __b), (vector unsigned int)(0),
12903  vec_lvsl(__a, (unsigned char *)__b));
12904 }
12905 
12906 static __inline__ vector bool int __ATTRS_o_ai
12907 vec_lvlxl(int __a, const vector bool int *__b) {
12908  return vec_perm(vec_ldl(__a, __b), (vector bool int)(0),
12909  vec_lvsl(__a, (unsigned char *)__b));
12910 }
12911 
12912 static __inline__ vector float __ATTRS_o_ai vec_lvlxl(int __a,
12913  const float *__b) {
12914  return vec_perm(vec_ldl(__a, __b), (vector float)(0), vec_lvsl(__a, __b));
12915 }
12916 
12917 static __inline__ vector float __ATTRS_o_ai vec_lvlxl(int __a,
12918  vector float *__b) {
12919  return vec_perm(vec_ldl(__a, __b), (vector float)(0),
12920  vec_lvsl(__a, (unsigned char *)__b));
12921 }
12922 
12923 /* vec_lvrx */
12924 
12925 static __inline__ vector signed char __ATTRS_o_ai
12926 vec_lvrx(int __a, const signed char *__b) {
12927  return vec_perm((vector signed char)(0), vec_ld(__a, __b),
12928  vec_lvsl(__a, __b));
12929 }
12930 
12931 static __inline__ vector signed char __ATTRS_o_ai
12932 vec_lvrx(int __a, const vector signed char *__b) {
12933  return vec_perm((vector signed char)(0), vec_ld(__a, __b),
12934  vec_lvsl(__a, (unsigned char *)__b));
12935 }
12936 
12937 static __inline__ vector unsigned char __ATTRS_o_ai
12938 vec_lvrx(int __a, const unsigned char *__b) {
12939  return vec_perm((vector unsigned char)(0), vec_ld(__a, __b),
12940  vec_lvsl(__a, __b));
12941 }
12942 
12943 static __inline__ vector unsigned char __ATTRS_o_ai
12944 vec_lvrx(int __a, const vector unsigned char *__b) {
12945  return vec_perm((vector unsigned char)(0), vec_ld(__a, __b),
12946  vec_lvsl(__a, (unsigned char *)__b));
12947 }
12948 
12949 static __inline__ vector bool char __ATTRS_o_ai
12950 vec_lvrx(int __a, const vector bool char *__b) {
12951  return vec_perm((vector bool char)(0), vec_ld(__a, __b),
12952  vec_lvsl(__a, (unsigned char *)__b));
12953 }
12954 
12955 static __inline__ vector short __ATTRS_o_ai vec_lvrx(int __a,
12956  const short *__b) {
12957  return vec_perm((vector short)(0), vec_ld(__a, __b), vec_lvsl(__a, __b));
12958 }
12959 
12960 static __inline__ vector short __ATTRS_o_ai vec_lvrx(int __a,
12961  const vector short *__b) {
12962  return vec_perm((vector short)(0), vec_ld(__a, __b),
12963  vec_lvsl(__a, (unsigned char *)__b));
12964 }
12965 
12966 static __inline__ vector unsigned short __ATTRS_o_ai
12967 vec_lvrx(int __a, const unsigned short *__b) {
12968  return vec_perm((vector unsigned short)(0), vec_ld(__a, __b),
12969  vec_lvsl(__a, __b));
12970 }
12971 
12972 static __inline__ vector unsigned short __ATTRS_o_ai
12973 vec_lvrx(int __a, const vector unsigned short *__b) {
12974  return vec_perm((vector unsigned short)(0), vec_ld(__a, __b),
12975  vec_lvsl(__a, (unsigned char *)__b));
12976 }
12977 
12978 static __inline__ vector bool short __ATTRS_o_ai
12979 vec_lvrx(int __a, const vector bool short *__b) {
12980  return vec_perm((vector bool short)(0), vec_ld(__a, __b),
12981  vec_lvsl(__a, (unsigned char *)__b));
12982 }
12983 
12984 static __inline__ vector pixel __ATTRS_o_ai vec_lvrx(int __a,
12985  const vector pixel *__b) {
12986  return vec_perm((vector pixel)(0), vec_ld(__a, __b),
12987  vec_lvsl(__a, (unsigned char *)__b));
12988 }
12989 
12990 static __inline__ vector int __ATTRS_o_ai vec_lvrx(int __a, const int *__b) {
12991  return vec_perm((vector int)(0), vec_ld(__a, __b), vec_lvsl(__a, __b));
12992 }
12993 
12994 static __inline__ vector int __ATTRS_o_ai vec_lvrx(int __a,
12995  const vector int *__b) {
12996  return vec_perm((vector int)(0), vec_ld(__a, __b),
12997  vec_lvsl(__a, (unsigned char *)__b));
12998 }
12999 
13000 static __inline__ vector unsigned int __ATTRS_o_ai
13001 vec_lvrx(int __a, const unsigned int *__b) {
13002  return vec_perm((vector unsigned int)(0), vec_ld(__a, __b),
13003  vec_lvsl(__a, __b));
13004 }
13005 
13006 static __inline__ vector unsigned int __ATTRS_o_ai
13007 vec_lvrx(int __a, const vector unsigned int *__b) {
13008  return vec_perm((vector unsigned int)(0), vec_ld(__a, __b),
13009  vec_lvsl(__a, (unsigned char *)__b));
13010 }
13011 
13012 static __inline__ vector bool int __ATTRS_o_ai
13013 vec_lvrx(int __a, const vector bool int *__b) {
13014  return vec_perm((vector bool int)(0), vec_ld(__a, __b),
13015  vec_lvsl(__a, (unsigned char *)__b));
13016 }
13017 
13018 static __inline__ vector float __ATTRS_o_ai vec_lvrx(int __a,
13019  const float *__b) {
13020  return vec_perm((vector float)(0), vec_ld(__a, __b), vec_lvsl(__a, __b));
13021 }
13022 
13023 static __inline__ vector float __ATTRS_o_ai vec_lvrx(int __a,
13024  const vector float *__b) {
13025  return vec_perm((vector float)(0), vec_ld(__a, __b),
13026  vec_lvsl(__a, (unsigned char *)__b));
13027 }
13028 
13029 /* vec_lvrxl */
13030 
13031 static __inline__ vector signed char __ATTRS_o_ai
13032 vec_lvrxl(int __a, const signed char *__b) {
13033  return vec_perm((vector signed char)(0), vec_ldl(__a, __b),
13034  vec_lvsl(__a, __b));
13035 }
13036 
13037 static __inline__ vector signed char __ATTRS_o_ai
13038 vec_lvrxl(int __a, const vector signed char *__b) {
13039  return vec_perm((vector signed char)(0), vec_ldl(__a, __b),
13040  vec_lvsl(__a, (unsigned char *)__b));
13041 }
13042 
13043 static __inline__ vector unsigned char __ATTRS_o_ai
13044 vec_lvrxl(int __a, const unsigned char *__b) {
13045  return vec_perm((vector unsigned char)(0), vec_ldl(__a, __b),
13046  vec_lvsl(__a, __b));
13047 }
13048 
13049 static __inline__ vector unsigned char __ATTRS_o_ai
13050 vec_lvrxl(int __a, const vector unsigned char *__b) {
13051  return vec_perm((vector unsigned char)(0), vec_ldl(__a, __b),
13052  vec_lvsl(__a, (unsigned char *)__b));
13053 }
13054 
13055 static __inline__ vector bool char __ATTRS_o_ai
13056 vec_lvrxl(int __a, const vector bool char *__b) {
13057  return vec_perm((vector bool char)(0), vec_ldl(__a, __b),
13058  vec_lvsl(__a, (unsigned char *)__b));
13059 }
13060 
13061 static __inline__ vector short __ATTRS_o_ai vec_lvrxl(int __a,
13062  const short *__b) {
13063  return vec_perm((vector short)(0), vec_ldl(__a, __b), vec_lvsl(__a, __b));
13064 }
13065 
13066 static __inline__ vector short __ATTRS_o_ai vec_lvrxl(int __a,
13067  const vector short *__b) {
13068  return vec_perm((vector short)(0), vec_ldl(__a, __b),
13069  vec_lvsl(__a, (unsigned char *)__b));
13070 }
13071 
13072 static __inline__ vector unsigned short __ATTRS_o_ai
13073 vec_lvrxl(int __a, const unsigned short *__b) {
13074  return vec_perm((vector unsigned short)(0), vec_ldl(__a, __b),
13075  vec_lvsl(__a, __b));
13076 }
13077 
13078 static __inline__ vector unsigned short __ATTRS_o_ai
13079 vec_lvrxl(int __a, const vector unsigned short *__b) {
13080  return vec_perm((vector unsigned short)(0), vec_ldl(__a, __b),
13081  vec_lvsl(__a, (unsigned char *)__b));
13082 }
13083 
13084 static __inline__ vector bool short __ATTRS_o_ai
13085 vec_lvrxl(int __a, const vector bool short *__b) {
13086  return vec_perm((vector bool short)(0), vec_ldl(__a, __b),
13087  vec_lvsl(__a, (unsigned char *)__b));
13088 }
13089 
13090 static __inline__ vector pixel __ATTRS_o_ai vec_lvrxl(int __a,
13091  const vector pixel *__b) {
13092  return vec_perm((vector pixel)(0), vec_ldl(__a, __b),
13093  vec_lvsl(__a, (unsigned char *)__b));
13094 }
13095 
13096 static __inline__ vector int __ATTRS_o_ai vec_lvrxl(int __a, const int *__b) {
13097  return vec_perm((vector int)(0), vec_ldl(__a, __b), vec_lvsl(__a, __b));
13098 }
13099 
13100 static __inline__ vector int __ATTRS_o_ai vec_lvrxl(int __a,
13101  const vector int *__b) {
13102  return vec_perm((vector int)(0), vec_ldl(__a, __b),
13103  vec_lvsl(__a, (unsigned char *)__b));
13104 }
13105 
13106 static __inline__ vector unsigned int __ATTRS_o_ai
13107 vec_lvrxl(int __a, const unsigned int *__b) {
13108  return vec_perm((vector unsigned int)(0), vec_ldl(__a, __b),
13109  vec_lvsl(__a, __b));
13110 }
13111 
13112 static __inline__ vector unsigned int __ATTRS_o_ai
13113 vec_lvrxl(int __a, const vector unsigned int *__b) {
13114  return vec_perm((vector unsigned int)(0), vec_ldl(__a, __b),
13115  vec_lvsl(__a, (unsigned char *)__b));
13116 }
13117 
13118 static __inline__ vector bool int __ATTRS_o_ai
13119 vec_lvrxl(int __a, const vector bool int *__b) {
13120  return vec_perm((vector bool int)(0), vec_ldl(__a, __b),
13121  vec_lvsl(__a, (unsigned char *)__b));
13122 }
13123 
13124 static __inline__ vector float __ATTRS_o_ai vec_lvrxl(int __a,
13125  const float *__b) {
13126  return vec_perm((vector float)(0), vec_ldl(__a, __b), vec_lvsl(__a, __b));
13127 }
13128 
13129 static __inline__ vector float __ATTRS_o_ai vec_lvrxl(int __a,
13130  const vector float *__b) {
13131  return vec_perm((vector float)(0), vec_ldl(__a, __b),
13132  vec_lvsl(__a, (unsigned char *)__b));
13133 }
13134 
13135 /* vec_stvlx */
13136 
13137 static __inline__ void __ATTRS_o_ai vec_stvlx(vector signed char __a, int __b,
13138  signed char *__c) {
13139  return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13140  __c);
13141 }
13142 
13143 static __inline__ void __ATTRS_o_ai vec_stvlx(vector signed char __a, int __b,
13144  vector signed char *__c) {
13145  return vec_st(
13146  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13147  __b, __c);
13148 }
13149 
13150 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned char __a, int __b,
13151  unsigned char *__c) {
13152  return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13153  __c);
13154 }
13155 
13156 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned char __a, int __b,
13157  vector unsigned char *__c) {
13158  return vec_st(
13159  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13160  __b, __c);
13161 }
13162 
13163 static __inline__ void __ATTRS_o_ai vec_stvlx(vector bool char __a, int __b,
13164  vector bool char *__c) {
13165  return vec_st(
13166  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13167  __b, __c);
13168 }
13169 
13170 static __inline__ void __ATTRS_o_ai vec_stvlx(vector short __a, int __b,
13171  short *__c) {
13172  return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13173  __c);
13174 }
13175 
13176 static __inline__ void __ATTRS_o_ai vec_stvlx(vector short __a, int __b,
13177  vector short *__c) {
13178  return vec_st(
13179  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13180  __b, __c);
13181 }
13182 
13183 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned short __a,
13184  int __b, unsigned short *__c) {
13185  return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13186  __c);
13187 }
13188 
13189 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned short __a,
13190  int __b,
13191  vector unsigned short *__c) {
13192  return vec_st(
13193  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13194  __b, __c);
13195 }
13196 
13197 static __inline__ void __ATTRS_o_ai vec_stvlx(vector bool short __a, int __b,
13198  vector bool short *__c) {
13199  return vec_st(
13200  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13201  __b, __c);
13202 }
13203 
13204 static __inline__ void __ATTRS_o_ai vec_stvlx(vector pixel __a, int __b,
13205  vector pixel *__c) {
13206  return vec_st(
13207  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13208  __b, __c);
13209 }
13210 
13211 static __inline__ void __ATTRS_o_ai vec_stvlx(vector int __a, int __b,
13212  int *__c) {
13213  return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13214  __c);
13215 }
13216 
13217 static __inline__ void __ATTRS_o_ai vec_stvlx(vector int __a, int __b,
13218  vector int *__c) {
13219  return vec_st(
13220  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13221  __b, __c);
13222 }
13223 
13224 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned int __a, int __b,
13225  unsigned int *__c) {
13226  return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13227  __c);
13228 }
13229 
13230 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned int __a, int __b,
13231  vector unsigned int *__c) {
13232  return vec_st(
13233  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13234  __b, __c);
13235 }
13236 
13237 static __inline__ void __ATTRS_o_ai vec_stvlx(vector bool int __a, int __b,
13238  vector bool int *__c) {
13239  return vec_st(
13240  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13241  __b, __c);
13242 }
13243 
13244 static __inline__ void __ATTRS_o_ai vec_stvlx(vector float __a, int __b,
13245  vector float *__c) {
13246  return vec_st(
13247  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13248  __b, __c);
13249 }
13250 
13251 /* vec_stvlxl */
13252 
13253 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector signed char __a, int __b,
13254  signed char *__c) {
13255  return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13256  __c);
13257 }
13258 
13259 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector signed char __a, int __b,
13260  vector signed char *__c) {
13261  return vec_stl(
13262  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13263  __b, __c);
13264 }
13265 
13266 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned char __a,
13267  int __b, unsigned char *__c) {
13268  return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13269  __c);
13270 }
13271 
13272 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned char __a,
13273  int __b,
13274  vector unsigned char *__c) {
13275  return vec_stl(
13276  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13277  __b, __c);
13278 }
13279 
13280 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector bool char __a, int __b,
13281  vector bool char *__c) {
13282  return vec_stl(
13283  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13284  __b, __c);
13285 }
13286 
13287 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector short __a, int __b,
13288  short *__c) {
13289  return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13290  __c);
13291 }
13292 
13293 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector short __a, int __b,
13294  vector short *__c) {
13295  return vec_stl(
13296  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13297  __b, __c);
13298 }
13299 
13300 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned short __a,
13301  int __b, unsigned short *__c) {
13302  return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13303  __c);
13304 }
13305 
13306 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned short __a,
13307  int __b,
13308  vector unsigned short *__c) {
13309  return vec_stl(
13310  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13311  __b, __c);
13312 }
13313 
13314 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector bool short __a, int __b,
13315  vector bool short *__c) {
13316  return vec_stl(
13317  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13318  __b, __c);
13319 }
13320 
13321 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector pixel __a, int __b,
13322  vector pixel *__c) {
13323  return vec_stl(
13324  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13325  __b, __c);
13326 }
13327 
13328 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector int __a, int __b,
13329  int *__c) {
13330  return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13331  __c);
13332 }
13333 
13334 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector int __a, int __b,
13335  vector int *__c) {
13336  return vec_stl(
13337  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13338  __b, __c);
13339 }
13340 
13341 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned int __a, int __b,
13342  unsigned int *__c) {
13343  return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
13344  __c);
13345 }
13346 
13347 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned int __a, int __b,
13348  vector unsigned int *__c) {
13349  return vec_stl(
13350  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13351  __b, __c);
13352 }
13353 
13354 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector bool int __a, int __b,
13355  vector bool int *__c) {
13356  return vec_stl(
13357  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13358  __b, __c);
13359 }
13360 
13361 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector float __a, int __b,
13362  vector float *__c) {
13363  return vec_stl(
13364  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
13365  __b, __c);
13366 }
13367 
13368 /* vec_stvrx */
13369 
13370 static __inline__ void __ATTRS_o_ai vec_stvrx(vector signed char __a, int __b,
13371  signed char *__c) {
13372  return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13373  __c);
13374 }
13375 
13376 static __inline__ void __ATTRS_o_ai vec_stvrx(vector signed char __a, int __b,
13377  vector signed char *__c) {
13378  return vec_st(
13379  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13380  __b, __c);
13381 }
13382 
13383 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned char __a, int __b,
13384  unsigned char *__c) {
13385  return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13386  __c);
13387 }
13388 
13389 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned char __a, int __b,
13390  vector unsigned char *__c) {
13391  return vec_st(
13392  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13393  __b, __c);
13394 }
13395 
13396 static __inline__ void __ATTRS_o_ai vec_stvrx(vector bool char __a, int __b,
13397  vector bool char *__c) {
13398  return vec_st(
13399  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13400  __b, __c);
13401 }
13402 
13403 static __inline__ void __ATTRS_o_ai vec_stvrx(vector short __a, int __b,
13404  short *__c) {
13405  return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13406  __c);
13407 }
13408 
13409 static __inline__ void __ATTRS_o_ai vec_stvrx(vector short __a, int __b,
13410  vector short *__c) {
13411  return vec_st(
13412  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13413  __b, __c);
13414 }
13415 
13416 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned short __a,
13417  int __b, unsigned short *__c) {
13418  return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13419  __c);
13420 }
13421 
13422 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned short __a,
13423  int __b,
13424  vector unsigned short *__c) {
13425  return vec_st(
13426  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13427  __b, __c);
13428 }
13429 
13430 static __inline__ void __ATTRS_o_ai vec_stvrx(vector bool short __a, int __b,
13431  vector bool short *__c) {
13432  return vec_st(
13433  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13434  __b, __c);
13435 }
13436 
13437 static __inline__ void __ATTRS_o_ai vec_stvrx(vector pixel __a, int __b,
13438  vector pixel *__c) {
13439  return vec_st(
13440  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13441  __b, __c);
13442 }
13443 
13444 static __inline__ void __ATTRS_o_ai vec_stvrx(vector int __a, int __b,
13445  int *__c) {
13446  return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13447  __c);
13448 }
13449 
13450 static __inline__ void __ATTRS_o_ai vec_stvrx(vector int __a, int __b,
13451  vector int *__c) {
13452  return vec_st(
13453  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13454  __b, __c);
13455 }
13456 
13457 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned int __a, int __b,
13458  unsigned int *__c) {
13459  return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13460  __c);
13461 }
13462 
13463 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned int __a, int __b,
13464  vector unsigned int *__c) {
13465  return vec_st(
13466  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13467  __b, __c);
13468 }
13469 
13470 static __inline__ void __ATTRS_o_ai vec_stvrx(vector bool int __a, int __b,
13471  vector bool int *__c) {
13472  return vec_st(
13473  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13474  __b, __c);
13475 }
13476 
13477 static __inline__ void __ATTRS_o_ai vec_stvrx(vector float __a, int __b,
13478  vector float *__c) {
13479  return vec_st(
13480  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13481  __b, __c);
13482 }
13483 
13484 /* vec_stvrxl */
13485 
13486 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector signed char __a, int __b,
13487  signed char *__c) {
13488  return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13489  __c);
13490 }
13491 
13492 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector signed char __a, int __b,
13493  vector signed char *__c) {
13494  return vec_stl(
13495  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13496  __b, __c);
13497 }
13498 
13499 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned char __a,
13500  int __b, unsigned char *__c) {
13501  return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13502  __c);
13503 }
13504 
13505 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned char __a,
13506  int __b,
13507  vector unsigned char *__c) {
13508  return vec_stl(
13509  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13510  __b, __c);
13511 }
13512 
13513 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector bool char __a, int __b,
13514  vector bool char *__c) {
13515  return vec_stl(
13516  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13517  __b, __c);
13518 }
13519 
13520 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector short __a, int __b,
13521  short *__c) {
13522  return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13523  __c);
13524 }
13525 
13526 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector short __a, int __b,
13527  vector short *__c) {
13528  return vec_stl(
13529  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13530  __b, __c);
13531 }
13532 
13533 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned short __a,
13534  int __b, unsigned short *__c) {
13535  return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13536  __c);
13537 }
13538 
13539 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned short __a,
13540  int __b,
13541  vector unsigned short *__c) {
13542  return vec_stl(
13543  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13544  __b, __c);
13545 }
13546 
13547 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector bool short __a, int __b,
13548  vector bool short *__c) {
13549  return vec_stl(
13550  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13551  __b, __c);
13552 }
13553 
13554 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector pixel __a, int __b,
13555  vector pixel *__c) {
13556  return vec_stl(
13557  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13558  __b, __c);
13559 }
13560 
13561 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector int __a, int __b,
13562  int *__c) {
13563  return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13564  __c);
13565 }
13566 
13567 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector int __a, int __b,
13568  vector int *__c) {
13569  return vec_stl(
13570  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13571  __b, __c);
13572 }
13573 
13574 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned int __a, int __b,
13575  unsigned int *__c) {
13576  return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
13577  __c);
13578 }
13579 
13580 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned int __a, int __b,
13581  vector unsigned int *__c) {
13582  return vec_stl(
13583  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13584  __b, __c);
13585 }
13586 
13587 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector bool int __a, int __b,
13588  vector bool int *__c) {
13589  return vec_stl(
13590  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13591  __b, __c);
13592 }
13593 
13594 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector float __a, int __b,
13595  vector float *__c) {
13596  return vec_stl(
13597  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
13598  __b, __c);
13599 }
13600 
13601 /* vec_promote */
13602 
13603 static __inline__ vector signed char __ATTRS_o_ai vec_promote(signed char __a,
13604  int __b) {
13605  vector signed char __res = (vector signed char)(0);
13606  __res[__b] = __a;
13607  return __res;
13608 }
13609 
13610 static __inline__ vector unsigned char __ATTRS_o_ai
13611 vec_promote(unsigned char __a, int __b) {
13612  vector unsigned char __res = (vector unsigned char)(0);
13613  __res[__b] = __a;
13614  return __res;
13615 }
13616 
13617 static __inline__ vector short __ATTRS_o_ai vec_promote(short __a, int __b) {
13618  vector short __res = (vector short)(0);
13619  __res[__b] = __a;
13620  return __res;
13621 }
13622 
13623 static __inline__ vector unsigned short __ATTRS_o_ai
13624 vec_promote(unsigned short __a, int __b) {
13625  vector unsigned short __res = (vector unsigned short)(0);
13626  __res[__b] = __a;
13627  return __res;
13628 }
13629 
13630 static __inline__ vector int __ATTRS_o_ai vec_promote(int __a, int __b) {
13631  vector int __res = (vector int)(0);
13632  __res[__b] = __a;
13633  return __res;
13634 }
13635 
13636 static __inline__ vector unsigned int __ATTRS_o_ai vec_promote(unsigned int __a,
13637  int __b) {
13638  vector unsigned int __res = (vector unsigned int)(0);
13639  __res[__b] = __a;
13640  return __res;
13641 }
13642 
13643 static __inline__ vector float __ATTRS_o_ai vec_promote(float __a, int __b) {
13644  vector float __res = (vector float)(0);
13645  __res[__b] = __a;
13646  return __res;
13647 }
13648 
13649 /* vec_splats */
13650 
13651 static __inline__ vector signed char __ATTRS_o_ai vec_splats(signed char __a) {
13652  return (vector signed char)(__a);
13653 }
13654 
13655 static __inline__ vector unsigned char __ATTRS_o_ai
13656 vec_splats(unsigned char __a) {
13657  return (vector unsigned char)(__a);
13658 }
13659 
13660 static __inline__ vector short __ATTRS_o_ai vec_splats(short __a) {
13661  return (vector short)(__a);
13662 }
13663 
13664 static __inline__ vector unsigned short __ATTRS_o_ai
13665 vec_splats(unsigned short __a) {
13666  return (vector unsigned short)(__a);
13667 }
13668 
13669 static __inline__ vector int __ATTRS_o_ai vec_splats(int __a) {
13670  return (vector int)(__a);
13671 }
13672 
13673 static __inline__ vector unsigned int __ATTRS_o_ai
13674 vec_splats(unsigned int __a) {
13675  return (vector unsigned int)(__a);
13676 }
13677 
13678 #ifdef __VSX__
13679 static __inline__ vector signed long long __ATTRS_o_ai
13680 vec_splats(signed long long __a) {
13681  return (vector signed long long)(__a);
13682 }
13683 
13684 static __inline__ vector unsigned long long __ATTRS_o_ai
13685 vec_splats(unsigned long long __a) {
13686  return (vector unsigned long long)(__a);
13687 }
13688 
13689 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
13690 static __inline__ vector signed __int128 __ATTRS_o_ai
13691 vec_splats(signed __int128 __a) {
13692  return (vector signed __int128)(__a);
13693 }
13694 
13695 static __inline__ vector unsigned __int128 __ATTRS_o_ai
13696 vec_splats(unsigned __int128 __a) {
13697  return (vector unsigned __int128)(__a);
13698 }
13699 
13700 #endif
13701 
13702 static __inline__ vector double __ATTRS_o_ai vec_splats(double __a) {
13703  return (vector double)(__a);
13704 }
13705 #endif
13706 
13707 static __inline__ vector float __ATTRS_o_ai vec_splats(float __a) {
13708  return (vector float)(__a);
13709 }
13710 
13711 /* ----------------------------- predicates --------------------------------- */
13712 
13713 /* vec_all_eq */
13714 
13715 static __inline__ int __ATTRS_o_ai vec_all_eq(vector signed char __a,
13716  vector signed char __b) {
13717  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
13718  (vector char)__b);
13719 }
13720 
13721 static __inline__ int __ATTRS_o_ai vec_all_eq(vector signed char __a,
13722  vector bool char __b) {
13723  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
13724  (vector char)__b);
13725 }
13726 
13727 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned char __a,
13728  vector unsigned 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 unsigned 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 bool char __a,
13740  vector signed 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 bool char __a,
13746  vector unsigned 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 bool 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 short __a,
13758  vector short __b) {
13759  return __builtin_altivec_vcmpequh_p(__CR6_LT, __a, __b);
13760 }
13761 
13762 static __inline__ int __ATTRS_o_ai vec_all_eq(vector short __a,
13763  vector bool short __b) {
13764  return __builtin_altivec_vcmpequh_p(__CR6_LT, __a, (vector short)__b);
13765 }
13766 
13767 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned short __a,
13768  vector unsigned short __b) {
13769  return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
13770  (vector short)__b);
13771 }
13772 
13773 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned short __a,
13774  vector bool short __b) {
13775  return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
13776  (vector short)__b);
13777 }
13778 
13779 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool short __a,
13780  vector 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 bool short __a,
13786  vector unsigned 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 bool 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 pixel __a,
13798  vector pixel __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 int __a, vector int __b) {
13804  return __builtin_altivec_vcmpequw_p(__CR6_LT, __a, __b);
13805 }
13806 
13807 static __inline__ int __ATTRS_o_ai vec_all_eq(vector int __a,
13808  vector bool int __b) {
13809  return __builtin_altivec_vcmpequw_p(__CR6_LT, __a, (vector int)__b);
13810 }
13811 
13812 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned int __a,
13813  vector unsigned int __b) {
13814  return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
13815  (vector int)__b);
13816 }
13817 
13818 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned int __a,
13819  vector bool int __b) {
13820  return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
13821  (vector int)__b);
13822 }
13823 
13824 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool int __a,
13825  vector 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 bool int __a,
13831  vector unsigned 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 bool int __b) {
13838  return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
13839  (vector int)__b);
13840 }
13841 
13842 #ifdef __POWER8_VECTOR__
13843 static __inline__ int __ATTRS_o_ai vec_all_eq(vector signed long long __a,
13844  vector signed long long __b) {
13845  return __builtin_altivec_vcmpequd_p(__CR6_LT, __a, __b);
13846 }
13847 
13848 static __inline__ int __ATTRS_o_ai vec_all_eq(vector long long __a,
13849  vector bool long long __b) {
13850  return __builtin_altivec_vcmpequd_p(__CR6_LT, __a, (vector long long)__b);
13851 }
13852 
13853 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned long long __a,
13854  vector unsigned long long __b) {
13855  return __builtin_altivec_vcmpequd_p(__CR6_LT, (vector long long)__a,
13856  (vector long long)__b);
13857 }
13858 
13859 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned long long __a,
13860  vector bool long long __b) {
13861  return __builtin_altivec_vcmpequd_p(__CR6_LT, (vector long long)__a,
13862  (vector long long)__b);
13863 }
13864 
13865 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool long long __a,
13866  vector 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 bool long long __a,
13872  vector unsigned 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 bool long long __b) {
13879  return __builtin_altivec_vcmpequd_p(__CR6_LT, (vector long long)__a,
13880  (vector long long)__b);
13881 }
13882 #endif
13883 
13884 static __inline__ int __ATTRS_o_ai vec_all_eq(vector float __a,
13885  vector float __b) {
13886 #ifdef __VSX__
13887  return __builtin_vsx_xvcmpeqsp_p(__CR6_LT, __a, __b);
13888 #else
13889  return __builtin_altivec_vcmpeqfp_p(__CR6_LT, __a, __b);
13890 #endif
13891 }
13892 
13893 #ifdef __VSX__
13894 static __inline__ int __ATTRS_o_ai vec_all_eq(vector double __a,
13895  vector double __b) {
13896  return __builtin_vsx_xvcmpeqdp_p(__CR6_LT, __a, __b);
13897 }
13898 #endif
13899 
13900 /* vec_all_ge */
13901 
13902 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed char __a,
13903  vector signed char __b) {
13904  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, __b, __a);
13905 }
13906 
13907 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed char __a,
13908  vector bool char __b) {
13909  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, (vector signed char)__b, __a);
13910 }
13911 
13912 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned char __a,
13913  vector unsigned char __b) {
13914  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __b, __a);
13915 }
13916 
13917 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned char __a,
13918  vector bool char __b) {
13919  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__b, __a);
13920 }
13921 
13922 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool char __a,
13923  vector signed char __b) {
13924  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__b,
13925  (vector unsigned char)__a);
13926 }
13927 
13928 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool char __a,
13929  vector unsigned char __b) {
13930  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __b, (vector unsigned char)__a);
13931 }
13932 
13933 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool char __a,
13934  vector bool char __b) {
13935  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__b,
13936  (vector unsigned char)__a);
13937 }
13938 
13939 static __inline__ int __ATTRS_o_ai vec_all_ge(vector short __a,
13940  vector short __b) {
13941  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, __b, __a);
13942 }
13943 
13944 static __inline__ int __ATTRS_o_ai vec_all_ge(vector short __a,
13945  vector bool short __b) {
13946  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, (vector short)__b, __a);
13947 }
13948 
13949 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned short __a,
13950  vector unsigned short __b) {
13951  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __b, __a);
13952 }
13953 
13954 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned short __a,
13955  vector bool short __b) {
13956  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__b,
13957  __a);
13958 }
13959 
13960 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool short __a,
13961  vector short __b) {
13962  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__b,
13963  (vector unsigned short)__a);
13964 }
13965 
13966 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool short __a,
13967  vector unsigned short __b) {
13968  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __b,
13969  (vector unsigned short)__a);
13970 }
13971 
13972 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool short __a,
13973  vector bool 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 int __a, vector int __b) {
13979  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, __b, __a);
13980 }
13981 
13982 static __inline__ int __ATTRS_o_ai vec_all_ge(vector int __a,
13983  vector bool int __b) {
13984  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, (vector int)__b, __a);
13985 }
13986 
13987 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned int __a,
13988  vector unsigned int __b) {
13989  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __b, __a);
13990 }
13991 
13992 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned int __a,
13993  vector bool int __b) {
13994  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__b, __a);
13995 }
13996 
13997 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool int __a,
13998  vector int __b) {
13999  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__b,
14000  (vector unsigned int)__a);
14001 }
14002 
14003 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool int __a,
14004  vector unsigned int __b) {
14005  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __b, (vector unsigned int)__a);
14006 }
14007 
14008 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool int __a,
14009  vector bool int __b) {
14010  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__b,
14011  (vector unsigned int)__a);
14012 }
14013 
14014 #ifdef __POWER8_VECTOR__
14015 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed long long __a,
14016  vector signed long long __b) {
14017  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, __b, __a);
14018 }
14019 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed long long __a,
14020  vector bool long long __b) {
14021  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, (vector signed long long)__b,
14022  __a);
14023 }
14024 
14025 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned long long __a,
14026  vector unsigned long long __b) {
14027  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __b, __a);
14028 }
14029 
14030 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned long long __a,
14031  vector bool long long __b) {
14032  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__b,
14033  __a);
14034 }
14035 
14036 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool long long __a,
14037  vector signed long long __b) {
14038  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__b,
14039  (vector unsigned long long)__a);
14040 }
14041 
14042 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool long long __a,
14043  vector unsigned long long __b) {
14044  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __b,
14045  (vector unsigned long long)__a);
14046 }
14047 
14048 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool long long __a,
14049  vector bool long long __b) {
14050  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__b,
14051  (vector unsigned long long)__a);
14052 }
14053 #endif
14054 
14055 static __inline__ int __ATTRS_o_ai vec_all_ge(vector float __a,
14056  vector float __b) {
14057 #ifdef __VSX__
14058  return __builtin_vsx_xvcmpgesp_p(__CR6_LT, __a, __b);
14059 #else
14060  return __builtin_altivec_vcmpgefp_p(__CR6_LT, __a, __b);
14061 #endif
14062 }
14063 
14064 #ifdef __VSX__
14065 static __inline__ int __ATTRS_o_ai vec_all_ge(vector double __a,
14066  vector double __b) {
14067  return __builtin_vsx_xvcmpgedp_p(__CR6_LT, __a, __b);
14068 }
14069 #endif
14070 
14071 /* vec_all_gt */
14072 
14073 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed char __a,
14074  vector signed char __b) {
14075  return __builtin_altivec_vcmpgtsb_p(__CR6_LT, __a, __b);
14076 }
14077 
14078 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed char __a,
14079  vector bool char __b) {
14080  return __builtin_altivec_vcmpgtsb_p(__CR6_LT, __a, (vector signed char)__b);
14081 }
14082 
14083 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned char __a,
14084  vector unsigned char __b) {
14085  return __builtin_altivec_vcmpgtub_p(__CR6_LT, __a, __b);
14086 }
14087 
14088 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned char __a,
14089  vector bool char __b) {
14090  return __builtin_altivec_vcmpgtub_p(__CR6_LT, __a, (vector unsigned char)__b);
14091 }
14092 
14093 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool char __a,
14094  vector signed char __b) {
14095  return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__a,
14096  (vector unsigned char)__b);
14097 }
14098 
14099 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool char __a,
14100  vector unsigned char __b) {
14101  return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__a, __b);
14102 }
14103 
14104 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool char __a,
14105  vector bool char __b) {
14106  return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__a,
14107  (vector unsigned char)__b);
14108 }
14109 
14110 static __inline__ int __ATTRS_o_ai vec_all_gt(vector short __a,
14111  vector short __b) {
14112  return __builtin_altivec_vcmpgtsh_p(__CR6_LT, __a, __b);
14113 }
14114 
14115 static __inline__ int __ATTRS_o_ai vec_all_gt(vector short __a,
14116  vector bool short __b) {
14117  return __builtin_altivec_vcmpgtsh_p(__CR6_LT, __a, (vector short)__b);
14118 }
14119 
14120 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned short __a,
14121  vector unsigned short __b) {
14122  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __a, __b);
14123 }
14124 
14125 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned short __a,
14126  vector bool short __b) {
14127  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __a,
14128  (vector unsigned short)__b);
14129 }
14130 
14131 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool short __a,
14132  vector short __b) {
14133  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__a,
14134  (vector unsigned short)__b);
14135 }
14136 
14137 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool short __a,
14138  vector unsigned short __b) {
14139  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__a,
14140  __b);
14141 }
14142 
14143 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool short __a,
14144  vector bool 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 int __a, vector int __b) {
14150  return __builtin_altivec_vcmpgtsw_p(__CR6_LT, __a, __b);
14151 }
14152 
14153 static __inline__ int __ATTRS_o_ai vec_all_gt(vector int __a,
14154  vector bool int __b) {
14155  return __builtin_altivec_vcmpgtsw_p(__CR6_LT, __a, (vector int)__b);
14156 }
14157 
14158 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned int __a,
14159  vector unsigned int __b) {
14160  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __a, __b);
14161 }
14162 
14163 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned int __a,
14164  vector bool int __b) {
14165  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __a, (vector unsigned int)__b);
14166 }
14167 
14168 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool int __a,
14169  vector int __b) {
14170  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__a,
14171  (vector unsigned int)__b);
14172 }
14173 
14174 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool int __a,
14175  vector unsigned int __b) {
14176  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__a, __b);
14177 }
14178 
14179 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool int __a,
14180  vector bool int __b) {
14181  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__a,
14182  (vector unsigned int)__b);
14183 }
14184 
14185 #ifdef __POWER8_VECTOR__
14186 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed long long __a,
14187  vector signed long long __b) {
14188  return __builtin_altivec_vcmpgtsd_p(__CR6_LT, __a, __b);
14189 }
14190 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed long long __a,
14191  vector bool long long __b) {
14192  return __builtin_altivec_vcmpgtsd_p(__CR6_LT, __a,
14193  (vector signed long long)__b);
14194 }
14195 
14196 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned long long __a,
14197  vector unsigned long long __b) {
14198  return __builtin_altivec_vcmpgtud_p(__CR6_LT, __a, __b);
14199 }
14200 
14201 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned long long __a,
14202  vector bool long long __b) {
14203  return __builtin_altivec_vcmpgtud_p(__CR6_LT, __a,
14204  (vector unsigned long long)__b);
14205 }
14206 
14207 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool long long __a,
14208  vector signed long long __b) {
14209  return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__a,
14210  (vector unsigned long long)__b);
14211 }
14212 
14213 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool long long __a,
14214  vector unsigned long long __b) {
14215  return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__a,
14216  __b);
14217 }
14218 
14219 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool long long __a,
14220  vector bool long long __b) {
14221  return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__a,
14222  (vector unsigned long long)__b);
14223 }
14224 #endif
14225 
14226 static __inline__ int __ATTRS_o_ai vec_all_gt(vector float __a,
14227  vector float __b) {
14228 #ifdef __VSX__
14229  return __builtin_vsx_xvcmpgtsp_p(__CR6_LT, __a, __b);
14230 #else
14231  return __builtin_altivec_vcmpgtfp_p(__CR6_LT, __a, __b);
14232 #endif
14233 }
14234 
14235 #ifdef __VSX__
14236 static __inline__ int __ATTRS_o_ai vec_all_gt(vector double __a,
14237  vector double __b) {
14238  return __builtin_vsx_xvcmpgtdp_p(__CR6_LT, __a, __b);
14239 }
14240 #endif
14241 
14242 /* vec_all_in */
14243 
14244 static __inline__ int __attribute__((__always_inline__))
14245 vec_all_in(vector float __a, vector float __b) {
14246  return __builtin_altivec_vcmpbfp_p(__CR6_EQ, __a, __b);
14247 }
14248 
14249 /* vec_all_le */
14250 
14251 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed char __a,
14252  vector signed char __b) {
14253  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, __a, __b);
14254 }
14255 
14256 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed char __a,
14257  vector bool char __b) {
14258  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, __a, (vector signed char)__b);
14259 }
14260 
14261 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned char __a,
14262  vector unsigned char __b) {
14263  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __a, __b);
14264 }
14265 
14266 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned char __a,
14267  vector bool char __b) {
14268  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __a, (vector unsigned char)__b);
14269 }
14270 
14271 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool char __a,
14272  vector signed char __b) {
14273  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__a,
14274  (vector unsigned char)__b);
14275 }
14276 
14277 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool char __a,
14278  vector unsigned char __b) {
14279  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__a, __b);
14280 }
14281 
14282 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool char __a,
14283  vector bool char __b) {
14284  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__a,
14285  (vector unsigned char)__b);
14286 }
14287 
14288 static __inline__ int __ATTRS_o_ai vec_all_le(vector short __a,
14289  vector short __b) {
14290  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, __a, __b);
14291 }
14292 
14293 static __inline__ int __ATTRS_o_ai vec_all_le(vector short __a,
14294  vector bool short __b) {
14295  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, __a, (vector short)__b);
14296 }
14297 
14298 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned short __a,
14299  vector unsigned short __b) {
14300  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __a, __b);
14301 }
14302 
14303 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned short __a,
14304  vector bool short __b) {
14305  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __a,
14306  (vector unsigned short)__b);
14307 }
14308 
14309 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool short __a,
14310  vector short __b) {
14311  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__a,
14312  (vector unsigned short)__b);
14313 }
14314 
14315 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool short __a,
14316  vector unsigned short __b) {
14317  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__a,
14318  __b);
14319 }
14320 
14321 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool short __a,
14322  vector bool 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 int __a, vector int __b) {
14328  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, __a, __b);
14329 }
14330 
14331 static __inline__ int __ATTRS_o_ai vec_all_le(vector int __a,
14332  vector bool int __b) {
14333  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, __a, (vector int)__b);
14334 }
14335 
14336 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned int __a,
14337  vector unsigned int __b) {
14338  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __a, __b);
14339 }
14340 
14341 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned int __a,
14342  vector bool int __b) {
14343  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __a, (vector unsigned int)__b);
14344 }
14345 
14346 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool int __a,
14347  vector int __b) {
14348  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__a,
14349  (vector unsigned int)__b);
14350 }
14351 
14352 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool int __a,
14353  vector unsigned int __b) {
14354  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__a, __b);
14355 }
14356 
14357 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool int __a,
14358  vector bool int __b) {
14359  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__a,
14360  (vector unsigned int)__b);
14361 }
14362 
14363 #ifdef __POWER8_VECTOR__
14364 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed long long __a,
14365  vector signed long long __b) {
14366  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, __a, __b);
14367 }
14368 
14369 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned long long __a,
14370  vector unsigned long long __b) {
14371  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __a, __b);
14372 }
14373 
14374 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed long long __a,
14375  vector bool long long __b) {
14376  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, __a,
14377  (vector signed long long)__b);
14378 }
14379 
14380 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned long long __a,
14381  vector bool long long __b) {
14382  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __a,
14383  (vector unsigned long long)__b);
14384 }
14385 
14386 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool long long __a,
14387  vector signed long long __b) {
14388  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__a,
14389  (vector unsigned long long)__b);
14390 }
14391 
14392 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool long long __a,
14393  vector unsigned long long __b) {
14394  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__a,
14395  __b);
14396 }
14397 
14398 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool long long __a,
14399  vector bool long long __b) {
14400  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__a,
14401  (vector unsigned long long)__b);
14402 }
14403 #endif
14404 
14405 static __inline__ int __ATTRS_o_ai vec_all_le(vector float __a,
14406  vector float __b) {
14407 #ifdef __VSX__
14408  return __builtin_vsx_xvcmpgesp_p(__CR6_LT, __b, __a);
14409 #else
14410  return __builtin_altivec_vcmpgefp_p(__CR6_LT, __b, __a);
14411 #endif
14412 }
14413 
14414 #ifdef __VSX__
14415 static __inline__ int __ATTRS_o_ai vec_all_le(vector double __a,
14416  vector double __b) {
14417  return __builtin_vsx_xvcmpgedp_p(__CR6_LT, __b, __a);
14418 }
14419 #endif
14420 
14421 /* vec_all_lt */
14422 
14423 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed char __a,
14424  vector signed char __b) {
14425  return __builtin_altivec_vcmpgtsb_p(__CR6_LT, __b, __a);
14426 }
14427 
14428 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed char __a,
14429  vector bool char __b) {
14430  return __builtin_altivec_vcmpgtsb_p(__CR6_LT, (vector signed char)__b, __a);
14431 }
14432 
14433 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned char __a,
14434  vector unsigned char __b) {
14435  return __builtin_altivec_vcmpgtub_p(__CR6_LT, __b, __a);
14436 }
14437 
14438 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned char __a,
14439  vector bool char __b) {
14440  return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__b, __a);
14441 }
14442 
14443 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool char __a,
14444  vector signed char __b) {
14445  return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__b,
14446  (vector unsigned char)__a);
14447 }
14448 
14449 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool char __a,
14450  vector unsigned char __b) {
14451  return __builtin_altivec_vcmpgtub_p(__CR6_LT, __b, (vector unsigned char)__a);
14452 }
14453 
14454 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool char __a,
14455  vector bool char __b) {
14456  return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__b,
14457  (vector unsigned char)__a);
14458 }
14459 
14460 static __inline__ int __ATTRS_o_ai vec_all_lt(vector short __a,
14461  vector short __b) {
14462  return __builtin_altivec_vcmpgtsh_p(__CR6_LT, __b, __a);
14463 }
14464 
14465 static __inline__ int __ATTRS_o_ai vec_all_lt(vector short __a,
14466  vector bool short __b) {
14467  return __builtin_altivec_vcmpgtsh_p(__CR6_LT, (vector short)__b, __a);
14468 }
14469 
14470 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned short __a,
14471  vector unsigned short __b) {
14472  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __b, __a);
14473 }
14474 
14475 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned short __a,
14476  vector bool short __b) {
14477  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__b,
14478  __a);
14479 }
14480 
14481 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool short __a,
14482  vector short __b) {
14483  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__b,
14484  (vector unsigned short)__a);
14485 }
14486 
14487 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool short __a,
14488  vector unsigned short __b) {
14489  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __b,
14490  (vector unsigned short)__a);
14491 }
14492 
14493 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool short __a,
14494  vector bool 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 int __a, vector int __b) {
14500  return __builtin_altivec_vcmpgtsw_p(__CR6_LT, __b, __a);
14501 }
14502 
14503 static __inline__ int __ATTRS_o_ai vec_all_lt(vector int __a,
14504  vector bool int __b) {
14505  return __builtin_altivec_vcmpgtsw_p(__CR6_LT, (vector int)__b, __a);
14506 }
14507 
14508 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned int __a,
14509  vector unsigned int __b) {
14510  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __b, __a);
14511 }
14512 
14513 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned int __a,
14514  vector bool int __b) {
14515  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__b, __a);
14516 }
14517 
14518 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool int __a,
14519  vector int __b) {
14520  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__b,
14521  (vector unsigned int)__a);
14522 }
14523 
14524 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool int __a,
14525  vector unsigned int __b) {
14526  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __b, (vector unsigned int)__a);
14527 }
14528 
14529 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool int __a,
14530  vector bool int __b) {
14531  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__b,
14532  (vector unsigned int)__a);
14533 }
14534 
14535 #ifdef __POWER8_VECTOR__
14536 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed long long __a,
14537  vector signed long long __b) {
14538  return __builtin_altivec_vcmpgtsd_p(__CR6_LT, __b, __a);
14539 }
14540 
14541 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned long long __a,
14542  vector unsigned long long __b) {
14543  return __builtin_altivec_vcmpgtud_p(__CR6_LT, __b, __a);
14544 }
14545 
14546 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed long long __a,
14547  vector bool long long __b) {
14548  return __builtin_altivec_vcmpgtsd_p(__CR6_LT, (vector signed long long)__b,
14549  __a);
14550 }
14551 
14552 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned long long __a,
14553  vector bool long long __b) {
14554  return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__b,
14555  __a);
14556 }
14557 
14558 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool long long __a,
14559  vector signed long long __b) {
14560  return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__b,
14561  (vector unsigned long long)__a);
14562 }
14563 
14564 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool long long __a,
14565  vector unsigned long long __b) {
14566  return __builtin_altivec_vcmpgtud_p(__CR6_LT, __b,
14567  (vector unsigned long long)__a);
14568 }
14569 
14570 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool long long __a,
14571  vector bool long long __b) {
14572  return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__b,
14573  (vector unsigned long long)__a);
14574 }
14575 #endif
14576 
14577 static __inline__ int __ATTRS_o_ai vec_all_lt(vector float __a,
14578  vector float __b) {
14579 #ifdef __VSX__
14580  return __builtin_vsx_xvcmpgtsp_p(__CR6_LT, __b, __a);
14581 #else
14582  return __builtin_altivec_vcmpgtfp_p(__CR6_LT, __b, __a);
14583 #endif
14584 }
14585 
14586 #ifdef __VSX__
14587 static __inline__ int __ATTRS_o_ai vec_all_lt(vector double __a,
14588  vector double __b) {
14589  return __builtin_vsx_xvcmpgtdp_p(__CR6_LT, __b, __a);
14590 }
14591 #endif
14592 
14593 /* vec_all_nan */
14594 
14595 static __inline__ int __ATTRS_o_ai vec_all_nan(vector float __a) {
14596 #ifdef __VSX__
14597  return __builtin_vsx_xvcmpeqsp_p(__CR6_EQ, __a, __a);
14598 #else
14599  return __builtin_altivec_vcmpeqfp_p(__CR6_EQ, __a, __a);
14600 #endif
14601 }
14602 
14603 #ifdef __VSX__
14604 static __inline__ int __ATTRS_o_ai vec_all_nan(vector double __a) {
14605  return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ, __a, __a);
14606 }
14607 #endif
14608 
14609 /* vec_all_ne */
14610 
14611 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed char __a,
14612  vector signed char __b) {
14613  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
14614  (vector char)__b);
14615 }
14616 
14617 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed char __a,
14618  vector bool char __b) {
14619  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
14620  (vector char)__b);
14621 }
14622 
14623 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned char __a,
14624  vector unsigned 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 unsigned 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 bool char __a,
14636  vector signed 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 bool char __a,
14642  vector unsigned 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 bool 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 short __a,
14654  vector short __b) {
14655  return __builtin_altivec_vcmpequh_p(__CR6_EQ, __a, __b);
14656 }
14657 
14658 static __inline__ int __ATTRS_o_ai vec_all_ne(vector short __a,
14659  vector bool short __b) {
14660  return __builtin_altivec_vcmpequh_p(__CR6_EQ, __a, (vector short)__b);
14661 }
14662 
14663 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned short __a,
14664  vector unsigned short __b) {
14665  return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
14666  (vector short)__b);
14667 }
14668 
14669 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned short __a,
14670  vector bool short __b) {
14671  return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
14672  (vector short)__b);
14673 }
14674 
14675 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool short __a,
14676  vector 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 bool short __a,
14682  vector unsigned 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 bool 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 pixel __a,
14694  vector pixel __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 int __a, vector int __b) {
14700  return __builtin_altivec_vcmpequw_p(__CR6_EQ, __a, __b);
14701 }
14702 
14703 static __inline__ int __ATTRS_o_ai vec_all_ne(vector int __a,
14704  vector bool int __b) {
14705  return __builtin_altivec_vcmpequw_p(__CR6_EQ, __a, (vector int)__b);
14706 }
14707 
14708 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned int __a,
14709  vector unsigned int __b) {
14710  return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
14711  (vector int)__b);
14712 }
14713 
14714 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned int __a,
14715  vector bool int __b) {
14716  return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
14717  (vector int)__b);
14718 }
14719 
14720 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool int __a,
14721  vector 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 bool int __a,
14727  vector unsigned 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 bool int __b) {
14734  return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
14735  (vector int)__b);
14736 }
14737 
14738 #ifdef __POWER8_VECTOR__
14739 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed long long __a,
14740  vector signed long long __b) {
14741  return __builtin_altivec_vcmpequd_p(__CR6_EQ, __a, __b);
14742 }
14743 
14744 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned long long __a,
14745  vector unsigned long long __b) {
14746  return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector long long)__a,
14747  (vector long long)__b);
14748 }
14749 
14750 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed long long __a,
14751  vector bool long long __b) {
14752  return __builtin_altivec_vcmpequd_p(__CR6_EQ, __a,
14753  (vector signed long long)__b);
14754 }
14755 
14756 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned long long __a,
14757  vector bool long long __b) {
14758  return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector signed long long)__a,
14759  (vector signed long long)__b);
14760 }
14761 
14762 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool long long __a,
14763  vector signed long long __b) {
14764  return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector signed long long)__a,
14765  (vector signed long long)__b);
14766 }
14767 
14768 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool long long __a,
14769  vector unsigned 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 bool long long __b) {
14776  return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector signed long long)__a,
14777  (vector signed long long)__b);
14778 }
14779 #endif
14780 
14781 static __inline__ int __ATTRS_o_ai vec_all_ne(vector float __a,
14782  vector float __b) {
14783 #ifdef __VSX__
14784  return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ, __a, __b);
14785 #else
14786  return __builtin_altivec_vcmpeqfp_p(__CR6_EQ, __a, __b);
14787 #endif
14788 }
14789 
14790 #ifdef __VSX__
14791 static __inline__ int __ATTRS_o_ai vec_all_ne(vector double __a,
14792  vector double __b) {
14793  return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ, __a, __b);
14794 }
14795 #endif
14796 
14797 /* vec_all_nge */
14798 
14799 static __inline__ int __ATTRS_o_ai vec_all_nge(vector float __a,
14800  vector float __b) {
14801 #ifdef __VSX__
14802  return __builtin_vsx_xvcmpgesp_p(__CR6_EQ, __a, __b);
14803 #else
14804  return __builtin_altivec_vcmpgefp_p(__CR6_EQ, __a, __b);
14805 #endif
14806 }
14807 
14808 #ifdef __VSX__
14809 static __inline__ int __ATTRS_o_ai vec_all_nge(vector double __a,
14810  vector double __b) {
14811  return __builtin_vsx_xvcmpgedp_p(__CR6_EQ, __a, __b);
14812 }
14813 #endif
14814 
14815 /* vec_all_ngt */
14816 
14817 static __inline__ int __ATTRS_o_ai vec_all_ngt(vector float __a,
14818  vector float __b) {
14819 #ifdef __VSX__
14820  return __builtin_vsx_xvcmpgtsp_p(__CR6_EQ, __a, __b);
14821 #else
14822  return __builtin_altivec_vcmpgtfp_p(__CR6_EQ, __a, __b);
14823 #endif
14824 }
14825 
14826 #ifdef __VSX__
14827 static __inline__ int __ATTRS_o_ai vec_all_ngt(vector double __a,
14828  vector double __b) {
14829  return __builtin_vsx_xvcmpgtdp_p(__CR6_EQ, __a, __b);
14830 }
14831 #endif
14832 
14833 /* vec_all_nle */
14834 
14835 static __inline__ int __attribute__((__always_inline__))
14836 vec_all_nle(vector float __a, vector float __b) {
14837  return __builtin_altivec_vcmpgefp_p(__CR6_EQ, __b, __a);
14838 }
14839 
14840 /* vec_all_nlt */
14841 
14842 static __inline__ int __attribute__((__always_inline__))
14843 vec_all_nlt(vector float __a, vector float __b) {
14844  return __builtin_altivec_vcmpgtfp_p(__CR6_EQ, __b, __a);
14845 }
14846 
14847 /* vec_all_numeric */
14848 
14849 static __inline__ int __attribute__((__always_inline__))
14850 vec_all_numeric(vector float __a) {
14851  return __builtin_altivec_vcmpeqfp_p(__CR6_LT, __a, __a);
14852 }
14853 
14854 /* vec_any_eq */
14855 
14856 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed char __a,
14857  vector signed char __b) {
14858  return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
14859  (vector char)__b);
14860 }
14861 
14862 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed char __a,
14863  vector bool char __b) {
14864  return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
14865  (vector char)__b);
14866 }
14867 
14868 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned char __a,
14869  vector unsigned 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 unsigned 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 bool char __a,
14881  vector signed 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 bool char __a,
14887  vector unsigned 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 bool 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 short __a,
14899  vector short __b) {
14900  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, __a, __b);
14901 }
14902 
14903 static __inline__ int __ATTRS_o_ai vec_any_eq(vector short __a,
14904  vector bool short __b) {
14905  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, __a, (vector short)__b);
14906 }
14907 
14908 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned short __a,
14909  vector unsigned short __b) {
14910  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
14911  (vector short)__b);
14912 }
14913 
14914 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned short __a,
14915  vector bool short __b) {
14916  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
14917  (vector short)__b);
14918 }
14919 
14920 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool short __a,
14921  vector 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 bool short __a,
14927  vector unsigned 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 bool 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 pixel __a,
14939  vector pixel __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 int __a, vector int __b) {
14945  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, __a, __b);
14946 }
14947 
14948 static __inline__ int __ATTRS_o_ai vec_any_eq(vector int __a,
14949  vector bool int __b) {
14950  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, __a, (vector int)__b);
14951 }
14952 
14953 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned int __a,
14954  vector unsigned int __b) {
14955  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
14956  (vector int)__b);
14957 }
14958 
14959 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned int __a,
14960  vector bool int __b) {
14961  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
14962  (vector int)__b);
14963 }
14964 
14965 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool int __a,
14966  vector 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 bool int __a,
14972  vector unsigned 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 bool int __b) {
14979  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
14980  (vector int)__b);
14981 }
14982 
14983 #ifdef __POWER8_VECTOR__
14984 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed long long __a,
14985  vector signed long long __b) {
14986  return __builtin_altivec_vcmpequd_p(__CR6_EQ_REV, __a, __b);
14987 }
14988 
14989 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned long long __a,
14990  vector unsigned long long __b) {
14991  return __builtin_altivec_vcmpequd_p(__CR6_EQ_REV, (vector long long)__a,
14992  (vector long long)__b);
14993 }
14994 
14995 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed long long __a,
14996  vector bool long long __b) {
14997  return __builtin_altivec_vcmpequd_p(__CR6_EQ_REV, __a,
14998  (vector signed long long)__b);
14999 }
15000 
15001 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned long long __a,
15002  vector bool long long __b) {
15003  return __builtin_altivec_vcmpequd_p(
15004  __CR6_EQ_REV, (vector signed long long)__a, (vector signed long long)__b);
15005 }
15006 
15007 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool long long __a,
15008  vector signed long long __b) {
15009  return __builtin_altivec_vcmpequd_p(
15010  __CR6_EQ_REV, (vector signed long long)__a, (vector signed long long)__b);
15011 }
15012 
15013 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool long long __a,
15014  vector unsigned 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 bool 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 #endif
15025 
15026 static __inline__ int __ATTRS_o_ai vec_any_eq(vector float __a,
15027  vector float __b) {
15028 #ifdef __VSX__
15029  return __builtin_vsx_xvcmpeqsp_p(__CR6_EQ_REV, __a, __b);
15030 #else
15031  return __builtin_altivec_vcmpeqfp_p(__CR6_EQ_REV, __a, __b);
15032 #endif
15033 }
15034 
15035 #ifdef __VSX__
15036 static __inline__ int __ATTRS_o_ai vec_any_eq(vector double __a,
15037  vector double __b) {
15038  return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ_REV, __a, __b);
15039 }
15040 #endif
15041 
15042 /* vec_any_ge */
15043 
15044 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed char __a,
15045  vector signed char __b) {
15046  return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, __b, __a);
15047 }
15048 
15049 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed char __a,
15050  vector bool char __b) {
15051  return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, (vector signed char)__b,
15052  __a);
15053 }
15054 
15055 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned char __a,
15056  vector unsigned char __b) {
15057  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __b, __a);
15058 }
15059 
15060 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned char __a,
15061  vector bool char __b) {
15062  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__b,
15063  __a);
15064 }
15065 
15066 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool char __a,
15067  vector signed char __b) {
15068  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__b,
15069  (vector unsigned char)__a);
15070 }
15071 
15072 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool char __a,
15073  vector unsigned char __b) {
15074  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __b,
15075  (vector unsigned char)__a);
15076 }
15077 
15078 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool char __a,
15079  vector bool 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 short __a,
15085  vector short __b) {
15086  return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, __b, __a);
15087 }
15088 
15089 static __inline__ int __ATTRS_o_ai vec_any_ge(vector short __a,
15090  vector bool short __b) {
15091  return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, (vector short)__b, __a);
15092 }
15093 
15094 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned short __a,
15095  vector unsigned short __b) {
15096  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __b, __a);
15097 }
15098 
15099 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned short __a,
15100  vector bool short __b) {
15101  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__b,
15102  __a);
15103 }
15104 
15105 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool short __a,
15106  vector short __b) {
15107  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__b,
15108  (vector unsigned short)__a);
15109 }
15110 
15111 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool short __a,
15112  vector unsigned short __b) {
15113  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __b,
15114  (vector unsigned short)__a);
15115 }
15116 
15117 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool short __a,
15118  vector bool 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 int __a, vector int __b) {
15124  return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, __b, __a);
15125 }
15126 
15127 static __inline__ int __ATTRS_o_ai vec_any_ge(vector int __a,
15128  vector bool int __b) {
15129  return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, (vector int)__b, __a);
15130 }
15131 
15132 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned int __a,
15133  vector unsigned int __b) {
15134  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __b, __a);
15135 }
15136 
15137 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned int __a,
15138  vector bool int __b) {
15139  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__b,
15140  __a);
15141 }
15142 
15143 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool int __a,
15144  vector int __b) {
15145  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__b,
15146  (vector unsigned int)__a);
15147 }
15148 
15149 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool int __a,
15150  vector unsigned int __b) {
15151  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __b,
15152  (vector unsigned int)__a);
15153 }
15154 
15155 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool int __a,
15156  vector bool int __b) {
15157  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__b,
15158  (vector unsigned int)__a);
15159 }
15160 
15161 #ifdef __POWER8_VECTOR__
15162 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed long long __a,
15163  vector signed long long __b) {
15164  return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV, __b, __a);
15165 }
15166 
15167 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned long long __a,
15168  vector unsigned long long __b) {
15169  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __b, __a);
15170 }
15171 
15172 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed long long __a,
15173  vector bool long long __b) {
15174  return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV,
15175  (vector signed long long)__b, __a);
15176 }
15177 
15178 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned long long __a,
15179  vector bool long long __b) {
15180  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
15181  (vector unsigned long long)__b, __a);
15182 }
15183 
15184 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool long long __a,
15185  vector signed long long __b) {
15186  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
15187  (vector unsigned long long)__b,
15188  (vector unsigned long long)__a);
15189 }
15190 
15191 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool long long __a,
15192  vector unsigned long long __b) {
15193  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __b,
15194  (vector unsigned long long)__a);
15195 }
15196 
15197 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool long long __a,
15198  vector bool long long __b) {
15199  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
15200  (vector unsigned long long)__b,
15201  (vector unsigned long long)__a);
15202 }
15203 #endif
15204 
15205 static __inline__ int __ATTRS_o_ai vec_any_ge(vector float __a,
15206  vector float __b) {
15207 #ifdef __VSX__
15208  return __builtin_vsx_xvcmpgesp_p(__CR6_EQ_REV, __a, __b);
15209 #else
15210  return __builtin_altivec_vcmpgefp_p(__CR6_EQ_REV, __a, __b);
15211 #endif
15212 }
15213 
15214 #ifdef __VSX__
15215 static __inline__ int __ATTRS_o_ai vec_any_ge(vector double __a,
15216  vector double __b) {
15217  return __builtin_vsx_xvcmpgedp_p(__CR6_EQ_REV, __a, __b);
15218 }
15219 #endif
15220 
15221 /* vec_any_gt */
15222 
15223 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed char __a,
15224  vector signed char __b) {
15225  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, __a, __b);
15226 }
15227 
15228 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed char __a,
15229  vector bool char __b) {
15230  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, __a,
15231  (vector signed char)__b);
15232 }
15233 
15234 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned char __a,
15235  vector unsigned char __b) {
15236  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __a, __b);
15237 }
15238 
15239 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned char __a,
15240  vector bool char __b) {
15241  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __a,
15242  (vector unsigned char)__b);
15243 }
15244 
15245 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool char __a,
15246  vector signed char __b) {
15247  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__a,
15248  (vector unsigned char)__b);
15249 }
15250 
15251 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool char __a,
15252  vector unsigned char __b) {
15253  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__a,
15254  __b);
15255 }
15256 
15257 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool char __a,
15258  vector bool 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 short __a,
15264  vector short __b) {
15265  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, __a, __b);
15266 }
15267 
15268 static __inline__ int __ATTRS_o_ai vec_any_gt(vector short __a,
15269  vector bool short __b) {
15270  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, __a, (vector short)__b);
15271 }
15272 
15273 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned short __a,
15274  vector unsigned short __b) {
15275  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __a, __b);
15276 }
15277 
15278 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned short __a,
15279  vector bool short __b) {
15280  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __a,
15281  (vector unsigned short)__b);
15282 }
15283 
15284 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool short __a,
15285  vector short __b) {
15286  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__a,
15287  (vector unsigned short)__b);
15288 }
15289 
15290 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool short __a,
15291  vector unsigned short __b) {
15292  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__a,
15293  __b);
15294 }
15295 
15296 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool short __a,
15297  vector bool 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 int __a, vector int __b) {
15303  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, __a, __b);
15304 }
15305 
15306 static __inline__ int __ATTRS_o_ai vec_any_gt(vector int __a,
15307  vector bool int __b) {
15308  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, __a, (vector int)__b);
15309 }
15310 
15311 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned int __a,
15312  vector unsigned int __b) {
15313  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __a, __b);
15314 }
15315 
15316 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned int __a,
15317  vector bool int __b) {
15318  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __a,
15319  (vector unsigned int)__b);
15320 }
15321 
15322 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool int __a,
15323  vector int __b) {
15324  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__a,
15325  (vector unsigned int)__b);
15326 }
15327 
15328 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool int __a,
15329  vector unsigned int __b) {
15330  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__a,
15331  __b);
15332 }
15333 
15334 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool int __a,
15335  vector bool int __b) {
15336  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__a,
15337  (vector unsigned int)__b);
15338 }
15339 
15340 #ifdef __POWER8_VECTOR__
15341 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed long long __a,
15342  vector signed long long __b) {
15343  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV, __a, __b);
15344 }
15345 
15346 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned long long __a,
15347  vector unsigned long long __b) {
15348  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __a, __b);
15349 }
15350 
15351 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed long long __a,
15352  vector bool long long __b) {
15353  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV, __a,
15354  (vector signed long long)__b);
15355 }
15356 
15357 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned long long __a,
15358  vector bool long long __b) {
15359  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __a,
15360  (vector unsigned long long)__b);
15361 }
15362 
15363 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool long long __a,
15364  vector signed long long __b) {
15365  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
15366  (vector unsigned long long)__a,
15367  (vector unsigned long long)__b);
15368 }
15369 
15370 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool long long __a,
15371  vector unsigned long long __b) {
15372  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
15373  (vector unsigned long long)__a, __b);
15374 }
15375 
15376 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool long long __a,
15377  vector bool long long __b) {
15378  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
15379  (vector unsigned long long)__a,
15380  (vector unsigned long long)__b);
15381 }
15382 #endif
15383 
15384 static __inline__ int __ATTRS_o_ai vec_any_gt(vector float __a,
15385  vector float __b) {
15386 #ifdef __VSX__
15387  return __builtin_vsx_xvcmpgtsp_p(__CR6_EQ_REV, __a, __b);
15388 #else
15389  return __builtin_altivec_vcmpgtfp_p(__CR6_EQ_REV, __a, __b);
15390 #endif
15391 }
15392 
15393 #ifdef __VSX__
15394 static __inline__ int __ATTRS_o_ai vec_any_gt(vector double __a,
15395  vector double __b) {
15396  return __builtin_vsx_xvcmpgtdp_p(__CR6_EQ_REV, __a, __b);
15397 }
15398 #endif
15399 
15400 /* vec_any_le */
15401 
15402 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed char __a,
15403  vector signed char __b) {
15404  return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, __a, __b);
15405 }
15406 
15407 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed char __a,
15408  vector bool char __b) {
15409  return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, __a,
15410  (vector signed char)__b);
15411 }
15412 
15413 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned char __a,
15414  vector unsigned char __b) {
15415  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __a, __b);
15416 }
15417 
15418 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned char __a,
15419  vector bool char __b) {
15420  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __a,
15421  (vector unsigned char)__b);
15422 }
15423 
15424 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool char __a,
15425  vector signed char __b) {
15426  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__a,
15427  (vector unsigned char)__b);
15428 }
15429 
15430 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool char __a,
15431  vector unsigned char __b) {
15432  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__a,
15433  __b);
15434 }
15435 
15436 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool char __a,
15437  vector bool 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 short __a,
15443  vector short __b) {
15444  return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, __a, __b);
15445 }
15446 
15447 static __inline__ int __ATTRS_o_ai vec_any_le(vector short __a,
15448  vector bool short __b) {
15449  return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, __a, (vector short)__b);
15450 }
15451 
15452 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned short __a,
15453  vector unsigned short __b) {
15454  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __a, __b);
15455 }
15456 
15457 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned short __a,
15458  vector bool short __b) {
15459  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __a,
15460  (vector unsigned short)__b);
15461 }
15462 
15463 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool short __a,
15464  vector short __b) {
15465  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__a,
15466  (vector unsigned short)__b);
15467 }
15468 
15469 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool short __a,
15470  vector unsigned short __b) {
15471  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__a,
15472  __b);
15473 }
15474 
15475 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool short __a,
15476  vector bool 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 int __a, vector int __b) {
15482  return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, __a, __b);
15483 }
15484 
15485 static __inline__ int __ATTRS_o_ai vec_any_le(vector int __a,
15486  vector bool int __b) {
15487  return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, __a, (vector int)__b);
15488 }
15489 
15490 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned int __a,
15491  vector unsigned int __b) {
15492  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __a, __b);
15493 }
15494 
15495 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned int __a,
15496  vector bool int __b) {
15497  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __a,
15498  (vector unsigned int)__b);
15499 }
15500 
15501 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool int __a,
15502  vector int __b) {
15503  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__a,
15504  (vector unsigned int)__b);
15505 }
15506 
15507 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool int __a,
15508  vector unsigned int __b) {
15509  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__a,
15510  __b);
15511 }
15512 
15513 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool int __a,
15514  vector bool int __b) {
15515  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__a,
15516  (vector unsigned int)__b);
15517 }
15518 
15519 #ifdef __POWER8_VECTOR__
15520 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed long long __a,
15521  vector signed long long __b) {
15522  return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV, __a, __b);
15523 }
15524 
15525 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned long long __a,
15526  vector unsigned long long __b) {
15527  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __a, __b);
15528 }
15529 
15530 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed long long __a,
15531  vector bool long long __b) {
15532  return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV, __a,
15533  (vector signed long long)__b);
15534 }
15535 
15536 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned long long __a,
15537  vector bool long long __b) {
15538  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __a,
15539  (vector unsigned long long)__b);
15540 }
15541 
15542 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool long long __a,
15543  vector signed long long __b) {
15544  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
15545  (vector unsigned long long)__a,
15546  (vector unsigned long long)__b);
15547 }
15548 
15549 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool long long __a,
15550  vector unsigned long long __b) {
15551  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
15552  (vector unsigned long long)__a, __b);
15553 }
15554 
15555 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool long long __a,
15556  vector bool long long __b) {
15557  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
15558  (vector unsigned long long)__a,
15559  (vector unsigned long long)__b);
15560 }
15561 #endif
15562 
15563 static __inline__ int __ATTRS_o_ai vec_any_le(vector float __a,
15564  vector float __b) {
15565 #ifdef __VSX__
15566  return __builtin_vsx_xvcmpgesp_p(__CR6_EQ_REV, __b, __a);
15567 #else
15568  return __builtin_altivec_vcmpgefp_p(__CR6_EQ_REV, __b, __a);
15569 #endif
15570 }
15571 
15572 #ifdef __VSX__
15573 static __inline__ int __ATTRS_o_ai vec_any_le(vector double __a,
15574  vector double __b) {
15575  return __builtin_vsx_xvcmpgedp_p(__CR6_EQ_REV, __b, __a);
15576 }
15577 #endif
15578 
15579 /* vec_any_lt */
15580 
15581 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed char __a,
15582  vector signed char __b) {
15583  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, __b, __a);
15584 }
15585 
15586 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed char __a,
15587  vector bool char __b) {
15588  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, (vector signed char)__b,
15589  __a);
15590 }
15591 
15592 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned char __a,
15593  vector unsigned char __b) {
15594  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __b, __a);
15595 }
15596 
15597 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned char __a,
15598  vector bool char __b) {
15599  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__b,
15600  __a);
15601 }
15602 
15603 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool char __a,
15604  vector signed char __b) {
15605  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__b,
15606  (vector unsigned char)__a);
15607 }
15608 
15609 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool char __a,
15610  vector unsigned char __b) {
15611  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __b,
15612  (vector unsigned char)__a);
15613 }
15614 
15615 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool char __a,
15616  vector bool 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 short __a,
15622  vector short __b) {
15623  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, __b, __a);
15624 }
15625 
15626 static __inline__ int __ATTRS_o_ai vec_any_lt(vector short __a,
15627  vector bool short __b) {
15628  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, (vector short)__b, __a);
15629 }
15630 
15631 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned short __a,
15632  vector unsigned short __b) {
15633  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __b, __a);
15634 }
15635 
15636 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned short __a,
15637  vector bool short __b) {
15638  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__b,
15639  __a);
15640 }
15641 
15642 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool short __a,
15643  vector short __b) {
15644  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__b,
15645  (vector unsigned short)__a);
15646 }
15647 
15648 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool short __a,
15649  vector unsigned short __b) {
15650  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __b,
15651  (vector unsigned short)__a);
15652 }
15653 
15654 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool short __a,
15655  vector bool 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 int __a, vector int __b) {
15661  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, __b, __a);
15662 }
15663 
15664 static __inline__ int __ATTRS_o_ai vec_any_lt(vector int __a,
15665  vector bool int __b) {
15666  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, (vector int)__b, __a);
15667 }
15668 
15669 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned int __a,
15670  vector unsigned int __b) {
15671  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __b, __a);
15672 }
15673 
15674 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned int __a,
15675  vector bool int __b) {
15676  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__b,
15677  __a);
15678 }
15679 
15680 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool int __a,
15681  vector int __b) {
15682  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__b,
15683  (vector unsigned int)__a);
15684 }
15685 
15686 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool int __a,
15687  vector unsigned int __b) {
15688  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __b,
15689  (vector unsigned int)__a);
15690 }
15691 
15692 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool int __a,
15693  vector bool int __b) {
15694  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__b,
15695  (vector unsigned int)__a);
15696 }
15697 
15698 #ifdef __POWER8_VECTOR__
15699 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed long long __a,
15700  vector signed long long __b) {
15701  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV, __b, __a);
15702 }
15703 
15704 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned long long __a,
15705  vector unsigned long long __b) {
15706  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __b, __a);
15707 }
15708 
15709 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed long long __a,
15710  vector bool long long __b) {
15711  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV,
15712  (vector signed long long)__b, __a);
15713 }
15714 
15715 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned long long __a,
15716  vector bool long long __b) {
15717  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
15718  (vector unsigned long long)__b, __a);
15719 }
15720 
15721 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool long long __a,
15722  vector signed long long __b) {
15723  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
15724  (vector unsigned long long)__b,
15725  (vector unsigned long long)__a);
15726 }
15727 
15728 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool long long __a,
15729  vector unsigned long long __b) {
15730  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __b,
15731  (vector unsigned long long)__a);
15732 }
15733 
15734 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool long long __a,
15735  vector bool long long __b) {
15736  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
15737  (vector unsigned long long)__b,
15738  (vector unsigned long long)__a);
15739 }
15740 #endif
15741 
15742 static __inline__ int __ATTRS_o_ai vec_any_lt(vector float __a,
15743  vector float __b) {
15744 #ifdef __VSX__
15745  return __builtin_vsx_xvcmpgtsp_p(__CR6_EQ_REV, __b, __a);
15746 #else
15747  return __builtin_altivec_vcmpgtfp_p(__CR6_EQ_REV, __b, __a);
15748 #endif
15749 }
15750 
15751 #ifdef __VSX__
15752 static __inline__ int __ATTRS_o_ai vec_any_lt(vector double __a,
15753  vector double __b) {
15754  return __builtin_vsx_xvcmpgtdp_p(__CR6_EQ_REV, __b, __a);
15755 }
15756 #endif
15757 
15758 /* vec_any_nan */
15759 
15760 static __inline__ int __attribute__((__always_inline__))
15761 vec_any_nan(vector float __a) {
15762  return __builtin_altivec_vcmpeqfp_p(__CR6_LT_REV, __a, __a);
15763 }
15764 
15765 /* vec_any_ne */
15766 
15767 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed char __a,
15768  vector signed char __b) {
15769  return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
15770  (vector char)__b);
15771 }
15772 
15773 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed char __a,
15774  vector bool char __b) {
15775  return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
15776  (vector char)__b);
15777 }
15778 
15779 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned char __a,
15780  vector unsigned 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 unsigned 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 bool char __a,
15792  vector signed 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 bool char __a,
15798  vector unsigned 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 bool 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 short __a,
15810  vector short __b) {
15811  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, __a, __b);
15812 }
15813 
15814 static __inline__ int __ATTRS_o_ai vec_any_ne(vector short __a,
15815  vector bool short __b) {
15816  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, __a, (vector short)__b);
15817 }
15818 
15819 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned short __a,
15820  vector unsigned short __b) {
15821  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
15822  (vector short)__b);
15823 }
15824 
15825 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned short __a,
15826  vector bool short __b) {
15827  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
15828  (vector short)__b);
15829 }
15830 
15831 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool short __a,
15832  vector 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 bool short __a,
15838  vector unsigned 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 bool 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 pixel __a,
15850  vector pixel __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 int __a, vector int __b) {
15856  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, __a, __b);
15857 }
15858 
15859 static __inline__ int __ATTRS_o_ai vec_any_ne(vector int __a,
15860  vector bool int __b) {
15861  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, __a, (vector int)__b);
15862 }
15863 
15864 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned int __a,
15865  vector unsigned int __b) {
15866  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
15867  (vector int)__b);
15868 }
15869 
15870 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned int __a,
15871  vector bool int __b) {
15872  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
15873  (vector int)__b);
15874 }
15875 
15876 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool int __a,
15877  vector 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 bool int __a,
15883  vector unsigned 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 bool int __b) {
15890  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
15891  (vector int)__b);
15892 }
15893 
15894 #ifdef __POWER8_VECTOR__
15895 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed long long __a,
15896  vector signed long long __b) {
15897  return __builtin_altivec_vcmpequd_p(__CR6_LT_REV, __a, __b);
15898 }
15899 
15900 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned long long __a,
15901  vector unsigned long long __b) {
15902  return __builtin_altivec_vcmpequd_p(__CR6_LT_REV, (vector long long)__a,
15903  (vector long long)__b);
15904 }
15905 
15906 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed long long __a,
15907  vector bool long long __b) {
15908  return __builtin_altivec_vcmpequd_p(__CR6_LT_REV, __a,
15909  (vector signed long long)__b);
15910 }
15911 
15912 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned long long __a,
15913  vector bool long long __b) {
15914  return __builtin_altivec_vcmpequd_p(
15915  __CR6_LT_REV, (vector signed long long)__a, (vector signed long long)__b);
15916 }
15917 
15918 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool long long __a,
15919  vector signed long long __b) {
15920  return __builtin_altivec_vcmpequd_p(
15921  __CR6_LT_REV, (vector signed long long)__a, (vector signed long long)__b);
15922 }
15923 
15924 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool long long __a,
15925  vector unsigned 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 bool 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 #endif
15936 
15937 static __inline__ int __ATTRS_o_ai vec_any_ne(vector float __a,
15938  vector float __b) {
15939 #ifdef __VSX__
15940  return __builtin_vsx_xvcmpeqsp_p(__CR6_LT_REV, __a, __b);
15941 #else
15942  return __builtin_altivec_vcmpeqfp_p(__CR6_LT_REV, __a, __b);
15943 #endif
15944 }
15945 
15946 #ifdef __VSX__
15947 static __inline__ int __ATTRS_o_ai vec_any_ne(vector double __a,
15948  vector double __b) {
15949  return __builtin_vsx_xvcmpeqdp_p(__CR6_LT_REV, __a, __b);
15950 }
15951 #endif
15952 
15953 /* vec_any_nge */
15954 
15955 static __inline__ int __attribute__((__always_inline__))
15956 vec_any_nge(vector float __a, vector float __b) {
15957  return __builtin_altivec_vcmpgefp_p(__CR6_LT_REV, __a, __b);
15958 }
15959 
15960 /* vec_any_ngt */
15961 
15962 static __inline__ int __attribute__((__always_inline__))
15963 vec_any_ngt(vector float __a, vector float __b) {
15964  return __builtin_altivec_vcmpgtfp_p(__CR6_LT_REV, __a, __b);
15965 }
15966 
15967 /* vec_any_nle */
15968 
15969 static __inline__ int __attribute__((__always_inline__))
15970 vec_any_nle(vector float __a, vector float __b) {
15971  return __builtin_altivec_vcmpgefp_p(__CR6_LT_REV, __b, __a);
15972 }
15973 
15974 /* vec_any_nlt */
15975 
15976 static __inline__ int __attribute__((__always_inline__))
15977 vec_any_nlt(vector float __a, vector float __b) {
15978  return __builtin_altivec_vcmpgtfp_p(__CR6_LT_REV, __b, __a);
15979 }
15980 
15981 /* vec_any_numeric */
15982 
15983 static __inline__ int __attribute__((__always_inline__))
15984 vec_any_numeric(vector float __a) {
15985  return __builtin_altivec_vcmpeqfp_p(__CR6_EQ_REV, __a, __a);
15986 }
15987 
15988 /* vec_any_out */
15989 
15990 static __inline__ int __attribute__((__always_inline__))
15991 vec_any_out(vector float __a, vector float __b) {
15992  return __builtin_altivec_vcmpbfp_p(__CR6_EQ_REV, __a, __b);
15993 }
15994 
15995 /* Power 8 Crypto functions
15996 Note: We diverge from the current GCC implementation with regard
15997 to cryptography and related functions as follows:
15998 - Only the SHA and AES instructions and builtins are disabled by -mno-crypto
15999 - The remaining ones are only available on Power8 and up so
16000  require -mpower8-vector
16001 The justification for this is that export requirements require that
16002 Category:Vector.Crypto is optional (i.e. compliant hardware may not provide
16003 support). As a result, we need to be able to turn off support for those.
16004 The remaining ones (currently controlled by -mcrypto for GCC) still
16005 need to be provided on compliant hardware even if Vector.Crypto is not
16006 provided.
16007 */
16008 #ifdef __CRYPTO__
16009 #define vec_sbox_be __builtin_altivec_crypto_vsbox
16010 #define vec_cipher_be __builtin_altivec_crypto_vcipher
16011 #define vec_cipherlast_be __builtin_altivec_crypto_vcipherlast
16012 #define vec_ncipher_be __builtin_altivec_crypto_vncipher
16013 #define vec_ncipherlast_be __builtin_altivec_crypto_vncipherlast
16014 
16015 static __inline__ vector unsigned long long __attribute__((__always_inline__))
16016 __builtin_crypto_vsbox(vector unsigned long long __a) {
16017  return __builtin_altivec_crypto_vsbox(__a);
16018 }
16019 
16020 static __inline__ vector unsigned long long __attribute__((__always_inline__))
16021 __builtin_crypto_vcipher(vector unsigned long long __a,
16022  vector unsigned long long __b) {
16023  return __builtin_altivec_crypto_vcipher(__a, __b);
16024 }
16025 
16026 static __inline__ vector unsigned long long __attribute__((__always_inline__))
16027 __builtin_crypto_vcipherlast(vector unsigned long long __a,
16028  vector unsigned long long __b) {
16029  return __builtin_altivec_crypto_vcipherlast(__a, __b);
16030 }
16031 
16032 static __inline__ vector unsigned long long __attribute__((__always_inline__))
16033 __builtin_crypto_vncipher(vector unsigned long long __a,
16034  vector unsigned long long __b) {
16035  return __builtin_altivec_crypto_vncipher(__a, __b);
16036 }
16037 
16038 static __inline__ vector unsigned long long __attribute__((__always_inline__))
16039 __builtin_crypto_vncipherlast(vector unsigned long long __a,
16040  vector unsigned long long __b) {
16041  return __builtin_altivec_crypto_vncipherlast(__a, __b);
16042 }
16043 
16044 #define __builtin_crypto_vshasigmad __builtin_altivec_crypto_vshasigmad
16045 #define __builtin_crypto_vshasigmaw __builtin_altivec_crypto_vshasigmaw
16046 
16047 #define vec_shasigma_be(X, Y, Z) \
16048  _Generic((X), vector unsigned int \
16049  : __builtin_crypto_vshasigmaw, vector unsigned long long \
16050  : __builtin_crypto_vshasigmad)((X), (Y), (Z))
16051 #endif
16052 
16053 #ifdef __POWER8_VECTOR__
16054 static __inline__ vector bool char __ATTRS_o_ai
16055 vec_permxor(vector bool char __a, vector bool char __b,
16056  vector bool char __c) {
16057  return __builtin_altivec_crypto_vpermxor(__a, __b, __c);
16058 }
16059 
16060 static __inline__ vector signed char __ATTRS_o_ai
16061 vec_permxor(vector signed char __a, vector signed char __b,
16062  vector signed char __c) {
16063  return __builtin_altivec_crypto_vpermxor(__a, __b, __c);
16064 }
16065 
16066 static __inline__ vector unsigned char __ATTRS_o_ai
16067 vec_permxor(vector unsigned char __a, vector unsigned char __b,
16068  vector unsigned char __c) {
16069  return __builtin_altivec_crypto_vpermxor(__a, __b, __c);
16070 }
16071 
16072 static __inline__ vector unsigned char __ATTRS_o_ai
16073 __builtin_crypto_vpermxor(vector unsigned char __a, vector unsigned char __b,
16074  vector unsigned char __c) {
16075  return __builtin_altivec_crypto_vpermxor(__a, __b, __c);
16076 }
16077 
16078 static __inline__ vector unsigned short __ATTRS_o_ai
16079 __builtin_crypto_vpermxor(vector unsigned short __a, vector unsigned short __b,
16080  vector unsigned short __c) {
16081  return (vector unsigned short)__builtin_altivec_crypto_vpermxor(
16082  (vector unsigned char)__a, (vector unsigned char)__b,
16083  (vector unsigned char)__c);
16084 }
16085 
16086 static __inline__ vector unsigned int __ATTRS_o_ai __builtin_crypto_vpermxor(
16087  vector unsigned int __a, vector unsigned int __b, vector unsigned int __c) {
16088  return (vector unsigned int)__builtin_altivec_crypto_vpermxor(
16089  (vector unsigned char)__a, (vector unsigned char)__b,
16090  (vector unsigned char)__c);
16091 }
16092 
16093 static __inline__ vector unsigned long long __ATTRS_o_ai
16094 __builtin_crypto_vpermxor(vector unsigned long long __a,
16095  vector unsigned long long __b,
16096  vector unsigned long long __c) {
16097  return (vector unsigned long long)__builtin_altivec_crypto_vpermxor(
16098  (vector unsigned char)__a, (vector unsigned char)__b,
16099  (vector unsigned char)__c);
16100 }
16101 
16102 static __inline__ vector unsigned char __ATTRS_o_ai
16103 __builtin_crypto_vpmsumb(vector unsigned char __a, vector unsigned char __b) {
16104  return __builtin_altivec_crypto_vpmsumb(__a, __b);
16105 }
16106 
16107 static __inline__ vector unsigned short __ATTRS_o_ai
16108 __builtin_crypto_vpmsumb(vector unsigned short __a, vector unsigned short __b) {
16109  return __builtin_altivec_crypto_vpmsumh(__a, __b);
16110 }
16111 
16112 static __inline__ vector unsigned int __ATTRS_o_ai
16113 __builtin_crypto_vpmsumb(vector unsigned int __a, vector unsigned int __b) {
16114  return __builtin_altivec_crypto_vpmsumw(__a, __b);
16115 }
16116 
16117 static __inline__ vector unsigned long long __ATTRS_o_ai
16118 __builtin_crypto_vpmsumb(vector unsigned long long __a,
16119  vector unsigned long long __b) {
16120  return __builtin_altivec_crypto_vpmsumd(__a, __b);
16121 }
16122 
16123 static __inline__ vector signed char __ATTRS_o_ai
16124 vec_vgbbd(vector signed char __a) {
16125  return __builtin_altivec_vgbbd((vector unsigned char)__a);
16126 }
16127 
16128 #define vec_pmsum_be __builtin_crypto_vpmsumb
16129 #define vec_gb __builtin_altivec_vgbbd
16130 
16131 static __inline__ vector unsigned char __ATTRS_o_ai
16132 vec_vgbbd(vector unsigned char __a) {
16133  return __builtin_altivec_vgbbd(__a);
16134 }
16135 
16136 static __inline__ vector long long __ATTRS_o_ai
16137 vec_vbpermq(vector signed char __a, vector signed char __b) {
16138  return __builtin_altivec_vbpermq((vector unsigned char)__a,
16139  (vector unsigned char)__b);
16140 }
16141 
16142 static __inline__ vector long long __ATTRS_o_ai
16143 vec_vbpermq(vector unsigned char __a, vector unsigned char __b) {
16144  return __builtin_altivec_vbpermq(__a, __b);
16145 }
16146 
16147 #ifdef __powerpc64__
16148 static __inline__ vector unsigned long long __attribute__((__always_inline__))
16149 vec_bperm(vector unsigned __int128 __a, vector unsigned char __b) {
16150  return __builtin_altivec_vbpermq((vector unsigned char)__a,
16151  (vector unsigned char)__b);
16152 }
16153 #endif
16154 #endif
16155 
16156 
16157 /* vec_reve */
16158 
16159 static inline __ATTRS_o_ai vector bool char vec_reve(vector bool char __a) {
16160  return __builtin_shufflevector(__a, __a, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6,
16161  5, 4, 3, 2, 1, 0);
16162 }
16163 
16164 static inline __ATTRS_o_ai vector signed char vec_reve(vector signed char __a) {
16165  return __builtin_shufflevector(__a, __a, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6,
16166  5, 4, 3, 2, 1, 0);
16167 }
16168 
16169 static inline __ATTRS_o_ai vector unsigned char
16170 vec_reve(vector unsigned char __a) {
16171  return __builtin_shufflevector(__a, __a, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6,
16172  5, 4, 3, 2, 1, 0);
16173 }
16174 
16175 static inline __ATTRS_o_ai vector bool int vec_reve(vector bool int __a) {
16176  return __builtin_shufflevector(__a, __a, 3, 2, 1, 0);
16177 }
16178 
16179 static inline __ATTRS_o_ai vector signed int vec_reve(vector signed int __a) {
16180  return __builtin_shufflevector(__a, __a, 3, 2, 1, 0);
16181 }
16182 
16183 static inline __ATTRS_o_ai vector unsigned int
16184 vec_reve(vector unsigned int __a) {
16185  return __builtin_shufflevector(__a, __a, 3, 2, 1, 0);
16186 }
16187 
16188 static inline __ATTRS_o_ai vector bool short vec_reve(vector bool short __a) {
16189  return __builtin_shufflevector(__a, __a, 7, 6, 5, 4, 3, 2, 1, 0);
16190 }
16191 
16192 static inline __ATTRS_o_ai vector signed short
16193 vec_reve(vector signed short __a) {
16194  return __builtin_shufflevector(__a, __a, 7, 6, 5, 4, 3, 2, 1, 0);
16195 }
16196 
16197 static inline __ATTRS_o_ai vector unsigned short
16198 vec_reve(vector unsigned short __a) {
16199  return __builtin_shufflevector(__a, __a, 7, 6, 5, 4, 3, 2, 1, 0);
16200 }
16201 
16202 static inline __ATTRS_o_ai vector float vec_reve(vector float __a) {
16203  return __builtin_shufflevector(__a, __a, 3, 2, 1, 0);
16204 }
16205 
16206 #ifdef __VSX__
16207 static inline __ATTRS_o_ai vector bool long long
16208 vec_reve(vector bool long long __a) {
16209  return __builtin_shufflevector(__a, __a, 1, 0);
16210 }
16211 
16212 static inline __ATTRS_o_ai vector signed long long
16213 vec_reve(vector signed long long __a) {
16214  return __builtin_shufflevector(__a, __a, 1, 0);
16215 }
16216 
16217 static inline __ATTRS_o_ai vector unsigned long long
16218 vec_reve(vector unsigned long long __a) {
16219  return __builtin_shufflevector(__a, __a, 1, 0);
16220 }
16221 
16222 static inline __ATTRS_o_ai vector double vec_reve(vector double __a) {
16223  return __builtin_shufflevector(__a, __a, 1, 0);
16224 }
16225 #endif
16226 
16227 /* vec_revb */
16228 static __inline__ vector bool char __ATTRS_o_ai
16229 vec_revb(vector bool char __a) {
16230  return __a;
16231 }
16232 
16233 static __inline__ vector signed char __ATTRS_o_ai
16234 vec_revb(vector signed char __a) {
16235  return __a;
16236 }
16237 
16238 static __inline__ vector unsigned char __ATTRS_o_ai
16239 vec_revb(vector unsigned char __a) {
16240  return __a;
16241 }
16242 
16243 static __inline__ vector bool short __ATTRS_o_ai
16244 vec_revb(vector bool short __a) {
16245  vector unsigned char __indices =
16246  { 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14 };
16247  return vec_perm(__a, __a, __indices);
16248 }
16249 
16250 static __inline__ vector signed short __ATTRS_o_ai
16251 vec_revb(vector signed short __a) {
16252  vector unsigned char __indices =
16253  { 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14 };
16254  return vec_perm(__a, __a, __indices);
16255 }
16256 
16257 static __inline__ vector unsigned short __ATTRS_o_ai
16258 vec_revb(vector unsigned short __a) {
16259  vector unsigned char __indices =
16260  { 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14 };
16261  return vec_perm(__a, __a, __indices);
16262 }
16263 
16264 static __inline__ vector bool int __ATTRS_o_ai
16265 vec_revb(vector bool int __a) {
16266  vector unsigned char __indices =
16267  { 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12 };
16268  return vec_perm(__a, __a, __indices);
16269 }
16270 
16271 static __inline__ vector signed int __ATTRS_o_ai
16272 vec_revb(vector signed int __a) {
16273  vector unsigned char __indices =
16274  { 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12 };
16275  return vec_perm(__a, __a, __indices);
16276 }
16277 
16278 static __inline__ vector unsigned int __ATTRS_o_ai
16279 vec_revb(vector unsigned int __a) {
16280  vector unsigned char __indices =
16281  { 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12 };
16282  return vec_perm(__a, __a, __indices);
16283 }
16284 
16285 static __inline__ vector float __ATTRS_o_ai
16286 vec_revb(vector float __a) {
16287  vector unsigned char __indices =
16288  { 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12 };
16289  return vec_perm(__a, __a, __indices);
16290 }
16291 
16292 #ifdef __VSX__
16293 static __inline__ vector bool long long __ATTRS_o_ai
16294 vec_revb(vector bool long long __a) {
16295  vector unsigned char __indices =
16296  { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8 };
16297  return vec_perm(__a, __a, __indices);
16298 }
16299 
16300 static __inline__ vector signed long long __ATTRS_o_ai
16301 vec_revb(vector signed long long __a) {
16302  vector unsigned char __indices =
16303  { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8 };
16304  return vec_perm(__a, __a, __indices);
16305 }
16306 
16307 static __inline__ vector unsigned long long __ATTRS_o_ai
16308 vec_revb(vector unsigned long long __a) {
16309  vector unsigned char __indices =
16310  { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8 };
16311  return vec_perm(__a, __a, __indices);
16312 }
16313 
16314 static __inline__ vector double __ATTRS_o_ai
16315 vec_revb(vector double __a) {
16316  vector unsigned char __indices =
16317  { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8 };
16318  return vec_perm(__a, __a, __indices);
16319 }
16320 #endif /* End __VSX__ */
16321 
16322 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
16323 static __inline__ vector signed __int128 __ATTRS_o_ai
16324 vec_revb(vector signed __int128 __a) {
16325  vector unsigned char __indices =
16326  { 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
16327  return (vector signed __int128)vec_perm((vector signed int)__a,
16328  (vector signed int)__a,
16329  __indices);
16330 }
16331 
16332 static __inline__ vector unsigned __int128 __ATTRS_o_ai
16333 vec_revb(vector unsigned __int128 __a) {
16334  vector unsigned char __indices =
16335  { 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
16336  return (vector unsigned __int128)vec_perm((vector signed int)__a,
16337  (vector signed int)__a,
16338  __indices);
16339 }
16340 #endif /* END __POWER8_VECTOR__ && __powerpc64__ */
16341 
16342 /* vec_xl */
16343 
16344 typedef vector signed char unaligned_vec_schar __attribute__((aligned(1)));
16345 typedef vector unsigned char unaligned_vec_uchar __attribute__((aligned(1)));
16346 typedef vector signed short unaligned_vec_sshort __attribute__((aligned(1)));
16347 typedef vector unsigned short unaligned_vec_ushort __attribute__((aligned(1)));
16348 typedef vector signed int unaligned_vec_sint __attribute__((aligned(1)));
16349 typedef vector unsigned int unaligned_vec_uint __attribute__((aligned(1)));
16350 typedef vector float unaligned_vec_float __attribute__((aligned(1)));
16351 
16352 static inline __ATTRS_o_ai vector signed char vec_xl(signed long long __offset,
16353  signed char *__ptr) {
16354  return *(unaligned_vec_schar *)(__ptr + __offset);
16355 }
16356 
16357 static inline __ATTRS_o_ai vector unsigned char
16358 vec_xl(signed long long __offset, unsigned char *__ptr) {
16359  return *(unaligned_vec_uchar*)(__ptr + __offset);
16360 }
16361 
16362 static inline __ATTRS_o_ai vector signed short vec_xl(signed long long __offset,
16363  signed short *__ptr) {
16364  return *(unaligned_vec_sshort *)(__ptr + __offset);
16365 }
16366 
16367 static inline __ATTRS_o_ai vector unsigned short
16368 vec_xl(signed long long __offset, unsigned short *__ptr) {
16369  return *(unaligned_vec_ushort *)(__ptr + __offset);
16370 }
16371 
16372 static inline __ATTRS_o_ai vector signed int vec_xl(signed long long __offset,
16373  signed int *__ptr) {
16374  return *(unaligned_vec_sint *)(__ptr + __offset);
16375 }
16376 
16377 static inline __ATTRS_o_ai vector unsigned int vec_xl(signed long long __offset,
16378  unsigned int *__ptr) {
16379  return *(unaligned_vec_uint *)(__ptr + __offset);
16380 }
16381 
16382 static inline __ATTRS_o_ai vector float vec_xl(signed long long __offset,
16383  float *__ptr) {
16384  return *(unaligned_vec_float *)(__ptr + __offset);
16385 }
16386 
16387 #ifdef __VSX__
16388 typedef vector signed long long unaligned_vec_sll __attribute__((aligned(1)));
16389 typedef vector unsigned long long unaligned_vec_ull __attribute__((aligned(1)));
16390 typedef vector double unaligned_vec_double __attribute__((aligned(1)));
16391 
16392 static inline __ATTRS_o_ai vector signed long long
16393 vec_xl(signed long long __offset, signed long long *__ptr) {
16394  return *(unaligned_vec_sll *)(__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 *(unaligned_vec_ull *)(__ptr + __offset);
16400 }
16401 
16402 static inline __ATTRS_o_ai vector double vec_xl(signed long long __offset,
16403  double *__ptr) {
16404  return *(unaligned_vec_double *)(__ptr + __offset);
16405 }
16406 #endif
16407 
16408 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
16409 typedef vector signed __int128 unaligned_vec_si128 __attribute__((aligned(1)));
16410 typedef vector unsigned __int128 unaligned_vec_ui128
16411  __attribute__((aligned(1)));
16412 static inline __ATTRS_o_ai vector signed __int128
16413 vec_xl(signed long long __offset, signed __int128 *__ptr) {
16414  return *(unaligned_vec_si128 *)(__ptr + __offset);
16415 }
16416 
16417 static inline __ATTRS_o_ai vector unsigned __int128
16418 vec_xl(signed long long __offset, unsigned __int128 *__ptr) {
16419  return *(unaligned_vec_ui128 *)(__ptr + __offset);
16420 }
16421 #endif
16422 
16423 /* vec_xl_be */
16424 
16425 #ifdef __LITTLE_ENDIAN__
16426 static __inline__ vector signed char __ATTRS_o_ai
16427 vec_xl_be(signed long long __offset, signed char *__ptr) {
16428  vector signed char __vec = __builtin_vsx_lxvd2x_be(__offset, __ptr);
16429  return __builtin_shufflevector(__vec, __vec, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14,
16430  13, 12, 11, 10, 9, 8);
16431 }
16432 
16433 static __inline__ vector unsigned char __ATTRS_o_ai
16434 vec_xl_be(signed long long __offset, unsigned char *__ptr) {
16435  vector unsigned char __vec = __builtin_vsx_lxvd2x_be(__offset, __ptr);
16436  return __builtin_shufflevector(__vec, __vec, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14,
16437  13, 12, 11, 10, 9, 8);
16438 }
16439 
16440 static __inline__ vector signed short __ATTRS_o_ai
16441 vec_xl_be(signed long long __offset, signed short *__ptr) {
16442  vector signed short __vec = __builtin_vsx_lxvd2x_be(__offset, __ptr);
16443  return __builtin_shufflevector(__vec, __vec, 3, 2, 1, 0, 7, 6, 5, 4);
16444 }
16445 
16446 static __inline__ vector unsigned short __ATTRS_o_ai
16447 vec_xl_be(signed long long __offset, unsigned short *__ptr) {
16448  vector unsigned short __vec = __builtin_vsx_lxvd2x_be(__offset, __ptr);
16449  return __builtin_shufflevector(__vec, __vec, 3, 2, 1, 0, 7, 6, 5, 4);
16450 }
16451 
16452 static __inline__ vector signed int __ATTRS_o_ai
16453 vec_xl_be(signed long long __offset, signed int *__ptr) {
16454  return (vector signed int)__builtin_vsx_lxvw4x_be(__offset, __ptr);
16455 }
16456 
16457 static __inline__ vector unsigned int __ATTRS_o_ai
16458 vec_xl_be(signed long long __offset, unsigned int *__ptr) {
16459  return (vector unsigned int)__builtin_vsx_lxvw4x_be(__offset, __ptr);
16460 }
16461 
16462 static __inline__ vector float __ATTRS_o_ai
16463 vec_xl_be(signed long long __offset, float *__ptr) {
16464  return (vector float)__builtin_vsx_lxvw4x_be(__offset, __ptr);
16465 }
16466 
16467 #ifdef __VSX__
16468 static __inline__ vector signed long long __ATTRS_o_ai
16469 vec_xl_be(signed long long __offset, signed long long *__ptr) {
16470  return (vector signed long long)__builtin_vsx_lxvd2x_be(__offset, __ptr);
16471 }
16472 
16473 static __inline__ vector unsigned long long __ATTRS_o_ai
16474 vec_xl_be(signed long long __offset, unsigned long long *__ptr) {
16475  return (vector unsigned long long)__builtin_vsx_lxvd2x_be(__offset, __ptr);
16476 }
16477 
16478 static __inline__ vector double __ATTRS_o_ai
16479 vec_xl_be(signed long long __offset, double *__ptr) {
16480  return (vector double)__builtin_vsx_lxvd2x_be(__offset, __ptr);
16481 }
16482 #endif
16483 
16484 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
16485 static __inline__ vector signed __int128 __ATTRS_o_ai
16486 vec_xl_be(signed long long __offset, signed __int128 *__ptr) {
16487  return vec_xl(__offset, __ptr);
16488 }
16489 
16490 static __inline__ vector unsigned __int128 __ATTRS_o_ai
16491 vec_xl_be(signed long long __offset, unsigned __int128 *__ptr) {
16492  return vec_xl(__offset, __ptr);
16493 }
16494 #endif
16495 #else
16496  #define vec_xl_be vec_xl
16497 #endif
16498 
16499 /* vec_xst */
16500 
16501 static inline __ATTRS_o_ai void vec_xst(vector signed char __vec,
16502  signed long long __offset,
16503  signed char *__ptr) {
16504  *(unaligned_vec_schar *)(__ptr + __offset) = __vec;
16505 }
16506 
16507 static inline __ATTRS_o_ai void vec_xst(vector unsigned char __vec,
16508  signed long long __offset,
16509  unsigned char *__ptr) {
16510  *(unaligned_vec_uchar *)(__ptr + __offset) = __vec;
16511 }
16512 
16513 static inline __ATTRS_o_ai void vec_xst(vector signed short __vec,
16514  signed long long __offset,
16515  signed short *__ptr) {
16516  *(unaligned_vec_sshort *)(__ptr + __offset) = __vec;
16517 }
16518 
16519 static inline __ATTRS_o_ai void vec_xst(vector unsigned short __vec,
16520  signed long long __offset,
16521  unsigned short *__ptr) {
16522  *(unaligned_vec_ushort *)(__ptr + __offset) = __vec;
16523 }
16524 
16525 static inline __ATTRS_o_ai void vec_xst(vector signed int __vec,
16526  signed long long __offset,
16527  signed int *__ptr) {
16528  *(unaligned_vec_sint *)(__ptr + __offset) = __vec;
16529 }
16530 
16531 static inline __ATTRS_o_ai void vec_xst(vector unsigned int __vec,
16532  signed long long __offset,
16533  unsigned int *__ptr) {
16534  *(unaligned_vec_uint *)(__ptr + __offset) = __vec;
16535 }
16536 
16537 static inline __ATTRS_o_ai void vec_xst(vector float __vec,
16538  signed long long __offset,
16539  float *__ptr) {
16540  *(unaligned_vec_float *)(__ptr + __offset) = __vec;
16541 }
16542 
16543 #ifdef __VSX__
16544 static inline __ATTRS_o_ai void vec_xst(vector signed long long __vec,
16545  signed long long __offset,
16546  signed long long *__ptr) {
16547  *(unaligned_vec_sll *)(__ptr + __offset) = __vec;
16548 }
16549 
16550 static inline __ATTRS_o_ai void vec_xst(vector unsigned long long __vec,
16551  signed long long __offset,
16552  unsigned long long *__ptr) {
16553  *(unaligned_vec_ull *)(__ptr + __offset) = __vec;
16554 }
16555 
16556 static inline __ATTRS_o_ai void vec_xst(vector double __vec,
16557  signed long long __offset,
16558  double *__ptr) {
16559  *(unaligned_vec_double *)(__ptr + __offset) = __vec;
16560 }
16561 #endif
16562 
16563 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
16564 static inline __ATTRS_o_ai void vec_xst(vector signed __int128 __vec,
16565  signed long long __offset,
16566  signed __int128 *__ptr) {
16567  *(unaligned_vec_si128 *)(__ptr + __offset) = __vec;
16568 }
16569 
16570 static inline __ATTRS_o_ai void vec_xst(vector unsigned __int128 __vec,
16571  signed long long __offset,
16572  unsigned __int128 *__ptr) {
16573  *(unaligned_vec_ui128 *)(__ptr + __offset) = __vec;
16574 }
16575 #endif
16576 
16577 /* vec_xst_be */
16578 
16579 #ifdef __LITTLE_ENDIAN__
16580 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed char __vec,
16581  signed long long __offset,
16582  signed char *__ptr) {
16583  vector signed char __tmp =
16584  __builtin_shufflevector(__vec, __vec, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14,
16585  13, 12, 11, 10, 9, 8);
16586  __builtin_vsx_stxvd2x_be(__tmp, __offset, __ptr);
16587 }
16588 
16589 static __inline__ void __ATTRS_o_ai vec_xst_be(vector unsigned char __vec,
16590  signed long long __offset,
16591  unsigned char *__ptr) {
16592  vector unsigned char __tmp =
16593  __builtin_shufflevector(__vec, __vec, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14,
16594  13, 12, 11, 10, 9, 8);
16595  __builtin_vsx_stxvd2x_be(__tmp, __offset, __ptr);
16596 }
16597 
16598 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed short __vec,
16599  signed long long __offset,
16600  signed short *__ptr) {
16601  vector signed short __tmp =
16602  __builtin_shufflevector(__vec, __vec, 3, 2, 1, 0, 7, 6, 5, 4);
16603  __builtin_vsx_stxvd2x_be(__tmp, __offset, __ptr);
16604 }
16605 
16606 static __inline__ void __ATTRS_o_ai vec_xst_be(vector unsigned short __vec,
16607  signed long long __offset,
16608  unsigned short *__ptr) {
16609  vector unsigned short __tmp =
16610  __builtin_shufflevector(__vec, __vec, 3, 2, 1, 0, 7, 6, 5, 4);
16611  __builtin_vsx_stxvd2x_be(__tmp, __offset, __ptr);
16612 }
16613 
16614 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed int __vec,
16615  signed long long __offset,
16616  signed int *__ptr) {
16617  __builtin_vsx_stxvw4x_be(__vec, __offset, __ptr);
16618 }
16619 
16620 static __inline__ void __ATTRS_o_ai vec_xst_be(vector unsigned int __vec,
16621  signed long long __offset,
16622  unsigned int *__ptr) {
16623  __builtin_vsx_stxvw4x_be(__vec, __offset, __ptr);
16624 }
16625 
16626 static __inline__ void __ATTRS_o_ai vec_xst_be(vector float __vec,
16627  signed long long __offset,
16628  float *__ptr) {
16629  __builtin_vsx_stxvw4x_be(__vec, __offset, __ptr);
16630 }
16631 
16632 #ifdef __VSX__
16633 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed long long __vec,
16634  signed long long __offset,
16635  signed long long *__ptr) {
16636  __builtin_vsx_stxvd2x_be(__vec, __offset, __ptr);
16637 }
16638 
16639 static __inline__ void __ATTRS_o_ai vec_xst_be(vector unsigned long long __vec,
16640  signed long long __offset,
16641  unsigned long long *__ptr) {
16642  __builtin_vsx_stxvd2x_be(__vec, __offset, __ptr);
16643 }
16644 
16645 static __inline__ void __ATTRS_o_ai vec_xst_be(vector double __vec,
16646  signed long long __offset,
16647  double *__ptr) {
16648  __builtin_vsx_stxvd2x_be(__vec, __offset, __ptr);
16649 }
16650 #endif
16651 
16652 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
16653 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed __int128 __vec,
16654  signed long long __offset,
16655  signed __int128 *__ptr) {
16656  vec_xst(__vec, __offset, __ptr);
16657 }
16658 
16659 static __inline__ void __ATTRS_o_ai vec_xst_be(vector unsigned __int128 __vec,
16660  signed long long __offset,
16661  unsigned __int128 *__ptr) {
16662  vec_xst(__vec, __offset, __ptr);
16663 }
16664 #endif
16665 #else
16666  #define vec_xst_be vec_xst
16667 #endif
16668 
16669 #ifdef __POWER9_VECTOR__
16670 #define vec_test_data_class(__a, __b) \
16671  _Generic((__a), \
16672  vector float: \
16673  (vector bool int)__builtin_vsx_xvtstdcsp((__a), (__b)), \
16674  vector double: \
16675  (vector bool long long)__builtin_vsx_xvtstdcdp((__a), (__b)) \
16676  )
16677 
16678 #endif /* #ifdef __POWER9_VECTOR__ */
16679 
16680 static vector float __ATTRS_o_ai vec_neg(vector float __a) {
16681  return -__a;
16682 }
16683 
16684 #ifdef __VSX__
16685 static vector double __ATTRS_o_ai vec_neg(vector double __a) {
16686  return -__a;
16687 }
16688 
16689 #endif
16690 
16691 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
16692 static vector long long __ATTRS_o_ai vec_neg(vector long long __a) {
16693  return -__a;
16694 }
16695 #endif
16696 
16697 static vector signed int __ATTRS_o_ai vec_neg(vector signed int __a) {
16698  return -__a;
16699 }
16700 
16701 static vector signed short __ATTRS_o_ai vec_neg(vector signed short __a) {
16702  return -__a;
16703 }
16704 
16705 static vector signed char __ATTRS_o_ai vec_neg(vector signed char __a) {
16706  return -__a;
16707 }
16708 
16709 static vector float __ATTRS_o_ai vec_nabs(vector float __a) {
16710  return - vec_abs(__a);
16711 }
16712 
16713 #ifdef __VSX__
16714 static vector double __ATTRS_o_ai vec_nabs(vector double __a) {
16715  return - vec_abs(__a);
16716 }
16717 
16718 #endif
16719 
16720 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
16721 static vector long long __ATTRS_o_ai vec_nabs(vector long long __a) {
16722  return __builtin_altivec_vminsd(__a, -__a);
16723 }
16724 #endif
16725 
16726 static vector signed int __ATTRS_o_ai vec_nabs(vector signed int __a) {
16727  return __builtin_altivec_vminsw(__a, -__a);
16728 }
16729 
16730 static vector signed short __ATTRS_o_ai vec_nabs(vector signed short __a) {
16731  return __builtin_altivec_vminsh(__a, -__a);
16732 }
16733 
16734 static vector signed char __ATTRS_o_ai vec_nabs(vector signed char __a) {
16735  return __builtin_altivec_vminsb(__a, -__a);
16736 }
16737 #undef __ATTRS_o_ai
16738 
16739 #endif /* __ALTIVEC_H */
static __inline__ vector int __ATTRS_o_ai vec_vupkhsh(vector short __a)
Definition: altivec.h:11698
#define __CR6_LT_REV
Definition: altivec.h:21
static __inline__ vector short __ATTRS_o_ai vec_vsrh(vector short __a, vector unsigned short __b)
Definition: altivec.h:9548
static __inline__ void __ATTRS_o_ai vec_stvehx(vector short __a, int __b, short *__c)
Definition: altivec.h:10580
static __inline__ vector signed char __ATTRS_o_ai vec_srl(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:9654
static __inline__ vector unsigned int __ATTRS_o_ai vec_vmaxuw(vector unsigned int __a, vector unsigned int __b)
Definition: altivec.h:4448
static __inline__ vector signed char __ATTRS_o_ai vec_rl(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:7586
static __inline__ int __ATTRS_o_ai vec_any_le(vector signed char __a, vector signed char __b)
Definition: altivec.h:15402
static __inline__ vector int __ATTRS_o_ai vec_sum4s(vector signed char __a, vector int __b)
Definition: altivec.h:11472
static __inline__ vector int __ATTRS_o_ai vec_msums(vector short __a, vector short __b, vector int __c)
Definition: altivec.h:5500
static __inline__ vector int __ATTRS_o_ai vec_vupklsh(vector short __a)
Definition: altivec.h:11837
static __inline__ vector signed char __ATTRS_o_ai vec_packs(vector short __a, vector short __b)
Definition: altivec.h:7014
static __inline__ vector signed char __ATTRS_o_ai vec_vsr(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:9841
static __inline__ vector unsigned char __ATTRS_o_ai vec_vpkshus(vector short __a, vector short __b)
Definition: altivec.h:7201
static __inline__ vector unsigned int __ATTRS_o_ai vec_vadduws(vector unsigned int __a, vector unsigned int __b)
Definition: altivec.h:737
static __inline__ vector unsigned int __ATTRS_o_ai vec_vminuw(vector unsigned int __a, vector unsigned int __b)
Definition: altivec.h:5352
static __inline__ vector signed char __ATTRS_o_ai vec_ld(int __a, const vector signed char *__b)
Definition: altivec.h:3446
static __inline__ vector float __ATTRS_o_ai vec_ceil(vector float __a)
Definition: altivec.h:1587
static __inline__ vector float __ATTRS_o_ai vec_trunc(vector float __a)
Definition: altivec.h:11582
static __inline__ vector int __ATTRS_o_ai vec_vsrw(vector int __a, vector unsigned int __b)
Definition: altivec.h:9561
static __inline__ vector unsigned char __ATTRS_o_ai vec_packsu(vector short __a, vector short __b)
Definition: altivec.h:7143
static __inline__ vector unsigned int __ATTRS_o_ai vec_vsubuws(vector unsigned int __a, vector unsigned int __b)
Definition: altivec.h:11350
static __inline__ vector bool char __ATTRS_o_ai vec_cmple(vector signed char __a, vector signed char __b)
Definition: altivec.h:2084
static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed char __a, vector signed char __b)
Definition: altivec.h:14856
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:338
static __inline__ vector signed char __ATTRS_o_ai vec_vand(vector signed char __a, vector signed char __b)
Definition: altivec.h:996
vector signed char unaligned_vec_schar __attribute__((aligned(1)))
Zeroes the upper 128 bits (bits 255:128) of all YMM registers.
Definition: altivec.h:16344
static __inline__ vector signed char __ATTRS_o_ai vec_vandc(vector signed char __a, vector signed char __b)
Definition: altivec.h:1349
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:7775
static __inline__ vector int __ATTRS_o_ai vec_lvewx(int __a, const int *__b)
Definition: altivec.h:3681
static __inline__ vector signed char __ATTRS_o_ai vec_vspltisb(signed char __a)
Definition: altivec.h:9419
static __inline__ vector short __ATTRS_o_ai vec_vadduhm(vector short __a, vector short __b)
Definition: altivec.h:451
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:7483
static __inline__ vector signed char __ATTRS_o_ai vec_mergel(vector signed char __a, vector signed char __b)
Definition: altivec.h:4746
static __inline__ vector signed char __ATTRS_o_ai vec_abss(vector signed char __a)
Definition: altivec.h:158
static __inline__ vector signed char __ATTRS_o_ai vec_div(vector signed char __a, vector signed char __b)
Definition: altivec.h:3236
static __inline__ vector signed char __ATTRS_o_ai vec_adds(vector signed char __a, vector signed char __b)
Definition: altivec.h:560
static __inline__ vector short __ATTRS_o_ai vec_mulo(vector signed char __a, vector signed char __b)
Definition: altivec.h:5740
static __inline__ vector unsigned int __ATTRS_o_ai vec_unsigned(vector float __a)
Definition: altivec.h:2998
long i
Definition: xmmintrin.h:1456
static __inline__ vector signed char __ATTRS_o_ai vec_lde(int __a, const signed char *__b)
Definition: altivec.h:3624
static __inline__ vector signed char __ATTRS_o_ai vec_vsububm(vector signed char __a, vector signed char __b)
Definition: altivec.h:11032
static __inline__ vector signed char __ATTRS_o_ai vec_nor(vector signed char __a, vector signed char __b)
Definition: altivec.h:6040
static __inline__ vector unsigned short __ATTRS_o_ai vec_vadduhs(vector unsigned short __a, vector unsigned short __b)
Definition: altivec.h:703
static __inline__ vector signed char __ATTRS_o_ai vec_splat(vector signed char __a, unsigned const int __b)
Definition: altivec.h:9181
static __inline__ vector signed char __ATTRS_o_ai vec_vaddubm(vector signed char __a, vector signed char __b)
Definition: altivec.h:418
static __inline__ vector bool char __ATTRS_o_ai vec_cmplt(vector signed char __a, vector signed char __b)
Definition: altivec.h:2140
static __inline__ void __ATTRS_o_ai vec_mtvscr(vector signed char __a)
Definition: altivec.h:5529
static __inline__ vector signed char __ATTRS_o_ai vec_sll(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:8615
static __inline__ vector int __ATTRS_o_ai vec_vmrglw(vector int __a, vector int __b)
Definition: altivec.h:4974
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:8402
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:11456
static __inline__ vector short __ATTRS_o_ai vec_vsubuhm(vector short __a, vector short __b)
Definition: altivec.h:11065
static __inline__ vector signed char __ATTRS_o_ai vec_vnor(vector signed char __a, vector signed char __b)
Definition: altivec.h:6103
static __inline__ vector signed char __ATTRS_o_ai vec_and(vector signed char __a, vector signed char __b)
Definition: altivec.h:810
static __inline__ vector signed char __ATTRS_o_ai vec_add(vector signed char __a, vector signed char __b)
Definition: altivec.h:198
static __inline__ vector int __ATTRS_o_ai vec_msum(vector signed char __a, vector unsigned char __b, vector int __c)
Definition: altivec.h:5444
static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed char __a, vector signed char __b)
Definition: altivec.h:13902
static __inline__ vector short __ATTRS_o_ai vec_vmrglh(vector short __a, vector short __b)
Definition: altivec.h:4938
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:7909
static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed char __a, vector signed char __b)
Definition: altivec.h:15767
#define __CR6_EQ_REV
Definition: altivec.h:19
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:10612
static __inline__ vector unsigned char __ATTRS_o_ai vec_xor(vector unsigned char __a, vector unsigned char __b)
Definition: altivec.h:12164
static __inline__ vector signed char __ATTRS_o_ai vec_sro(vector signed char __a, vector signed char __b)
Definition: altivec.h:10014
static __inline__ vector short __ATTRS_o_ai vec_vsplth(vector short __a, unsigned char __b)
Definition: altivec.h:9329
static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsl(int __a, const signed char *__b)
Definition: altivec.h:3903
#define __CR6_LT
Definition: altivec.h:20
static __inline__ vector signed char __ATTRS_o_ai vec_vminsb(vector signed char __a, vector signed char __b)
Definition: altivec.h:5267
static __inline__ void int __a
Definition: emmintrin.h:4185
static vector float __ATTRS_o_ai vec_nabs(vector float __a)
Definition: altivec.h:16709
static __inline__ vector signed char __ATTRS_o_ai vec_insert(signed char __a, vector signed char __b, int __c)
Definition: altivec.h:12623
static __inline__ vector signed char __ATTRS_o_ai vec_lvrxl(int __a, const signed char *__b)
Definition: altivec.h:13032
__tmp
Definition: xmmintrin.h:166
static __ATTRS_o_ai vector signed char vec_xl(signed long long __offset, signed char *__ptr)
Definition: altivec.h:16352
static __inline__ vector signed char __ATTRS_o_ai vec_vpkuhum(vector signed short __a, vector signed short __b)
Definition: altivec.h:6846
static __inline__ vector float __ATTRS_o_ai vec_rsqrte(vector float __a)
Definition: altivec.h:7750
__v16qu mask
Definition: emmintrin.h:2133
static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed char __a, vector signed char __b)
Definition: altivec.h:15581
static __inline__ vector unsigned char __ATTRS_o_ai vec_sl(vector unsigned char __a, vector unsigned char __b)
Definition: altivec.h:8029
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:4141
static __inline__ int __ATTRS_o_ai vec_all_nge(vector float __a, vector float __b)
Definition: altivec.h:14799
static __inline__ vector float __ATTRS_o_ai vec_float(vector signed int __a)
Definition: altivec.h:3040
#define NULL
static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed char __a, vector signed char __b)
Definition: altivec.h:14073
static __inline__ vector unsigned char __ATTRS_o_ai vec_vmaxub(vector unsigned char __a, vector unsigned char __b)
Definition: altivec.h:4380
static __inline__ vector signed char __ATTRS_o_ai vec_subs(vector signed char __a, vector signed char __b)
Definition: altivec.h:11173
static __inline__ vector signed char __ATTRS_o_ai vec_mul(vector signed char __a, vector signed char __b)
Definition: altivec.h:5580
static __inline__ vector int __ATTRS_o_ai vec_vadduwm(vector int __a, vector int __b)
Definition: altivec.h:485
static __inline__ vector float __ATTRS_o_ai vec_floor(vector float __a)
Definition: altivec.h:3422
static __inline__ vector signed char __ATTRS_o_ai vec_or(vector signed char __a, vector signed char __b)
Definition: altivec.h:6176
static __inline__ vector signed char __ATTRS_o_ai vec_andc(vector signed char __a, vector signed char __b)
Definition: altivec.h:1163
static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed char __a, vector signed char __b)
Definition: altivec.h:15044
static __inline__ vector unsigned char __ATTRS_o_ai vec_vsububs(vector unsigned char __a, vector unsigned char __b)
Definition: altivec.h:11282
static __inline__ vector short __ATTRS_o_ai vec_vaddshs(vector short __a, vector short __b)
Definition: altivec.h:685
static __inline__ vector signed int __ATTRS_o_ai vec_signed(vector float __a)
Definition: altivec.h:2956
static __inline__ vector signed char __ATTRS_o_ai vec_slo(vector signed char __a, vector signed char __b)
Definition: altivec.h:8975
static __inline__ vector unsigned short __ATTRS_o_ai vec_vpkswus(vector int __a, vector int __b)
Definition: altivec.h:7221
static __inline__ vector signed char __ATTRS_o_ai vec_vsrab(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:9618
static __inline__ vector bool char __ATTRS_o_ai vec_cmpeq(vector signed char __a, vector signed char __b)
Definition: altivec.h:1625
static __inline__ vector signed char __ATTRS_o_ai vec_splats(signed char __a)
Definition: altivec.h:13651
static __inline__ void __ATTRS_o_ai vec_stvlx(vector signed char __a, int __b, signed char *__c)
Definition: altivec.h:13137
static __inline__ vector signed char __ATTRS_o_ai vec_sub(vector signed char __a, vector signed char __b)
Definition: altivec.h:10904
static __inline__ vector signed char __ATTRS_o_ai vec_sra(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:9574
static __inline__ void __ATTRS_o_ai vec_stvx(vector signed char __a, int __b, vector signed char *__c)
Definition: altivec.h:10350
static __inline__ vector int __ATTRS_o_ai vec_vmrghw(vector int __a, vector int __b)
Definition: altivec.h:4711
static __inline__ vector int __ATTRS_o_ai vec_vspltw(vector int __a, unsigned char __b)
Definition: altivec.h:9369
static __inline__ vector signed int __ATTRS_o_ai vec_subc(vector signed int __a, vector signed int __b)
Definition: altivec.h:11141
static __inline__ vector signed char __ATTRS_o_ai vec_max(vector signed char __a, vector signed char __b)
Definition: altivec.h:4223
static __inline__ vector signed char __ATTRS_o_ai vec_vmaxsb(vector signed char __a, vector signed char __b)
Definition: altivec.h:4363
static __inline__ vector signed char __ATTRS_o_ai vec_vor(vector signed char __a, vector signed char __b)
Definition: altivec.h:6520
static __inline__ vector signed int __ATTRS_o_ai vec_sld(vector signed int, vector signed int, unsigned const int __c)
Definition: altivec.h:8250
static __inline__ vector int __ATTRS_o_ai vec_vminsw(vector int __a, vector int __b)
Definition: altivec.h:5334
static __inline__ vector unsigned short __ATTRS_o_ai vec_vmaxuh(vector unsigned short __a, vector unsigned short __b)
Definition: altivec.h:4414
static __inline__ vector short __ATTRS_o_ai vec_vslh(vector short __a, vector unsigned short __b)
Definition: altivec.h:8093
static __inline__ vector signed char __ATTRS_o_ai vec_vmrglb(vector signed char __a, vector signed char __b)
Definition: altivec.h:4911
static __inline__ vector float vector float __b
Definition: altivec.h:520
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:7261
static __inline__ void __ATTRS_o_ai vec_stvlxl(vector signed char __a, int __b, signed char *__c)
Definition: altivec.h:13253
static __inline__ vector short __ATTRS_o_ai vec_vupklsb(vector signed char __a)
Definition: altivec.h:11818
static __inline__ vector bool char __ATTRS_o_ai vec_cmpge(vector signed char __a, vector signed char __b)
Definition: altivec.h:1968
static __inline__ vector signed char __ATTRS_o_ai vec_vsl(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:8802
static __inline__ vector short __ATTRS_o_ai vec_unpackh(vector signed char __a)
Definition: altivec.h:11609
__inline __m128d __m128d const int __mask
Definition: emmintrin.h:1148
static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed char __a, vector signed char __b)
Definition: altivec.h:14611
static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed char __a, vector signed char __b)
Definition: altivec.h:14423
static __inline__ vector int __ATTRS_o_ai vec_vsraw(vector int __a, vector unsigned int __b)
Definition: altivec.h:9641
static __inline__ vector signed char __ATTRS_o_ai vec_lvrx(int __a, const signed char *__b)
Definition: altivec.h:12926
static __inline__ vector signed char __ATTRS_o_ai vec_vmrghb(vector signed char __a, vector signed char __b)
Definition: altivec.h:4648
static __inline__ vector short __ATTRS_o_ai vec_vmladduhm(vector short __a, vector short __b, vector short __c)
Definition: altivec.h:5406
static __ATTRS_o_ai void vec_xst(vector signed char __vec, signed long long __offset, signed char *__ptr)
Definition: altivec.h:16501
static __inline__ vector unsigned short __ATTRS_o_ai vec_vminuh(vector unsigned short __a, vector unsigned short __b)
Definition: altivec.h:5318
static __inline__ vector signed char __ATTRS_o_ai vec_lvlxl(int __a, const signed char *__b)
Definition: altivec.h:12820
static __inline__ vector short __ATTRS_o_ai vec_lvehx(int __a, const short *__b)
Definition: altivec.h:3669
static __inline__ vector signed char __ATTRS_o_ai vec_vslo(vector signed char __a, vector signed char __b)
Definition: altivec.h:9091
#define vec_xl_be
Definition: altivec.h:16496
static __inline__ vector unsigned char __ATTRS_o_ai vec_vaddubs(vector unsigned char __a, vector unsigned char __b)
Definition: altivec.h:669
#define __CR6_EQ
Definition: altivec.h:18
static __inline__ vector short __ATTRS_o_ai vec_vsrah(vector short __a, vector unsigned short __b)
Definition: altivec.h:9630
static __inline__ vector int __ATTRS_o_ai vec_splat_s32(signed char __a)
Definition: altivec.h:9444
static __inline__ vector signed char __ATTRS_o_ai vec_splat_s8(signed char __a)
Definition: altivec.h:9411
static __inline__ vector signed char __ATTRS_o_ai vec_vslb(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:8079
static __inline__ vector signed char __ATTRS_o_ai vec_lvxl(int __a, const vector signed char *__b)
Definition: altivec.h:3787
static __inline__ vector signed int __ATTRS_o_ai vec_addc(vector signed int __a, vector signed int __b)
Definition: altivec.h:527
static __inline__ vector bool char __ATTRS_o_ai vec_cmpgt(vector signed char __a, vector signed char __b)
Definition: altivec.h:1908
static __inline__ vector signed char __ATTRS_o_ai vec_vspltb(vector signed char __a, unsigned char __b)
Definition: altivec.h:9311
static __inline__ vector float __ATTRS_o_ai vec_nmsub(vector float __a, vector float __b, vector float __c)
Definition: altivec.h:6010
static __inline__ vector signed char __ATTRS_o_ai vec_vxor(vector signed char __a, vector signed char __b)
Definition: altivec.h:12332
static __inline__ vector unsigned char __ATTRS_o_ai vec_splat_u8(unsigned char __a)
Definition: altivec.h:9459
static __inline__ vector unsigned short __ATTRS_o_ai vec_splat_u16(signed char __a)
Definition: altivec.h:9467
static __inline__ vector unsigned char __ATTRS_o_ai vec_vminub(vector unsigned char __a, vector unsigned char __b)
Definition: altivec.h:5284
static __inline__ vector short __ATTRS_o_ai vec_vupkhsb(vector signed char __a)
Definition: altivec.h:11679
static __inline__ void __ATTRS_o_ai vec_stl(vector signed char __a, int __b, vector signed char *__c)
Definition: altivec.h:10639
static __inline__ void __ATTRS_o_ai vec_stvrxl(vector signed char __a, int __b, signed char *__c)
Definition: altivec.h:13486
static __inline__ vector signed char __ATTRS_o_ai vec_promote(signed char __a, int __b)
Definition: altivec.h:13603
static __inline__ void __ATTRS_o_ai vec_st(vector signed char __a, int __b, vector signed char *__c)
Definition: altivec.h:10219
static __inline__ void __ATTRS_o_ai vec_ste(vector signed char __a, int __b, signed char *__c)
Definition: altivec.h:10482
static __inline__ vector signed char __ATTRS_o_ai vec_avg(vector signed char __a, vector signed char __b)
Definition: altivec.h:1514
static vector float __ATTRS_o_ai vec_neg(vector float __a)
Definition: altivec.h:16680
static __inline__ vector unsigned int __ATTRS_o_ai vec_splat_u32(signed char __a)
Definition: altivec.h:9475
static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed char __a, vector signed char __b)
Definition: altivec.h:15223
static __inline__ vector signed char __ATTRS_o_ai vec_lvlx(int __a, const signed char *__b)
Definition: altivec.h:12714
static __inline__ vector short __ATTRS_o_ai vec_vminsh(vector short __a, vector short __b)
Definition: altivec.h:5300
static __inline__ vector int __ATTRS_o_ai vec_vsubuwm(vector int __a, vector int __b)
Definition: altivec.h:11099
static __inline__ vector short __ATTRS_o_ai vec_vmaxsh(vector short __a, vector short __b)
Definition: altivec.h:4396
static __inline__ vector signed char __ATTRS_o_ai vec_pack(vector signed short __a, vector signed short __b)
Definition: altivec.h:6688
static __inline__ vector float __ATTRS_o_ai vec_re(vector float __a)
Definition: altivec.h:7562
static __inline__ vector unsigned short __ATTRS_o_ai vec_vsubuhs(vector unsigned short __a, vector unsigned short __b)
Definition: altivec.h:11316
static __inline__ vector short __ATTRS_o_ai vec_mule(vector signed char __a, vector signed char __b)
Definition: altivec.h:5638
static __inline__ vector signed char __ATTRS_o_ai vec_vsro(vector signed char __a, vector signed char __b)
Definition: altivec.h:10130
static __inline__ vector short __ATTRS_o_ai vec_vspltish(signed char __a)
Definition: altivec.h:9435
static __inline__ vector int __ATTRS_o_ai vec_vspltisw(signed char __a)
Definition: altivec.h:9451
static __inline__ vector signed char __ATTRS_o_ai vec_ldl(int __a, const vector signed char *__b)
Definition: altivec.h:3698
static __inline__ signed char __ATTRS_o_ai vec_extract(vector signed char __a, int __b)
Definition: altivec.h:12498
#define vec_xst_be
Definition: altivec.h:16666
static __inline__ vector signed char __ATTRS_o_ai vec_lvebx(int __a, const signed char *__b)
Definition: altivec.h:3658
static __inline__ void __ATTRS_o_ai vec_stvebx(vector signed char __a, int __b, signed char *__c)
Definition: altivec.h:10558
static __inline__ vector int __ATTRS_o_ai vec_vrlw(vector int __a, vector unsigned int __b)
Definition: altivec.h:7683
static __inline__ vector unsigned char __ATTRS_o_ai vec_sr(vector unsigned char __a, vector unsigned char __b)
Definition: altivec.h:9484
static __inline__ int __ATTRS_o_ai vec_all_nan(vector float __a)
Definition: altivec.h:14595
static __inline__ void __ATTRS_o_ai vec_stvrx(vector signed char __a, int __b, signed char *__c)
Definition: altivec.h:13370
static __inline__ vector short __ATTRS_o_ai vec_vrlh(vector short __a, vector unsigned short __b)
Definition: altivec.h:7672
static __inline__ vector int __ATTRS_o_ai vec_vmaxsw(vector int __a, vector int __b)
Definition: altivec.h:4430
#define __ATTRS_o_ai
Definition: altivec.h:42
static __inline__ vector short __ATTRS_o_ai vec_vmrghh(vector short __a, vector short __b)
Definition: altivec.h:4675
static __inline__ vector bool char __ATTRS_o_ai vec_revb(vector bool char __a)
Definition: altivec.h:16229
static __inline__ vector signed char __ATTRS_o_ai vec_vsrb(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:9534
static __inline__ vector signed char __ATTRS_o_ai vec_abs(vector signed char __a)
Definition: altivec.h:115
static __inline__ vector signed char __ATTRS_o_ai vec_lvx(int __a, const vector signed char *__b)
Definition: altivec.h:3535
static __inline__ vector float __ATTRS_o_ai vec_round(vector float __a)
Definition: altivec.h:7695
static __inline__ vector short __ATTRS_o_ai vec_unpackl(vector signed char __a)
Definition: altivec.h:11748
static __inline__ void __ATTRS_o_ai vec_stvxl(vector signed char __a, int __b, vector signed char *__c)
Definition: altivec.h:10770
static __inline__ int __ATTRS_o_ai vec_all_ngt(vector float __a, vector float __b)
Definition: altivec.h:14817
static __inline__ vector signed char __ATTRS_o_ai vec_vsldoi(vector signed char __a, vector signed char __b, unsigned char __c)
Definition: altivec.h:8465
static __inline__ int __ATTRS_o_ai vec_all_le(vector signed char __a, vector signed char __b)
Definition: altivec.h:14251
static __inline__ vector signed char __ATTRS_o_ai vec_vsubsbs(vector signed char __a, vector signed char __b)
Definition: altivec.h:11265
static __ATTRS_o_ai vector bool char vec_reve(vector bool char __a)
Definition: altivec.h:16159
static __inline__ vector signed char __ATTRS_o_ai vec_mergeh(vector signed char __a, vector signed char __b)
Definition: altivec.h:4476
static __inline__ vector short __ATTRS_o_ai vec_splat_s16(signed char __a)
Definition: altivec.h:9428
static __inline__ vector int __ATTRS_o_ai vec_vslw(vector int __a, vector unsigned int __b)
Definition: altivec.h:8106
static __inline__ vector signed char __ATTRS_o_ai vec_min(vector signed char __a, vector signed char __b)
Definition: altivec.h:5127
static __inline__ vector short __ATTRS_o_ai vec_vsubshs(vector short __a, vector short __b)
Definition: altivec.h:11298
static __inline__ vector float vector float vector float __c
Definition: altivec.h:4185
static __inline__ vector signed char __ATTRS_o_ai vec_vrlb(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:7660
static __inline__ vector signed char __ATTRS_o_ai vec_vaddsbs(vector signed char __a, vector signed char __b)
Definition: altivec.h:652
static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsr(int __a, const signed char *__b)
Definition: altivec.h:4024
static __inline__ vector int __ATTRS_o_ai vec_vaddsws(vector int __a, vector int __b)
Definition: altivec.h:719
static __inline__ vector short __ATTRS_o_ai vec_vpkuwum(vector int __a, vector int __b)
Definition: altivec.h:6894
static __inline__ int __ATTRS_o_ai vec_all_eq(vector signed char __a, vector signed char __b)
Definition: altivec.h:13715
static __inline__ vector int __ATTRS_o_ai vec_vsubsws(vector int __a, vector int __b)
Definition: altivec.h:11332