clang  3.9.0
altivec.h
Go to the documentation of this file.
1 /*===---- altivec.h - Standard header for type generic math ---------------===*\
2  *
3  * Permission is hereby granted, free of charge, to any person obtaining a copy
4  * of this software and associated documentation files (the "Software"), to deal
5  * in the Software without restriction, including without limitation the rights
6  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7  * copies of the Software, and to permit persons to whom the Software is
8  * furnished to do so, subject to the following conditions:
9  *
10  * The above copyright notice and this permission notice shall be included in
11  * all copies or substantial portions of the Software.
12  *
13  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19  * THE SOFTWARE.
20  *
21 \*===----------------------------------------------------------------------===*/
22 
23 #ifndef __ALTIVEC_H
24 #define __ALTIVEC_H
25 
26 #ifndef __ALTIVEC__
27 #error "AltiVec support not enabled"
28 #endif
29 
30 /* Constants for mapping CR6 bits to predicate result. */
31 
32 #define __CR6_EQ 0
33 #define __CR6_EQ_REV 1
34 #define __CR6_LT 2
35 #define __CR6_LT_REV 3
36 
37 #define __ATTRS_o_ai __attribute__((__overloadable__, __always_inline__))
38 
39 static __inline__ vector signed char __ATTRS_o_ai vec_perm(
40  vector signed char __a, vector signed char __b, vector unsigned char __c);
41 
42 static __inline__ vector unsigned char __ATTRS_o_ai
43 vec_perm(vector unsigned char __a, vector unsigned char __b,
44  vector unsigned char __c);
45 
46 static __inline__ vector bool char __ATTRS_o_ai
47 vec_perm(vector bool char __a, vector bool char __b, vector unsigned char __c);
48 
49 static __inline__ vector short __ATTRS_o_ai vec_perm(vector signed short __a,
50  vector signed short __b,
51  vector unsigned char __c);
52 
53 static __inline__ vector unsigned short __ATTRS_o_ai
54 vec_perm(vector unsigned short __a, vector unsigned short __b,
55  vector unsigned char __c);
56 
57 static __inline__ vector bool short __ATTRS_o_ai vec_perm(
58  vector bool short __a, vector bool short __b, vector unsigned char __c);
59 
60 static __inline__ vector pixel __ATTRS_o_ai vec_perm(vector pixel __a,
61  vector pixel __b,
62  vector unsigned char __c);
63 
64 static __inline__ vector int __ATTRS_o_ai vec_perm(vector signed int __a,
65  vector signed int __b,
66  vector unsigned char __c);
67 
68 static __inline__ vector unsigned int __ATTRS_o_ai vec_perm(
69  vector unsigned int __a, vector unsigned int __b, vector unsigned char __c);
70 
71 static __inline__ vector bool int __ATTRS_o_ai
72 vec_perm(vector bool int __a, vector bool int __b, vector unsigned char __c);
73 
74 static __inline__ vector float __ATTRS_o_ai vec_perm(vector float __a,
75  vector float __b,
76  vector unsigned char __c);
77 
78 #ifdef __VSX__
79 static __inline__ vector long long __ATTRS_o_ai
80 vec_perm(vector signed long long __a, vector signed long long __b,
81  vector unsigned char __c);
82 
83 static __inline__ vector unsigned long long __ATTRS_o_ai
84 vec_perm(vector unsigned long long __a, vector unsigned long long __b,
85  vector unsigned char __c);
86 
87 static __inline__ vector bool long long __ATTRS_o_ai
88 vec_perm(vector bool long long __a, vector bool long long __b,
89  vector unsigned char __c);
90 
91 static __inline__ vector double __ATTRS_o_ai vec_perm(vector double __a,
92  vector double __b,
93  vector unsigned char __c);
94 #endif
95 
96 static __inline__ vector unsigned char __ATTRS_o_ai
97 vec_xor(vector unsigned char __a, vector unsigned char __b);
98 
99 /* vec_abs */
100 
101 #define __builtin_altivec_abs_v16qi vec_abs
102 #define __builtin_altivec_abs_v8hi vec_abs
103 #define __builtin_altivec_abs_v4si vec_abs
104 
105 static __inline__ vector signed char __ATTRS_o_ai
106 vec_abs(vector signed char __a) {
107  return __builtin_altivec_vmaxsb(__a, -__a);
108 }
109 
110 static __inline__ vector signed short __ATTRS_o_ai
111 vec_abs(vector signed short __a) {
112  return __builtin_altivec_vmaxsh(__a, -__a);
113 }
114 
115 static __inline__ vector signed int __ATTRS_o_ai
116 vec_abs(vector signed int __a) {
117  return __builtin_altivec_vmaxsw(__a, -__a);
118 }
119 
120 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
121 static __inline__ vector signed long long __ATTRS_o_ai
122 vec_abs(vector signed long long __a) {
123  return __builtin_altivec_vmaxsd(__a, -__a);
124 }
125 #endif
126 
127 static __inline__ vector float __ATTRS_o_ai vec_abs(vector float __a) {
128 #ifdef __VSX__
129  return __builtin_vsx_xvabssp(__a);
130 #else
131  vector unsigned int __res =
132  (vector unsigned int)__a & (vector unsigned int)(0x7FFFFFFF);
133  return (vector float)__res;
134 #endif
135 }
136 
137 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
138 static __inline__ vector double __ATTRS_o_ai vec_abs(vector double __a) {
139  return __builtin_vsx_xvabsdp(__a);
140 }
141 #endif
142 
143 /* vec_abss */
144 #define __builtin_altivec_abss_v16qi vec_abss
145 #define __builtin_altivec_abss_v8hi vec_abss
146 #define __builtin_altivec_abss_v4si vec_abss
147 
148 static __inline__ vector signed char __ATTRS_o_ai
149 vec_abss(vector signed char __a) {
150  return __builtin_altivec_vmaxsb(
151  __a, __builtin_altivec_vsubsbs((vector signed char)(0), __a));
152 }
153 
154 static __inline__ vector signed short __ATTRS_o_ai
155 vec_abss(vector signed short __a) {
156  return __builtin_altivec_vmaxsh(
157  __a, __builtin_altivec_vsubshs((vector signed short)(0), __a));
158 }
159 
160 static __inline__ vector signed int __ATTRS_o_ai
161 vec_abss(vector signed int __a) {
162  return __builtin_altivec_vmaxsw(
163  __a, __builtin_altivec_vsubsws((vector signed int)(0), __a));
164 }
165 
166 /* vec_add */
167 
168 static __inline__ vector signed char __ATTRS_o_ai
169 vec_add(vector signed char __a, vector signed char __b) {
170  return __a + __b;
171 }
172 
173 static __inline__ vector signed char __ATTRS_o_ai
174 vec_add(vector bool char __a, vector signed char __b) {
175  return (vector signed char)__a + __b;
176 }
177 
178 static __inline__ vector signed char __ATTRS_o_ai
179 vec_add(vector signed char __a, vector bool char __b) {
180  return __a + (vector signed char)__b;
181 }
182 
183 static __inline__ vector unsigned char __ATTRS_o_ai
184 vec_add(vector unsigned char __a, vector unsigned char __b) {
185  return __a + __b;
186 }
187 
188 static __inline__ vector unsigned char __ATTRS_o_ai
189 vec_add(vector bool char __a, vector unsigned char __b) {
190  return (vector unsigned char)__a + __b;
191 }
192 
193 static __inline__ vector unsigned char __ATTRS_o_ai
194 vec_add(vector unsigned char __a, vector bool char __b) {
195  return __a + (vector unsigned char)__b;
196 }
197 
198 static __inline__ vector short __ATTRS_o_ai vec_add(vector short __a,
199  vector short __b) {
200  return __a + __b;
201 }
202 
203 static __inline__ vector short __ATTRS_o_ai vec_add(vector bool short __a,
204  vector short __b) {
205  return (vector short)__a + __b;
206 }
207 
208 static __inline__ vector short __ATTRS_o_ai vec_add(vector short __a,
209  vector bool short __b) {
210  return __a + (vector short)__b;
211 }
212 
213 static __inline__ vector unsigned short __ATTRS_o_ai
214 vec_add(vector unsigned short __a, vector unsigned short __b) {
215  return __a + __b;
216 }
217 
218 static __inline__ vector unsigned short __ATTRS_o_ai
219 vec_add(vector bool short __a, vector unsigned short __b) {
220  return (vector unsigned short)__a + __b;
221 }
222 
223 static __inline__ vector unsigned short __ATTRS_o_ai
224 vec_add(vector unsigned short __a, vector bool short __b) {
225  return __a + (vector unsigned short)__b;
226 }
227 
228 static __inline__ vector int __ATTRS_o_ai vec_add(vector int __a,
229  vector int __b) {
230  return __a + __b;
231 }
232 
233 static __inline__ vector int __ATTRS_o_ai vec_add(vector bool int __a,
234  vector int __b) {
235  return (vector int)__a + __b;
236 }
237 
238 static __inline__ vector int __ATTRS_o_ai vec_add(vector int __a,
239  vector bool int __b) {
240  return __a + (vector int)__b;
241 }
242 
243 static __inline__ vector unsigned int __ATTRS_o_ai
244 vec_add(vector unsigned int __a, vector unsigned int __b) {
245  return __a + __b;
246 }
247 
248 static __inline__ vector unsigned int __ATTRS_o_ai
249 vec_add(vector bool int __a, vector unsigned int __b) {
250  return (vector unsigned int)__a + __b;
251 }
252 
253 static __inline__ vector unsigned int __ATTRS_o_ai
254 vec_add(vector unsigned int __a, vector bool int __b) {
255  return __a + (vector unsigned int)__b;
256 }
257 
258 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
259 static __inline__ vector signed long long __ATTRS_o_ai
260 vec_add(vector signed long long __a, vector signed long long __b) {
261  return __a + __b;
262 }
263 
264 static __inline__ vector unsigned long long __ATTRS_o_ai
265 vec_add(vector unsigned long long __a, vector unsigned long long __b) {
266  return __a + __b;
267 }
268 
269 static __inline__ vector signed __int128 __ATTRS_o_ai
270 vec_add(vector signed __int128 __a, vector signed __int128 __b) {
271  return __a + __b;
272 }
273 
274 static __inline__ vector unsigned __int128 __ATTRS_o_ai
275 vec_add(vector unsigned __int128 __a, vector unsigned __int128 __b) {
276  return __a + __b;
277 }
278 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
279 
280 static __inline__ vector float __ATTRS_o_ai vec_add(vector float __a,
281  vector float __b) {
282  return __a + __b;
283 }
284 
285 #ifdef __VSX__
286 static __inline__ vector double __ATTRS_o_ai vec_add(vector double __a,
287  vector double __b) {
288  return __a + __b;
289 }
290 #endif // __VSX__
291 
292 /* vec_adde */
293 
294 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
295 static __inline__ vector signed __int128 __ATTRS_o_ai
296 vec_adde(vector signed __int128 __a, vector signed __int128 __b,
297  vector signed __int128 __c) {
298  return __builtin_altivec_vaddeuqm(__a, __b, __c);
299 }
300 
301 static __inline__ vector unsigned __int128 __ATTRS_o_ai
302 vec_adde(vector unsigned __int128 __a, vector unsigned __int128 __b,
303  vector unsigned __int128 __c) {
304  return __builtin_altivec_vaddeuqm(__a, __b, __c);
305 }
306 #endif
307 
308 /* vec_addec */
309 
310 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
311 static __inline__ vector signed __int128 __ATTRS_o_ai
312 vec_addec(vector signed __int128 __a, vector signed __int128 __b,
313  vector signed __int128 __c) {
314  return __builtin_altivec_vaddecuq(__a, __b, __c);
315 }
316 
317 static __inline__ vector unsigned __int128 __ATTRS_o_ai
318 vec_addec(vector unsigned __int128 __a, vector unsigned __int128 __b,
319  vector unsigned __int128 __c) {
320  return __builtin_altivec_vaddecuq(__a, __b, __c);
321 }
322 #endif
323 
324 /* vec_vaddubm */
325 
326 #define __builtin_altivec_vaddubm vec_vaddubm
327 
328 static __inline__ vector signed char __ATTRS_o_ai
329 vec_vaddubm(vector signed char __a, vector signed char __b) {
330  return __a + __b;
331 }
332 
333 static __inline__ vector signed char __ATTRS_o_ai
334 vec_vaddubm(vector bool char __a, vector signed char __b) {
335  return (vector signed char)__a + __b;
336 }
337 
338 static __inline__ vector signed char __ATTRS_o_ai
339 vec_vaddubm(vector signed char __a, vector bool char __b) {
340  return __a + (vector signed char)__b;
341 }
342 
343 static __inline__ vector unsigned char __ATTRS_o_ai
344 vec_vaddubm(vector unsigned char __a, vector unsigned char __b) {
345  return __a + __b;
346 }
347 
348 static __inline__ vector unsigned char __ATTRS_o_ai
349 vec_vaddubm(vector bool char __a, vector unsigned char __b) {
350  return (vector unsigned char)__a + __b;
351 }
352 
353 static __inline__ vector unsigned char __ATTRS_o_ai
354 vec_vaddubm(vector unsigned char __a, vector bool char __b) {
355  return __a + (vector unsigned char)__b;
356 }
357 
358 /* vec_vadduhm */
359 
360 #define __builtin_altivec_vadduhm vec_vadduhm
361 
362 static __inline__ vector short __ATTRS_o_ai vec_vadduhm(vector short __a,
363  vector short __b) {
364  return __a + __b;
365 }
366 
367 static __inline__ vector short __ATTRS_o_ai vec_vadduhm(vector bool short __a,
368  vector short __b) {
369  return (vector short)__a + __b;
370 }
371 
372 static __inline__ vector short __ATTRS_o_ai vec_vadduhm(vector short __a,
373  vector bool short __b) {
374  return __a + (vector short)__b;
375 }
376 
377 static __inline__ vector unsigned short __ATTRS_o_ai
378 vec_vadduhm(vector unsigned short __a, vector unsigned short __b) {
379  return __a + __b;
380 }
381 
382 static __inline__ vector unsigned short __ATTRS_o_ai
383 vec_vadduhm(vector bool short __a, vector unsigned short __b) {
384  return (vector unsigned short)__a + __b;
385 }
386 
387 static __inline__ vector unsigned short __ATTRS_o_ai
388 vec_vadduhm(vector unsigned short __a, vector bool short __b) {
389  return __a + (vector unsigned short)__b;
390 }
391 
392 /* vec_vadduwm */
393 
394 #define __builtin_altivec_vadduwm vec_vadduwm
395 
396 static __inline__ vector int __ATTRS_o_ai vec_vadduwm(vector int __a,
397  vector int __b) {
398  return __a + __b;
399 }
400 
401 static __inline__ vector int __ATTRS_o_ai vec_vadduwm(vector bool int __a,
402  vector int __b) {
403  return (vector int)__a + __b;
404 }
405 
406 static __inline__ vector int __ATTRS_o_ai vec_vadduwm(vector int __a,
407  vector bool int __b) {
408  return __a + (vector int)__b;
409 }
410 
411 static __inline__ vector unsigned int __ATTRS_o_ai
412 vec_vadduwm(vector unsigned int __a, vector unsigned int __b) {
413  return __a + __b;
414 }
415 
416 static __inline__ vector unsigned int __ATTRS_o_ai
417 vec_vadduwm(vector bool int __a, vector unsigned int __b) {
418  return (vector unsigned int)__a + __b;
419 }
420 
421 static __inline__ vector unsigned int __ATTRS_o_ai
422 vec_vadduwm(vector unsigned int __a, vector bool int __b) {
423  return __a + (vector unsigned int)__b;
424 }
425 
426 /* vec_vaddfp */
427 
428 #define __builtin_altivec_vaddfp vec_vaddfp
429 
430 static __inline__ vector float __attribute__((__always_inline__))
431 vec_vaddfp(vector float __a, vector float __b) {
432  return __a + __b;
433 }
434 
435 /* vec_addc */
436 
437 static __inline__ vector signed int __ATTRS_o_ai
438 vec_addc(vector signed int __a, vector signed int __b) {
439  return (vector signed int)__builtin_altivec_vaddcuw((vector unsigned int)__a,
440  (vector unsigned int)__b);
441 }
442 
443 static __inline__ vector unsigned int __ATTRS_o_ai
444 vec_addc(vector unsigned int __a, vector unsigned int __b) {
445  return __builtin_altivec_vaddcuw(__a, __b);
446 }
447 
448 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
449 static __inline__ vector signed __int128 __ATTRS_o_ai
450 vec_addc(vector signed __int128 __a, vector signed __int128 __b) {
451  return (vector signed __int128)__builtin_altivec_vaddcuq(
452  (vector unsigned __int128)__a, (vector unsigned __int128)__b);
453 }
454 
455 static __inline__ vector unsigned __int128 __ATTRS_o_ai
456 vec_addc(vector unsigned __int128 __a, vector unsigned __int128 __b) {
457  return __builtin_altivec_vaddcuq(__a, __b);
458 }
459 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
460 
461 /* vec_vaddcuw */
462 
463 static __inline__ vector unsigned int __attribute__((__always_inline__))
464 vec_vaddcuw(vector unsigned int __a, vector unsigned int __b) {
465  return __builtin_altivec_vaddcuw(__a, __b);
466 }
467 
468 /* vec_adds */
469 
470 static __inline__ vector signed char __ATTRS_o_ai
471 vec_adds(vector signed char __a, vector signed char __b) {
472  return __builtin_altivec_vaddsbs(__a, __b);
473 }
474 
475 static __inline__ vector signed char __ATTRS_o_ai
476 vec_adds(vector bool char __a, vector signed char __b) {
477  return __builtin_altivec_vaddsbs((vector signed char)__a, __b);
478 }
479 
480 static __inline__ vector signed char __ATTRS_o_ai
481 vec_adds(vector signed char __a, vector bool char __b) {
482  return __builtin_altivec_vaddsbs(__a, (vector signed char)__b);
483 }
484 
485 static __inline__ vector unsigned char __ATTRS_o_ai
486 vec_adds(vector unsigned char __a, vector unsigned char __b) {
487  return __builtin_altivec_vaddubs(__a, __b);
488 }
489 
490 static __inline__ vector unsigned char __ATTRS_o_ai
491 vec_adds(vector bool char __a, vector unsigned char __b) {
492  return __builtin_altivec_vaddubs((vector unsigned char)__a, __b);
493 }
494 
495 static __inline__ vector unsigned char __ATTRS_o_ai
496 vec_adds(vector unsigned char __a, vector bool char __b) {
497  return __builtin_altivec_vaddubs(__a, (vector unsigned char)__b);
498 }
499 
500 static __inline__ vector short __ATTRS_o_ai vec_adds(vector short __a,
501  vector short __b) {
502  return __builtin_altivec_vaddshs(__a, __b);
503 }
504 
505 static __inline__ vector short __ATTRS_o_ai vec_adds(vector bool short __a,
506  vector short __b) {
507  return __builtin_altivec_vaddshs((vector short)__a, __b);
508 }
509 
510 static __inline__ vector short __ATTRS_o_ai vec_adds(vector short __a,
511  vector bool short __b) {
512  return __builtin_altivec_vaddshs(__a, (vector short)__b);
513 }
514 
515 static __inline__ vector unsigned short __ATTRS_o_ai
516 vec_adds(vector unsigned short __a, vector unsigned short __b) {
517  return __builtin_altivec_vadduhs(__a, __b);
518 }
519 
520 static __inline__ vector unsigned short __ATTRS_o_ai
521 vec_adds(vector bool short __a, vector unsigned short __b) {
522  return __builtin_altivec_vadduhs((vector unsigned short)__a, __b);
523 }
524 
525 static __inline__ vector unsigned short __ATTRS_o_ai
526 vec_adds(vector unsigned short __a, vector bool short __b) {
527  return __builtin_altivec_vadduhs(__a, (vector unsigned short)__b);
528 }
529 
530 static __inline__ vector int __ATTRS_o_ai vec_adds(vector int __a,
531  vector int __b) {
532  return __builtin_altivec_vaddsws(__a, __b);
533 }
534 
535 static __inline__ vector int __ATTRS_o_ai vec_adds(vector bool int __a,
536  vector int __b) {
537  return __builtin_altivec_vaddsws((vector int)__a, __b);
538 }
539 
540 static __inline__ vector int __ATTRS_o_ai vec_adds(vector int __a,
541  vector bool int __b) {
542  return __builtin_altivec_vaddsws(__a, (vector int)__b);
543 }
544 
545 static __inline__ vector unsigned int __ATTRS_o_ai
546 vec_adds(vector unsigned int __a, vector unsigned int __b) {
547  return __builtin_altivec_vadduws(__a, __b);
548 }
549 
550 static __inline__ vector unsigned int __ATTRS_o_ai
551 vec_adds(vector bool int __a, vector unsigned int __b) {
552  return __builtin_altivec_vadduws((vector unsigned int)__a, __b);
553 }
554 
555 static __inline__ vector unsigned int __ATTRS_o_ai
556 vec_adds(vector unsigned int __a, vector bool int __b) {
557  return __builtin_altivec_vadduws(__a, (vector unsigned int)__b);
558 }
559 
560 /* vec_vaddsbs */
561 
562 static __inline__ vector signed char __ATTRS_o_ai
563 vec_vaddsbs(vector signed char __a, vector signed char __b) {
564  return __builtin_altivec_vaddsbs(__a, __b);
565 }
566 
567 static __inline__ vector signed char __ATTRS_o_ai
568 vec_vaddsbs(vector bool char __a, vector signed char __b) {
569  return __builtin_altivec_vaddsbs((vector signed char)__a, __b);
570 }
571 
572 static __inline__ vector signed char __ATTRS_o_ai
573 vec_vaddsbs(vector signed char __a, vector bool char __b) {
574  return __builtin_altivec_vaddsbs(__a, (vector signed char)__b);
575 }
576 
577 /* vec_vaddubs */
578 
579 static __inline__ vector unsigned char __ATTRS_o_ai
580 vec_vaddubs(vector unsigned char __a, vector unsigned char __b) {
581  return __builtin_altivec_vaddubs(__a, __b);
582 }
583 
584 static __inline__ vector unsigned char __ATTRS_o_ai
585 vec_vaddubs(vector bool char __a, vector unsigned char __b) {
586  return __builtin_altivec_vaddubs((vector unsigned char)__a, __b);
587 }
588 
589 static __inline__ vector unsigned char __ATTRS_o_ai
590 vec_vaddubs(vector unsigned char __a, vector bool char __b) {
591  return __builtin_altivec_vaddubs(__a, (vector unsigned char)__b);
592 }
593 
594 /* vec_vaddshs */
595 
596 static __inline__ vector short __ATTRS_o_ai vec_vaddshs(vector short __a,
597  vector short __b) {
598  return __builtin_altivec_vaddshs(__a, __b);
599 }
600 
601 static __inline__ vector short __ATTRS_o_ai vec_vaddshs(vector bool short __a,
602  vector short __b) {
603  return __builtin_altivec_vaddshs((vector short)__a, __b);
604 }
605 
606 static __inline__ vector short __ATTRS_o_ai vec_vaddshs(vector short __a,
607  vector bool short __b) {
608  return __builtin_altivec_vaddshs(__a, (vector short)__b);
609 }
610 
611 /* vec_vadduhs */
612 
613 static __inline__ vector unsigned short __ATTRS_o_ai
614 vec_vadduhs(vector unsigned short __a, vector unsigned short __b) {
615  return __builtin_altivec_vadduhs(__a, __b);
616 }
617 
618 static __inline__ vector unsigned short __ATTRS_o_ai
619 vec_vadduhs(vector bool short __a, vector unsigned short __b) {
620  return __builtin_altivec_vadduhs((vector unsigned short)__a, __b);
621 }
622 
623 static __inline__ vector unsigned short __ATTRS_o_ai
624 vec_vadduhs(vector unsigned short __a, vector bool short __b) {
625  return __builtin_altivec_vadduhs(__a, (vector unsigned short)__b);
626 }
627 
628 /* vec_vaddsws */
629 
630 static __inline__ vector int __ATTRS_o_ai vec_vaddsws(vector int __a,
631  vector int __b) {
632  return __builtin_altivec_vaddsws(__a, __b);
633 }
634 
635 static __inline__ vector int __ATTRS_o_ai vec_vaddsws(vector bool int __a,
636  vector int __b) {
637  return __builtin_altivec_vaddsws((vector int)__a, __b);
638 }
639 
640 static __inline__ vector int __ATTRS_o_ai vec_vaddsws(vector int __a,
641  vector bool int __b) {
642  return __builtin_altivec_vaddsws(__a, (vector int)__b);
643 }
644 
645 /* vec_vadduws */
646 
647 static __inline__ vector unsigned int __ATTRS_o_ai
648 vec_vadduws(vector unsigned int __a, vector unsigned int __b) {
649  return __builtin_altivec_vadduws(__a, __b);
650 }
651 
652 static __inline__ vector unsigned int __ATTRS_o_ai
653 vec_vadduws(vector bool int __a, vector unsigned int __b) {
654  return __builtin_altivec_vadduws((vector unsigned int)__a, __b);
655 }
656 
657 static __inline__ vector unsigned int __ATTRS_o_ai
658 vec_vadduws(vector unsigned int __a, vector bool int __b) {
659  return __builtin_altivec_vadduws(__a, (vector unsigned int)__b);
660 }
661 
662 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
663 /* vec_vadduqm */
664 
665 static __inline__ vector signed __int128 __ATTRS_o_ai
666 vec_vadduqm(vector signed __int128 __a, vector signed __int128 __b) {
667  return __a + __b;
668 }
669 
670 static __inline__ vector unsigned __int128 __ATTRS_o_ai
671 vec_vadduqm(vector unsigned __int128 __a, vector unsigned __int128 __b) {
672  return __a + __b;
673 }
674 
675 /* vec_vaddeuqm */
676 
677 static __inline__ vector signed __int128 __ATTRS_o_ai
678 vec_vaddeuqm(vector signed __int128 __a, vector signed __int128 __b,
679  vector signed __int128 __c) {
680  return __builtin_altivec_vaddeuqm(__a, __b, __c);
681 }
682 
683 static __inline__ vector unsigned __int128 __ATTRS_o_ai
684 vec_vaddeuqm(vector unsigned __int128 __a, vector unsigned __int128 __b,
685  vector unsigned __int128 __c) {
686  return __builtin_altivec_vaddeuqm(__a, __b, __c);
687 }
688 
689 /* vec_vaddcuq */
690 
691 static __inline__ vector signed __int128 __ATTRS_o_ai
692 vec_vaddcuq(vector signed __int128 __a, vector signed __int128 __b) {
693  return __builtin_altivec_vaddcuq(__a, __b);
694 }
695 
696 static __inline__ vector unsigned __int128 __ATTRS_o_ai
697 vec_vaddcuq(vector unsigned __int128 __a, vector unsigned __int128 __b) {
698  return __builtin_altivec_vaddcuq(__a, __b);
699 }
700 
701 /* vec_vaddecuq */
702 
703 static __inline__ vector signed __int128 __ATTRS_o_ai
704 vec_vaddecuq(vector signed __int128 __a, vector signed __int128 __b,
705  vector signed __int128 __c) {
706  return __builtin_altivec_vaddecuq(__a, __b, __c);
707 }
708 
709 static __inline__ vector unsigned __int128 __ATTRS_o_ai
710 vec_vaddecuq(vector unsigned __int128 __a, vector unsigned __int128 __b,
711  vector unsigned __int128 __c) {
712  return __builtin_altivec_vaddecuq(__a, __b, __c);
713 }
714 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
715 
716 /* vec_and */
717 
718 #define __builtin_altivec_vand vec_and
719 
720 static __inline__ vector signed char __ATTRS_o_ai
721 vec_and(vector signed char __a, vector signed char __b) {
722  return __a & __b;
723 }
724 
725 static __inline__ vector signed char __ATTRS_o_ai
726 vec_and(vector bool char __a, vector signed char __b) {
727  return (vector signed char)__a & __b;
728 }
729 
730 static __inline__ vector signed char __ATTRS_o_ai
731 vec_and(vector signed char __a, vector bool char __b) {
732  return __a & (vector signed char)__b;
733 }
734 
735 static __inline__ vector unsigned char __ATTRS_o_ai
736 vec_and(vector unsigned char __a, vector unsigned char __b) {
737  return __a & __b;
738 }
739 
740 static __inline__ vector unsigned char __ATTRS_o_ai
741 vec_and(vector bool char __a, vector unsigned char __b) {
742  return (vector unsigned char)__a & __b;
743 }
744 
745 static __inline__ vector unsigned char __ATTRS_o_ai
746 vec_and(vector unsigned char __a, vector bool char __b) {
747  return __a & (vector unsigned char)__b;
748 }
749 
750 static __inline__ vector bool char __ATTRS_o_ai vec_and(vector bool char __a,
751  vector bool char __b) {
752  return __a & __b;
753 }
754 
755 static __inline__ vector short __ATTRS_o_ai vec_and(vector short __a,
756  vector short __b) {
757  return __a & __b;
758 }
759 
760 static __inline__ vector short __ATTRS_o_ai vec_and(vector bool short __a,
761  vector short __b) {
762  return (vector short)__a & __b;
763 }
764 
765 static __inline__ vector short __ATTRS_o_ai vec_and(vector short __a,
766  vector bool short __b) {
767  return __a & (vector short)__b;
768 }
769 
770 static __inline__ vector unsigned short __ATTRS_o_ai
771 vec_and(vector unsigned short __a, vector unsigned short __b) {
772  return __a & __b;
773 }
774 
775 static __inline__ vector unsigned short __ATTRS_o_ai
776 vec_and(vector bool short __a, vector unsigned short __b) {
777  return (vector unsigned short)__a & __b;
778 }
779 
780 static __inline__ vector unsigned short __ATTRS_o_ai
781 vec_and(vector unsigned short __a, vector bool short __b) {
782  return __a & (vector unsigned short)__b;
783 }
784 
785 static __inline__ vector bool short __ATTRS_o_ai
786 vec_and(vector bool short __a, vector bool short __b) {
787  return __a & __b;
788 }
789 
790 static __inline__ vector int __ATTRS_o_ai vec_and(vector int __a,
791  vector int __b) {
792  return __a & __b;
793 }
794 
795 static __inline__ vector int __ATTRS_o_ai vec_and(vector bool int __a,
796  vector int __b) {
797  return (vector int)__a & __b;
798 }
799 
800 static __inline__ vector int __ATTRS_o_ai vec_and(vector int __a,
801  vector bool int __b) {
802  return __a & (vector int)__b;
803 }
804 
805 static __inline__ vector unsigned int __ATTRS_o_ai
806 vec_and(vector unsigned int __a, vector unsigned int __b) {
807  return __a & __b;
808 }
809 
810 static __inline__ vector unsigned int __ATTRS_o_ai
811 vec_and(vector bool int __a, vector unsigned int __b) {
812  return (vector unsigned int)__a & __b;
813 }
814 
815 static __inline__ vector unsigned int __ATTRS_o_ai
816 vec_and(vector unsigned int __a, vector bool int __b) {
817  return __a & (vector unsigned int)__b;
818 }
819 
820 static __inline__ vector bool int __ATTRS_o_ai vec_and(vector bool int __a,
821  vector bool int __b) {
822  return __a & __b;
823 }
824 
825 static __inline__ vector float __ATTRS_o_ai vec_and(vector float __a,
826  vector float __b) {
827  vector unsigned int __res =
828  (vector unsigned int)__a & (vector unsigned int)__b;
829  return (vector float)__res;
830 }
831 
832 static __inline__ vector float __ATTRS_o_ai vec_and(vector bool int __a,
833  vector float __b) {
834  vector unsigned int __res =
835  (vector unsigned int)__a & (vector unsigned int)__b;
836  return (vector float)__res;
837 }
838 
839 static __inline__ vector float __ATTRS_o_ai vec_and(vector float __a,
840  vector bool int __b) {
841  vector unsigned int __res =
842  (vector unsigned int)__a & (vector unsigned int)__b;
843  return (vector float)__res;
844 }
845 
846 #ifdef __VSX__
847 static __inline__ vector double __ATTRS_o_ai vec_and(vector bool long long __a,
848  vector double __b) {
849  vector unsigned long long __res =
850  (vector unsigned long long)__a & (vector unsigned long long)__b;
851  return (vector double)__res;
852 }
853 
854 static __inline__ vector double __ATTRS_o_ai
855 vec_and(vector double __a, vector bool long long __b) {
856  vector unsigned long long __res =
857  (vector unsigned long long)__a & (vector unsigned long long)__b;
858  return (vector double)__res;
859 }
860 
861 static __inline__ vector double __ATTRS_o_ai vec_and(vector double __a,
862  vector double __b) {
863  vector unsigned long long __res =
864  (vector unsigned long long)__a & (vector unsigned long long)__b;
865  return (vector double)__res;
866 }
867 
868 static __inline__ vector signed long long __ATTRS_o_ai
869 vec_and(vector signed long long __a, vector signed long long __b) {
870  return __a & __b;
871 }
872 
873 static __inline__ vector signed long long __ATTRS_o_ai
874 vec_and(vector bool long long __a, vector signed long long __b) {
875  return (vector signed long long)__a & __b;
876 }
877 
878 static __inline__ vector signed long long __ATTRS_o_ai
879 vec_and(vector signed long long __a, vector bool long long __b) {
880  return __a & (vector signed long long)__b;
881 }
882 
883 static __inline__ vector unsigned long long __ATTRS_o_ai
884 vec_and(vector unsigned long long __a, vector unsigned long long __b) {
885  return __a & __b;
886 }
887 
888 static __inline__ vector unsigned long long __ATTRS_o_ai
889 vec_and(vector bool long long __a, vector unsigned long long __b) {
890  return (vector unsigned long long)__a & __b;
891 }
892 
893 static __inline__ vector unsigned long long __ATTRS_o_ai
894 vec_and(vector unsigned long long __a, vector bool long long __b) {
895  return __a & (vector unsigned long long)__b;
896 }
897 
898 static __inline__ vector bool long long __ATTRS_o_ai
899 vec_and(vector bool long long __a, vector bool long long __b) {
900  return __a & __b;
901 }
902 #endif
903 
904 /* vec_vand */
905 
906 static __inline__ vector signed char __ATTRS_o_ai
907 vec_vand(vector signed char __a, vector signed char __b) {
908  return __a & __b;
909 }
910 
911 static __inline__ vector signed char __ATTRS_o_ai
912 vec_vand(vector bool char __a, vector signed char __b) {
913  return (vector signed char)__a & __b;
914 }
915 
916 static __inline__ vector signed char __ATTRS_o_ai
917 vec_vand(vector signed char __a, vector bool char __b) {
918  return __a & (vector signed char)__b;
919 }
920 
921 static __inline__ vector unsigned char __ATTRS_o_ai
922 vec_vand(vector unsigned char __a, vector unsigned char __b) {
923  return __a & __b;
924 }
925 
926 static __inline__ vector unsigned char __ATTRS_o_ai
927 vec_vand(vector bool char __a, vector unsigned char __b) {
928  return (vector unsigned char)__a & __b;
929 }
930 
931 static __inline__ vector unsigned char __ATTRS_o_ai
932 vec_vand(vector unsigned char __a, vector bool char __b) {
933  return __a & (vector unsigned char)__b;
934 }
935 
936 static __inline__ vector bool char __ATTRS_o_ai vec_vand(vector bool char __a,
937  vector bool char __b) {
938  return __a & __b;
939 }
940 
941 static __inline__ vector short __ATTRS_o_ai vec_vand(vector short __a,
942  vector short __b) {
943  return __a & __b;
944 }
945 
946 static __inline__ vector short __ATTRS_o_ai vec_vand(vector bool short __a,
947  vector short __b) {
948  return (vector short)__a & __b;
949 }
950 
951 static __inline__ vector short __ATTRS_o_ai vec_vand(vector short __a,
952  vector bool short __b) {
953  return __a & (vector short)__b;
954 }
955 
956 static __inline__ vector unsigned short __ATTRS_o_ai
957 vec_vand(vector unsigned short __a, vector unsigned short __b) {
958  return __a & __b;
959 }
960 
961 static __inline__ vector unsigned short __ATTRS_o_ai
962 vec_vand(vector bool short __a, vector unsigned short __b) {
963  return (vector unsigned short)__a & __b;
964 }
965 
966 static __inline__ vector unsigned short __ATTRS_o_ai
967 vec_vand(vector unsigned short __a, vector bool short __b) {
968  return __a & (vector unsigned short)__b;
969 }
970 
971 static __inline__ vector bool short __ATTRS_o_ai
972 vec_vand(vector bool short __a, vector bool short __b) {
973  return __a & __b;
974 }
975 
976 static __inline__ vector int __ATTRS_o_ai vec_vand(vector int __a,
977  vector int __b) {
978  return __a & __b;
979 }
980 
981 static __inline__ vector int __ATTRS_o_ai vec_vand(vector bool int __a,
982  vector int __b) {
983  return (vector int)__a & __b;
984 }
985 
986 static __inline__ vector int __ATTRS_o_ai vec_vand(vector int __a,
987  vector bool int __b) {
988  return __a & (vector int)__b;
989 }
990 
991 static __inline__ vector unsigned int __ATTRS_o_ai
992 vec_vand(vector unsigned int __a, vector unsigned int __b) {
993  return __a & __b;
994 }
995 
996 static __inline__ vector unsigned int __ATTRS_o_ai
997 vec_vand(vector bool int __a, vector unsigned int __b) {
998  return (vector unsigned int)__a & __b;
999 }
1000 
1001 static __inline__ vector unsigned int __ATTRS_o_ai
1002 vec_vand(vector unsigned int __a, vector bool int __b) {
1003  return __a & (vector unsigned int)__b;
1004 }
1005 
1006 static __inline__ vector bool int __ATTRS_o_ai vec_vand(vector bool int __a,
1007  vector bool int __b) {
1008  return __a & __b;
1009 }
1010 
1011 static __inline__ vector float __ATTRS_o_ai vec_vand(vector float __a,
1012  vector float __b) {
1013  vector unsigned int __res =
1014  (vector unsigned int)__a & (vector unsigned int)__b;
1015  return (vector float)__res;
1016 }
1017 
1018 static __inline__ vector float __ATTRS_o_ai vec_vand(vector bool int __a,
1019  vector float __b) {
1020  vector unsigned int __res =
1021  (vector unsigned int)__a & (vector unsigned int)__b;
1022  return (vector float)__res;
1023 }
1024 
1025 static __inline__ vector float __ATTRS_o_ai vec_vand(vector float __a,
1026  vector bool int __b) {
1027  vector unsigned int __res =
1028  (vector unsigned int)__a & (vector unsigned int)__b;
1029  return (vector float)__res;
1030 }
1031 
1032 #ifdef __VSX__
1033 static __inline__ vector signed long long __ATTRS_o_ai
1034 vec_vand(vector signed long long __a, vector signed long long __b) {
1035  return __a & __b;
1036 }
1037 
1038 static __inline__ vector signed long long __ATTRS_o_ai
1039 vec_vand(vector bool long long __a, vector signed long long __b) {
1040  return (vector signed long long)__a & __b;
1041 }
1042 
1043 static __inline__ vector signed long long __ATTRS_o_ai
1044 vec_vand(vector signed long long __a, vector bool long long __b) {
1045  return __a & (vector signed long long)__b;
1046 }
1047 
1048 static __inline__ vector unsigned long long __ATTRS_o_ai
1049 vec_vand(vector unsigned long long __a, vector unsigned long long __b) {
1050  return __a & __b;
1051 }
1052 
1053 static __inline__ vector unsigned long long __ATTRS_o_ai
1054 vec_vand(vector bool long long __a, vector unsigned long long __b) {
1055  return (vector unsigned long long)__a & __b;
1056 }
1057 
1058 static __inline__ vector unsigned long long __ATTRS_o_ai
1059 vec_vand(vector unsigned long long __a, vector bool long long __b) {
1060  return __a & (vector unsigned long long)__b;
1061 }
1062 
1063 static __inline__ vector bool long long __ATTRS_o_ai
1064 vec_vand(vector bool long long __a, vector bool long long __b) {
1065  return __a & __b;
1066 }
1067 #endif
1068 
1069 /* vec_andc */
1070 
1071 #define __builtin_altivec_vandc vec_andc
1072 
1073 static __inline__ vector signed char __ATTRS_o_ai
1074 vec_andc(vector signed char __a, vector signed char __b) {
1075  return __a & ~__b;
1076 }
1077 
1078 static __inline__ vector signed char __ATTRS_o_ai
1079 vec_andc(vector bool char __a, vector signed char __b) {
1080  return (vector signed char)__a & ~__b;
1081 }
1082 
1083 static __inline__ vector signed char __ATTRS_o_ai
1084 vec_andc(vector signed char __a, vector bool char __b) {
1085  return __a & ~(vector signed char)__b;
1086 }
1087 
1088 static __inline__ vector unsigned char __ATTRS_o_ai
1089 vec_andc(vector unsigned char __a, vector unsigned char __b) {
1090  return __a & ~__b;
1091 }
1092 
1093 static __inline__ vector unsigned char __ATTRS_o_ai
1094 vec_andc(vector bool char __a, vector unsigned char __b) {
1095  return (vector unsigned char)__a & ~__b;
1096 }
1097 
1098 static __inline__ vector unsigned char __ATTRS_o_ai
1099 vec_andc(vector unsigned char __a, vector bool char __b) {
1100  return __a & ~(vector unsigned char)__b;
1101 }
1102 
1103 static __inline__ vector bool char __ATTRS_o_ai vec_andc(vector bool char __a,
1104  vector bool char __b) {
1105  return __a & ~__b;
1106 }
1107 
1108 static __inline__ vector short __ATTRS_o_ai vec_andc(vector short __a,
1109  vector short __b) {
1110  return __a & ~__b;
1111 }
1112 
1113 static __inline__ vector short __ATTRS_o_ai vec_andc(vector bool short __a,
1114  vector short __b) {
1115  return (vector short)__a & ~__b;
1116 }
1117 
1118 static __inline__ vector short __ATTRS_o_ai vec_andc(vector short __a,
1119  vector bool short __b) {
1120  return __a & ~(vector short)__b;
1121 }
1122 
1123 static __inline__ vector unsigned short __ATTRS_o_ai
1124 vec_andc(vector unsigned short __a, vector unsigned short __b) {
1125  return __a & ~__b;
1126 }
1127 
1128 static __inline__ vector unsigned short __ATTRS_o_ai
1129 vec_andc(vector bool short __a, vector unsigned short __b) {
1130  return (vector unsigned short)__a & ~__b;
1131 }
1132 
1133 static __inline__ vector unsigned short __ATTRS_o_ai
1134 vec_andc(vector unsigned short __a, vector bool short __b) {
1135  return __a & ~(vector unsigned short)__b;
1136 }
1137 
1138 static __inline__ vector bool short __ATTRS_o_ai
1139 vec_andc(vector bool short __a, vector bool short __b) {
1140  return __a & ~__b;
1141 }
1142 
1143 static __inline__ vector int __ATTRS_o_ai vec_andc(vector int __a,
1144  vector int __b) {
1145  return __a & ~__b;
1146 }
1147 
1148 static __inline__ vector int __ATTRS_o_ai vec_andc(vector bool int __a,
1149  vector int __b) {
1150  return (vector int)__a & ~__b;
1151 }
1152 
1153 static __inline__ vector int __ATTRS_o_ai vec_andc(vector int __a,
1154  vector bool int __b) {
1155  return __a & ~(vector int)__b;
1156 }
1157 
1158 static __inline__ vector unsigned int __ATTRS_o_ai
1159 vec_andc(vector unsigned int __a, vector unsigned int __b) {
1160  return __a & ~__b;
1161 }
1162 
1163 static __inline__ vector unsigned int __ATTRS_o_ai
1164 vec_andc(vector bool int __a, vector unsigned int __b) {
1165  return (vector unsigned int)__a & ~__b;
1166 }
1167 
1168 static __inline__ vector unsigned int __ATTRS_o_ai
1169 vec_andc(vector unsigned int __a, vector bool int __b) {
1170  return __a & ~(vector unsigned int)__b;
1171 }
1172 
1173 static __inline__ vector bool int __ATTRS_o_ai vec_andc(vector bool int __a,
1174  vector bool int __b) {
1175  return __a & ~__b;
1176 }
1177 
1178 static __inline__ vector float __ATTRS_o_ai vec_andc(vector float __a,
1179  vector float __b) {
1180  vector unsigned int __res =
1181  (vector unsigned int)__a & ~(vector unsigned int)__b;
1182  return (vector float)__res;
1183 }
1184 
1185 static __inline__ vector float __ATTRS_o_ai vec_andc(vector bool int __a,
1186  vector float __b) {
1187  vector unsigned int __res =
1188  (vector unsigned int)__a & ~(vector unsigned int)__b;
1189  return (vector float)__res;
1190 }
1191 
1192 static __inline__ vector float __ATTRS_o_ai vec_andc(vector float __a,
1193  vector bool int __b) {
1194  vector unsigned int __res =
1195  (vector unsigned int)__a & ~(vector unsigned int)__b;
1196  return (vector float)__res;
1197 }
1198 
1199 #ifdef __VSX__
1200 static __inline__ vector double __ATTRS_o_ai vec_andc(vector bool long long __a,
1201  vector double __b) {
1202  vector unsigned long long __res =
1203  (vector unsigned long long)__a & ~(vector unsigned long long)__b;
1204  return (vector double)__res;
1205 }
1206 
1207 static __inline__ vector double __ATTRS_o_ai
1208 vec_andc(vector double __a, vector bool long long __b) {
1209  vector unsigned long long __res =
1210  (vector unsigned long long)__a & ~(vector unsigned long long)__b;
1211  return (vector double)__res;
1212 }
1213 
1214 static __inline__ vector double __ATTRS_o_ai vec_andc(vector double __a,
1215  vector double __b) {
1216  vector unsigned long long __res =
1217  (vector unsigned long long)__a & ~(vector unsigned long long)__b;
1218  return (vector double)__res;
1219 }
1220 
1221 static __inline__ vector signed long long __ATTRS_o_ai
1222 vec_andc(vector signed long long __a, vector signed long long __b) {
1223  return __a & ~__b;
1224 }
1225 
1226 static __inline__ vector signed long long __ATTRS_o_ai
1227 vec_andc(vector bool long long __a, vector signed long long __b) {
1228  return (vector signed long long)__a & ~__b;
1229 }
1230 
1231 static __inline__ vector signed long long __ATTRS_o_ai
1232 vec_andc(vector signed long long __a, vector bool long long __b) {
1233  return __a & ~(vector signed long long)__b;
1234 }
1235 
1236 static __inline__ vector unsigned long long __ATTRS_o_ai
1237 vec_andc(vector unsigned long long __a, vector unsigned long long __b) {
1238  return __a & ~__b;
1239 }
1240 
1241 static __inline__ vector unsigned long long __ATTRS_o_ai
1242 vec_andc(vector bool long long __a, vector unsigned long long __b) {
1243  return (vector unsigned long long)__a & ~__b;
1244 }
1245 
1246 static __inline__ vector unsigned long long __ATTRS_o_ai
1247 vec_andc(vector unsigned long long __a, vector bool long long __b) {
1248  return __a & ~(vector unsigned long long)__b;
1249 }
1250 
1251 static __inline__ vector bool long long __ATTRS_o_ai
1252 vec_andc(vector bool long long __a, vector bool long long __b) {
1253  return __a & ~__b;
1254 }
1255 #endif
1256 
1257 /* vec_vandc */
1258 
1259 static __inline__ vector signed char __ATTRS_o_ai
1260 vec_vandc(vector signed char __a, vector signed char __b) {
1261  return __a & ~__b;
1262 }
1263 
1264 static __inline__ vector signed char __ATTRS_o_ai
1265 vec_vandc(vector bool char __a, vector signed char __b) {
1266  return (vector signed char)__a & ~__b;
1267 }
1268 
1269 static __inline__ vector signed char __ATTRS_o_ai
1270 vec_vandc(vector signed char __a, vector bool char __b) {
1271  return __a & ~(vector signed char)__b;
1272 }
1273 
1274 static __inline__ vector unsigned char __ATTRS_o_ai
1275 vec_vandc(vector unsigned char __a, vector unsigned char __b) {
1276  return __a & ~__b;
1277 }
1278 
1279 static __inline__ vector unsigned char __ATTRS_o_ai
1280 vec_vandc(vector bool char __a, vector unsigned char __b) {
1281  return (vector unsigned char)__a & ~__b;
1282 }
1283 
1284 static __inline__ vector unsigned char __ATTRS_o_ai
1285 vec_vandc(vector unsigned char __a, vector bool char __b) {
1286  return __a & ~(vector unsigned char)__b;
1287 }
1288 
1289 static __inline__ vector bool char __ATTRS_o_ai
1290 vec_vandc(vector bool char __a, vector bool char __b) {
1291  return __a & ~__b;
1292 }
1293 
1294 static __inline__ vector short __ATTRS_o_ai vec_vandc(vector short __a,
1295  vector short __b) {
1296  return __a & ~__b;
1297 }
1298 
1299 static __inline__ vector short __ATTRS_o_ai vec_vandc(vector bool short __a,
1300  vector short __b) {
1301  return (vector short)__a & ~__b;
1302 }
1303 
1304 static __inline__ vector short __ATTRS_o_ai vec_vandc(vector short __a,
1305  vector bool short __b) {
1306  return __a & ~(vector short)__b;
1307 }
1308 
1309 static __inline__ vector unsigned short __ATTRS_o_ai
1310 vec_vandc(vector unsigned short __a, vector unsigned short __b) {
1311  return __a & ~__b;
1312 }
1313 
1314 static __inline__ vector unsigned short __ATTRS_o_ai
1315 vec_vandc(vector bool short __a, vector unsigned short __b) {
1316  return (vector unsigned short)__a & ~__b;
1317 }
1318 
1319 static __inline__ vector unsigned short __ATTRS_o_ai
1320 vec_vandc(vector unsigned short __a, vector bool short __b) {
1321  return __a & ~(vector unsigned short)__b;
1322 }
1323 
1324 static __inline__ vector bool short __ATTRS_o_ai
1325 vec_vandc(vector bool short __a, vector bool short __b) {
1326  return __a & ~__b;
1327 }
1328 
1329 static __inline__ vector int __ATTRS_o_ai vec_vandc(vector int __a,
1330  vector int __b) {
1331  return __a & ~__b;
1332 }
1333 
1334 static __inline__ vector int __ATTRS_o_ai vec_vandc(vector bool int __a,
1335  vector int __b) {
1336  return (vector int)__a & ~__b;
1337 }
1338 
1339 static __inline__ vector int __ATTRS_o_ai vec_vandc(vector int __a,
1340  vector bool int __b) {
1341  return __a & ~(vector int)__b;
1342 }
1343 
1344 static __inline__ vector unsigned int __ATTRS_o_ai
1345 vec_vandc(vector unsigned int __a, vector unsigned int __b) {
1346  return __a & ~__b;
1347 }
1348 
1349 static __inline__ vector unsigned int __ATTRS_o_ai
1350 vec_vandc(vector bool int __a, vector unsigned int __b) {
1351  return (vector unsigned int)__a & ~__b;
1352 }
1353 
1354 static __inline__ vector unsigned int __ATTRS_o_ai
1355 vec_vandc(vector unsigned int __a, vector bool int __b) {
1356  return __a & ~(vector unsigned int)__b;
1357 }
1358 
1359 static __inline__ vector bool int __ATTRS_o_ai vec_vandc(vector bool int __a,
1360  vector bool int __b) {
1361  return __a & ~__b;
1362 }
1363 
1364 static __inline__ vector float __ATTRS_o_ai vec_vandc(vector float __a,
1365  vector float __b) {
1366  vector unsigned int __res =
1367  (vector unsigned int)__a & ~(vector unsigned int)__b;
1368  return (vector float)__res;
1369 }
1370 
1371 static __inline__ vector float __ATTRS_o_ai vec_vandc(vector bool int __a,
1372  vector float __b) {
1373  vector unsigned int __res =
1374  (vector unsigned int)__a & ~(vector unsigned int)__b;
1375  return (vector float)__res;
1376 }
1377 
1378 static __inline__ vector float __ATTRS_o_ai vec_vandc(vector float __a,
1379  vector bool int __b) {
1380  vector unsigned int __res =
1381  (vector unsigned int)__a & ~(vector unsigned int)__b;
1382  return (vector float)__res;
1383 }
1384 
1385 #ifdef __VSX__
1386 static __inline__ vector signed long long __ATTRS_o_ai
1387 vec_vandc(vector signed long long __a, vector signed long long __b) {
1388  return __a & ~__b;
1389 }
1390 
1391 static __inline__ vector signed long long __ATTRS_o_ai
1392 vec_vandc(vector bool long long __a, vector signed long long __b) {
1393  return (vector signed long long)__a & ~__b;
1394 }
1395 
1396 static __inline__ vector signed long long __ATTRS_o_ai
1397 vec_vandc(vector signed long long __a, vector bool long long __b) {
1398  return __a & ~(vector signed long long)__b;
1399 }
1400 
1401 static __inline__ vector unsigned long long __ATTRS_o_ai
1402 vec_vandc(vector unsigned long long __a, vector unsigned long long __b) {
1403  return __a & ~__b;
1404 }
1405 
1406 static __inline__ vector unsigned long long __ATTRS_o_ai
1407 vec_vandc(vector bool long long __a, vector unsigned long long __b) {
1408  return (vector unsigned long long)__a & ~__b;
1409 }
1410 
1411 static __inline__ vector unsigned long long __ATTRS_o_ai
1412 vec_vandc(vector unsigned long long __a, vector bool long long __b) {
1413  return __a & ~(vector unsigned long long)__b;
1414 }
1415 
1416 static __inline__ vector bool long long __ATTRS_o_ai
1417 vec_vandc(vector bool long long __a, vector bool long long __b) {
1418  return __a & ~__b;
1419 }
1420 #endif
1421 
1422 /* vec_avg */
1423 
1424 static __inline__ vector signed char __ATTRS_o_ai
1425 vec_avg(vector signed char __a, vector signed char __b) {
1426  return __builtin_altivec_vavgsb(__a, __b);
1427 }
1428 
1429 static __inline__ vector unsigned char __ATTRS_o_ai
1430 vec_avg(vector unsigned char __a, vector unsigned char __b) {
1431  return __builtin_altivec_vavgub(__a, __b);
1432 }
1433 
1434 static __inline__ vector short __ATTRS_o_ai vec_avg(vector short __a,
1435  vector short __b) {
1436  return __builtin_altivec_vavgsh(__a, __b);
1437 }
1438 
1439 static __inline__ vector unsigned short __ATTRS_o_ai
1440 vec_avg(vector unsigned short __a, vector unsigned short __b) {
1441  return __builtin_altivec_vavguh(__a, __b);
1442 }
1443 
1444 static __inline__ vector int __ATTRS_o_ai vec_avg(vector int __a,
1445  vector int __b) {
1446  return __builtin_altivec_vavgsw(__a, __b);
1447 }
1448 
1449 static __inline__ vector unsigned int __ATTRS_o_ai
1450 vec_avg(vector unsigned int __a, vector unsigned int __b) {
1451  return __builtin_altivec_vavguw(__a, __b);
1452 }
1453 
1454 /* vec_vavgsb */
1455 
1456 static __inline__ vector signed char __attribute__((__always_inline__))
1457 vec_vavgsb(vector signed char __a, vector signed char __b) {
1458  return __builtin_altivec_vavgsb(__a, __b);
1459 }
1460 
1461 /* vec_vavgub */
1462 
1463 static __inline__ vector unsigned char __attribute__((__always_inline__))
1464 vec_vavgub(vector unsigned char __a, vector unsigned char __b) {
1465  return __builtin_altivec_vavgub(__a, __b);
1466 }
1467 
1468 /* vec_vavgsh */
1469 
1470 static __inline__ vector short __attribute__((__always_inline__))
1471 vec_vavgsh(vector short __a, vector short __b) {
1472  return __builtin_altivec_vavgsh(__a, __b);
1473 }
1474 
1475 /* vec_vavguh */
1476 
1477 static __inline__ vector unsigned short __attribute__((__always_inline__))
1478 vec_vavguh(vector unsigned short __a, vector unsigned short __b) {
1479  return __builtin_altivec_vavguh(__a, __b);
1480 }
1481 
1482 /* vec_vavgsw */
1483 
1484 static __inline__ vector int __attribute__((__always_inline__))
1485 vec_vavgsw(vector int __a, vector int __b) {
1486  return __builtin_altivec_vavgsw(__a, __b);
1487 }
1488 
1489 /* vec_vavguw */
1490 
1491 static __inline__ vector unsigned int __attribute__((__always_inline__))
1492 vec_vavguw(vector unsigned int __a, vector unsigned int __b) {
1493  return __builtin_altivec_vavguw(__a, __b);
1494 }
1495 
1496 /* vec_ceil */
1497 
1498 static __inline__ vector float __ATTRS_o_ai vec_ceil(vector float __a) {
1499 #ifdef __VSX__
1500  return __builtin_vsx_xvrspip(__a);
1501 #else
1502  return __builtin_altivec_vrfip(__a);
1503 #endif
1504 }
1505 
1506 #ifdef __VSX__
1507 static __inline__ vector double __ATTRS_o_ai vec_ceil(vector double __a) {
1508  return __builtin_vsx_xvrdpip(__a);
1509 }
1510 #endif
1511 
1512 /* vec_vrfip */
1513 
1514 static __inline__ vector float __attribute__((__always_inline__))
1515 vec_vrfip(vector float __a) {
1516  return __builtin_altivec_vrfip(__a);
1517 }
1518 
1519 /* vec_cmpb */
1520 
1521 static __inline__ vector int __attribute__((__always_inline__))
1522 vec_cmpb(vector float __a, vector float __b) {
1523  return __builtin_altivec_vcmpbfp(__a, __b);
1524 }
1525 
1526 /* vec_vcmpbfp */
1527 
1528 static __inline__ vector int __attribute__((__always_inline__))
1529 vec_vcmpbfp(vector float __a, vector float __b) {
1530  return __builtin_altivec_vcmpbfp(__a, __b);
1531 }
1532 
1533 /* vec_cmpeq */
1534 
1535 static __inline__ vector bool char __ATTRS_o_ai
1536 vec_cmpeq(vector signed char __a, vector signed char __b) {
1537  return (vector bool char)__builtin_altivec_vcmpequb((vector char)__a,
1538  (vector char)__b);
1539 }
1540 
1541 static __inline__ vector bool char __ATTRS_o_ai
1542 vec_cmpeq(vector unsigned char __a, vector unsigned char __b) {
1543  return (vector bool char)__builtin_altivec_vcmpequb((vector char)__a,
1544  (vector char)__b);
1545 }
1546 
1547 static __inline__ vector bool short __ATTRS_o_ai vec_cmpeq(vector short __a,
1548  vector short __b) {
1549  return (vector bool short)__builtin_altivec_vcmpequh(__a, __b);
1550 }
1551 
1552 static __inline__ vector bool short __ATTRS_o_ai
1553 vec_cmpeq(vector unsigned short __a, vector unsigned short __b) {
1554  return (vector bool short)__builtin_altivec_vcmpequh((vector short)__a,
1555  (vector short)__b);
1556 }
1557 
1558 static __inline__ vector bool int __ATTRS_o_ai vec_cmpeq(vector int __a,
1559  vector int __b) {
1560  return (vector bool int)__builtin_altivec_vcmpequw(__a, __b);
1561 }
1562 
1563 static __inline__ vector bool int __ATTRS_o_ai
1564 vec_cmpeq(vector unsigned int __a, vector unsigned int __b) {
1565  return (vector bool int)__builtin_altivec_vcmpequw((vector int)__a,
1566  (vector int)__b);
1567 }
1568 
1569 #ifdef __POWER8_VECTOR__
1570 static __inline__ vector bool long long __ATTRS_o_ai
1571 vec_cmpeq(vector signed long long __a, vector signed long long __b) {
1572  return (vector bool long long)__builtin_altivec_vcmpequd(__a, __b);
1573 }
1574 
1575 static __inline__ vector bool long long __ATTRS_o_ai
1576 vec_cmpeq(vector unsigned long long __a, vector unsigned long long __b) {
1577  return (vector bool long long)__builtin_altivec_vcmpequd(
1578  (vector long long)__a, (vector long long)__b);
1579 }
1580 #endif
1581 
1582 static __inline__ vector bool int __ATTRS_o_ai vec_cmpeq(vector float __a,
1583  vector float __b) {
1584 #ifdef __VSX__
1585  return (vector bool int)__builtin_vsx_xvcmpeqsp(__a, __b);
1586 #else
1587  return (vector bool int)__builtin_altivec_vcmpeqfp(__a, __b);
1588 #endif
1589 }
1590 
1591 #ifdef __VSX__
1592 static __inline__ vector bool long long __ATTRS_o_ai
1593 vec_cmpeq(vector double __a, vector double __b) {
1594  return (vector bool long long)__builtin_vsx_xvcmpeqdp(__a, __b);
1595 }
1596 #endif
1597 
1598 /* vec_cmpgt */
1599 
1600 static __inline__ vector bool char __ATTRS_o_ai
1601 vec_cmpgt(vector signed char __a, vector signed char __b) {
1602  return (vector bool char)__builtin_altivec_vcmpgtsb(__a, __b);
1603 }
1604 
1605 static __inline__ vector bool char __ATTRS_o_ai
1606 vec_cmpgt(vector unsigned char __a, vector unsigned char __b) {
1607  return (vector bool char)__builtin_altivec_vcmpgtub(__a, __b);
1608 }
1609 
1610 static __inline__ vector bool short __ATTRS_o_ai vec_cmpgt(vector short __a,
1611  vector short __b) {
1612  return (vector bool short)__builtin_altivec_vcmpgtsh(__a, __b);
1613 }
1614 
1615 static __inline__ vector bool short __ATTRS_o_ai
1616 vec_cmpgt(vector unsigned short __a, vector unsigned short __b) {
1617  return (vector bool short)__builtin_altivec_vcmpgtuh(__a, __b);
1618 }
1619 
1620 static __inline__ vector bool int __ATTRS_o_ai vec_cmpgt(vector int __a,
1621  vector int __b) {
1622  return (vector bool int)__builtin_altivec_vcmpgtsw(__a, __b);
1623 }
1624 
1625 static __inline__ vector bool int __ATTRS_o_ai
1626 vec_cmpgt(vector unsigned int __a, vector unsigned int __b) {
1627  return (vector bool int)__builtin_altivec_vcmpgtuw(__a, __b);
1628 }
1629 
1630 #ifdef __POWER8_VECTOR__
1631 static __inline__ vector bool long long __ATTRS_o_ai
1632 vec_cmpgt(vector signed long long __a, vector signed long long __b) {
1633  return (vector bool long long)__builtin_altivec_vcmpgtsd(__a, __b);
1634 }
1635 
1636 static __inline__ vector bool long long __ATTRS_o_ai
1637 vec_cmpgt(vector unsigned long long __a, vector unsigned long long __b) {
1638  return (vector bool long long)__builtin_altivec_vcmpgtud(__a, __b);
1639 }
1640 #endif
1641 
1642 static __inline__ vector bool int __ATTRS_o_ai vec_cmpgt(vector float __a,
1643  vector float __b) {
1644 #ifdef __VSX__
1645  return (vector bool int)__builtin_vsx_xvcmpgtsp(__a, __b);
1646 #else
1647  return (vector bool int)__builtin_altivec_vcmpgtfp(__a, __b);
1648 #endif
1649 }
1650 
1651 #ifdef __VSX__
1652 static __inline__ vector bool long long __ATTRS_o_ai
1653 vec_cmpgt(vector double __a, vector double __b) {
1654  return (vector bool long long)__builtin_vsx_xvcmpgtdp(__a, __b);
1655 }
1656 #endif
1657 
1658 /* vec_cmpge */
1659 
1660 static __inline__ vector bool char __ATTRS_o_ai
1661 vec_cmpge(vector signed char __a, vector signed char __b) {
1662  return ~(vec_cmpgt(__b, __a));
1663 }
1664 
1665 static __inline__ vector bool char __ATTRS_o_ai
1666 vec_cmpge(vector unsigned char __a, vector unsigned char __b) {
1667  return ~(vec_cmpgt(__b, __a));
1668 }
1669 
1670 static __inline__ vector bool short __ATTRS_o_ai
1671 vec_cmpge(vector signed short __a, vector signed short __b) {
1672  return ~(vec_cmpgt(__b, __a));
1673 }
1674 
1675 static __inline__ vector bool short __ATTRS_o_ai
1676 vec_cmpge(vector unsigned short __a, vector unsigned short __b) {
1677  return ~(vec_cmpgt(__b, __a));
1678 }
1679 
1680 static __inline__ vector bool int __ATTRS_o_ai
1681 vec_cmpge(vector signed int __a, vector signed int __b) {
1682  return ~(vec_cmpgt(__b, __a));
1683 }
1684 
1685 static __inline__ vector bool int __ATTRS_o_ai
1686 vec_cmpge(vector unsigned int __a, vector unsigned int __b) {
1687  return ~(vec_cmpgt(__b, __a));
1688 }
1689 
1690 static __inline__ vector bool int __ATTRS_o_ai vec_cmpge(vector float __a,
1691  vector float __b) {
1692 #ifdef __VSX__
1693  return (vector bool int)__builtin_vsx_xvcmpgesp(__a, __b);
1694 #else
1695  return (vector bool int)__builtin_altivec_vcmpgefp(__a, __b);
1696 #endif
1697 }
1698 
1699 #ifdef __VSX__
1700 static __inline__ vector bool long long __ATTRS_o_ai
1701 vec_cmpge(vector double __a, vector double __b) {
1702  return (vector bool long long)__builtin_vsx_xvcmpgedp(__a, __b);
1703 }
1704 #endif
1705 
1706 #ifdef __POWER8_VECTOR__
1707 static __inline__ vector bool long long __ATTRS_o_ai
1708 vec_cmpge(vector signed long long __a, vector signed long long __b) {
1709  return ~(vec_cmpgt(__b, __a));
1710 }
1711 
1712 static __inline__ vector bool long long __ATTRS_o_ai
1713 vec_cmpge(vector unsigned long long __a, vector unsigned long long __b) {
1714  return ~(vec_cmpgt(__b, __a));
1715 }
1716 #endif
1717 
1718 /* vec_vcmpgefp */
1719 
1720 static __inline__ vector bool int __attribute__((__always_inline__))
1721 vec_vcmpgefp(vector float __a, vector float __b) {
1722  return (vector bool int)__builtin_altivec_vcmpgefp(__a, __b);
1723 }
1724 
1725 /* vec_vcmpgtsb */
1726 
1727 static __inline__ vector bool char __attribute__((__always_inline__))
1728 vec_vcmpgtsb(vector signed char __a, vector signed char __b) {
1729  return (vector bool char)__builtin_altivec_vcmpgtsb(__a, __b);
1730 }
1731 
1732 /* vec_vcmpgtub */
1733 
1734 static __inline__ vector bool char __attribute__((__always_inline__))
1735 vec_vcmpgtub(vector unsigned char __a, vector unsigned char __b) {
1736  return (vector bool char)__builtin_altivec_vcmpgtub(__a, __b);
1737 }
1738 
1739 /* vec_vcmpgtsh */
1740 
1741 static __inline__ vector bool short __attribute__((__always_inline__))
1742 vec_vcmpgtsh(vector short __a, vector short __b) {
1743  return (vector bool short)__builtin_altivec_vcmpgtsh(__a, __b);
1744 }
1745 
1746 /* vec_vcmpgtuh */
1747 
1748 static __inline__ vector bool short __attribute__((__always_inline__))
1749 vec_vcmpgtuh(vector unsigned short __a, vector unsigned short __b) {
1750  return (vector bool short)__builtin_altivec_vcmpgtuh(__a, __b);
1751 }
1752 
1753 /* vec_vcmpgtsw */
1754 
1755 static __inline__ vector bool int __attribute__((__always_inline__))
1756 vec_vcmpgtsw(vector int __a, vector int __b) {
1757  return (vector bool int)__builtin_altivec_vcmpgtsw(__a, __b);
1758 }
1759 
1760 /* vec_vcmpgtuw */
1761 
1762 static __inline__ vector bool int __attribute__((__always_inline__))
1763 vec_vcmpgtuw(vector unsigned int __a, vector unsigned int __b) {
1764  return (vector bool int)__builtin_altivec_vcmpgtuw(__a, __b);
1765 }
1766 
1767 /* vec_vcmpgtfp */
1768 
1769 static __inline__ vector bool int __attribute__((__always_inline__))
1770 vec_vcmpgtfp(vector float __a, vector float __b) {
1771  return (vector bool int)__builtin_altivec_vcmpgtfp(__a, __b);
1772 }
1773 
1774 /* vec_cmple */
1775 
1776 static __inline__ vector bool char __ATTRS_o_ai
1777 vec_cmple(vector signed char __a, vector signed char __b) {
1778  return vec_cmpge(__b, __a);
1779 }
1780 
1781 static __inline__ vector bool char __ATTRS_o_ai
1782 vec_cmple(vector unsigned char __a, vector unsigned char __b) {
1783  return vec_cmpge(__b, __a);
1784 }
1785 
1786 static __inline__ vector bool short __ATTRS_o_ai
1787 vec_cmple(vector signed short __a, vector signed short __b) {
1788  return vec_cmpge(__b, __a);
1789 }
1790 
1791 static __inline__ vector bool short __ATTRS_o_ai
1792 vec_cmple(vector unsigned short __a, vector unsigned short __b) {
1793  return vec_cmpge(__b, __a);
1794 }
1795 
1796 static __inline__ vector bool int __ATTRS_o_ai
1797 vec_cmple(vector signed int __a, vector signed int __b) {
1798  return vec_cmpge(__b, __a);
1799 }
1800 
1801 static __inline__ vector bool int __ATTRS_o_ai
1802 vec_cmple(vector unsigned int __a, vector unsigned int __b) {
1803  return vec_cmpge(__b, __a);
1804 }
1805 
1806 static __inline__ vector bool int __ATTRS_o_ai vec_cmple(vector float __a,
1807  vector float __b) {
1808  return vec_cmpge(__b, __a);
1809 }
1810 
1811 #ifdef __VSX__
1812 static __inline__ vector bool long long __ATTRS_o_ai
1813 vec_cmple(vector double __a, vector double __b) {
1814  return vec_cmpge(__b, __a);
1815 }
1816 #endif
1817 
1818 #ifdef __POWER8_VECTOR__
1819 static __inline__ vector bool long long __ATTRS_o_ai
1820 vec_cmple(vector signed long long __a, vector signed long long __b) {
1821  return vec_cmpge(__b, __a);
1822 }
1823 
1824 static __inline__ vector bool long long __ATTRS_o_ai
1825 vec_cmple(vector unsigned long long __a, vector unsigned long long __b) {
1826  return vec_cmpge(__b, __a);
1827 }
1828 #endif
1829 
1830 /* vec_cmplt */
1831 
1832 static __inline__ vector bool char __ATTRS_o_ai
1833 vec_cmplt(vector signed char __a, vector signed char __b) {
1834  return vec_cmpgt(__b, __a);
1835 }
1836 
1837 static __inline__ vector bool char __ATTRS_o_ai
1838 vec_cmplt(vector unsigned char __a, vector unsigned char __b) {
1839  return vec_cmpgt(__b, __a);
1840 }
1841 
1842 static __inline__ vector bool short __ATTRS_o_ai vec_cmplt(vector short __a,
1843  vector short __b) {
1844  return vec_cmpgt(__b, __a);
1845 }
1846 
1847 static __inline__ vector bool short __ATTRS_o_ai
1848 vec_cmplt(vector unsigned short __a, vector unsigned short __b) {
1849  return vec_cmpgt(__b, __a);
1850 }
1851 
1852 static __inline__ vector bool int __ATTRS_o_ai vec_cmplt(vector int __a,
1853  vector int __b) {
1854  return vec_cmpgt(__b, __a);
1855 }
1856 
1857 static __inline__ vector bool int __ATTRS_o_ai
1858 vec_cmplt(vector unsigned int __a, vector unsigned int __b) {
1859  return vec_cmpgt(__b, __a);
1860 }
1861 
1862 static __inline__ vector bool int __ATTRS_o_ai vec_cmplt(vector float __a,
1863  vector float __b) {
1864  return vec_cmpgt(__b, __a);
1865 }
1866 
1867 #ifdef __VSX__
1868 static __inline__ vector bool long long __ATTRS_o_ai
1869 vec_cmplt(vector double __a, vector double __b) {
1870  return vec_cmpgt(__b, __a);
1871 }
1872 #endif
1873 
1874 #ifdef __POWER8_VECTOR__
1875 static __inline__ vector bool long long __ATTRS_o_ai
1876 vec_cmplt(vector signed long long __a, vector signed long long __b) {
1877  return vec_cmpgt(__b, __a);
1878 }
1879 
1880 static __inline__ vector bool long long __ATTRS_o_ai
1881 vec_cmplt(vector unsigned long long __a, vector unsigned long long __b) {
1882  return vec_cmpgt(__b, __a);
1883 }
1884 
1885 /* vec_cntlz */
1886 
1887 static __inline__ vector signed char __ATTRS_o_ai
1888 vec_cntlz(vector signed char __a) {
1889  return __builtin_altivec_vclzb(__a);
1890 }
1891 static __inline__ vector unsigned char __ATTRS_o_ai
1892 vec_cntlz(vector unsigned char __a) {
1893  return __builtin_altivec_vclzb(__a);
1894 }
1895 static __inline__ vector signed short __ATTRS_o_ai
1896 vec_cntlz(vector signed short __a) {
1897  return __builtin_altivec_vclzh(__a);
1898 }
1899 static __inline__ vector unsigned short __ATTRS_o_ai
1900 vec_cntlz(vector unsigned short __a) {
1901  return __builtin_altivec_vclzh(__a);
1902 }
1903 static __inline__ vector signed int __ATTRS_o_ai
1904 vec_cntlz(vector signed int __a) {
1905  return __builtin_altivec_vclzw(__a);
1906 }
1907 static __inline__ vector unsigned int __ATTRS_o_ai
1908 vec_cntlz(vector unsigned int __a) {
1909  return __builtin_altivec_vclzw(__a);
1910 }
1911 static __inline__ vector signed long long __ATTRS_o_ai
1912 vec_cntlz(vector signed long long __a) {
1913  return __builtin_altivec_vclzd(__a);
1914 }
1915 static __inline__ vector unsigned long long __ATTRS_o_ai
1916 vec_cntlz(vector unsigned long long __a) {
1917  return __builtin_altivec_vclzd(__a);
1918 }
1919 #endif
1920 
1921 /* vec_cpsgn */
1922 
1923 #ifdef __VSX__
1924 static __inline__ vector float __ATTRS_o_ai vec_cpsgn(vector float __a,
1925  vector float __b) {
1926  return __builtin_vsx_xvcpsgnsp(__a, __b);
1927 }
1928 
1929 static __inline__ vector double __ATTRS_o_ai vec_cpsgn(vector double __a,
1930  vector double __b) {
1931  return __builtin_vsx_xvcpsgndp(__a, __b);
1932 }
1933 #endif
1934 
1935 /* vec_ctf */
1936 
1937 static __inline__ vector float __ATTRS_o_ai vec_ctf(vector int __a, int __b) {
1938  return __builtin_altivec_vcfsx(__a, __b);
1939 }
1940 
1941 static __inline__ vector float __ATTRS_o_ai vec_ctf(vector unsigned int __a,
1942  int __b) {
1943  return __builtin_altivec_vcfux((vector int)__a, __b);
1944 }
1945 
1946 #ifdef __VSX__
1947 static __inline__ vector double __ATTRS_o_ai
1948 vec_ctf(vector unsigned long long __a, int __b) {
1949  vector double __ret = __builtin_convertvector(__a, vector double);
1950  __ret *= (vector double)(vector unsigned long long)((0x3ffULL - __b) << 52);
1951  return __ret;
1952 }
1953 
1954 static __inline__ vector double __ATTRS_o_ai
1955 vec_ctf(vector signed long long __a, int __b) {
1956  vector double __ret = __builtin_convertvector(__a, vector double);
1957  __ret *= (vector double)(vector unsigned long long)((0x3ffULL - __b) << 52);
1958  return __ret;
1959 }
1960 #endif
1961 
1962 /* vec_vcfsx */
1963 
1964 static __inline__ vector float __attribute__((__always_inline__))
1965 vec_vcfsx(vector int __a, int __b) {
1966  return __builtin_altivec_vcfsx(__a, __b);
1967 }
1968 
1969 /* vec_vcfux */
1970 
1971 static __inline__ vector float __attribute__((__always_inline__))
1972 vec_vcfux(vector unsigned int __a, int __b) {
1973  return __builtin_altivec_vcfux((vector int)__a, __b);
1974 }
1975 
1976 /* vec_cts */
1977 
1978 static __inline__ vector int __ATTRS_o_ai vec_cts(vector float __a, int __b) {
1979  return __builtin_altivec_vctsxs(__a, __b);
1980 }
1981 
1982 #ifdef __VSX__
1983 static __inline__ vector signed long long __ATTRS_o_ai
1984 vec_cts(vector double __a, int __b) {
1985  __a *= (vector double)(vector unsigned long long)((0x3ffULL + __b) << 52);
1986  return __builtin_convertvector(__a, vector signed long long);
1987 }
1988 #endif
1989 
1990 /* vec_vctsxs */
1991 
1992 static __inline__ vector int __attribute__((__always_inline__))
1993 vec_vctsxs(vector float __a, int __b) {
1994  return __builtin_altivec_vctsxs(__a, __b);
1995 }
1996 
1997 /* vec_ctu */
1998 
1999 static __inline__ vector unsigned int __ATTRS_o_ai vec_ctu(vector float __a,
2000  int __b) {
2001  return __builtin_altivec_vctuxs(__a, __b);
2002 }
2003 
2004 #ifdef __VSX__
2005 static __inline__ vector unsigned long long __ATTRS_o_ai
2006 vec_ctu(vector double __a, int __b) {
2007  __a *= (vector double)(vector unsigned long long)((0x3ffULL + __b) << 52);
2008  return __builtin_convertvector(__a, vector unsigned long long);
2009 }
2010 #endif
2011 
2012 /* vec_vctuxs */
2013 
2014 static __inline__ vector unsigned int __attribute__((__always_inline__))
2015 vec_vctuxs(vector float __a, int __b) {
2016  return __builtin_altivec_vctuxs(__a, __b);
2017 }
2018 
2019 /* vec_double */
2020 
2021 #ifdef __VSX__
2022 static __inline__ vector double __ATTRS_o_ai
2023 vec_double(vector signed long long __a) {
2024  vector double __ret = {__a[0], __a[1]};
2025  return __ret;
2026 }
2027 
2028 static __inline__ vector double __ATTRS_o_ai
2029 vec_double(vector unsigned long long __a) {
2030  vector double __ret = {__a[0], __a[1]};
2031  return __ret;
2032 }
2033 #endif
2034 
2035 /* vec_div */
2036 
2037 /* Integer vector divides (vectors are scalarized, elements divided
2038  and the vectors reassembled).
2039 */
2040 static __inline__ vector signed char __ATTRS_o_ai
2041 vec_div(vector signed char __a, vector signed char __b) {
2042  return __a / __b;
2043 }
2044 
2045 static __inline__ vector unsigned char __ATTRS_o_ai
2046 vec_div(vector unsigned char __a, vector unsigned char __b) {
2047  return __a / __b;
2048 }
2049 
2050 static __inline__ vector signed short __ATTRS_o_ai
2051 vec_div(vector signed short __a, vector signed short __b) {
2052  return __a / __b;
2053 }
2054 
2055 static __inline__ vector unsigned short __ATTRS_o_ai
2056 vec_div(vector unsigned short __a, vector unsigned short __b) {
2057  return __a / __b;
2058 }
2059 
2060 static __inline__ vector signed int __ATTRS_o_ai
2061 vec_div(vector signed int __a, vector signed int __b) {
2062  return __a / __b;
2063 }
2064 
2065 static __inline__ vector unsigned int __ATTRS_o_ai
2066 vec_div(vector unsigned int __a, vector unsigned int __b) {
2067  return __a / __b;
2068 }
2069 
2070 #ifdef __VSX__
2071 static __inline__ vector signed long long __ATTRS_o_ai
2072 vec_div(vector signed long long __a, vector signed long long __b) {
2073  return __a / __b;
2074 }
2075 
2076 static __inline__ vector unsigned long long __ATTRS_o_ai
2077 vec_div(vector unsigned long long __a, vector unsigned long long __b) {
2078  return __a / __b;
2079 }
2080 
2081 static __inline__ vector float __ATTRS_o_ai vec_div(vector float __a,
2082  vector float __b) {
2083  return __a / __b;
2084 }
2085 
2086 static __inline__ vector double __ATTRS_o_ai vec_div(vector double __a,
2087  vector double __b) {
2088  return __a / __b;
2089 }
2090 #endif
2091 
2092 /* vec_dss */
2093 
2094 static __inline__ void __attribute__((__always_inline__)) vec_dss(int __a) {
2095  __builtin_altivec_dss(__a);
2096 }
2097 
2098 /* vec_dssall */
2099 
2100 static __inline__ void __attribute__((__always_inline__)) vec_dssall(void) {
2101  __builtin_altivec_dssall();
2102 }
2103 
2104 /* vec_dst */
2105 #define vec_dst(__PTR, __CW, __STR) \
2106  __extension__( \
2107  { __builtin_altivec_dst((const void *)(__PTR), (__CW), (__STR)); })
2108 
2109 /* vec_dstst */
2110 #define vec_dstst(__PTR, __CW, __STR) \
2111  __extension__( \
2112  { __builtin_altivec_dstst((const void *)(__PTR), (__CW), (__STR)); })
2113 
2114 /* vec_dststt */
2115 #define vec_dststt(__PTR, __CW, __STR) \
2116  __extension__( \
2117  { __builtin_altivec_dststt((const void *)(__PTR), (__CW), (__STR)); })
2118 
2119 /* vec_dstt */
2120 #define vec_dstt(__PTR, __CW, __STR) \
2121  __extension__( \
2122  { __builtin_altivec_dstt((const void *)(__PTR), (__CW), (__STR)); })
2123 
2124 /* vec_eqv */
2125 
2126 #ifdef __POWER8_VECTOR__
2127 static __inline__ vector signed char __ATTRS_o_ai
2128 vec_eqv(vector signed char __a, vector signed char __b) {
2129  return (vector signed char)__builtin_vsx_xxleqv((vector unsigned int)__a,
2130  (vector unsigned int)__b);
2131 }
2132 
2133 static __inline__ vector unsigned char __ATTRS_o_ai
2134 vec_eqv(vector unsigned char __a, vector unsigned char __b) {
2135  return (vector unsigned char)__builtin_vsx_xxleqv((vector unsigned int)__a,
2136  (vector unsigned int)__b);
2137 }
2138 
2139 static __inline__ vector bool char __ATTRS_o_ai vec_eqv(vector bool char __a,
2140  vector bool char __b) {
2141  return (vector bool char)__builtin_vsx_xxleqv((vector unsigned int)__a,
2142  (vector unsigned int)__b);
2143 }
2144 
2145 static __inline__ vector signed short __ATTRS_o_ai
2146 vec_eqv(vector signed short __a, vector signed short __b) {
2147  return (vector signed short)__builtin_vsx_xxleqv((vector unsigned int)__a,
2148  (vector unsigned int)__b);
2149 }
2150 
2151 static __inline__ vector unsigned short __ATTRS_o_ai
2152 vec_eqv(vector unsigned short __a, vector unsigned short __b) {
2153  return (vector unsigned short)__builtin_vsx_xxleqv((vector unsigned int)__a,
2154  (vector unsigned int)__b);
2155 }
2156 
2157 static __inline__ vector bool short __ATTRS_o_ai
2158 vec_eqv(vector bool short __a, vector bool short __b) {
2159  return (vector bool short)__builtin_vsx_xxleqv((vector unsigned int)__a,
2160  (vector unsigned int)__b);
2161 }
2162 
2163 static __inline__ vector signed int __ATTRS_o_ai
2164 vec_eqv(vector signed int __a, vector signed int __b) {
2165  return (vector signed int)__builtin_vsx_xxleqv((vector unsigned int)__a,
2166  (vector unsigned int)__b);
2167 }
2168 
2169 static __inline__ vector unsigned int __ATTRS_o_ai
2170 vec_eqv(vector unsigned int __a, vector unsigned int __b) {
2171  return __builtin_vsx_xxleqv(__a, __b);
2172 }
2173 
2174 static __inline__ vector bool int __ATTRS_o_ai vec_eqv(vector bool int __a,
2175  vector bool int __b) {
2176  return (vector bool int)__builtin_vsx_xxleqv((vector unsigned int)__a,
2177  (vector unsigned int)__b);
2178 }
2179 
2180 static __inline__ vector signed long long __ATTRS_o_ai
2181 vec_eqv(vector signed long long __a, vector signed long long __b) {
2182  return (vector signed long long)__builtin_vsx_xxleqv(
2183  (vector unsigned int)__a, (vector unsigned int)__b);
2184 }
2185 
2186 static __inline__ vector unsigned long long __ATTRS_o_ai
2187 vec_eqv(vector unsigned long long __a, vector unsigned long long __b) {
2188  return (vector unsigned long long)__builtin_vsx_xxleqv(
2189  (vector unsigned int)__a, (vector unsigned int)__b);
2190 }
2191 
2192 static __inline__ vector bool long long __ATTRS_o_ai
2193 vec_eqv(vector bool long long __a, vector bool long long __b) {
2194  return (vector bool long long)__builtin_vsx_xxleqv((vector unsigned int)__a,
2195  (vector unsigned int)__b);
2196 }
2197 
2198 static __inline__ vector float __ATTRS_o_ai vec_eqv(vector float __a,
2199  vector float __b) {
2200  return (vector float)__builtin_vsx_xxleqv((vector unsigned int)__a,
2201  (vector unsigned int)__b);
2202 }
2203 
2204 static __inline__ vector double __ATTRS_o_ai vec_eqv(vector double __a,
2205  vector double __b) {
2206  return (vector double)__builtin_vsx_xxleqv((vector unsigned int)__a,
2207  (vector unsigned int)__b);
2208 }
2209 #endif
2210 
2211 /* vec_expte */
2212 
2213 static __inline__ vector float __attribute__((__always_inline__))
2214 vec_expte(vector float __a) {
2215  return __builtin_altivec_vexptefp(__a);
2216 }
2217 
2218 /* vec_vexptefp */
2219 
2220 static __inline__ vector float __attribute__((__always_inline__))
2221 vec_vexptefp(vector float __a) {
2222  return __builtin_altivec_vexptefp(__a);
2223 }
2224 
2225 /* vec_floor */
2226 
2227 static __inline__ vector float __ATTRS_o_ai vec_floor(vector float __a) {
2228 #ifdef __VSX__
2229  return __builtin_vsx_xvrspim(__a);
2230 #else
2231  return __builtin_altivec_vrfim(__a);
2232 #endif
2233 }
2234 
2235 #ifdef __VSX__
2236 static __inline__ vector double __ATTRS_o_ai vec_floor(vector double __a) {
2237  return __builtin_vsx_xvrdpim(__a);
2238 }
2239 #endif
2240 
2241 /* vec_vrfim */
2242 
2243 static __inline__ vector float __attribute__((__always_inline__))
2244 vec_vrfim(vector float __a) {
2245  return __builtin_altivec_vrfim(__a);
2246 }
2247 
2248 /* vec_ld */
2249 
2250 static __inline__ vector signed char __ATTRS_o_ai
2251 vec_ld(int __a, const vector signed char *__b) {
2252  return (vector signed char)__builtin_altivec_lvx(__a, __b);
2253 }
2254 
2255 static __inline__ vector signed char __ATTRS_o_ai
2256 vec_ld(int __a, const signed char *__b) {
2257  return (vector signed char)__builtin_altivec_lvx(__a, __b);
2258 }
2259 
2260 static __inline__ vector unsigned char __ATTRS_o_ai
2261 vec_ld(int __a, const vector unsigned char *__b) {
2262  return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
2263 }
2264 
2265 static __inline__ vector unsigned char __ATTRS_o_ai
2266 vec_ld(int __a, const unsigned char *__b) {
2267  return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
2268 }
2269 
2270 static __inline__ vector bool char __ATTRS_o_ai
2271 vec_ld(int __a, const vector bool char *__b) {
2272  return (vector bool char)__builtin_altivec_lvx(__a, __b);
2273 }
2274 
2275 static __inline__ vector short __ATTRS_o_ai vec_ld(int __a,
2276  const vector short *__b) {
2277  return (vector short)__builtin_altivec_lvx(__a, __b);
2278 }
2279 
2280 static __inline__ vector short __ATTRS_o_ai vec_ld(int __a, const short *__b) {
2281  return (vector short)__builtin_altivec_lvx(__a, __b);
2282 }
2283 
2284 static __inline__ vector unsigned short __ATTRS_o_ai
2285 vec_ld(int __a, const vector unsigned short *__b) {
2286  return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
2287 }
2288 
2289 static __inline__ vector unsigned short __ATTRS_o_ai
2290 vec_ld(int __a, const unsigned short *__b) {
2291  return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
2292 }
2293 
2294 static __inline__ vector bool short __ATTRS_o_ai
2295 vec_ld(int __a, const vector bool short *__b) {
2296  return (vector bool short)__builtin_altivec_lvx(__a, __b);
2297 }
2298 
2299 static __inline__ vector pixel __ATTRS_o_ai vec_ld(int __a,
2300  const vector pixel *__b) {
2301  return (vector pixel)__builtin_altivec_lvx(__a, __b);
2302 }
2303 
2304 static __inline__ vector int __ATTRS_o_ai vec_ld(int __a,
2305  const vector int *__b) {
2306  return (vector int)__builtin_altivec_lvx(__a, __b);
2307 }
2308 
2309 static __inline__ vector int __ATTRS_o_ai vec_ld(int __a, const int *__b) {
2310  return (vector int)__builtin_altivec_lvx(__a, __b);
2311 }
2312 
2313 static __inline__ vector unsigned int __ATTRS_o_ai
2314 vec_ld(int __a, const vector unsigned int *__b) {
2315  return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
2316 }
2317 
2318 static __inline__ vector unsigned int __ATTRS_o_ai
2319 vec_ld(int __a, const unsigned int *__b) {
2320  return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
2321 }
2322 
2323 static __inline__ vector bool int __ATTRS_o_ai
2324 vec_ld(int __a, const vector bool int *__b) {
2325  return (vector bool int)__builtin_altivec_lvx(__a, __b);
2326 }
2327 
2328 static __inline__ vector float __ATTRS_o_ai vec_ld(int __a,
2329  const vector float *__b) {
2330  return (vector float)__builtin_altivec_lvx(__a, __b);
2331 }
2332 
2333 static __inline__ vector float __ATTRS_o_ai vec_ld(int __a, const float *__b) {
2334  return (vector float)__builtin_altivec_lvx(__a, __b);
2335 }
2336 
2337 /* vec_lvx */
2338 
2339 static __inline__ vector signed char __ATTRS_o_ai
2340 vec_lvx(int __a, const vector signed char *__b) {
2341  return (vector signed char)__builtin_altivec_lvx(__a, __b);
2342 }
2343 
2344 static __inline__ vector signed char __ATTRS_o_ai
2345 vec_lvx(int __a, const signed char *__b) {
2346  return (vector signed char)__builtin_altivec_lvx(__a, __b);
2347 }
2348 
2349 static __inline__ vector unsigned char __ATTRS_o_ai
2350 vec_lvx(int __a, const vector unsigned char *__b) {
2351  return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
2352 }
2353 
2354 static __inline__ vector unsigned char __ATTRS_o_ai
2355 vec_lvx(int __a, const unsigned char *__b) {
2356  return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
2357 }
2358 
2359 static __inline__ vector bool char __ATTRS_o_ai
2360 vec_lvx(int __a, const vector bool char *__b) {
2361  return (vector bool char)__builtin_altivec_lvx(__a, __b);
2362 }
2363 
2364 static __inline__ vector short __ATTRS_o_ai vec_lvx(int __a,
2365  const vector short *__b) {
2366  return (vector short)__builtin_altivec_lvx(__a, __b);
2367 }
2368 
2369 static __inline__ vector short __ATTRS_o_ai vec_lvx(int __a, const short *__b) {
2370  return (vector short)__builtin_altivec_lvx(__a, __b);
2371 }
2372 
2373 static __inline__ vector unsigned short __ATTRS_o_ai
2374 vec_lvx(int __a, const vector unsigned short *__b) {
2375  return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
2376 }
2377 
2378 static __inline__ vector unsigned short __ATTRS_o_ai
2379 vec_lvx(int __a, const unsigned short *__b) {
2380  return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
2381 }
2382 
2383 static __inline__ vector bool short __ATTRS_o_ai
2384 vec_lvx(int __a, const vector bool short *__b) {
2385  return (vector bool short)__builtin_altivec_lvx(__a, __b);
2386 }
2387 
2388 static __inline__ vector pixel __ATTRS_o_ai vec_lvx(int __a,
2389  const vector pixel *__b) {
2390  return (vector pixel)__builtin_altivec_lvx(__a, __b);
2391 }
2392 
2393 static __inline__ vector int __ATTRS_o_ai vec_lvx(int __a,
2394  const vector int *__b) {
2395  return (vector int)__builtin_altivec_lvx(__a, __b);
2396 }
2397 
2398 static __inline__ vector int __ATTRS_o_ai vec_lvx(int __a, const int *__b) {
2399  return (vector int)__builtin_altivec_lvx(__a, __b);
2400 }
2401 
2402 static __inline__ vector unsigned int __ATTRS_o_ai
2403 vec_lvx(int __a, const vector unsigned int *__b) {
2404  return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
2405 }
2406 
2407 static __inline__ vector unsigned int __ATTRS_o_ai
2408 vec_lvx(int __a, const unsigned int *__b) {
2409  return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
2410 }
2411 
2412 static __inline__ vector bool int __ATTRS_o_ai
2413 vec_lvx(int __a, const vector bool int *__b) {
2414  return (vector bool int)__builtin_altivec_lvx(__a, __b);
2415 }
2416 
2417 static __inline__ vector float __ATTRS_o_ai vec_lvx(int __a,
2418  const vector float *__b) {
2419  return (vector float)__builtin_altivec_lvx(__a, __b);
2420 }
2421 
2422 static __inline__ vector float __ATTRS_o_ai vec_lvx(int __a, const float *__b) {
2423  return (vector float)__builtin_altivec_lvx(__a, __b);
2424 }
2425 
2426 /* vec_lde */
2427 
2428 static __inline__ vector signed char __ATTRS_o_ai
2429 vec_lde(int __a, const signed char *__b) {
2430  return (vector signed char)__builtin_altivec_lvebx(__a, __b);
2431 }
2432 
2433 static __inline__ vector unsigned char __ATTRS_o_ai
2434 vec_lde(int __a, const unsigned char *__b) {
2435  return (vector unsigned char)__builtin_altivec_lvebx(__a, __b);
2436 }
2437 
2438 static __inline__ vector short __ATTRS_o_ai vec_lde(int __a, const short *__b) {
2439  return (vector short)__builtin_altivec_lvehx(__a, __b);
2440 }
2441 
2442 static __inline__ vector unsigned short __ATTRS_o_ai
2443 vec_lde(int __a, const unsigned short *__b) {
2444  return (vector unsigned short)__builtin_altivec_lvehx(__a, __b);
2445 }
2446 
2447 static __inline__ vector int __ATTRS_o_ai vec_lde(int __a, const int *__b) {
2448  return (vector int)__builtin_altivec_lvewx(__a, __b);
2449 }
2450 
2451 static __inline__ vector unsigned int __ATTRS_o_ai
2452 vec_lde(int __a, const unsigned int *__b) {
2453  return (vector unsigned int)__builtin_altivec_lvewx(__a, __b);
2454 }
2455 
2456 static __inline__ vector float __ATTRS_o_ai vec_lde(int __a, const float *__b) {
2457  return (vector float)__builtin_altivec_lvewx(__a, __b);
2458 }
2459 
2460 /* vec_lvebx */
2461 
2462 static __inline__ vector signed char __ATTRS_o_ai
2463 vec_lvebx(int __a, const signed char *__b) {
2464  return (vector signed char)__builtin_altivec_lvebx(__a, __b);
2465 }
2466 
2467 static __inline__ vector unsigned char __ATTRS_o_ai
2468 vec_lvebx(int __a, const unsigned char *__b) {
2469  return (vector unsigned char)__builtin_altivec_lvebx(__a, __b);
2470 }
2471 
2472 /* vec_lvehx */
2473 
2474 static __inline__ vector short __ATTRS_o_ai vec_lvehx(int __a,
2475  const short *__b) {
2476  return (vector short)__builtin_altivec_lvehx(__a, __b);
2477 }
2478 
2479 static __inline__ vector unsigned short __ATTRS_o_ai
2480 vec_lvehx(int __a, const unsigned short *__b) {
2481  return (vector unsigned short)__builtin_altivec_lvehx(__a, __b);
2482 }
2483 
2484 /* vec_lvewx */
2485 
2486 static __inline__ vector int __ATTRS_o_ai vec_lvewx(int __a, const int *__b) {
2487  return (vector int)__builtin_altivec_lvewx(__a, __b);
2488 }
2489 
2490 static __inline__ vector unsigned int __ATTRS_o_ai
2491 vec_lvewx(int __a, const unsigned int *__b) {
2492  return (vector unsigned int)__builtin_altivec_lvewx(__a, __b);
2493 }
2494 
2495 static __inline__ vector float __ATTRS_o_ai vec_lvewx(int __a,
2496  const float *__b) {
2497  return (vector float)__builtin_altivec_lvewx(__a, __b);
2498 }
2499 
2500 /* vec_ldl */
2501 
2502 static __inline__ vector signed char __ATTRS_o_ai
2503 vec_ldl(int __a, const vector signed char *__b) {
2504  return (vector signed char)__builtin_altivec_lvxl(__a, __b);
2505 }
2506 
2507 static __inline__ vector signed char __ATTRS_o_ai
2508 vec_ldl(int __a, const signed char *__b) {
2509  return (vector signed char)__builtin_altivec_lvxl(__a, __b);
2510 }
2511 
2512 static __inline__ vector unsigned char __ATTRS_o_ai
2513 vec_ldl(int __a, const vector unsigned char *__b) {
2514  return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
2515 }
2516 
2517 static __inline__ vector unsigned char __ATTRS_o_ai
2518 vec_ldl(int __a, const unsigned char *__b) {
2519  return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
2520 }
2521 
2522 static __inline__ vector bool char __ATTRS_o_ai
2523 vec_ldl(int __a, const vector bool char *__b) {
2524  return (vector bool char)__builtin_altivec_lvxl(__a, __b);
2525 }
2526 
2527 static __inline__ vector short __ATTRS_o_ai vec_ldl(int __a,
2528  const vector short *__b) {
2529  return (vector short)__builtin_altivec_lvxl(__a, __b);
2530 }
2531 
2532 static __inline__ vector short __ATTRS_o_ai vec_ldl(int __a, const short *__b) {
2533  return (vector short)__builtin_altivec_lvxl(__a, __b);
2534 }
2535 
2536 static __inline__ vector unsigned short __ATTRS_o_ai
2537 vec_ldl(int __a, const vector unsigned short *__b) {
2538  return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
2539 }
2540 
2541 static __inline__ vector unsigned short __ATTRS_o_ai
2542 vec_ldl(int __a, const unsigned short *__b) {
2543  return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
2544 }
2545 
2546 static __inline__ vector bool short __ATTRS_o_ai
2547 vec_ldl(int __a, const vector bool short *__b) {
2548  return (vector bool short)__builtin_altivec_lvxl(__a, __b);
2549 }
2550 
2551 static __inline__ vector pixel __ATTRS_o_ai vec_ldl(int __a,
2552  const vector pixel *__b) {
2553  return (vector pixel short)__builtin_altivec_lvxl(__a, __b);
2554 }
2555 
2556 static __inline__ vector int __ATTRS_o_ai vec_ldl(int __a,
2557  const vector int *__b) {
2558  return (vector int)__builtin_altivec_lvxl(__a, __b);
2559 }
2560 
2561 static __inline__ vector int __ATTRS_o_ai vec_ldl(int __a, const int *__b) {
2562  return (vector int)__builtin_altivec_lvxl(__a, __b);
2563 }
2564 
2565 static __inline__ vector unsigned int __ATTRS_o_ai
2566 vec_ldl(int __a, const vector unsigned int *__b) {
2567  return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
2568 }
2569 
2570 static __inline__ vector unsigned int __ATTRS_o_ai
2571 vec_ldl(int __a, const unsigned int *__b) {
2572  return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
2573 }
2574 
2575 static __inline__ vector bool int __ATTRS_o_ai
2576 vec_ldl(int __a, const vector bool int *__b) {
2577  return (vector bool int)__builtin_altivec_lvxl(__a, __b);
2578 }
2579 
2580 static __inline__ vector float __ATTRS_o_ai vec_ldl(int __a,
2581  const vector float *__b) {
2582  return (vector float)__builtin_altivec_lvxl(__a, __b);
2583 }
2584 
2585 static __inline__ vector float __ATTRS_o_ai vec_ldl(int __a, const float *__b) {
2586  return (vector float)__builtin_altivec_lvxl(__a, __b);
2587 }
2588 
2589 /* vec_lvxl */
2590 
2591 static __inline__ vector signed char __ATTRS_o_ai
2592 vec_lvxl(int __a, const vector signed char *__b) {
2593  return (vector signed char)__builtin_altivec_lvxl(__a, __b);
2594 }
2595 
2596 static __inline__ vector signed char __ATTRS_o_ai
2597 vec_lvxl(int __a, const signed char *__b) {
2598  return (vector signed char)__builtin_altivec_lvxl(__a, __b);
2599 }
2600 
2601 static __inline__ vector unsigned char __ATTRS_o_ai
2602 vec_lvxl(int __a, const vector unsigned char *__b) {
2603  return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
2604 }
2605 
2606 static __inline__ vector unsigned char __ATTRS_o_ai
2607 vec_lvxl(int __a, const unsigned char *__b) {
2608  return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
2609 }
2610 
2611 static __inline__ vector bool char __ATTRS_o_ai
2612 vec_lvxl(int __a, const vector bool char *__b) {
2613  return (vector bool char)__builtin_altivec_lvxl(__a, __b);
2614 }
2615 
2616 static __inline__ vector short __ATTRS_o_ai vec_lvxl(int __a,
2617  const vector short *__b) {
2618  return (vector short)__builtin_altivec_lvxl(__a, __b);
2619 }
2620 
2621 static __inline__ vector short __ATTRS_o_ai vec_lvxl(int __a,
2622  const short *__b) {
2623  return (vector short)__builtin_altivec_lvxl(__a, __b);
2624 }
2625 
2626 static __inline__ vector unsigned short __ATTRS_o_ai
2627 vec_lvxl(int __a, const vector unsigned short *__b) {
2628  return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
2629 }
2630 
2631 static __inline__ vector unsigned short __ATTRS_o_ai
2632 vec_lvxl(int __a, const unsigned short *__b) {
2633  return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
2634 }
2635 
2636 static __inline__ vector bool short __ATTRS_o_ai
2637 vec_lvxl(int __a, const vector bool short *__b) {
2638  return (vector bool short)__builtin_altivec_lvxl(__a, __b);
2639 }
2640 
2641 static __inline__ vector pixel __ATTRS_o_ai vec_lvxl(int __a,
2642  const vector pixel *__b) {
2643  return (vector pixel)__builtin_altivec_lvxl(__a, __b);
2644 }
2645 
2646 static __inline__ vector int __ATTRS_o_ai vec_lvxl(int __a,
2647  const vector int *__b) {
2648  return (vector int)__builtin_altivec_lvxl(__a, __b);
2649 }
2650 
2651 static __inline__ vector int __ATTRS_o_ai vec_lvxl(int __a, const int *__b) {
2652  return (vector int)__builtin_altivec_lvxl(__a, __b);
2653 }
2654 
2655 static __inline__ vector unsigned int __ATTRS_o_ai
2656 vec_lvxl(int __a, const vector unsigned int *__b) {
2657  return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
2658 }
2659 
2660 static __inline__ vector unsigned int __ATTRS_o_ai
2661 vec_lvxl(int __a, const unsigned int *__b) {
2662  return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
2663 }
2664 
2665 static __inline__ vector bool int __ATTRS_o_ai
2666 vec_lvxl(int __a, const vector bool int *__b) {
2667  return (vector bool int)__builtin_altivec_lvxl(__a, __b);
2668 }
2669 
2670 static __inline__ vector float __ATTRS_o_ai vec_lvxl(int __a,
2671  const vector float *__b) {
2672  return (vector float)__builtin_altivec_lvxl(__a, __b);
2673 }
2674 
2675 static __inline__ vector float __ATTRS_o_ai vec_lvxl(int __a,
2676  const float *__b) {
2677  return (vector float)__builtin_altivec_lvxl(__a, __b);
2678 }
2679 
2680 /* vec_loge */
2681 
2682 static __inline__ vector float __attribute__((__always_inline__))
2683 vec_loge(vector float __a) {
2684  return __builtin_altivec_vlogefp(__a);
2685 }
2686 
2687 /* vec_vlogefp */
2688 
2689 static __inline__ vector float __attribute__((__always_inline__))
2690 vec_vlogefp(vector float __a) {
2691  return __builtin_altivec_vlogefp(__a);
2692 }
2693 
2694 /* vec_lvsl */
2695 
2696 #ifdef __LITTLE_ENDIAN__
2697 static __inline__ vector unsigned char __ATTRS_o_ai
2698  __attribute__((__deprecated__("use assignment for unaligned little endian \
2699 loads/stores"))) vec_lvsl(int __a, const signed char *__b) {
2700  vector unsigned char mask =
2701  (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
2702  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
2703  7, 6, 5, 4, 3, 2, 1, 0};
2704  return vec_perm(mask, mask, reverse);
2705 }
2706 #else
2707 static __inline__ vector unsigned char __ATTRS_o_ai
2708 vec_lvsl(int __a, const signed char *__b) {
2709  return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
2710 }
2711 #endif
2712 
2713 #ifdef __LITTLE_ENDIAN__
2714 static __inline__ vector unsigned char __ATTRS_o_ai
2715  __attribute__((__deprecated__("use assignment for unaligned little endian \
2716 loads/stores"))) vec_lvsl(int __a, const unsigned char *__b) {
2717  vector unsigned char mask =
2718  (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
2719  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
2720  7, 6, 5, 4, 3, 2, 1, 0};
2721  return vec_perm(mask, mask, reverse);
2722 }
2723 #else
2724 static __inline__ vector unsigned char __ATTRS_o_ai
2725 vec_lvsl(int __a, const unsigned char *__b) {
2726  return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
2727 }
2728 #endif
2729 
2730 #ifdef __LITTLE_ENDIAN__
2731 static __inline__ vector unsigned char __ATTRS_o_ai
2732  __attribute__((__deprecated__("use assignment for unaligned little endian \
2733 loads/stores"))) vec_lvsl(int __a, const short *__b) {
2734  vector unsigned char mask =
2735  (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
2736  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
2737  7, 6, 5, 4, 3, 2, 1, 0};
2738  return vec_perm(mask, mask, reverse);
2739 }
2740 #else
2741 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsl(int __a,
2742  const short *__b) {
2743  return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
2744 }
2745 #endif
2746 
2747 #ifdef __LITTLE_ENDIAN__
2748 static __inline__ vector unsigned char __ATTRS_o_ai
2749  __attribute__((__deprecated__("use assignment for unaligned little endian \
2750 loads/stores"))) vec_lvsl(int __a, const unsigned short *__b) {
2751  vector unsigned char mask =
2752  (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
2753  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
2754  7, 6, 5, 4, 3, 2, 1, 0};
2755  return vec_perm(mask, mask, reverse);
2756 }
2757 #else
2758 static __inline__ vector unsigned char __ATTRS_o_ai
2759 vec_lvsl(int __a, const unsigned short *__b) {
2760  return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
2761 }
2762 #endif
2763 
2764 #ifdef __LITTLE_ENDIAN__
2765 static __inline__ vector unsigned char __ATTRS_o_ai
2766  __attribute__((__deprecated__("use assignment for unaligned little endian \
2767 loads/stores"))) vec_lvsl(int __a, const int *__b) {
2768  vector unsigned char mask =
2769  (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
2770  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
2771  7, 6, 5, 4, 3, 2, 1, 0};
2772  return vec_perm(mask, mask, reverse);
2773 }
2774 #else
2775 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsl(int __a,
2776  const int *__b) {
2777  return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
2778 }
2779 #endif
2780 
2781 #ifdef __LITTLE_ENDIAN__
2782 static __inline__ vector unsigned char __ATTRS_o_ai
2783  __attribute__((__deprecated__("use assignment for unaligned little endian \
2784 loads/stores"))) vec_lvsl(int __a, const unsigned int *__b) {
2785  vector unsigned char mask =
2786  (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
2787  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
2788  7, 6, 5, 4, 3, 2, 1, 0};
2789  return vec_perm(mask, mask, reverse);
2790 }
2791 #else
2792 static __inline__ vector unsigned char __ATTRS_o_ai
2793 vec_lvsl(int __a, const unsigned int *__b) {
2794  return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
2795 }
2796 #endif
2797 
2798 #ifdef __LITTLE_ENDIAN__
2799 static __inline__ vector unsigned char __ATTRS_o_ai
2800  __attribute__((__deprecated__("use assignment for unaligned little endian \
2801 loads/stores"))) vec_lvsl(int __a, const float *__b) {
2802  vector unsigned char mask =
2803  (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
2804  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
2805  7, 6, 5, 4, 3, 2, 1, 0};
2806  return vec_perm(mask, mask, reverse);
2807 }
2808 #else
2809 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsl(int __a,
2810  const float *__b) {
2811  return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
2812 }
2813 #endif
2814 
2815 /* vec_lvsr */
2816 
2817 #ifdef __LITTLE_ENDIAN__
2818 static __inline__ vector unsigned char __ATTRS_o_ai
2819  __attribute__((__deprecated__("use assignment for unaligned little endian \
2820 loads/stores"))) vec_lvsr(int __a, const signed char *__b) {
2821  vector unsigned char mask =
2822  (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
2823  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
2824  7, 6, 5, 4, 3, 2, 1, 0};
2825  return vec_perm(mask, mask, reverse);
2826 }
2827 #else
2828 static __inline__ vector unsigned char __ATTRS_o_ai
2829 vec_lvsr(int __a, const signed char *__b) {
2830  return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
2831 }
2832 #endif
2833 
2834 #ifdef __LITTLE_ENDIAN__
2835 static __inline__ vector unsigned char __ATTRS_o_ai
2836  __attribute__((__deprecated__("use assignment for unaligned little endian \
2837 loads/stores"))) vec_lvsr(int __a, const unsigned char *__b) {
2838  vector unsigned char mask =
2839  (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
2840  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
2841  7, 6, 5, 4, 3, 2, 1, 0};
2842  return vec_perm(mask, mask, reverse);
2843 }
2844 #else
2845 static __inline__ vector unsigned char __ATTRS_o_ai
2846 vec_lvsr(int __a, const unsigned char *__b) {
2847  return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
2848 }
2849 #endif
2850 
2851 #ifdef __LITTLE_ENDIAN__
2852 static __inline__ vector unsigned char __ATTRS_o_ai
2853  __attribute__((__deprecated__("use assignment for unaligned little endian \
2854 loads/stores"))) vec_lvsr(int __a, const short *__b) {
2855  vector unsigned char mask =
2856  (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
2857  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
2858  7, 6, 5, 4, 3, 2, 1, 0};
2859  return vec_perm(mask, mask, reverse);
2860 }
2861 #else
2862 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsr(int __a,
2863  const short *__b) {
2864  return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
2865 }
2866 #endif
2867 
2868 #ifdef __LITTLE_ENDIAN__
2869 static __inline__ vector unsigned char __ATTRS_o_ai
2870  __attribute__((__deprecated__("use assignment for unaligned little endian \
2871 loads/stores"))) vec_lvsr(int __a, const unsigned short *__b) {
2872  vector unsigned char mask =
2873  (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
2874  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
2875  7, 6, 5, 4, 3, 2, 1, 0};
2876  return vec_perm(mask, mask, reverse);
2877 }
2878 #else
2879 static __inline__ vector unsigned char __ATTRS_o_ai
2880 vec_lvsr(int __a, const unsigned short *__b) {
2881  return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
2882 }
2883 #endif
2884 
2885 #ifdef __LITTLE_ENDIAN__
2886 static __inline__ vector unsigned char __ATTRS_o_ai
2887  __attribute__((__deprecated__("use assignment for unaligned little endian \
2888 loads/stores"))) vec_lvsr(int __a, const int *__b) {
2889  vector unsigned char mask =
2890  (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
2891  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
2892  7, 6, 5, 4, 3, 2, 1, 0};
2893  return vec_perm(mask, mask, reverse);
2894 }
2895 #else
2896 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsr(int __a,
2897  const int *__b) {
2898  return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
2899 }
2900 #endif
2901 
2902 #ifdef __LITTLE_ENDIAN__
2903 static __inline__ vector unsigned char __ATTRS_o_ai
2904  __attribute__((__deprecated__("use assignment for unaligned little endian \
2905 loads/stores"))) vec_lvsr(int __a, const unsigned int *__b) {
2906  vector unsigned char mask =
2907  (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
2908  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
2909  7, 6, 5, 4, 3, 2, 1, 0};
2910  return vec_perm(mask, mask, reverse);
2911 }
2912 #else
2913 static __inline__ vector unsigned char __ATTRS_o_ai
2914 vec_lvsr(int __a, const unsigned int *__b) {
2915  return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
2916 }
2917 #endif
2918 
2919 #ifdef __LITTLE_ENDIAN__
2920 static __inline__ vector unsigned char __ATTRS_o_ai
2921  __attribute__((__deprecated__("use assignment for unaligned little endian \
2922 loads/stores"))) vec_lvsr(int __a, const float *__b) {
2923  vector unsigned char mask =
2924  (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
2925  vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
2926  7, 6, 5, 4, 3, 2, 1, 0};
2927  return vec_perm(mask, mask, reverse);
2928 }
2929 #else
2930 static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsr(int __a,
2931  const float *__b) {
2932  return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
2933 }
2934 #endif
2935 
2936 /* vec_madd */
2937 static __inline__ vector signed short __ATTRS_o_ai
2938 vec_mladd(vector signed short, vector signed short, vector signed short);
2939 static __inline__ vector signed short __ATTRS_o_ai
2940 vec_mladd(vector signed short, vector unsigned short, vector unsigned short);
2941 static __inline__ vector signed short __ATTRS_o_ai
2942 vec_mladd(vector unsigned short, vector signed short, vector signed short);
2943 static __inline__ vector unsigned short __ATTRS_o_ai
2944 vec_mladd(vector unsigned short, vector unsigned short, vector unsigned short);
2945 
2946 static __inline__ vector signed short __ATTRS_o_ai vec_madd(
2947  vector signed short __a, vector signed short __b, vector signed short __c) {
2948  return vec_mladd(__a, __b, __c);
2949 }
2950 
2951 static __inline__ vector signed short __ATTRS_o_ai
2952 vec_madd(vector signed short __a, vector unsigned short __b,
2953  vector unsigned short __c) {
2954  return vec_mladd(__a, __b, __c);
2955 }
2956 
2957 static __inline__ vector signed short __ATTRS_o_ai
2958 vec_madd(vector unsigned short __a, vector signed short __b,
2959  vector signed short __c) {
2960  return vec_mladd(__a, __b, __c);
2961 }
2962 
2963 static __inline__ vector unsigned short __ATTRS_o_ai
2964 vec_madd(vector unsigned short __a, vector unsigned short __b,
2965  vector unsigned short __c) {
2966  return vec_mladd(__a, __b, __c);
2967 }
2968 
2969 static __inline__ vector float __ATTRS_o_ai vec_madd(vector float __a,
2970  vector float __b,
2971  vector float __c) {
2972 #ifdef __VSX__
2973  return __builtin_vsx_xvmaddasp(__a, __b, __c);
2974 #else
2975  return __builtin_altivec_vmaddfp(__a, __b, __c);
2976 #endif
2977 }
2978 
2979 #ifdef __VSX__
2980 static __inline__ vector double __ATTRS_o_ai vec_madd(vector double __a,
2981  vector double __b,
2982  vector double __c) {
2983  return __builtin_vsx_xvmaddadp(__a, __b, __c);
2984 }
2985 #endif
2986 
2987 /* vec_vmaddfp */
2988 
2989 static __inline__ vector float __attribute__((__always_inline__))
2990 vec_vmaddfp(vector float __a, vector float __b, vector float __c) {
2991  return __builtin_altivec_vmaddfp(__a, __b, __c);
2992 }
2993 
2994 /* vec_madds */
2995 
2996 static __inline__ vector signed short __attribute__((__always_inline__))
2997 vec_madds(vector signed short __a, vector signed short __b,
2998  vector signed short __c) {
2999  return __builtin_altivec_vmhaddshs(__a, __b, __c);
3000 }
3001 
3002 /* vec_vmhaddshs */
3003 static __inline__ vector signed short __attribute__((__always_inline__))
3004 vec_vmhaddshs(vector signed short __a, vector signed short __b,
3005  vector signed short __c) {
3006  return __builtin_altivec_vmhaddshs(__a, __b, __c);
3007 }
3008 
3009 /* vec_msub */
3010 
3011 #ifdef __VSX__
3012 static __inline__ vector float __ATTRS_o_ai vec_msub(vector float __a,
3013  vector float __b,
3014  vector float __c) {
3015  return __builtin_vsx_xvmsubasp(__a, __b, __c);
3016 }
3017 
3018 static __inline__ vector double __ATTRS_o_ai vec_msub(vector double __a,
3019  vector double __b,
3020  vector double __c) {
3021  return __builtin_vsx_xvmsubadp(__a, __b, __c);
3022 }
3023 #endif
3024 
3025 /* vec_max */
3026 
3027 static __inline__ vector signed char __ATTRS_o_ai
3028 vec_max(vector signed char __a, vector signed char __b) {
3029  return __builtin_altivec_vmaxsb(__a, __b);
3030 }
3031 
3032 static __inline__ vector signed char __ATTRS_o_ai
3033 vec_max(vector bool char __a, vector signed char __b) {
3034  return __builtin_altivec_vmaxsb((vector signed char)__a, __b);
3035 }
3036 
3037 static __inline__ vector signed char __ATTRS_o_ai
3038 vec_max(vector signed char __a, vector bool char __b) {
3039  return __builtin_altivec_vmaxsb(__a, (vector signed char)__b);
3040 }
3041 
3042 static __inline__ vector unsigned char __ATTRS_o_ai
3043 vec_max(vector unsigned char __a, vector unsigned char __b) {
3044  return __builtin_altivec_vmaxub(__a, __b);
3045 }
3046 
3047 static __inline__ vector unsigned char __ATTRS_o_ai
3048 vec_max(vector bool char __a, vector unsigned char __b) {
3049  return __builtin_altivec_vmaxub((vector unsigned char)__a, __b);
3050 }
3051 
3052 static __inline__ vector unsigned char __ATTRS_o_ai
3053 vec_max(vector unsigned char __a, vector bool char __b) {
3054  return __builtin_altivec_vmaxub(__a, (vector unsigned char)__b);
3055 }
3056 
3057 static __inline__ vector short __ATTRS_o_ai vec_max(vector short __a,
3058  vector short __b) {
3059  return __builtin_altivec_vmaxsh(__a, __b);
3060 }
3061 
3062 static __inline__ vector short __ATTRS_o_ai vec_max(vector bool short __a,
3063  vector short __b) {
3064  return __builtin_altivec_vmaxsh((vector short)__a, __b);
3065 }
3066 
3067 static __inline__ vector short __ATTRS_o_ai vec_max(vector short __a,
3068  vector bool short __b) {
3069  return __builtin_altivec_vmaxsh(__a, (vector short)__b);
3070 }
3071 
3072 static __inline__ vector unsigned short __ATTRS_o_ai
3073 vec_max(vector unsigned short __a, vector unsigned short __b) {
3074  return __builtin_altivec_vmaxuh(__a, __b);
3075 }
3076 
3077 static __inline__ vector unsigned short __ATTRS_o_ai
3078 vec_max(vector bool short __a, vector unsigned short __b) {
3079  return __builtin_altivec_vmaxuh((vector unsigned short)__a, __b);
3080 }
3081 
3082 static __inline__ vector unsigned short __ATTRS_o_ai
3083 vec_max(vector unsigned short __a, vector bool short __b) {
3084  return __builtin_altivec_vmaxuh(__a, (vector unsigned short)__b);
3085 }
3086 
3087 static __inline__ vector int __ATTRS_o_ai vec_max(vector int __a,
3088  vector int __b) {
3089  return __builtin_altivec_vmaxsw(__a, __b);
3090 }
3091 
3092 static __inline__ vector int __ATTRS_o_ai vec_max(vector bool int __a,
3093  vector int __b) {
3094  return __builtin_altivec_vmaxsw((vector int)__a, __b);
3095 }
3096 
3097 static __inline__ vector int __ATTRS_o_ai vec_max(vector int __a,
3098  vector bool int __b) {
3099  return __builtin_altivec_vmaxsw(__a, (vector int)__b);
3100 }
3101 
3102 static __inline__ vector unsigned int __ATTRS_o_ai
3103 vec_max(vector unsigned int __a, vector unsigned int __b) {
3104  return __builtin_altivec_vmaxuw(__a, __b);
3105 }
3106 
3107 static __inline__ vector unsigned int __ATTRS_o_ai
3108 vec_max(vector bool int __a, vector unsigned int __b) {
3109  return __builtin_altivec_vmaxuw((vector unsigned int)__a, __b);
3110 }
3111 
3112 static __inline__ vector unsigned int __ATTRS_o_ai
3113 vec_max(vector unsigned int __a, vector bool int __b) {
3114  return __builtin_altivec_vmaxuw(__a, (vector unsigned int)__b);
3115 }
3116 
3117 #ifdef __POWER8_VECTOR__
3118 static __inline__ vector signed long long __ATTRS_o_ai
3119 vec_max(vector signed long long __a, vector signed long long __b) {
3120  return __builtin_altivec_vmaxsd(__a, __b);
3121 }
3122 
3123 static __inline__ vector signed long long __ATTRS_o_ai
3124 vec_max(vector bool long long __a, vector signed long long __b) {
3125  return __builtin_altivec_vmaxsd((vector signed long long)__a, __b);
3126 }
3127 
3128 static __inline__ vector signed long long __ATTRS_o_ai
3129 vec_max(vector signed long long __a, vector bool long long __b) {
3130  return __builtin_altivec_vmaxsd(__a, (vector signed long long)__b);
3131 }
3132 
3133 static __inline__ vector unsigned long long __ATTRS_o_ai
3134 vec_max(vector unsigned long long __a, vector unsigned long long __b) {
3135  return __builtin_altivec_vmaxud(__a, __b);
3136 }
3137 
3138 static __inline__ vector unsigned long long __ATTRS_o_ai
3139 vec_max(vector bool long long __a, vector unsigned long long __b) {
3140  return __builtin_altivec_vmaxud((vector unsigned long long)__a, __b);
3141 }
3142 
3143 static __inline__ vector unsigned long long __ATTRS_o_ai
3144 vec_max(vector unsigned long long __a, vector bool long long __b) {
3145  return __builtin_altivec_vmaxud(__a, (vector unsigned long long)__b);
3146 }
3147 #endif
3148 
3149 static __inline__ vector float __ATTRS_o_ai vec_max(vector float __a,
3150  vector float __b) {
3151 #ifdef __VSX__
3152  return __builtin_vsx_xvmaxsp(__a, __b);
3153 #else
3154  return __builtin_altivec_vmaxfp(__a, __b);
3155 #endif
3156 }
3157 
3158 #ifdef __VSX__
3159 static __inline__ vector double __ATTRS_o_ai vec_max(vector double __a,
3160  vector double __b) {
3161  return __builtin_vsx_xvmaxdp(__a, __b);
3162 }
3163 #endif
3164 
3165 /* vec_vmaxsb */
3166 
3167 static __inline__ vector signed char __ATTRS_o_ai
3168 vec_vmaxsb(vector signed char __a, vector signed char __b) {
3169  return __builtin_altivec_vmaxsb(__a, __b);
3170 }
3171 
3172 static __inline__ vector signed char __ATTRS_o_ai
3173 vec_vmaxsb(vector bool char __a, vector signed char __b) {
3174  return __builtin_altivec_vmaxsb((vector signed char)__a, __b);
3175 }
3176 
3177 static __inline__ vector signed char __ATTRS_o_ai
3178 vec_vmaxsb(vector signed char __a, vector bool char __b) {
3179  return __builtin_altivec_vmaxsb(__a, (vector signed char)__b);
3180 }
3181 
3182 /* vec_vmaxub */
3183 
3184 static __inline__ vector unsigned char __ATTRS_o_ai
3185 vec_vmaxub(vector unsigned char __a, vector unsigned char __b) {
3186  return __builtin_altivec_vmaxub(__a, __b);
3187 }
3188 
3189 static __inline__ vector unsigned char __ATTRS_o_ai
3190 vec_vmaxub(vector bool char __a, vector unsigned char __b) {
3191  return __builtin_altivec_vmaxub((vector unsigned char)__a, __b);
3192 }
3193 
3194 static __inline__ vector unsigned char __ATTRS_o_ai
3195 vec_vmaxub(vector unsigned char __a, vector bool char __b) {
3196  return __builtin_altivec_vmaxub(__a, (vector unsigned char)__b);
3197 }
3198 
3199 /* vec_vmaxsh */
3200 
3201 static __inline__ vector short __ATTRS_o_ai vec_vmaxsh(vector short __a,
3202  vector short __b) {
3203  return __builtin_altivec_vmaxsh(__a, __b);
3204 }
3205 
3206 static __inline__ vector short __ATTRS_o_ai vec_vmaxsh(vector bool short __a,
3207  vector short __b) {
3208  return __builtin_altivec_vmaxsh((vector short)__a, __b);
3209 }
3210 
3211 static __inline__ vector short __ATTRS_o_ai vec_vmaxsh(vector short __a,
3212  vector bool short __b) {
3213  return __builtin_altivec_vmaxsh(__a, (vector short)__b);
3214 }
3215 
3216 /* vec_vmaxuh */
3217 
3218 static __inline__ vector unsigned short __ATTRS_o_ai
3219 vec_vmaxuh(vector unsigned short __a, vector unsigned short __b) {
3220  return __builtin_altivec_vmaxuh(__a, __b);
3221 }
3222 
3223 static __inline__ vector unsigned short __ATTRS_o_ai
3224 vec_vmaxuh(vector bool short __a, vector unsigned short __b) {
3225  return __builtin_altivec_vmaxuh((vector unsigned short)__a, __b);
3226 }
3227 
3228 static __inline__ vector unsigned short __ATTRS_o_ai
3229 vec_vmaxuh(vector unsigned short __a, vector bool short __b) {
3230  return __builtin_altivec_vmaxuh(__a, (vector unsigned short)__b);
3231 }
3232 
3233 /* vec_vmaxsw */
3234 
3235 static __inline__ vector int __ATTRS_o_ai vec_vmaxsw(vector int __a,
3236  vector int __b) {
3237  return __builtin_altivec_vmaxsw(__a, __b);
3238 }
3239 
3240 static __inline__ vector int __ATTRS_o_ai vec_vmaxsw(vector bool int __a,
3241  vector int __b) {
3242  return __builtin_altivec_vmaxsw((vector int)__a, __b);
3243 }
3244 
3245 static __inline__ vector int __ATTRS_o_ai vec_vmaxsw(vector int __a,
3246  vector bool int __b) {
3247  return __builtin_altivec_vmaxsw(__a, (vector int)__b);
3248 }
3249 
3250 /* vec_vmaxuw */
3251 
3252 static __inline__ vector unsigned int __ATTRS_o_ai
3253 vec_vmaxuw(vector unsigned int __a, vector unsigned int __b) {
3254  return __builtin_altivec_vmaxuw(__a, __b);
3255 }
3256 
3257 static __inline__ vector unsigned int __ATTRS_o_ai
3258 vec_vmaxuw(vector bool int __a, vector unsigned int __b) {
3259  return __builtin_altivec_vmaxuw((vector unsigned int)__a, __b);
3260 }
3261 
3262 static __inline__ vector unsigned int __ATTRS_o_ai
3263 vec_vmaxuw(vector unsigned int __a, vector bool int __b) {
3264  return __builtin_altivec_vmaxuw(__a, (vector unsigned int)__b);
3265 }
3266 
3267 /* vec_vmaxfp */
3268 
3269 static __inline__ vector float __attribute__((__always_inline__))
3270 vec_vmaxfp(vector float __a, vector float __b) {
3271 #ifdef __VSX__
3272  return __builtin_vsx_xvmaxsp(__a, __b);
3273 #else
3274  return __builtin_altivec_vmaxfp(__a, __b);
3275 #endif
3276 }
3277 
3278 /* vec_mergeh */
3279 
3280 static __inline__ vector signed char __ATTRS_o_ai
3281 vec_mergeh(vector signed char __a, vector signed char __b) {
3282  return vec_perm(__a, __b,
3283  (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
3284  0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
3285  0x06, 0x16, 0x07, 0x17));
3286 }
3287 
3288 static __inline__ vector unsigned char __ATTRS_o_ai
3289 vec_mergeh(vector unsigned char __a, vector unsigned char __b) {
3290  return vec_perm(__a, __b,
3291  (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
3292  0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
3293  0x06, 0x16, 0x07, 0x17));
3294 }
3295 
3296 static __inline__ vector bool char __ATTRS_o_ai
3297 vec_mergeh(vector bool char __a, vector bool char __b) {
3298  return vec_perm(__a, __b,
3299  (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
3300  0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
3301  0x06, 0x16, 0x07, 0x17));
3302 }
3303 
3304 static __inline__ vector short __ATTRS_o_ai vec_mergeh(vector short __a,
3305  vector short __b) {
3306  return vec_perm(__a, __b,
3307  (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
3308  0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
3309  0x06, 0x07, 0x16, 0x17));
3310 }
3311 
3312 static __inline__ vector unsigned short __ATTRS_o_ai
3313 vec_mergeh(vector unsigned short __a, vector unsigned short __b) {
3314  return vec_perm(__a, __b,
3315  (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
3316  0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
3317  0x06, 0x07, 0x16, 0x17));
3318 }
3319 
3320 static __inline__ vector bool short __ATTRS_o_ai
3321 vec_mergeh(vector bool short __a, vector bool short __b) {
3322  return vec_perm(__a, __b,
3323  (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
3324  0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
3325  0x06, 0x07, 0x16, 0x17));
3326 }
3327 
3328 static __inline__ vector pixel __ATTRS_o_ai vec_mergeh(vector pixel __a,
3329  vector pixel __b) {
3330  return vec_perm(__a, __b,
3331  (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
3332  0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
3333  0x06, 0x07, 0x16, 0x17));
3334 }
3335 
3336 static __inline__ vector int __ATTRS_o_ai vec_mergeh(vector int __a,
3337  vector int __b) {
3338  return vec_perm(__a, __b,
3339  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
3340  0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
3341  0x14, 0x15, 0x16, 0x17));
3342 }
3343 
3344 static __inline__ vector unsigned int __ATTRS_o_ai
3345 vec_mergeh(vector unsigned int __a, vector unsigned int __b) {
3346  return vec_perm(__a, __b,
3347  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
3348  0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
3349  0x14, 0x15, 0x16, 0x17));
3350 }
3351 
3352 static __inline__ vector bool int __ATTRS_o_ai vec_mergeh(vector bool int __a,
3353  vector bool int __b) {
3354  return vec_perm(__a, __b,
3355  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
3356  0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
3357  0x14, 0x15, 0x16, 0x17));
3358 }
3359 
3360 static __inline__ vector float __ATTRS_o_ai vec_mergeh(vector float __a,
3361  vector float __b) {
3362  return vec_perm(__a, __b,
3363  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
3364  0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
3365  0x14, 0x15, 0x16, 0x17));
3366 }
3367 
3368 #ifdef __VSX__
3369 static __inline__ vector signed long long __ATTRS_o_ai
3370 vec_mergeh(vector signed long long __a, vector signed long long __b) {
3371  return vec_perm(__a, __b,
3372  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
3373  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
3374  0x14, 0x15, 0x16, 0x17));
3375 }
3376 
3377 static __inline__ vector signed long long __ATTRS_o_ai
3378 vec_mergeh(vector signed long long __a, vector bool long long __b) {
3379  return vec_perm(__a, (vector signed long long)__b,
3380  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
3381  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
3382  0x14, 0x15, 0x16, 0x17));
3383 }
3384 
3385 static __inline__ vector signed long long __ATTRS_o_ai
3386 vec_mergeh(vector bool long long __a, vector signed long long __b) {
3387  return vec_perm((vector signed long long)__a, __b,
3388  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
3389  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
3390  0x14, 0x15, 0x16, 0x17));
3391 }
3392 
3393 static __inline__ vector unsigned long long __ATTRS_o_ai
3394 vec_mergeh(vector unsigned long long __a, vector unsigned long long __b) {
3395  return vec_perm(__a, __b,
3396  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
3397  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
3398  0x14, 0x15, 0x16, 0x17));
3399 }
3400 
3401 static __inline__ vector unsigned long long __ATTRS_o_ai
3402 vec_mergeh(vector unsigned long long __a, vector bool long long __b) {
3403  return vec_perm(__a, (vector unsigned long long)__b,
3404  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
3405  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
3406  0x14, 0x15, 0x16, 0x17));
3407 }
3408 
3409 static __inline__ vector unsigned long long __ATTRS_o_ai
3410 vec_mergeh(vector bool long long __a, vector unsigned long long __b) {
3411  return vec_perm((vector unsigned long long)__a, __b,
3412  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
3413  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
3414  0x14, 0x15, 0x16, 0x17));
3415 }
3416 
3417 static __inline__ vector bool long long __ATTRS_o_ai
3418 vec_mergeh(vector bool long long __a, vector bool long long __b) {
3419  return vec_perm(__a, __b,
3420  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
3421  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
3422  0x14, 0x15, 0x16, 0x17));
3423 }
3424 
3425 static __inline__ vector double __ATTRS_o_ai vec_mergeh(vector double __a,
3426  vector double __b) {
3427  return vec_perm(__a, __b,
3428  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
3429  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
3430  0x14, 0x15, 0x16, 0x17));
3431 }
3432 static __inline__ vector double __ATTRS_o_ai
3433 vec_mergeh(vector double __a, vector bool long long __b) {
3434  return vec_perm(__a, (vector double)__b,
3435  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
3436  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
3437  0x14, 0x15, 0x16, 0x17));
3438 }
3439 static __inline__ vector double __ATTRS_o_ai
3440 vec_mergeh(vector bool long long __a, vector double __b) {
3441  return vec_perm((vector double)__a, __b,
3442  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
3443  0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
3444  0x14, 0x15, 0x16, 0x17));
3445 }
3446 #endif
3447 
3448 /* vec_vmrghb */
3449 
3450 #define __builtin_altivec_vmrghb vec_vmrghb
3451 
3452 static __inline__ vector signed char __ATTRS_o_ai
3453 vec_vmrghb(vector signed char __a, vector signed char __b) {
3454  return vec_perm(__a, __b,
3455  (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
3456  0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
3457  0x06, 0x16, 0x07, 0x17));
3458 }
3459 
3460 static __inline__ vector unsigned char __ATTRS_o_ai
3461 vec_vmrghb(vector unsigned char __a, vector unsigned char __b) {
3462  return vec_perm(__a, __b,
3463  (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
3464  0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
3465  0x06, 0x16, 0x07, 0x17));
3466 }
3467 
3468 static __inline__ vector bool char __ATTRS_o_ai
3469 vec_vmrghb(vector bool char __a, vector bool char __b) {
3470  return vec_perm(__a, __b,
3471  (vector unsigned char)(0x00, 0x10, 0x01, 0x11, 0x02, 0x12,
3472  0x03, 0x13, 0x04, 0x14, 0x05, 0x15,
3473  0x06, 0x16, 0x07, 0x17));
3474 }
3475 
3476 /* vec_vmrghh */
3477 
3478 #define __builtin_altivec_vmrghh vec_vmrghh
3479 
3480 static __inline__ vector short __ATTRS_o_ai vec_vmrghh(vector short __a,
3481  vector short __b) {
3482  return vec_perm(__a, __b,
3483  (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
3484  0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
3485  0x06, 0x07, 0x16, 0x17));
3486 }
3487 
3488 static __inline__ vector unsigned short __ATTRS_o_ai
3489 vec_vmrghh(vector unsigned short __a, vector unsigned short __b) {
3490  return vec_perm(__a, __b,
3491  (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
3492  0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
3493  0x06, 0x07, 0x16, 0x17));
3494 }
3495 
3496 static __inline__ vector bool short __ATTRS_o_ai
3497 vec_vmrghh(vector bool short __a, vector bool short __b) {
3498  return vec_perm(__a, __b,
3499  (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
3500  0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
3501  0x06, 0x07, 0x16, 0x17));
3502 }
3503 
3504 static __inline__ vector pixel __ATTRS_o_ai vec_vmrghh(vector pixel __a,
3505  vector pixel __b) {
3506  return vec_perm(__a, __b,
3507  (vector unsigned char)(0x00, 0x01, 0x10, 0x11, 0x02, 0x03,
3508  0x12, 0x13, 0x04, 0x05, 0x14, 0x15,
3509  0x06, 0x07, 0x16, 0x17));
3510 }
3511 
3512 /* vec_vmrghw */
3513 
3514 #define __builtin_altivec_vmrghw vec_vmrghw
3515 
3516 static __inline__ vector int __ATTRS_o_ai vec_vmrghw(vector int __a,
3517  vector int __b) {
3518  return vec_perm(__a, __b,
3519  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
3520  0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
3521  0x14, 0x15, 0x16, 0x17));
3522 }
3523 
3524 static __inline__ vector unsigned int __ATTRS_o_ai
3525 vec_vmrghw(vector unsigned int __a, vector unsigned int __b) {
3526  return vec_perm(__a, __b,
3527  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
3528  0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
3529  0x14, 0x15, 0x16, 0x17));
3530 }
3531 
3532 static __inline__ vector bool int __ATTRS_o_ai vec_vmrghw(vector bool int __a,
3533  vector bool int __b) {
3534  return vec_perm(__a, __b,
3535  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
3536  0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
3537  0x14, 0x15, 0x16, 0x17));
3538 }
3539 
3540 static __inline__ vector float __ATTRS_o_ai vec_vmrghw(vector float __a,
3541  vector float __b) {
3542  return vec_perm(__a, __b,
3543  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
3544  0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
3545  0x14, 0x15, 0x16, 0x17));
3546 }
3547 
3548 /* vec_mergel */
3549 
3550 static __inline__ vector signed char __ATTRS_o_ai
3551 vec_mergel(vector signed char __a, vector signed char __b) {
3552  return vec_perm(__a, __b,
3553  (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
3554  0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
3555  0x0E, 0x1E, 0x0F, 0x1F));
3556 }
3557 
3558 static __inline__ vector unsigned char __ATTRS_o_ai
3559 vec_mergel(vector unsigned char __a, vector unsigned char __b) {
3560  return vec_perm(__a, __b,
3561  (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
3562  0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
3563  0x0E, 0x1E, 0x0F, 0x1F));
3564 }
3565 
3566 static __inline__ vector bool char __ATTRS_o_ai
3567 vec_mergel(vector bool char __a, vector bool char __b) {
3568  return vec_perm(__a, __b,
3569  (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
3570  0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
3571  0x0E, 0x1E, 0x0F, 0x1F));
3572 }
3573 
3574 static __inline__ vector short __ATTRS_o_ai vec_mergel(vector short __a,
3575  vector short __b) {
3576  return vec_perm(__a, __b,
3577  (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
3578  0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
3579  0x0E, 0x0F, 0x1E, 0x1F));
3580 }
3581 
3582 static __inline__ vector unsigned short __ATTRS_o_ai
3583 vec_mergel(vector unsigned short __a, vector unsigned short __b) {
3584  return vec_perm(__a, __b,
3585  (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
3586  0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
3587  0x0E, 0x0F, 0x1E, 0x1F));
3588 }
3589 
3590 static __inline__ vector bool short __ATTRS_o_ai
3591 vec_mergel(vector bool short __a, vector bool short __b) {
3592  return vec_perm(__a, __b,
3593  (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
3594  0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
3595  0x0E, 0x0F, 0x1E, 0x1F));
3596 }
3597 
3598 static __inline__ vector pixel __ATTRS_o_ai vec_mergel(vector pixel __a,
3599  vector pixel __b) {
3600  return vec_perm(__a, __b,
3601  (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
3602  0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
3603  0x0E, 0x0F, 0x1E, 0x1F));
3604 }
3605 
3606 static __inline__ vector int __ATTRS_o_ai vec_mergel(vector int __a,
3607  vector int __b) {
3608  return vec_perm(__a, __b,
3609  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
3610  0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
3611  0x1C, 0x1D, 0x1E, 0x1F));
3612 }
3613 
3614 static __inline__ vector unsigned int __ATTRS_o_ai
3615 vec_mergel(vector unsigned int __a, vector unsigned int __b) {
3616  return vec_perm(__a, __b,
3617  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
3618  0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
3619  0x1C, 0x1D, 0x1E, 0x1F));
3620 }
3621 
3622 static __inline__ vector bool int __ATTRS_o_ai vec_mergel(vector bool int __a,
3623  vector bool int __b) {
3624  return vec_perm(__a, __b,
3625  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
3626  0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
3627  0x1C, 0x1D, 0x1E, 0x1F));
3628 }
3629 
3630 static __inline__ vector float __ATTRS_o_ai vec_mergel(vector float __a,
3631  vector float __b) {
3632  return vec_perm(__a, __b,
3633  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
3634  0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
3635  0x1C, 0x1D, 0x1E, 0x1F));
3636 }
3637 
3638 #ifdef __VSX__
3639 static __inline__ vector signed long long __ATTRS_o_ai
3640 vec_mergel(vector signed long long __a, vector signed long long __b) {
3641  return vec_perm(__a, __b,
3642  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
3643  0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
3644  0x1C, 0x1D, 0x1E, 0x1F));
3645 }
3646 static __inline__ vector signed long long __ATTRS_o_ai
3647 vec_mergel(vector signed long long __a, vector bool long long __b) {
3648  return vec_perm(__a, (vector signed long long)__b,
3649  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
3650  0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
3651  0x1C, 0x1D, 0x1E, 0x1F));
3652 }
3653 static __inline__ vector signed long long __ATTRS_o_ai
3654 vec_mergel(vector bool long long __a, vector signed long long __b) {
3655  return vec_perm((vector signed long long)__a, __b,
3656  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
3657  0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
3658  0x1C, 0x1D, 0x1E, 0x1F));
3659 }
3660 static __inline__ vector unsigned long long __ATTRS_o_ai
3661 vec_mergel(vector unsigned long long __a, vector unsigned long long __b) {
3662  return vec_perm(__a, __b,
3663  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
3664  0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
3665  0x1C, 0x1D, 0x1E, 0x1F));
3666 }
3667 static __inline__ vector unsigned long long __ATTRS_o_ai
3668 vec_mergel(vector unsigned long long __a, vector bool long long __b) {
3669  return vec_perm(__a, (vector unsigned long long)__b,
3670  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
3671  0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
3672  0x1C, 0x1D, 0x1E, 0x1F));
3673 }
3674 static __inline__ vector unsigned long long __ATTRS_o_ai
3675 vec_mergel(vector bool long long __a, vector unsigned long long __b) {
3676  return vec_perm((vector unsigned long long)__a, __b,
3677  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
3678  0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
3679  0x1C, 0x1D, 0x1E, 0x1F));
3680 }
3681 static __inline__ vector bool long long __ATTRS_o_ai
3682 vec_mergel(vector bool long long __a, vector bool long long __b) {
3683  return vec_perm(__a, __b,
3684  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
3685  0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
3686  0x1C, 0x1D, 0x1E, 0x1F));
3687 }
3688 static __inline__ vector double __ATTRS_o_ai vec_mergel(vector double __a,
3689  vector double __b) {
3690  return vec_perm(__a, __b,
3691  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
3692  0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
3693  0x1C, 0x1D, 0x1E, 0x1F));
3694 }
3695 static __inline__ vector double __ATTRS_o_ai
3696 vec_mergel(vector double __a, vector bool long long __b) {
3697  return vec_perm(__a, (vector double)__b,
3698  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
3699  0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
3700  0x1C, 0x1D, 0x1E, 0x1F));
3701 }
3702 static __inline__ vector double __ATTRS_o_ai
3703 vec_mergel(vector bool long long __a, vector double __b) {
3704  return vec_perm((vector double)__a, __b,
3705  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
3706  0x0E, 0x0F, 0x18, 0X19, 0x1A, 0x1B,
3707  0x1C, 0x1D, 0x1E, 0x1F));
3708 }
3709 #endif
3710 
3711 /* vec_vmrglb */
3712 
3713 #define __builtin_altivec_vmrglb vec_vmrglb
3714 
3715 static __inline__ vector signed char __ATTRS_o_ai
3716 vec_vmrglb(vector signed char __a, vector signed char __b) {
3717  return vec_perm(__a, __b,
3718  (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
3719  0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
3720  0x0E, 0x1E, 0x0F, 0x1F));
3721 }
3722 
3723 static __inline__ vector unsigned char __ATTRS_o_ai
3724 vec_vmrglb(vector unsigned char __a, vector unsigned char __b) {
3725  return vec_perm(__a, __b,
3726  (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
3727  0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
3728  0x0E, 0x1E, 0x0F, 0x1F));
3729 }
3730 
3731 static __inline__ vector bool char __ATTRS_o_ai
3732 vec_vmrglb(vector bool char __a, vector bool char __b) {
3733  return vec_perm(__a, __b,
3734  (vector unsigned char)(0x08, 0x18, 0x09, 0x19, 0x0A, 0x1A,
3735  0x0B, 0x1B, 0x0C, 0x1C, 0x0D, 0x1D,
3736  0x0E, 0x1E, 0x0F, 0x1F));
3737 }
3738 
3739 /* vec_vmrglh */
3740 
3741 #define __builtin_altivec_vmrglh vec_vmrglh
3742 
3743 static __inline__ vector short __ATTRS_o_ai vec_vmrglh(vector short __a,
3744  vector short __b) {
3745  return vec_perm(__a, __b,
3746  (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
3747  0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
3748  0x0E, 0x0F, 0x1E, 0x1F));
3749 }
3750 
3751 static __inline__ vector unsigned short __ATTRS_o_ai
3752 vec_vmrglh(vector unsigned short __a, vector unsigned short __b) {
3753  return vec_perm(__a, __b,
3754  (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
3755  0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
3756  0x0E, 0x0F, 0x1E, 0x1F));
3757 }
3758 
3759 static __inline__ vector bool short __ATTRS_o_ai
3760 vec_vmrglh(vector bool short __a, vector bool short __b) {
3761  return vec_perm(__a, __b,
3762  (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
3763  0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
3764  0x0E, 0x0F, 0x1E, 0x1F));
3765 }
3766 
3767 static __inline__ vector pixel __ATTRS_o_ai vec_vmrglh(vector pixel __a,
3768  vector pixel __b) {
3769  return vec_perm(__a, __b,
3770  (vector unsigned char)(0x08, 0x09, 0x18, 0x19, 0x0A, 0x0B,
3771  0x1A, 0x1B, 0x0C, 0x0D, 0x1C, 0x1D,
3772  0x0E, 0x0F, 0x1E, 0x1F));
3773 }
3774 
3775 /* vec_vmrglw */
3776 
3777 #define __builtin_altivec_vmrglw vec_vmrglw
3778 
3779 static __inline__ vector int __ATTRS_o_ai vec_vmrglw(vector int __a,
3780  vector int __b) {
3781  return vec_perm(__a, __b,
3782  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
3783  0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
3784  0x1C, 0x1D, 0x1E, 0x1F));
3785 }
3786 
3787 static __inline__ vector unsigned int __ATTRS_o_ai
3788 vec_vmrglw(vector unsigned int __a, vector unsigned int __b) {
3789  return vec_perm(__a, __b,
3790  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
3791  0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
3792  0x1C, 0x1D, 0x1E, 0x1F));
3793 }
3794 
3795 static __inline__ vector bool int __ATTRS_o_ai vec_vmrglw(vector bool int __a,
3796  vector bool int __b) {
3797  return vec_perm(__a, __b,
3798  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
3799  0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
3800  0x1C, 0x1D, 0x1E, 0x1F));
3801 }
3802 
3803 static __inline__ vector float __ATTRS_o_ai vec_vmrglw(vector float __a,
3804  vector float __b) {
3805  return vec_perm(__a, __b,
3806  (vector unsigned char)(0x08, 0x09, 0x0A, 0x0B, 0x18, 0x19,
3807  0x1A, 0x1B, 0x0C, 0x0D, 0x0E, 0x0F,
3808  0x1C, 0x1D, 0x1E, 0x1F));
3809 }
3810 
3811 #ifdef __POWER8_VECTOR__
3812 /* vec_mergee */
3813 
3814 static __inline__ vector bool int __ATTRS_o_ai vec_mergee(vector bool int __a,
3815  vector bool int __b) {
3816  return vec_perm(__a, __b,
3817  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
3818  0x12, 0x13, 0x08, 0x09, 0x0A, 0x0B,
3819  0x18, 0x19, 0x1A, 0x1B));
3820 }
3821 
3822 static __inline__ vector signed int __ATTRS_o_ai
3823 vec_mergee(vector signed int __a, vector signed int __b) {
3824  return vec_perm(__a, __b,
3825  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
3826  0x12, 0x13, 0x08, 0x09, 0x0A, 0x0B,
3827  0x18, 0x19, 0x1A, 0x1B));
3828 }
3829 
3830 static __inline__ vector unsigned int __ATTRS_o_ai
3831 vec_mergee(vector unsigned int __a, vector unsigned int __b) {
3832  return vec_perm(__a, __b,
3833  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x10, 0x11,
3834  0x12, 0x13, 0x08, 0x09, 0x0A, 0x0B,
3835  0x18, 0x19, 0x1A, 0x1B));
3836 }
3837 
3838 /* vec_mergeo */
3839 
3840 static __inline__ vector bool int __ATTRS_o_ai vec_mergeo(vector bool int __a,
3841  vector bool int __b) {
3842  return vec_perm(__a, __b,
3843  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x14, 0x15,
3844  0x16, 0x17, 0x0C, 0x0D, 0x0E, 0x0F,
3845  0x1C, 0x1D, 0x1E, 0x1F));
3846 }
3847 
3848 static __inline__ vector signed int __ATTRS_o_ai
3849 vec_mergeo(vector signed int __a, vector signed int __b) {
3850  return vec_perm(__a, __b,
3851  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x14, 0x15,
3852  0x16, 0x17, 0x0C, 0x0D, 0x0E, 0x0F,
3853  0x1C, 0x1D, 0x1E, 0x1F));
3854 }
3855 
3856 static __inline__ vector unsigned int __ATTRS_o_ai
3857 vec_mergeo(vector unsigned int __a, vector unsigned int __b) {
3858  return vec_perm(__a, __b,
3859  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x14, 0x15,
3860  0x16, 0x17, 0x0C, 0x0D, 0x0E, 0x0F,
3861  0x1C, 0x1D, 0x1E, 0x1F));
3862 }
3863 
3864 #endif
3865 
3866 /* vec_mfvscr */
3867 
3868 static __inline__ vector unsigned short __attribute__((__always_inline__))
3869 vec_mfvscr(void) {
3870  return __builtin_altivec_mfvscr();
3871 }
3872 
3873 /* vec_min */
3874 
3875 static __inline__ vector signed char __ATTRS_o_ai
3876 vec_min(vector signed char __a, vector signed char __b) {
3877  return __builtin_altivec_vminsb(__a, __b);
3878 }
3879 
3880 static __inline__ vector signed char __ATTRS_o_ai
3881 vec_min(vector bool char __a, vector signed char __b) {
3882  return __builtin_altivec_vminsb((vector signed char)__a, __b);
3883 }
3884 
3885 static __inline__ vector signed char __ATTRS_o_ai
3886 vec_min(vector signed char __a, vector bool char __b) {
3887  return __builtin_altivec_vminsb(__a, (vector signed char)__b);
3888 }
3889 
3890 static __inline__ vector unsigned char __ATTRS_o_ai
3891 vec_min(vector unsigned char __a, vector unsigned char __b) {
3892  return __builtin_altivec_vminub(__a, __b);
3893 }
3894 
3895 static __inline__ vector unsigned char __ATTRS_o_ai
3896 vec_min(vector bool char __a, vector unsigned char __b) {
3897  return __builtin_altivec_vminub((vector unsigned char)__a, __b);
3898 }
3899 
3900 static __inline__ vector unsigned char __ATTRS_o_ai
3901 vec_min(vector unsigned char __a, vector bool char __b) {
3902  return __builtin_altivec_vminub(__a, (vector unsigned char)__b);
3903 }
3904 
3905 static __inline__ vector short __ATTRS_o_ai vec_min(vector short __a,
3906  vector short __b) {
3907  return __builtin_altivec_vminsh(__a, __b);
3908 }
3909 
3910 static __inline__ vector short __ATTRS_o_ai vec_min(vector bool short __a,
3911  vector short __b) {
3912  return __builtin_altivec_vminsh((vector short)__a, __b);
3913 }
3914 
3915 static __inline__ vector short __ATTRS_o_ai vec_min(vector short __a,
3916  vector bool short __b) {
3917  return __builtin_altivec_vminsh(__a, (vector short)__b);
3918 }
3919 
3920 static __inline__ vector unsigned short __ATTRS_o_ai
3921 vec_min(vector unsigned short __a, vector unsigned short __b) {
3922  return __builtin_altivec_vminuh(__a, __b);
3923 }
3924 
3925 static __inline__ vector unsigned short __ATTRS_o_ai
3926 vec_min(vector bool short __a, vector unsigned short __b) {
3927  return __builtin_altivec_vminuh((vector unsigned short)__a, __b);
3928 }
3929 
3930 static __inline__ vector unsigned short __ATTRS_o_ai
3931 vec_min(vector unsigned short __a, vector bool short __b) {
3932  return __builtin_altivec_vminuh(__a, (vector unsigned short)__b);
3933 }
3934 
3935 static __inline__ vector int __ATTRS_o_ai vec_min(vector int __a,
3936  vector int __b) {
3937  return __builtin_altivec_vminsw(__a, __b);
3938 }
3939 
3940 static __inline__ vector int __ATTRS_o_ai vec_min(vector bool int __a,
3941  vector int __b) {
3942  return __builtin_altivec_vminsw((vector int)__a, __b);
3943 }
3944 
3945 static __inline__ vector int __ATTRS_o_ai vec_min(vector int __a,
3946  vector bool int __b) {
3947  return __builtin_altivec_vminsw(__a, (vector int)__b);
3948 }
3949 
3950 static __inline__ vector unsigned int __ATTRS_o_ai
3951 vec_min(vector unsigned int __a, vector unsigned int __b) {
3952  return __builtin_altivec_vminuw(__a, __b);
3953 }
3954 
3955 static __inline__ vector unsigned int __ATTRS_o_ai
3956 vec_min(vector bool int __a, vector unsigned int __b) {
3957  return __builtin_altivec_vminuw((vector unsigned int)__a, __b);
3958 }
3959 
3960 static __inline__ vector unsigned int __ATTRS_o_ai
3961 vec_min(vector unsigned int __a, vector bool int __b) {
3962  return __builtin_altivec_vminuw(__a, (vector unsigned int)__b);
3963 }
3964 
3965 #ifdef __POWER8_VECTOR__
3966 static __inline__ vector signed long long __ATTRS_o_ai
3967 vec_min(vector signed long long __a, vector signed long long __b) {
3968  return __builtin_altivec_vminsd(__a, __b);
3969 }
3970 
3971 static __inline__ vector signed long long __ATTRS_o_ai
3972 vec_min(vector bool long long __a, vector signed long long __b) {
3973  return __builtin_altivec_vminsd((vector signed long long)__a, __b);
3974 }
3975 
3976 static __inline__ vector signed long long __ATTRS_o_ai
3977 vec_min(vector signed long long __a, vector bool long long __b) {
3978  return __builtin_altivec_vminsd(__a, (vector signed long long)__b);
3979 }
3980 
3981 static __inline__ vector unsigned long long __ATTRS_o_ai
3982 vec_min(vector unsigned long long __a, vector unsigned long long __b) {
3983  return __builtin_altivec_vminud(__a, __b);
3984 }
3985 
3986 static __inline__ vector unsigned long long __ATTRS_o_ai
3987 vec_min(vector bool long long __a, vector unsigned long long __b) {
3988  return __builtin_altivec_vminud((vector unsigned long long)__a, __b);
3989 }
3990 
3991 static __inline__ vector unsigned long long __ATTRS_o_ai
3992 vec_min(vector unsigned long long __a, vector bool long long __b) {
3993  return __builtin_altivec_vminud(__a, (vector unsigned long long)__b);
3994 }
3995 #endif
3996 
3997 static __inline__ vector float __ATTRS_o_ai vec_min(vector float __a,
3998  vector float __b) {
3999 #ifdef __VSX__
4000  return __builtin_vsx_xvminsp(__a, __b);
4001 #else
4002  return __builtin_altivec_vminfp(__a, __b);
4003 #endif
4004 }
4005 
4006 #ifdef __VSX__
4007 static __inline__ vector double __ATTRS_o_ai vec_min(vector double __a,
4008  vector double __b) {
4009  return __builtin_vsx_xvmindp(__a, __b);
4010 }
4011 #endif
4012 
4013 /* vec_vminsb */
4014 
4015 static __inline__ vector signed char __ATTRS_o_ai
4016 vec_vminsb(vector signed char __a, vector signed char __b) {
4017  return __builtin_altivec_vminsb(__a, __b);
4018 }
4019 
4020 static __inline__ vector signed char __ATTRS_o_ai
4021 vec_vminsb(vector bool char __a, vector signed char __b) {
4022  return __builtin_altivec_vminsb((vector signed char)__a, __b);
4023 }
4024 
4025 static __inline__ vector signed char __ATTRS_o_ai
4026 vec_vminsb(vector signed char __a, vector bool char __b) {
4027  return __builtin_altivec_vminsb(__a, (vector signed char)__b);
4028 }
4029 
4030 /* vec_vminub */
4031 
4032 static __inline__ vector unsigned char __ATTRS_o_ai
4033 vec_vminub(vector unsigned char __a, vector unsigned char __b) {
4034  return __builtin_altivec_vminub(__a, __b);
4035 }
4036 
4037 static __inline__ vector unsigned char __ATTRS_o_ai
4038 vec_vminub(vector bool char __a, vector unsigned char __b) {
4039  return __builtin_altivec_vminub((vector unsigned char)__a, __b);
4040 }
4041 
4042 static __inline__ vector unsigned char __ATTRS_o_ai
4043 vec_vminub(vector unsigned char __a, vector bool char __b) {
4044  return __builtin_altivec_vminub(__a, (vector unsigned char)__b);
4045 }
4046 
4047 /* vec_vminsh */
4048 
4049 static __inline__ vector short __ATTRS_o_ai vec_vminsh(vector short __a,
4050  vector short __b) {
4051  return __builtin_altivec_vminsh(__a, __b);
4052 }
4053 
4054 static __inline__ vector short __ATTRS_o_ai vec_vminsh(vector bool short __a,
4055  vector short __b) {
4056  return __builtin_altivec_vminsh((vector short)__a, __b);
4057 }
4058 
4059 static __inline__ vector short __ATTRS_o_ai vec_vminsh(vector short __a,
4060  vector bool short __b) {
4061  return __builtin_altivec_vminsh(__a, (vector short)__b);
4062 }
4063 
4064 /* vec_vminuh */
4065 
4066 static __inline__ vector unsigned short __ATTRS_o_ai
4067 vec_vminuh(vector unsigned short __a, vector unsigned short __b) {
4068  return __builtin_altivec_vminuh(__a, __b);
4069 }
4070 
4071 static __inline__ vector unsigned short __ATTRS_o_ai
4072 vec_vminuh(vector bool short __a, vector unsigned short __b) {
4073  return __builtin_altivec_vminuh((vector unsigned short)__a, __b);
4074 }
4075 
4076 static __inline__ vector unsigned short __ATTRS_o_ai
4077 vec_vminuh(vector unsigned short __a, vector bool short __b) {
4078  return __builtin_altivec_vminuh(__a, (vector unsigned short)__b);
4079 }
4080 
4081 /* vec_vminsw */
4082 
4083 static __inline__ vector int __ATTRS_o_ai vec_vminsw(vector int __a,
4084  vector int __b) {
4085  return __builtin_altivec_vminsw(__a, __b);
4086 }
4087 
4088 static __inline__ vector int __ATTRS_o_ai vec_vminsw(vector bool int __a,
4089  vector int __b) {
4090  return __builtin_altivec_vminsw((vector int)__a, __b);
4091 }
4092 
4093 static __inline__ vector int __ATTRS_o_ai vec_vminsw(vector int __a,
4094  vector bool int __b) {
4095  return __builtin_altivec_vminsw(__a, (vector int)__b);
4096 }
4097 
4098 /* vec_vminuw */
4099 
4100 static __inline__ vector unsigned int __ATTRS_o_ai
4101 vec_vminuw(vector unsigned int __a, vector unsigned int __b) {
4102  return __builtin_altivec_vminuw(__a, __b);
4103 }
4104 
4105 static __inline__ vector unsigned int __ATTRS_o_ai
4106 vec_vminuw(vector bool int __a, vector unsigned int __b) {
4107  return __builtin_altivec_vminuw((vector unsigned int)__a, __b);
4108 }
4109 
4110 static __inline__ vector unsigned int __ATTRS_o_ai
4111 vec_vminuw(vector unsigned int __a, vector bool int __b) {
4112  return __builtin_altivec_vminuw(__a, (vector unsigned int)__b);
4113 }
4114 
4115 /* vec_vminfp */
4116 
4117 static __inline__ vector float __attribute__((__always_inline__))
4118 vec_vminfp(vector float __a, vector float __b) {
4119 #ifdef __VSX__
4120  return __builtin_vsx_xvminsp(__a, __b);
4121 #else
4122  return __builtin_altivec_vminfp(__a, __b);
4123 #endif
4124 }
4125 
4126 /* vec_mladd */
4127 
4128 #define __builtin_altivec_vmladduhm vec_mladd
4129 
4130 static __inline__ vector short __ATTRS_o_ai vec_mladd(vector short __a,
4131  vector short __b,
4132  vector short __c) {
4133  return __a * __b + __c;
4134 }
4135 
4136 static __inline__ vector short __ATTRS_o_ai vec_mladd(
4137  vector short __a, vector unsigned short __b, vector unsigned short __c) {
4138  return __a * (vector short)__b + (vector short)__c;
4139 }
4140 
4141 static __inline__ vector short __ATTRS_o_ai vec_mladd(vector unsigned short __a,
4142  vector short __b,
4143  vector short __c) {
4144  return (vector short)__a * __b + __c;
4145 }
4146 
4147 static __inline__ vector unsigned short __ATTRS_o_ai
4148 vec_mladd(vector unsigned short __a, vector unsigned short __b,
4149  vector unsigned short __c) {
4150  return __a * __b + __c;
4151 }
4152 
4153 /* vec_vmladduhm */
4154 
4155 static __inline__ vector short __ATTRS_o_ai vec_vmladduhm(vector short __a,
4156  vector short __b,
4157  vector short __c) {
4158  return __a * __b + __c;
4159 }
4160 
4161 static __inline__ vector short __ATTRS_o_ai vec_vmladduhm(
4162  vector short __a, vector unsigned short __b, vector unsigned short __c) {
4163  return __a * (vector short)__b + (vector short)__c;
4164 }
4165 
4166 static __inline__ vector short __ATTRS_o_ai
4167 vec_vmladduhm(vector unsigned short __a, vector short __b, vector short __c) {
4168  return (vector short)__a * __b + __c;
4169 }
4170 
4171 static __inline__ vector unsigned short __ATTRS_o_ai
4172 vec_vmladduhm(vector unsigned short __a, vector unsigned short __b,
4173  vector unsigned short __c) {
4174  return __a * __b + __c;
4175 }
4176 
4177 /* vec_mradds */
4178 
4179 static __inline__ vector short __attribute__((__always_inline__))
4180 vec_mradds(vector short __a, vector short __b, vector short __c) {
4181  return __builtin_altivec_vmhraddshs(__a, __b, __c);
4182 }
4183 
4184 /* vec_vmhraddshs */
4185 
4186 static __inline__ vector short __attribute__((__always_inline__))
4187 vec_vmhraddshs(vector short __a, vector short __b, vector short __c) {
4188  return __builtin_altivec_vmhraddshs(__a, __b, __c);
4189 }
4190 
4191 /* vec_msum */
4192 
4193 static __inline__ vector int __ATTRS_o_ai vec_msum(vector signed char __a,
4194  vector unsigned char __b,
4195  vector int __c) {
4196  return __builtin_altivec_vmsummbm(__a, __b, __c);
4197 }
4198 
4199 static __inline__ vector unsigned int __ATTRS_o_ai
4200 vec_msum(vector unsigned char __a, vector unsigned char __b,
4201  vector unsigned int __c) {
4202  return __builtin_altivec_vmsumubm(__a, __b, __c);
4203 }
4204 
4205 static __inline__ vector int __ATTRS_o_ai vec_msum(vector short __a,
4206  vector short __b,
4207  vector int __c) {
4208  return __builtin_altivec_vmsumshm(__a, __b, __c);
4209 }
4210 
4211 static __inline__ vector unsigned int __ATTRS_o_ai
4212 vec_msum(vector unsigned short __a, vector unsigned short __b,
4213  vector unsigned int __c) {
4214  return __builtin_altivec_vmsumuhm(__a, __b, __c);
4215 }
4216 
4217 /* vec_vmsummbm */
4218 
4219 static __inline__ vector int __attribute__((__always_inline__))
4220 vec_vmsummbm(vector signed char __a, vector unsigned char __b, vector int __c) {
4221  return __builtin_altivec_vmsummbm(__a, __b, __c);
4222 }
4223 
4224 /* vec_vmsumubm */
4225 
4226 static __inline__ vector unsigned int __attribute__((__always_inline__))
4227 vec_vmsumubm(vector unsigned char __a, vector unsigned char __b,
4228  vector unsigned int __c) {
4229  return __builtin_altivec_vmsumubm(__a, __b, __c);
4230 }
4231 
4232 /* vec_vmsumshm */
4233 
4234 static __inline__ vector int __attribute__((__always_inline__))
4235 vec_vmsumshm(vector short __a, vector short __b, vector int __c) {
4236  return __builtin_altivec_vmsumshm(__a, __b, __c);
4237 }
4238 
4239 /* vec_vmsumuhm */
4240 
4241 static __inline__ vector unsigned int __attribute__((__always_inline__))
4242 vec_vmsumuhm(vector unsigned short __a, vector unsigned short __b,
4243  vector unsigned int __c) {
4244  return __builtin_altivec_vmsumuhm(__a, __b, __c);
4245 }
4246 
4247 /* vec_msums */
4248 
4249 static __inline__ vector int __ATTRS_o_ai vec_msums(vector short __a,
4250  vector short __b,
4251  vector int __c) {
4252  return __builtin_altivec_vmsumshs(__a, __b, __c);
4253 }
4254 
4255 static __inline__ vector unsigned int __ATTRS_o_ai
4256 vec_msums(vector unsigned short __a, vector unsigned short __b,
4257  vector unsigned int __c) {
4258  return __builtin_altivec_vmsumuhs(__a, __b, __c);
4259 }
4260 
4261 /* vec_vmsumshs */
4262 
4263 static __inline__ vector int __attribute__((__always_inline__))
4264 vec_vmsumshs(vector short __a, vector short __b, vector int __c) {
4265  return __builtin_altivec_vmsumshs(__a, __b, __c);
4266 }
4267 
4268 /* vec_vmsumuhs */
4269 
4270 static __inline__ vector unsigned int __attribute__((__always_inline__))
4271 vec_vmsumuhs(vector unsigned short __a, vector unsigned short __b,
4272  vector unsigned int __c) {
4273  return __builtin_altivec_vmsumuhs(__a, __b, __c);
4274 }
4275 
4276 /* vec_mtvscr */
4277 
4278 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector signed char __a) {
4279  __builtin_altivec_mtvscr((vector int)__a);
4280 }
4281 
4282 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector unsigned char __a) {
4283  __builtin_altivec_mtvscr((vector int)__a);
4284 }
4285 
4286 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector bool char __a) {
4287  __builtin_altivec_mtvscr((vector int)__a);
4288 }
4289 
4290 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector short __a) {
4291  __builtin_altivec_mtvscr((vector int)__a);
4292 }
4293 
4294 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector unsigned short __a) {
4295  __builtin_altivec_mtvscr((vector int)__a);
4296 }
4297 
4298 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector bool short __a) {
4299  __builtin_altivec_mtvscr((vector int)__a);
4300 }
4301 
4302 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector pixel __a) {
4303  __builtin_altivec_mtvscr((vector int)__a);
4304 }
4305 
4306 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector int __a) {
4307  __builtin_altivec_mtvscr((vector int)__a);
4308 }
4309 
4310 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector unsigned int __a) {
4311  __builtin_altivec_mtvscr((vector int)__a);
4312 }
4313 
4314 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector bool int __a) {
4315  __builtin_altivec_mtvscr((vector int)__a);
4316 }
4317 
4318 static __inline__ void __ATTRS_o_ai vec_mtvscr(vector float __a) {
4319  __builtin_altivec_mtvscr((vector int)__a);
4320 }
4321 
4322 /* vec_mul */
4323 
4324 /* Integer vector multiplication will involve multiplication of the odd/even
4325  elements separately, then truncating the results and moving to the
4326  result vector.
4327 */
4328 static __inline__ vector signed char __ATTRS_o_ai
4329 vec_mul(vector signed char __a, vector signed char __b) {
4330  return __a * __b;
4331 }
4332 
4333 static __inline__ vector unsigned char __ATTRS_o_ai
4334 vec_mul(vector unsigned char __a, vector unsigned char __b) {
4335  return __a * __b;
4336 }
4337 
4338 static __inline__ vector signed short __ATTRS_o_ai
4339 vec_mul(vector signed short __a, vector signed short __b) {
4340  return __a * __b;
4341 }
4342 
4343 static __inline__ vector unsigned short __ATTRS_o_ai
4344 vec_mul(vector unsigned short __a, vector unsigned short __b) {
4345  return __a * __b;
4346 }
4347 
4348 static __inline__ vector signed int __ATTRS_o_ai
4349 vec_mul(vector signed int __a, vector signed int __b) {
4350  return __a * __b;
4351 }
4352 
4353 static __inline__ vector unsigned int __ATTRS_o_ai
4354 vec_mul(vector unsigned int __a, vector unsigned int __b) {
4355  return __a * __b;
4356 }
4357 
4358 #ifdef __VSX__
4359 static __inline__ vector signed long long __ATTRS_o_ai
4360 vec_mul(vector signed long long __a, vector signed long long __b) {
4361  return __a * __b;
4362 }
4363 
4364 static __inline__ vector unsigned long long __ATTRS_o_ai
4365 vec_mul(vector unsigned long long __a, vector unsigned long long __b) {
4366  return __a * __b;
4367 }
4368 #endif
4369 
4370 static __inline__ vector float __ATTRS_o_ai vec_mul(vector float __a,
4371  vector float __b) {
4372  return __a * __b;
4373 }
4374 
4375 #ifdef __VSX__
4376 static __inline__ vector double __ATTRS_o_ai vec_mul(vector double __a,
4377  vector double __b) {
4378  return __a * __b;
4379 }
4380 #endif
4381 
4382 /* The vmulos* and vmules* instructions have a big endian bias, so
4383  we must reverse the meaning of "even" and "odd" for little endian. */
4384 
4385 /* vec_mule */
4386 
4387 static __inline__ vector short __ATTRS_o_ai vec_mule(vector signed char __a,
4388  vector signed char __b) {
4389 #ifdef __LITTLE_ENDIAN__
4390  return __builtin_altivec_vmulosb(__a, __b);
4391 #else
4392  return __builtin_altivec_vmulesb(__a, __b);
4393 #endif
4394 }
4395 
4396 static __inline__ vector unsigned short __ATTRS_o_ai
4397 vec_mule(vector unsigned char __a, vector unsigned char __b) {
4398 #ifdef __LITTLE_ENDIAN__
4399  return __builtin_altivec_vmuloub(__a, __b);
4400 #else
4401  return __builtin_altivec_vmuleub(__a, __b);
4402 #endif
4403 }
4404 
4405 static __inline__ vector int __ATTRS_o_ai vec_mule(vector short __a,
4406  vector short __b) {
4407 #ifdef __LITTLE_ENDIAN__
4408  return __builtin_altivec_vmulosh(__a, __b);
4409 #else
4410  return __builtin_altivec_vmulesh(__a, __b);
4411 #endif
4412 }
4413 
4414 static __inline__ vector unsigned int __ATTRS_o_ai
4415 vec_mule(vector unsigned short __a, vector unsigned short __b) {
4416 #ifdef __LITTLE_ENDIAN__
4417  return __builtin_altivec_vmulouh(__a, __b);
4418 #else
4419  return __builtin_altivec_vmuleuh(__a, __b);
4420 #endif
4421 }
4422 
4423 #ifdef __POWER8_VECTOR__
4424 static __inline__ vector signed long long __ATTRS_o_ai
4425 vec_mule(vector signed int __a, vector signed int __b) {
4426 #ifdef __LITTLE_ENDIAN__
4427  return __builtin_altivec_vmulosw(__a, __b);
4428 #else
4429  return __builtin_altivec_vmulesw(__a, __b);
4430 #endif
4431 }
4432 
4433 static __inline__ vector unsigned long long __ATTRS_o_ai
4434 vec_mule(vector unsigned int __a, vector unsigned int __b) {
4435 #ifdef __LITTLE_ENDIAN__
4436  return __builtin_altivec_vmulouw(__a, __b);
4437 #else
4438  return __builtin_altivec_vmuleuw(__a, __b);
4439 #endif
4440 }
4441 #endif
4442 
4443 /* vec_vmulesb */
4444 
4445 static __inline__ vector short __attribute__((__always_inline__))
4446 vec_vmulesb(vector signed char __a, vector signed char __b) {
4447 #ifdef __LITTLE_ENDIAN__
4448  return __builtin_altivec_vmulosb(__a, __b);
4449 #else
4450  return __builtin_altivec_vmulesb(__a, __b);
4451 #endif
4452 }
4453 
4454 /* vec_vmuleub */
4455 
4456 static __inline__ vector unsigned short __attribute__((__always_inline__))
4457 vec_vmuleub(vector unsigned char __a, vector unsigned char __b) {
4458 #ifdef __LITTLE_ENDIAN__
4459  return __builtin_altivec_vmuloub(__a, __b);
4460 #else
4461  return __builtin_altivec_vmuleub(__a, __b);
4462 #endif
4463 }
4464 
4465 /* vec_vmulesh */
4466 
4467 static __inline__ vector int __attribute__((__always_inline__))
4468 vec_vmulesh(vector short __a, vector short __b) {
4469 #ifdef __LITTLE_ENDIAN__
4470  return __builtin_altivec_vmulosh(__a, __b);
4471 #else
4472  return __builtin_altivec_vmulesh(__a, __b);
4473 #endif
4474 }
4475 
4476 /* vec_vmuleuh */
4477 
4478 static __inline__ vector unsigned int __attribute__((__always_inline__))
4479 vec_vmuleuh(vector unsigned short __a, vector unsigned short __b) {
4480 #ifdef __LITTLE_ENDIAN__
4481  return __builtin_altivec_vmulouh(__a, __b);
4482 #else
4483  return __builtin_altivec_vmuleuh(__a, __b);
4484 #endif
4485 }
4486 
4487 /* vec_mulo */
4488 
4489 static __inline__ vector short __ATTRS_o_ai vec_mulo(vector signed char __a,
4490  vector signed char __b) {
4491 #ifdef __LITTLE_ENDIAN__
4492  return __builtin_altivec_vmulesb(__a, __b);
4493 #else
4494  return __builtin_altivec_vmulosb(__a, __b);
4495 #endif
4496 }
4497 
4498 static __inline__ vector unsigned short __ATTRS_o_ai
4499 vec_mulo(vector unsigned char __a, vector unsigned char __b) {
4500 #ifdef __LITTLE_ENDIAN__
4501  return __builtin_altivec_vmuleub(__a, __b);
4502 #else
4503  return __builtin_altivec_vmuloub(__a, __b);
4504 #endif
4505 }
4506 
4507 static __inline__ vector int __ATTRS_o_ai vec_mulo(vector short __a,
4508  vector short __b) {
4509 #ifdef __LITTLE_ENDIAN__
4510  return __builtin_altivec_vmulesh(__a, __b);
4511 #else
4512  return __builtin_altivec_vmulosh(__a, __b);
4513 #endif
4514 }
4515 
4516 static __inline__ vector unsigned int __ATTRS_o_ai
4517 vec_mulo(vector unsigned short __a, vector unsigned short __b) {
4518 #ifdef __LITTLE_ENDIAN__
4519  return __builtin_altivec_vmuleuh(__a, __b);
4520 #else
4521  return __builtin_altivec_vmulouh(__a, __b);
4522 #endif
4523 }
4524 
4525 #ifdef __POWER8_VECTOR__
4526 static __inline__ vector signed long long __ATTRS_o_ai
4527 vec_mulo(vector signed int __a, vector signed int __b) {
4528 #ifdef __LITTLE_ENDIAN__
4529  return __builtin_altivec_vmulesw(__a, __b);
4530 #else
4531  return __builtin_altivec_vmulosw(__a, __b);
4532 #endif
4533 }
4534 
4535 static __inline__ vector unsigned long long __ATTRS_o_ai
4536 vec_mulo(vector unsigned int __a, vector unsigned int __b) {
4537 #ifdef __LITTLE_ENDIAN__
4538  return __builtin_altivec_vmuleuw(__a, __b);
4539 #else
4540  return __builtin_altivec_vmulouw(__a, __b);
4541 #endif
4542 }
4543 #endif
4544 
4545 /* vec_vmulosb */
4546 
4547 static __inline__ vector short __attribute__((__always_inline__))
4548 vec_vmulosb(vector signed char __a, vector signed char __b) {
4549 #ifdef __LITTLE_ENDIAN__
4550  return __builtin_altivec_vmulesb(__a, __b);
4551 #else
4552  return __builtin_altivec_vmulosb(__a, __b);
4553 #endif
4554 }
4555 
4556 /* vec_vmuloub */
4557 
4558 static __inline__ vector unsigned short __attribute__((__always_inline__))
4559 vec_vmuloub(vector unsigned char __a, vector unsigned char __b) {
4560 #ifdef __LITTLE_ENDIAN__
4561  return __builtin_altivec_vmuleub(__a, __b);
4562 #else
4563  return __builtin_altivec_vmuloub(__a, __b);
4564 #endif
4565 }
4566 
4567 /* vec_vmulosh */
4568 
4569 static __inline__ vector int __attribute__((__always_inline__))
4570 vec_vmulosh(vector short __a, vector short __b) {
4571 #ifdef __LITTLE_ENDIAN__
4572  return __builtin_altivec_vmulesh(__a, __b);
4573 #else
4574  return __builtin_altivec_vmulosh(__a, __b);
4575 #endif
4576 }
4577 
4578 /* vec_vmulouh */
4579 
4580 static __inline__ vector unsigned int __attribute__((__always_inline__))
4581 vec_vmulouh(vector unsigned short __a, vector unsigned short __b) {
4582 #ifdef __LITTLE_ENDIAN__
4583  return __builtin_altivec_vmuleuh(__a, __b);
4584 #else
4585  return __builtin_altivec_vmulouh(__a, __b);
4586 #endif
4587 }
4588 
4589 /* vec_nand */
4590 
4591 #ifdef __POWER8_VECTOR__
4592 static __inline__ vector signed char __ATTRS_o_ai
4593 vec_nand(vector signed char __a, vector signed char __b) {
4594  return ~(__a & __b);
4595 }
4596 
4597 static __inline__ vector signed char __ATTRS_o_ai
4598 vec_nand(vector signed char __a, vector bool char __b) {
4599  return ~(__a & __b);
4600 }
4601 
4602 static __inline__ vector signed char __ATTRS_o_ai
4603 vec_nand(vector bool char __a, vector signed char __b) {
4604  return ~(__a & __b);
4605 }
4606 
4607 static __inline__ vector unsigned char __ATTRS_o_ai
4608 vec_nand(vector unsigned char __a, vector unsigned char __b) {
4609  return ~(__a & __b);
4610 }
4611 
4612 static __inline__ vector unsigned char __ATTRS_o_ai
4613 vec_nand(vector unsigned char __a, vector bool char __b) {
4614  return ~(__a & __b);
4615 }
4616 
4617 static __inline__ vector unsigned char __ATTRS_o_ai
4618 vec_nand(vector bool char __a, vector unsigned char __b) {
4619  return ~(__a & __b);
4620 }
4621 
4622 static __inline__ vector bool char __ATTRS_o_ai vec_nand(vector bool char __a,
4623  vector bool char __b) {
4624  return ~(__a & __b);
4625 }
4626 
4627 static __inline__ vector signed short __ATTRS_o_ai
4628 vec_nand(vector signed short __a, vector signed short __b) {
4629  return ~(__a & __b);
4630 }
4631 
4632 static __inline__ vector signed short __ATTRS_o_ai
4633 vec_nand(vector signed short __a, vector bool short __b) {
4634  return ~(__a & __b);
4635 }
4636 
4637 static __inline__ vector signed short __ATTRS_o_ai
4638 vec_nand(vector bool short __a, vector signed short __b) {
4639  return ~(__a & __b);
4640 }
4641 
4642 static __inline__ vector unsigned short __ATTRS_o_ai
4643 vec_nand(vector unsigned short __a, vector unsigned short __b) {
4644  return ~(__a & __b);
4645 }
4646 
4647 static __inline__ vector unsigned short __ATTRS_o_ai
4648 vec_nand(vector unsigned short __a, vector bool short __b) {
4649  return ~(__a & __b);
4650 }
4651 
4652 static __inline__ vector bool short __ATTRS_o_ai
4653 vec_nand(vector bool short __a, vector bool short __b) {
4654  return ~(__a & __b);
4655 }
4656 
4657 static __inline__ vector signed int __ATTRS_o_ai
4658 vec_nand(vector signed int __a, vector signed int __b) {
4659  return ~(__a & __b);
4660 }
4661 
4662 static __inline__ vector signed int __ATTRS_o_ai vec_nand(vector signed int __a,
4663  vector bool int __b) {
4664  return ~(__a & __b);
4665 }
4666 
4667 static __inline__ vector signed int __ATTRS_o_ai
4668 vec_nand(vector bool int __a, vector signed int __b) {
4669  return ~(__a & __b);
4670 }
4671 
4672 static __inline__ vector unsigned int __ATTRS_o_ai
4673 vec_nand(vector unsigned int __a, vector unsigned int __b) {
4674  return ~(__a & __b);
4675 }
4676 
4677 static __inline__ vector unsigned int __ATTRS_o_ai
4678 vec_nand(vector unsigned int __a, vector bool int __b) {
4679  return ~(__a & __b);
4680 }
4681 
4682 static __inline__ vector unsigned int __ATTRS_o_ai
4683 vec_nand(vector bool int __a, vector unsigned int __b) {
4684  return ~(__a & __b);
4685 }
4686 
4687 static __inline__ vector bool int __ATTRS_o_ai vec_nand(vector bool int __a,
4688  vector bool int __b) {
4689  return ~(__a & __b);
4690 }
4691 
4692 static __inline__ vector signed long long __ATTRS_o_ai
4693 vec_nand(vector signed long long __a, vector signed long long __b) {
4694  return ~(__a & __b);
4695 }
4696 
4697 static __inline__ vector signed long long __ATTRS_o_ai
4698 vec_nand(vector signed long long __a, vector bool long long __b) {
4699  return ~(__a & __b);
4700 }
4701 
4702 static __inline__ vector signed long long __ATTRS_o_ai
4703 vec_nand(vector bool long long __a, vector signed long long __b) {
4704  return ~(__a & __b);
4705 }
4706 
4707 static __inline__ vector unsigned long long __ATTRS_o_ai
4708 vec_nand(vector unsigned long long __a, vector unsigned long long __b) {
4709  return ~(__a & __b);
4710 }
4711 
4712 static __inline__ vector unsigned long long __ATTRS_o_ai
4713 vec_nand(vector unsigned long long __a, vector bool long long __b) {
4714  return ~(__a & __b);
4715 }
4716 
4717 static __inline__ vector unsigned long long __ATTRS_o_ai
4718 vec_nand(vector bool long long __a, vector unsigned long long __b) {
4719  return ~(__a & __b);
4720 }
4721 
4722 static __inline__ vector bool long long __ATTRS_o_ai
4723 vec_nand(vector bool long long __a, vector bool long long __b) {
4724  return ~(__a & __b);
4725 }
4726 
4727 #endif
4728 
4729 /* vec_nmadd */
4730 
4731 #ifdef __VSX__
4732 static __inline__ vector float __ATTRS_o_ai vec_nmadd(vector float __a,
4733  vector float __b,
4734  vector float __c) {
4735  return __builtin_vsx_xvnmaddasp(__a, __b, __c);
4736 }
4737 
4738 static __inline__ vector double __ATTRS_o_ai vec_nmadd(vector double __a,
4739  vector double __b,
4740  vector double __c) {
4741  return __builtin_vsx_xvnmaddadp(__a, __b, __c);
4742 }
4743 #endif
4744 
4745 /* vec_nmsub */
4746 
4747 static __inline__ vector float __ATTRS_o_ai vec_nmsub(vector float __a,
4748  vector float __b,
4749  vector float __c) {
4750 #ifdef __VSX__
4751  return __builtin_vsx_xvnmsubasp(__a, __b, __c);
4752 #else
4753  return __builtin_altivec_vnmsubfp(__a, __b, __c);
4754 #endif
4755 }
4756 
4757 #ifdef __VSX__
4758 static __inline__ vector double __ATTRS_o_ai vec_nmsub(vector double __a,
4759  vector double __b,
4760  vector double __c) {
4761  return __builtin_vsx_xvnmsubadp(__a, __b, __c);
4762 }
4763 #endif
4764 
4765 /* vec_vnmsubfp */
4766 
4767 static __inline__ vector float __attribute__((__always_inline__))
4768 vec_vnmsubfp(vector float __a, vector float __b, vector float __c) {
4769  return __builtin_altivec_vnmsubfp(__a, __b, __c);
4770 }
4771 
4772 /* vec_nor */
4773 
4774 #define __builtin_altivec_vnor vec_nor
4775 
4776 static __inline__ vector signed char __ATTRS_o_ai
4777 vec_nor(vector signed char __a, vector signed char __b) {
4778  return ~(__a | __b);
4779 }
4780 
4781 static __inline__ vector unsigned char __ATTRS_o_ai
4782 vec_nor(vector unsigned char __a, vector unsigned char __b) {
4783  return ~(__a | __b);
4784 }
4785 
4786 static __inline__ vector bool char __ATTRS_o_ai vec_nor(vector bool char __a,
4787  vector bool char __b) {
4788  return ~(__a | __b);
4789 }
4790 
4791 static __inline__ vector short __ATTRS_o_ai vec_nor(vector short __a,
4792  vector short __b) {
4793  return ~(__a | __b);
4794 }
4795 
4796 static __inline__ vector unsigned short __ATTRS_o_ai
4797 vec_nor(vector unsigned short __a, vector unsigned short __b) {
4798  return ~(__a | __b);
4799 }
4800 
4801 static __inline__ vector bool short __ATTRS_o_ai
4802 vec_nor(vector bool short __a, vector bool short __b) {
4803  return ~(__a | __b);
4804 }
4805 
4806 static __inline__ vector int __ATTRS_o_ai vec_nor(vector int __a,
4807  vector int __b) {
4808  return ~(__a | __b);
4809 }
4810 
4811 static __inline__ vector unsigned int __ATTRS_o_ai
4812 vec_nor(vector unsigned int __a, vector unsigned int __b) {
4813  return ~(__a | __b);
4814 }
4815 
4816 static __inline__ vector bool int __ATTRS_o_ai vec_nor(vector bool int __a,
4817  vector bool int __b) {
4818  return ~(__a | __b);
4819 }
4820 
4821 static __inline__ vector float __ATTRS_o_ai vec_nor(vector float __a,
4822  vector float __b) {
4823  vector unsigned int __res =
4824  ~((vector unsigned int)__a | (vector unsigned int)__b);
4825  return (vector float)__res;
4826 }
4827 
4828 #ifdef __VSX__
4829 static __inline__ vector double __ATTRS_o_ai vec_nor(vector double __a,
4830  vector double __b) {
4831  vector unsigned long long __res =
4832  ~((vector unsigned long long)__a | (vector unsigned long long)__b);
4833  return (vector double)__res;
4834 }
4835 #endif
4836 
4837 /* vec_vnor */
4838 
4839 static __inline__ vector signed char __ATTRS_o_ai
4840 vec_vnor(vector signed char __a, vector signed char __b) {
4841  return ~(__a | __b);
4842 }
4843 
4844 static __inline__ vector unsigned char __ATTRS_o_ai
4845 vec_vnor(vector unsigned char __a, vector unsigned char __b) {
4846  return ~(__a | __b);
4847 }
4848 
4849 static __inline__ vector bool char __ATTRS_o_ai vec_vnor(vector bool char __a,
4850  vector bool char __b) {
4851  return ~(__a | __b);
4852 }
4853 
4854 static __inline__ vector short __ATTRS_o_ai vec_vnor(vector short __a,
4855  vector short __b) {
4856  return ~(__a | __b);
4857 }
4858 
4859 static __inline__ vector unsigned short __ATTRS_o_ai
4860 vec_vnor(vector unsigned short __a, vector unsigned short __b) {
4861  return ~(__a | __b);
4862 }
4863 
4864 static __inline__ vector bool short __ATTRS_o_ai
4865 vec_vnor(vector bool short __a, vector bool short __b) {
4866  return ~(__a | __b);
4867 }
4868 
4869 static __inline__ vector int __ATTRS_o_ai vec_vnor(vector int __a,
4870  vector int __b) {
4871  return ~(__a | __b);
4872 }
4873 
4874 static __inline__ vector unsigned int __ATTRS_o_ai
4875 vec_vnor(vector unsigned int __a, vector unsigned int __b) {
4876  return ~(__a | __b);
4877 }
4878 
4879 static __inline__ vector bool int __ATTRS_o_ai vec_vnor(vector bool int __a,
4880  vector bool int __b) {
4881  return ~(__a | __b);
4882 }
4883 
4884 static __inline__ vector float __ATTRS_o_ai vec_vnor(vector float __a,
4885  vector float __b) {
4886  vector unsigned int __res =
4887  ~((vector unsigned int)__a | (vector unsigned int)__b);
4888  return (vector float)__res;
4889 }
4890 
4891 #ifdef __VSX__
4892 static __inline__ vector signed long long __ATTRS_o_ai
4893 vec_nor(vector signed long long __a, vector signed long long __b) {
4894  return ~(__a | __b);
4895 }
4896 
4897 static __inline__ vector unsigned long long __ATTRS_o_ai
4898 vec_nor(vector unsigned long long __a, vector unsigned long long __b) {
4899  return ~(__a | __b);
4900 }
4901 
4902 static __inline__ vector bool long long __ATTRS_o_ai
4903 vec_nor(vector bool long long __a, vector bool long long __b) {
4904  return ~(__a | __b);
4905 }
4906 #endif
4907 
4908 /* vec_or */
4909 
4910 #define __builtin_altivec_vor vec_or
4911 
4912 static __inline__ vector signed char __ATTRS_o_ai
4913 vec_or(vector signed char __a, vector signed char __b) {
4914  return __a | __b;
4915 }
4916 
4917 static __inline__ vector signed char __ATTRS_o_ai
4918 vec_or(vector bool char __a, vector signed char __b) {
4919  return (vector signed char)__a | __b;
4920 }
4921 
4922 static __inline__ vector signed char __ATTRS_o_ai vec_or(vector signed char __a,
4923  vector bool char __b) {
4924  return __a | (vector signed char)__b;
4925 }
4926 
4927 static __inline__ vector unsigned char __ATTRS_o_ai
4928 vec_or(vector unsigned char __a, vector unsigned char __b) {
4929  return __a | __b;
4930 }
4931 
4932 static __inline__ vector unsigned char __ATTRS_o_ai
4933 vec_or(vector bool char __a, vector unsigned char __b) {
4934  return (vector unsigned char)__a | __b;
4935 }
4936 
4937 static __inline__ vector unsigned char __ATTRS_o_ai
4938 vec_or(vector unsigned char __a, vector bool char __b) {
4939  return __a | (vector unsigned char)__b;
4940 }
4941 
4942 static __inline__ vector bool char __ATTRS_o_ai vec_or(vector bool char __a,
4943  vector bool char __b) {
4944  return __a | __b;
4945 }
4946 
4947 static __inline__ vector short __ATTRS_o_ai vec_or(vector short __a,
4948  vector short __b) {
4949  return __a | __b;
4950 }
4951 
4952 static __inline__ vector short __ATTRS_o_ai vec_or(vector bool short __a,
4953  vector short __b) {
4954  return (vector short)__a | __b;
4955 }
4956 
4957 static __inline__ vector short __ATTRS_o_ai vec_or(vector short __a,
4958  vector bool short __b) {
4959  return __a | (vector short)__b;
4960 }
4961 
4962 static __inline__ vector unsigned short __ATTRS_o_ai
4963 vec_or(vector unsigned short __a, vector unsigned short __b) {
4964  return __a | __b;
4965 }
4966 
4967 static __inline__ vector unsigned short __ATTRS_o_ai
4968 vec_or(vector bool short __a, vector unsigned short __b) {
4969  return (vector unsigned short)__a | __b;
4970 }
4971 
4972 static __inline__ vector unsigned short __ATTRS_o_ai
4973 vec_or(vector unsigned short __a, vector bool short __b) {
4974  return __a | (vector unsigned short)__b;
4975 }
4976 
4977 static __inline__ vector bool short __ATTRS_o_ai vec_or(vector bool short __a,
4978  vector bool short __b) {
4979  return __a | __b;
4980 }
4981 
4982 static __inline__ vector int __ATTRS_o_ai vec_or(vector int __a,
4983  vector int __b) {
4984  return __a | __b;
4985 }
4986 
4987 static __inline__ vector int __ATTRS_o_ai vec_or(vector bool int __a,
4988  vector int __b) {
4989  return (vector int)__a | __b;
4990 }
4991 
4992 static __inline__ vector int __ATTRS_o_ai vec_or(vector int __a,
4993  vector bool int __b) {
4994  return __a | (vector int)__b;
4995 }
4996 
4997 static __inline__ vector unsigned int __ATTRS_o_ai
4998 vec_or(vector unsigned int __a, vector unsigned int __b) {
4999  return __a | __b;
5000 }
5001 
5002 static __inline__ vector unsigned int __ATTRS_o_ai
5003 vec_or(vector bool int __a, vector unsigned int __b) {
5004  return (vector unsigned int)__a | __b;
5005 }
5006 
5007 static __inline__ vector unsigned int __ATTRS_o_ai
5008 vec_or(vector unsigned int __a, vector bool int __b) {
5009  return __a | (vector unsigned int)__b;
5010 }
5011 
5012 static __inline__ vector bool int __ATTRS_o_ai vec_or(vector bool int __a,
5013  vector bool int __b) {
5014  return __a | __b;
5015 }
5016 
5017 static __inline__ vector float __ATTRS_o_ai vec_or(vector float __a,
5018  vector float __b) {
5019  vector unsigned int __res =
5020  (vector unsigned int)__a | (vector unsigned int)__b;
5021  return (vector float)__res;
5022 }
5023 
5024 static __inline__ vector float __ATTRS_o_ai vec_or(vector bool int __a,
5025  vector float __b) {
5026  vector unsigned int __res =
5027  (vector unsigned int)__a | (vector unsigned int)__b;
5028  return (vector float)__res;
5029 }
5030 
5031 static __inline__ vector float __ATTRS_o_ai vec_or(vector float __a,
5032  vector bool int __b) {
5033  vector unsigned int __res =
5034  (vector unsigned int)__a | (vector unsigned int)__b;
5035  return (vector float)__res;
5036 }
5037 
5038 #ifdef __VSX__
5039 static __inline__ vector double __ATTRS_o_ai vec_or(vector bool long long __a,
5040  vector double __b) {
5041  return (vector unsigned long long)__a | (vector unsigned long long)__b;
5042 }
5043 
5044 static __inline__ vector double __ATTRS_o_ai vec_or(vector double __a,
5045  vector bool long long __b) {
5046  return (vector unsigned long long)__a | (vector unsigned long long)__b;
5047 }
5048 
5049 static __inline__ vector double __ATTRS_o_ai vec_or(vector double __a,
5050  vector double __b) {
5051  vector unsigned long long __res =
5052  (vector unsigned long long)__a | (vector unsigned long long)__b;
5053  return (vector double)__res;
5054 }
5055 
5056 static __inline__ vector signed long long __ATTRS_o_ai
5057 vec_or(vector signed long long __a, vector signed long long __b) {
5058  return __a | __b;
5059 }
5060 
5061 static __inline__ vector signed long long __ATTRS_o_ai
5062 vec_or(vector bool long long __a, vector signed long long __b) {
5063  return (vector signed long long)__a | __b;
5064 }
5065 
5066 static __inline__ vector signed long long __ATTRS_o_ai
5067 vec_or(vector signed long long __a, vector bool long long __b) {
5068  return __a | (vector signed long long)__b;
5069 }
5070 
5071 static __inline__ vector unsigned long long __ATTRS_o_ai
5072 vec_or(vector unsigned long long __a, vector unsigned long long __b) {
5073  return __a | __b;
5074 }
5075 
5076 static __inline__ vector unsigned long long __ATTRS_o_ai
5077 vec_or(vector bool long long __a, vector unsigned long long __b) {
5078  return (vector unsigned long long)__a | __b;
5079 }
5080 
5081 static __inline__ vector unsigned long long __ATTRS_o_ai
5082 vec_or(vector unsigned long long __a, vector bool long long __b) {
5083  return __a | (vector unsigned long long)__b;
5084 }
5085 
5086 static __inline__ vector bool long long __ATTRS_o_ai
5087 vec_or(vector bool long long __a, vector bool long long __b) {
5088  return __a | __b;
5089 }
5090 #endif
5091 
5092 #ifdef __POWER8_VECTOR__
5093 static __inline__ vector signed char __ATTRS_o_ai
5094 vec_orc(vector signed char __a, vector signed char __b) {
5095  return __a | ~__b;
5096 }
5097 
5098 static __inline__ vector signed char __ATTRS_o_ai
5099 vec_orc(vector signed char __a, vector bool char __b) {
5100  return __a | ~__b;
5101 }
5102 
5103 static __inline__ vector signed char __ATTRS_o_ai
5104 vec_orc(vector bool char __a, vector signed char __b) {
5105  return __a | ~__b;
5106 }
5107 
5108 static __inline__ vector unsigned char __ATTRS_o_ai
5109 vec_orc(vector unsigned char __a, vector unsigned char __b) {
5110  return __a | ~__b;
5111 }
5112 
5113 static __inline__ vector unsigned char __ATTRS_o_ai
5114 vec_orc(vector unsigned char __a, vector bool char __b) {
5115  return __a | ~__b;
5116 }
5117 
5118 static __inline__ vector unsigned char __ATTRS_o_ai
5119 vec_orc(vector bool char __a, vector unsigned char __b) {
5120  return __a | ~__b;
5121 }
5122 
5123 static __inline__ vector bool char __ATTRS_o_ai vec_orc(vector bool char __a,
5124  vector bool char __b) {
5125  return __a | ~__b;
5126 }
5127 
5128 static __inline__ vector signed short __ATTRS_o_ai
5129 vec_orc(vector signed short __a, vector signed short __b) {
5130  return __a | ~__b;
5131 }
5132 
5133 static __inline__ vector signed short __ATTRS_o_ai
5134 vec_orc(vector signed short __a, vector bool short __b) {
5135  return __a | ~__b;
5136 }
5137 
5138 static __inline__ vector signed short __ATTRS_o_ai
5139 vec_orc(vector bool short __a, vector signed short __b) {
5140  return __a | ~__b;
5141 }
5142 
5143 static __inline__ vector unsigned short __ATTRS_o_ai
5144 vec_orc(vector unsigned short __a, vector unsigned short __b) {
5145  return __a | ~__b;
5146 }
5147 
5148 static __inline__ vector unsigned short __ATTRS_o_ai
5149 vec_orc(vector unsigned short __a, vector bool short __b) {
5150  return __a | ~__b;
5151 }
5152 
5153 static __inline__ vector unsigned short __ATTRS_o_ai
5154 vec_orc(vector bool short __a, vector unsigned short __b) {
5155  return __a | ~__b;
5156 }
5157 
5158 static __inline__ vector bool short __ATTRS_o_ai
5159 vec_orc(vector bool short __a, vector bool short __b) {
5160  return __a | ~__b;
5161 }
5162 
5163 static __inline__ vector signed int __ATTRS_o_ai
5164 vec_orc(vector signed int __a, vector signed int __b) {
5165  return __a | ~__b;
5166 }
5167 
5168 static __inline__ vector signed int __ATTRS_o_ai vec_orc(vector signed int __a,
5169  vector bool int __b) {
5170  return __a | ~__b;
5171 }
5172 
5173 static __inline__ vector signed int __ATTRS_o_ai
5174 vec_orc(vector bool int __a, vector signed int __b) {
5175  return __a | ~__b;
5176 }
5177 
5178 static __inline__ vector unsigned int __ATTRS_o_ai
5179 vec_orc(vector unsigned int __a, vector unsigned int __b) {
5180  return __a | ~__b;
5181 }
5182 
5183 static __inline__ vector unsigned int __ATTRS_o_ai
5184 vec_orc(vector unsigned int __a, vector bool int __b) {
5185  return __a | ~__b;
5186 }
5187 
5188 static __inline__ vector unsigned int __ATTRS_o_ai
5189 vec_orc(vector bool int __a, vector unsigned int __b) {
5190  return __a | ~__b;
5191 }
5192 
5193 static __inline__ vector bool int __ATTRS_o_ai vec_orc(vector bool int __a,
5194  vector bool int __b) {
5195  return __a | ~__b;
5196 }
5197 
5198 static __inline__ vector signed long long __ATTRS_o_ai
5199 vec_orc(vector signed long long __a, vector signed long long __b) {
5200  return __a | ~__b;
5201 }
5202 
5203 static __inline__ vector signed long long __ATTRS_o_ai
5204 vec_orc(vector signed long long __a, vector bool long long __b) {
5205  return __a | ~__b;
5206 }
5207 
5208 static __inline__ vector signed long long __ATTRS_o_ai
5209 vec_orc(vector bool long long __a, vector signed long long __b) {
5210  return __a | ~__b;
5211 }
5212 
5213 static __inline__ vector unsigned long long __ATTRS_o_ai
5214 vec_orc(vector unsigned long long __a, vector unsigned long long __b) {
5215  return __a | ~__b;
5216 }
5217 
5218 static __inline__ vector unsigned long long __ATTRS_o_ai
5219 vec_orc(vector unsigned long long __a, vector bool long long __b) {
5220  return __a | ~__b;
5221 }
5222 
5223 static __inline__ vector unsigned long long __ATTRS_o_ai
5224 vec_orc(vector bool long long __a, vector unsigned long long __b) {
5225  return __a | ~__b;
5226 }
5227 
5228 static __inline__ vector bool long long __ATTRS_o_ai
5229 vec_orc(vector bool long long __a, vector bool long long __b) {
5230  return __a | ~__b;
5231 }
5232 #endif
5233 
5234 /* vec_vor */
5235 
5236 static __inline__ vector signed char __ATTRS_o_ai
5237 vec_vor(vector signed char __a, vector signed char __b) {
5238  return __a | __b;
5239 }
5240 
5241 static __inline__ vector signed char __ATTRS_o_ai
5242 vec_vor(vector bool char __a, vector signed char __b) {
5243  return (vector signed char)__a | __b;
5244 }
5245 
5246 static __inline__ vector signed char __ATTRS_o_ai
5247 vec_vor(vector signed char __a, vector bool char __b) {
5248  return __a | (vector signed char)__b;
5249 }
5250 
5251 static __inline__ vector unsigned char __ATTRS_o_ai
5252 vec_vor(vector unsigned char __a, vector unsigned char __b) {
5253  return __a | __b;
5254 }
5255 
5256 static __inline__ vector unsigned char __ATTRS_o_ai
5257 vec_vor(vector bool char __a, vector unsigned char __b) {
5258  return (vector unsigned char)__a | __b;
5259 }
5260 
5261 static __inline__ vector unsigned char __ATTRS_o_ai
5262 vec_vor(vector unsigned char __a, vector bool char __b) {
5263  return __a | (vector unsigned char)__b;
5264 }
5265 
5266 static __inline__ vector bool char __ATTRS_o_ai vec_vor(vector bool char __a,
5267  vector bool char __b) {
5268  return __a | __b;
5269 }
5270 
5271 static __inline__ vector short __ATTRS_o_ai vec_vor(vector short __a,
5272  vector short __b) {
5273  return __a | __b;
5274 }
5275 
5276 static __inline__ vector short __ATTRS_o_ai vec_vor(vector bool short __a,
5277  vector short __b) {
5278  return (vector short)__a | __b;
5279 }
5280 
5281 static __inline__ vector short __ATTRS_o_ai vec_vor(vector short __a,
5282  vector bool short __b) {
5283  return __a | (vector short)__b;
5284 }
5285 
5286 static __inline__ vector unsigned short __ATTRS_o_ai
5287 vec_vor(vector unsigned short __a, vector unsigned short __b) {
5288  return __a | __b;
5289 }
5290 
5291 static __inline__ vector unsigned short __ATTRS_o_ai
5292 vec_vor(vector bool short __a, vector unsigned short __b) {
5293  return (vector unsigned short)__a | __b;
5294 }
5295 
5296 static __inline__ vector unsigned short __ATTRS_o_ai
5297 vec_vor(vector unsigned short __a, vector bool short __b) {
5298  return __a | (vector unsigned short)__b;
5299 }
5300 
5301 static __inline__ vector bool short __ATTRS_o_ai
5302 vec_vor(vector bool short __a, vector bool short __b) {
5303  return __a | __b;
5304 }
5305 
5306 static __inline__ vector int __ATTRS_o_ai vec_vor(vector int __a,
5307  vector int __b) {
5308  return __a | __b;
5309 }
5310 
5311 static __inline__ vector int __ATTRS_o_ai vec_vor(vector bool int __a,
5312  vector int __b) {
5313  return (vector int)__a | __b;
5314 }
5315 
5316 static __inline__ vector int __ATTRS_o_ai vec_vor(vector int __a,
5317  vector bool int __b) {
5318  return __a | (vector int)__b;
5319 }
5320 
5321 static __inline__ vector unsigned int __ATTRS_o_ai
5322 vec_vor(vector unsigned int __a, vector unsigned int __b) {
5323  return __a | __b;
5324 }
5325 
5326 static __inline__ vector unsigned int __ATTRS_o_ai
5327 vec_vor(vector bool int __a, vector unsigned int __b) {
5328  return (vector unsigned int)__a | __b;
5329 }
5330 
5331 static __inline__ vector unsigned int __ATTRS_o_ai
5332 vec_vor(vector unsigned int __a, vector bool int __b) {
5333  return __a | (vector unsigned int)__b;
5334 }
5335 
5336 static __inline__ vector bool int __ATTRS_o_ai vec_vor(vector bool int __a,
5337  vector bool int __b) {
5338  return __a | __b;
5339 }
5340 
5341 static __inline__ vector float __ATTRS_o_ai vec_vor(vector float __a,
5342  vector float __b) {
5343  vector unsigned int __res =
5344  (vector unsigned int)__a | (vector unsigned int)__b;
5345  return (vector float)__res;
5346 }
5347 
5348 static __inline__ vector float __ATTRS_o_ai vec_vor(vector bool int __a,
5349  vector float __b) {
5350  vector unsigned int __res =
5351  (vector unsigned int)__a | (vector unsigned int)__b;
5352  return (vector float)__res;
5353 }
5354 
5355 static __inline__ vector float __ATTRS_o_ai vec_vor(vector float __a,
5356  vector bool int __b) {
5357  vector unsigned int __res =
5358  (vector unsigned int)__a | (vector unsigned int)__b;
5359  return (vector float)__res;
5360 }
5361 
5362 #ifdef __VSX__
5363 static __inline__ vector signed long long __ATTRS_o_ai
5364 vec_vor(vector signed long long __a, vector signed long long __b) {
5365  return __a | __b;
5366 }
5367 
5368 static __inline__ vector signed long long __ATTRS_o_ai
5369 vec_vor(vector bool long long __a, vector signed long long __b) {
5370  return (vector signed long long)__a | __b;
5371 }
5372 
5373 static __inline__ vector signed long long __ATTRS_o_ai
5374 vec_vor(vector signed long long __a, vector bool long long __b) {
5375  return __a | (vector signed long long)__b;
5376 }
5377 
5378 static __inline__ vector unsigned long long __ATTRS_o_ai
5379 vec_vor(vector unsigned long long __a, vector unsigned long long __b) {
5380  return __a | __b;
5381 }
5382 
5383 static __inline__ vector unsigned long long __ATTRS_o_ai
5384 vec_vor(vector bool long long __a, vector unsigned long long __b) {
5385  return (vector unsigned long long)__a | __b;
5386 }
5387 
5388 static __inline__ vector unsigned long long __ATTRS_o_ai
5389 vec_vor(vector unsigned long long __a, vector bool long long __b) {
5390  return __a | (vector unsigned long long)__b;
5391 }
5392 
5393 static __inline__ vector bool long long __ATTRS_o_ai
5394 vec_vor(vector bool long long __a, vector bool long long __b) {
5395  return __a | __b;
5396 }
5397 #endif
5398 
5399 /* vec_pack */
5400 
5401 /* The various vector pack instructions have a big-endian bias, so for
5402  little endian we must handle reversed element numbering. */
5403 
5404 static __inline__ vector signed char __ATTRS_o_ai
5405 vec_pack(vector signed short __a, vector signed short __b) {
5406 #ifdef __LITTLE_ENDIAN__
5407  return (vector signed char)vec_perm(
5408  __a, __b,
5409  (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
5410  0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
5411 #else
5412  return (vector signed char)vec_perm(
5413  __a, __b,
5414  (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
5415  0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
5416 #endif
5417 }
5418 
5419 static __inline__ vector unsigned char __ATTRS_o_ai
5420 vec_pack(vector unsigned short __a, vector unsigned short __b) {
5421 #ifdef __LITTLE_ENDIAN__
5422  return (vector unsigned char)vec_perm(
5423  __a, __b,
5424  (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
5425  0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
5426 #else
5427  return (vector unsigned char)vec_perm(
5428  __a, __b,
5429  (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
5430  0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
5431 #endif
5432 }
5433 
5434 static __inline__ vector bool char __ATTRS_o_ai
5435 vec_pack(vector bool short __a, vector bool short __b) {
5436 #ifdef __LITTLE_ENDIAN__
5437  return (vector bool char)vec_perm(
5438  __a, __b,
5439  (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
5440  0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
5441 #else
5442  return (vector bool char)vec_perm(
5443  __a, __b,
5444  (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
5445  0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
5446 #endif
5447 }
5448 
5449 static __inline__ vector short __ATTRS_o_ai vec_pack(vector int __a,
5450  vector int __b) {
5451 #ifdef __LITTLE_ENDIAN__
5452  return (vector short)vec_perm(
5453  __a, __b,
5454  (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
5455  0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
5456 #else
5457  return (vector short)vec_perm(
5458  __a, __b,
5459  (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
5460  0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
5461 #endif
5462 }
5463 
5464 static __inline__ vector unsigned short __ATTRS_o_ai
5465 vec_pack(vector unsigned int __a, vector unsigned int __b) {
5466 #ifdef __LITTLE_ENDIAN__
5467  return (vector unsigned short)vec_perm(
5468  __a, __b,
5469  (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
5470  0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
5471 #else
5472  return (vector unsigned short)vec_perm(
5473  __a, __b,
5474  (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
5475  0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
5476 #endif
5477 }
5478 
5479 static __inline__ vector bool short __ATTRS_o_ai vec_pack(vector bool int __a,
5480  vector bool int __b) {
5481 #ifdef __LITTLE_ENDIAN__
5482  return (vector bool short)vec_perm(
5483  __a, __b,
5484  (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
5485  0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
5486 #else
5487  return (vector bool short)vec_perm(
5488  __a, __b,
5489  (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
5490  0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
5491 #endif
5492 }
5493 
5494 #ifdef __VSX__
5495 static __inline__ vector signed int __ATTRS_o_ai
5496 vec_pack(vector signed long long __a, vector signed long long __b) {
5497 #ifdef __LITTLE_ENDIAN__
5498  return (vector signed int)vec_perm(
5499  __a, __b,
5500  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
5501  0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
5502 #else
5503  return (vector signed int)vec_perm(
5504  __a, __b,
5505  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
5506  0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
5507 #endif
5508 }
5509 static __inline__ vector unsigned int __ATTRS_o_ai
5510 vec_pack(vector unsigned long long __a, vector unsigned long long __b) {
5511 #ifdef __LITTLE_ENDIAN__
5512  return (vector unsigned int)vec_perm(
5513  __a, __b,
5514  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
5515  0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
5516 #else
5517  return (vector unsigned int)vec_perm(
5518  __a, __b,
5519  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
5520  0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
5521 #endif
5522 }
5523 
5524 static __inline__ vector bool int __ATTRS_o_ai
5525 vec_pack(vector bool long long __a, vector bool long long __b) {
5526 #ifdef __LITTLE_ENDIAN__
5527  return (vector bool int)vec_perm(
5528  __a, __b,
5529  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
5530  0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
5531 #else
5532  return (vector bool int)vec_perm(
5533  __a, __b,
5534  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
5535  0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
5536 #endif
5537 }
5538 
5539 #endif
5540 
5541 /* vec_vpkuhum */
5542 
5543 #define __builtin_altivec_vpkuhum vec_vpkuhum
5544 
5545 static __inline__ vector signed char __ATTRS_o_ai
5546 vec_vpkuhum(vector signed short __a, vector signed short __b) {
5547 #ifdef __LITTLE_ENDIAN__
5548  return (vector signed char)vec_perm(
5549  __a, __b,
5550  (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
5551  0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
5552 #else
5553  return (vector signed char)vec_perm(
5554  __a, __b,
5555  (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
5556  0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
5557 #endif
5558 }
5559 
5560 static __inline__ vector unsigned char __ATTRS_o_ai
5561 vec_vpkuhum(vector unsigned short __a, vector unsigned short __b) {
5562 #ifdef __LITTLE_ENDIAN__
5563  return (vector unsigned char)vec_perm(
5564  __a, __b,
5565  (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
5566  0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
5567 #else
5568  return (vector unsigned char)vec_perm(
5569  __a, __b,
5570  (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
5571  0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
5572 #endif
5573 }
5574 
5575 static __inline__ vector bool char __ATTRS_o_ai
5576 vec_vpkuhum(vector bool short __a, vector bool short __b) {
5577 #ifdef __LITTLE_ENDIAN__
5578  return (vector bool char)vec_perm(
5579  __a, __b,
5580  (vector unsigned char)(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E,
5581  0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E));
5582 #else
5583  return (vector bool char)vec_perm(
5584  __a, __b,
5585  (vector unsigned char)(0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
5586  0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F));
5587 #endif
5588 }
5589 
5590 /* vec_vpkuwum */
5591 
5592 #define __builtin_altivec_vpkuwum vec_vpkuwum
5593 
5594 static __inline__ vector short __ATTRS_o_ai vec_vpkuwum(vector int __a,
5595  vector int __b) {
5596 #ifdef __LITTLE_ENDIAN__
5597  return (vector short)vec_perm(
5598  __a, __b,
5599  (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
5600  0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
5601 #else
5602  return (vector short)vec_perm(
5603  __a, __b,
5604  (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
5605  0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
5606 #endif
5607 }
5608 
5609 static __inline__ vector unsigned short __ATTRS_o_ai
5610 vec_vpkuwum(vector unsigned int __a, vector unsigned int __b) {
5611 #ifdef __LITTLE_ENDIAN__
5612  return (vector unsigned short)vec_perm(
5613  __a, __b,
5614  (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
5615  0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
5616 #else
5617  return (vector unsigned short)vec_perm(
5618  __a, __b,
5619  (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
5620  0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
5621 #endif
5622 }
5623 
5624 static __inline__ vector bool short __ATTRS_o_ai
5625 vec_vpkuwum(vector bool int __a, vector bool int __b) {
5626 #ifdef __LITTLE_ENDIAN__
5627  return (vector bool short)vec_perm(
5628  __a, __b,
5629  (vector unsigned char)(0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0C, 0x0D,
5630  0x10, 0x11, 0x14, 0x15, 0x18, 0x19, 0x1C, 0x1D));
5631 #else
5632  return (vector bool short)vec_perm(
5633  __a, __b,
5634  (vector unsigned char)(0x02, 0x03, 0x06, 0x07, 0x0A, 0x0B, 0x0E, 0x0F,
5635  0x12, 0x13, 0x16, 0x17, 0x1A, 0x1B, 0x1E, 0x1F));
5636 #endif
5637 }
5638 
5639 /* vec_vpkudum */
5640 
5641 #ifdef __POWER8_VECTOR__
5642 #define __builtin_altivec_vpkudum vec_vpkudum
5643 
5644 static __inline__ vector int __ATTRS_o_ai vec_vpkudum(vector long long __a,
5645  vector long long __b) {
5646 #ifdef __LITTLE_ENDIAN__
5647  return (vector int)vec_perm(
5648  __a, __b,
5649  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
5650  0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
5651 #else
5652  return (vector int)vec_perm(
5653  __a, __b,
5654  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
5655  0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
5656 #endif
5657 }
5658 
5659 static __inline__ vector unsigned int __ATTRS_o_ai
5660 vec_vpkudum(vector unsigned long long __a, vector unsigned long long __b) {
5661 #ifdef __LITTLE_ENDIAN__
5662  return (vector unsigned int)vec_perm(
5663  __a, __b,
5664  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
5665  0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
5666 #else
5667  return (vector unsigned int)vec_perm(
5668  __a, __b,
5669  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
5670  0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
5671 #endif
5672 }
5673 
5674 static __inline__ vector bool int __ATTRS_o_ai
5675 vec_vpkudum(vector bool long long __a, vector bool long long __b) {
5676 #ifdef __LITTLE_ENDIAN__
5677  return (vector bool int)vec_perm(
5678  (vector long long)__a, (vector long long)__b,
5679  (vector unsigned char)(0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
5680  0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B));
5681 #else
5682  return (vector bool int)vec_perm(
5683  (vector long long)__a, (vector long long)__b,
5684  (vector unsigned char)(0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
5685  0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F));
5686 #endif
5687 }
5688 #endif
5689 
5690 /* vec_packpx */
5691 
5692 static __inline__ vector pixel __attribute__((__always_inline__))
5693 vec_packpx(vector unsigned int __a, vector unsigned int __b) {
5694 #ifdef __LITTLE_ENDIAN__
5695  return (vector pixel)__builtin_altivec_vpkpx(__b, __a);
5696 #else
5697  return (vector pixel)__builtin_altivec_vpkpx(__a, __b);
5698 #endif
5699 }
5700 
5701 /* vec_vpkpx */
5702 
5703 static __inline__ vector pixel __attribute__((__always_inline__))
5704 vec_vpkpx(vector unsigned int __a, vector unsigned int __b) {
5705 #ifdef __LITTLE_ENDIAN__
5706  return (vector pixel)__builtin_altivec_vpkpx(__b, __a);
5707 #else
5708  return (vector pixel)__builtin_altivec_vpkpx(__a, __b);
5709 #endif
5710 }
5711 
5712 /* vec_packs */
5713 
5714 static __inline__ vector signed char __ATTRS_o_ai vec_packs(vector short __a,
5715  vector short __b) {
5716 #ifdef __LITTLE_ENDIAN__
5717  return __builtin_altivec_vpkshss(__b, __a);
5718 #else
5719  return __builtin_altivec_vpkshss(__a, __b);
5720 #endif
5721 }
5722 
5723 static __inline__ vector unsigned char __ATTRS_o_ai
5724 vec_packs(vector unsigned short __a, vector unsigned short __b) {
5725 #ifdef __LITTLE_ENDIAN__
5726  return __builtin_altivec_vpkuhus(__b, __a);
5727 #else
5728  return __builtin_altivec_vpkuhus(__a, __b);
5729 #endif
5730 }
5731 
5732 static __inline__ vector signed short __ATTRS_o_ai vec_packs(vector int __a,
5733  vector int __b) {
5734 #ifdef __LITTLE_ENDIAN__
5735  return __builtin_altivec_vpkswss(__b, __a);
5736 #else
5737  return __builtin_altivec_vpkswss(__a, __b);
5738 #endif
5739 }
5740 
5741 static __inline__ vector unsigned short __ATTRS_o_ai
5742 vec_packs(vector unsigned int __a, vector unsigned int __b) {
5743 #ifdef __LITTLE_ENDIAN__
5744  return __builtin_altivec_vpkuwus(__b, __a);
5745 #else
5746  return __builtin_altivec_vpkuwus(__a, __b);
5747 #endif
5748 }
5749 
5750 #ifdef __POWER8_VECTOR__
5751 static __inline__ vector int __ATTRS_o_ai vec_packs(vector long long __a,
5752  vector long long __b) {
5753 #ifdef __LITTLE_ENDIAN__
5754  return __builtin_altivec_vpksdss(__b, __a);
5755 #else
5756  return __builtin_altivec_vpksdss(__a, __b);
5757 #endif
5758 }
5759 
5760 static __inline__ vector unsigned int __ATTRS_o_ai
5761 vec_packs(vector unsigned long long __a, vector unsigned long long __b) {
5762 #ifdef __LITTLE_ENDIAN__
5763  return __builtin_altivec_vpkudus(__b, __a);
5764 #else
5765  return __builtin_altivec_vpkudus(__a, __b);
5766 #endif
5767 }
5768 #endif
5769 
5770 /* vec_vpkshss */
5771 
5772 static __inline__ vector signed char __attribute__((__always_inline__))
5773 vec_vpkshss(vector short __a, vector short __b) {
5774 #ifdef __LITTLE_ENDIAN__
5775  return __builtin_altivec_vpkshss(__b, __a);
5776 #else
5777  return __builtin_altivec_vpkshss(__a, __b);
5778 #endif
5779 }
5780 
5781 /* vec_vpksdss */
5782 
5783 #ifdef __POWER8_VECTOR__
5784 static __inline__ vector int __ATTRS_o_ai vec_vpksdss(vector long long __a,
5785  vector long long __b) {
5786 #ifdef __LITTLE_ENDIAN__
5787  return __builtin_altivec_vpksdss(__b, __a);
5788 #else
5789  return __builtin_altivec_vpksdss(__a, __b);
5790 #endif
5791 }
5792 #endif
5793 
5794 /* vec_vpkuhus */
5795 
5796 static __inline__ vector unsigned char __attribute__((__always_inline__))
5797 vec_vpkuhus(vector unsigned short __a, vector unsigned short __b) {
5798 #ifdef __LITTLE_ENDIAN__
5799  return __builtin_altivec_vpkuhus(__b, __a);
5800 #else
5801  return __builtin_altivec_vpkuhus(__a, __b);
5802 #endif
5803 }
5804 
5805 /* vec_vpkudus */
5806 
5807 #ifdef __POWER8_VECTOR__
5808 static __inline__ vector unsigned int __attribute__((__always_inline__))
5809 vec_vpkudus(vector unsigned long long __a, vector unsigned long long __b) {
5810 #ifdef __LITTLE_ENDIAN__
5811  return __builtin_altivec_vpkudus(__b, __a);
5812 #else
5813  return __builtin_altivec_vpkudus(__a, __b);
5814 #endif
5815 }
5816 #endif
5817 
5818 /* vec_vpkswss */
5819 
5820 static __inline__ vector signed short __attribute__((__always_inline__))
5821 vec_vpkswss(vector int __a, vector int __b) {
5822 #ifdef __LITTLE_ENDIAN__
5823  return __builtin_altivec_vpkswss(__b, __a);
5824 #else
5825  return __builtin_altivec_vpkswss(__a, __b);
5826 #endif
5827 }
5828 
5829 /* vec_vpkuwus */
5830 
5831 static __inline__ vector unsigned short __attribute__((__always_inline__))
5832 vec_vpkuwus(vector unsigned int __a, vector unsigned int __b) {
5833 #ifdef __LITTLE_ENDIAN__
5834  return __builtin_altivec_vpkuwus(__b, __a);
5835 #else
5836  return __builtin_altivec_vpkuwus(__a, __b);
5837 #endif
5838 }
5839 
5840 /* vec_packsu */
5841 
5842 static __inline__ vector unsigned char __ATTRS_o_ai
5843 vec_packsu(vector short __a, vector short __b) {
5844 #ifdef __LITTLE_ENDIAN__
5845  return __builtin_altivec_vpkshus(__b, __a);
5846 #else
5847  return __builtin_altivec_vpkshus(__a, __b);
5848 #endif
5849 }
5850 
5851 static __inline__ vector unsigned char __ATTRS_o_ai
5852 vec_packsu(vector unsigned short __a, vector unsigned short __b) {
5853 #ifdef __LITTLE_ENDIAN__
5854  return __builtin_altivec_vpkuhus(__b, __a);
5855 #else
5856  return __builtin_altivec_vpkuhus(__a, __b);
5857 #endif
5858 }
5859 
5860 static __inline__ vector unsigned short __ATTRS_o_ai
5861 vec_packsu(vector int __a, vector int __b) {
5862 #ifdef __LITTLE_ENDIAN__
5863  return __builtin_altivec_vpkswus(__b, __a);
5864 #else
5865  return __builtin_altivec_vpkswus(__a, __b);
5866 #endif
5867 }
5868 
5869 static __inline__ vector unsigned short __ATTRS_o_ai
5870 vec_packsu(vector unsigned int __a, vector unsigned int __b) {
5871 #ifdef __LITTLE_ENDIAN__
5872  return __builtin_altivec_vpkuwus(__b, __a);
5873 #else
5874  return __builtin_altivec_vpkuwus(__a, __b);
5875 #endif
5876 }
5877 
5878 #ifdef __POWER8_VECTOR__
5879 static __inline__ vector unsigned int __ATTRS_o_ai
5880 vec_packsu(vector long long __a, vector long long __b) {
5881 #ifdef __LITTLE_ENDIAN__
5882  return __builtin_altivec_vpksdus(__b, __a);
5883 #else
5884  return __builtin_altivec_vpksdus(__a, __b);
5885 #endif
5886 }
5887 
5888 static __inline__ vector unsigned int __ATTRS_o_ai
5889 vec_packsu(vector unsigned long long __a, vector unsigned long long __b) {
5890 #ifdef __LITTLE_ENDIAN__
5891  return __builtin_altivec_vpkudus(__b, __a);
5892 #else
5893  return __builtin_altivec_vpkudus(__a, __b);
5894 #endif
5895 }
5896 #endif
5897 
5898 /* vec_vpkshus */
5899 
5900 static __inline__ vector unsigned char __ATTRS_o_ai
5901 vec_vpkshus(vector short __a, vector short __b) {
5902 #ifdef __LITTLE_ENDIAN__
5903  return __builtin_altivec_vpkshus(__b, __a);
5904 #else
5905  return __builtin_altivec_vpkshus(__a, __b);
5906 #endif
5907 }
5908 
5909 static __inline__ vector unsigned char __ATTRS_o_ai
5910 vec_vpkshus(vector unsigned short __a, vector unsigned short __b) {
5911 #ifdef __LITTLE_ENDIAN__
5912  return __builtin_altivec_vpkuhus(__b, __a);
5913 #else
5914  return __builtin_altivec_vpkuhus(__a, __b);
5915 #endif
5916 }
5917 
5918 /* vec_vpkswus */
5919 
5920 static __inline__ vector unsigned short __ATTRS_o_ai
5921 vec_vpkswus(vector int __a, vector int __b) {
5922 #ifdef __LITTLE_ENDIAN__
5923  return __builtin_altivec_vpkswus(__b, __a);
5924 #else
5925  return __builtin_altivec_vpkswus(__a, __b);
5926 #endif
5927 }
5928 
5929 static __inline__ vector unsigned short __ATTRS_o_ai
5930 vec_vpkswus(vector unsigned int __a, vector unsigned int __b) {
5931 #ifdef __LITTLE_ENDIAN__
5932  return __builtin_altivec_vpkuwus(__b, __a);
5933 #else
5934  return __builtin_altivec_vpkuwus(__a, __b);
5935 #endif
5936 }
5937 
5938 /* vec_vpksdus */
5939 
5940 #ifdef __POWER8_VECTOR__
5941 static __inline__ vector unsigned int __ATTRS_o_ai
5942 vec_vpksdus(vector long long __a, vector long long __b) {
5943 #ifdef __LITTLE_ENDIAN__
5944  return __builtin_altivec_vpksdus(__b, __a);
5945 #else
5946  return __builtin_altivec_vpksdus(__a, __b);
5947 #endif
5948 }
5949 #endif
5950 
5951 /* vec_perm */
5952 
5953 // The vperm instruction is defined architecturally with a big-endian bias.
5954 // For little endian, we swap the input operands and invert the permute
5955 // control vector. Only the rightmost 5 bits matter, so we could use
5956 // a vector of all 31s instead of all 255s to perform the inversion.
5957 // However, when the PCV is not a constant, using 255 has an advantage
5958 // in that the vec_xor can be recognized as a vec_nor (and for P8 and
5959 // later, possibly a vec_nand).
5960 
5961 static __inline__ vector signed char __ATTRS_o_ai vec_perm(
5962  vector signed char __a, vector signed char __b, vector unsigned char __c) {
5963 #ifdef __LITTLE_ENDIAN__
5964  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
5965  255, 255, 255, 255, 255, 255, 255, 255};
5966  __d = vec_xor(__c, __d);
5967  return (vector signed char)__builtin_altivec_vperm_4si((vector int)__b,
5968  (vector int)__a, __d);
5969 #else
5970  return (vector signed char)__builtin_altivec_vperm_4si((vector int)__a,
5971  (vector int)__b, __c);
5972 #endif
5973 }
5974 
5975 static __inline__ vector unsigned char __ATTRS_o_ai
5976 vec_perm(vector unsigned char __a, vector unsigned char __b,
5977  vector unsigned char __c) {
5978 #ifdef __LITTLE_ENDIAN__
5979  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
5980  255, 255, 255, 255, 255, 255, 255, 255};
5981  __d = vec_xor(__c, __d);
5982  return (vector unsigned char)__builtin_altivec_vperm_4si(
5983  (vector int)__b, (vector int)__a, __d);
5984 #else
5985  return (vector unsigned char)__builtin_altivec_vperm_4si(
5986  (vector int)__a, (vector int)__b, __c);
5987 #endif
5988 }
5989 
5990 static __inline__ vector bool char __ATTRS_o_ai
5991 vec_perm(vector bool char __a, vector bool char __b, vector unsigned char __c) {
5992 #ifdef __LITTLE_ENDIAN__
5993  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
5994  255, 255, 255, 255, 255, 255, 255, 255};
5995  __d = vec_xor(__c, __d);
5996  return (vector bool char)__builtin_altivec_vperm_4si((vector int)__b,
5997  (vector int)__a, __d);
5998 #else
5999  return (vector bool char)__builtin_altivec_vperm_4si((vector int)__a,
6000  (vector int)__b, __c);
6001 #endif
6002 }
6003 
6004 static __inline__ vector short __ATTRS_o_ai vec_perm(vector signed short __a,
6005  vector signed short __b,
6006  vector unsigned char __c) {
6007 #ifdef __LITTLE_ENDIAN__
6008  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
6009  255, 255, 255, 255, 255, 255, 255, 255};
6010  __d = vec_xor(__c, __d);
6011  return (vector signed short)__builtin_altivec_vperm_4si((vector int)__b,
6012  (vector int)__a, __d);
6013 #else
6014  return (vector signed short)__builtin_altivec_vperm_4si((vector int)__a,
6015  (vector int)__b, __c);
6016 #endif
6017 }
6018 
6019 static __inline__ vector unsigned short __ATTRS_o_ai
6020 vec_perm(vector unsigned short __a, vector unsigned short __b,
6021  vector unsigned char __c) {
6022 #ifdef __LITTLE_ENDIAN__
6023  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
6024  255, 255, 255, 255, 255, 255, 255, 255};
6025  __d = vec_xor(__c, __d);
6026  return (vector unsigned short)__builtin_altivec_vperm_4si(
6027  (vector int)__b, (vector int)__a, __d);
6028 #else
6029  return (vector unsigned short)__builtin_altivec_vperm_4si(
6030  (vector int)__a, (vector int)__b, __c);
6031 #endif
6032 }
6033 
6034 static __inline__ vector bool short __ATTRS_o_ai vec_perm(
6035  vector bool short __a, vector bool short __b, vector unsigned char __c) {
6036 #ifdef __LITTLE_ENDIAN__
6037  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
6038  255, 255, 255, 255, 255, 255, 255, 255};
6039  __d = vec_xor(__c, __d);
6040  return (vector bool short)__builtin_altivec_vperm_4si((vector int)__b,
6041  (vector int)__a, __d);
6042 #else
6043  return (vector bool short)__builtin_altivec_vperm_4si((vector int)__a,
6044  (vector int)__b, __c);
6045 #endif
6046 }
6047 
6048 static __inline__ vector pixel __ATTRS_o_ai vec_perm(vector pixel __a,
6049  vector pixel __b,
6050  vector unsigned char __c) {
6051 #ifdef __LITTLE_ENDIAN__
6052  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
6053  255, 255, 255, 255, 255, 255, 255, 255};
6054  __d = vec_xor(__c, __d);
6055  return (vector pixel)__builtin_altivec_vperm_4si((vector int)__b,
6056  (vector int)__a, __d);
6057 #else
6058  return (vector pixel)__builtin_altivec_vperm_4si((vector int)__a,
6059  (vector int)__b, __c);
6060 #endif
6061 }
6062 
6063 static __inline__ vector int __ATTRS_o_ai vec_perm(vector signed int __a,
6064  vector signed int __b,
6065  vector unsigned char __c) {
6066 #ifdef __LITTLE_ENDIAN__
6067  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
6068  255, 255, 255, 255, 255, 255, 255, 255};
6069  __d = vec_xor(__c, __d);
6070  return (vector signed int)__builtin_altivec_vperm_4si(__b, __a, __d);
6071 #else
6072  return (vector signed int)__builtin_altivec_vperm_4si(__a, __b, __c);
6073 #endif
6074 }
6075 
6076 static __inline__ vector unsigned int __ATTRS_o_ai
6077 vec_perm(vector unsigned int __a, vector unsigned int __b,
6078  vector unsigned char __c) {
6079 #ifdef __LITTLE_ENDIAN__
6080  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
6081  255, 255, 255, 255, 255, 255, 255, 255};
6082  __d = vec_xor(__c, __d);
6083  return (vector unsigned int)__builtin_altivec_vperm_4si((vector int)__b,
6084  (vector int)__a, __d);
6085 #else
6086  return (vector unsigned int)__builtin_altivec_vperm_4si((vector int)__a,
6087  (vector int)__b, __c);
6088 #endif
6089 }
6090 
6091 static __inline__ vector bool int __ATTRS_o_ai
6092 vec_perm(vector bool int __a, vector bool int __b, vector unsigned char __c) {
6093 #ifdef __LITTLE_ENDIAN__
6094  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
6095  255, 255, 255, 255, 255, 255, 255, 255};
6096  __d = vec_xor(__c, __d);
6097  return (vector bool int)__builtin_altivec_vperm_4si((vector int)__b,
6098  (vector int)__a, __d);
6099 #else
6100  return (vector bool int)__builtin_altivec_vperm_4si((vector int)__a,
6101  (vector int)__b, __c);
6102 #endif
6103 }
6104 
6105 static __inline__ vector float __ATTRS_o_ai vec_perm(vector float __a,
6106  vector float __b,
6107  vector unsigned char __c) {
6108 #ifdef __LITTLE_ENDIAN__
6109  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
6110  255, 255, 255, 255, 255, 255, 255, 255};
6111  __d = vec_xor(__c, __d);
6112  return (vector float)__builtin_altivec_vperm_4si((vector int)__b,
6113  (vector int)__a, __d);
6114 #else
6115  return (vector float)__builtin_altivec_vperm_4si((vector int)__a,
6116  (vector int)__b, __c);
6117 #endif
6118 }
6119 
6120 #ifdef __VSX__
6121 static __inline__ vector long long __ATTRS_o_ai
6122 vec_perm(vector signed long long __a, vector signed long long __b,
6123  vector unsigned char __c) {
6124 #ifdef __LITTLE_ENDIAN__
6125  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
6126  255, 255, 255, 255, 255, 255, 255, 255};
6127  __d = vec_xor(__c, __d);
6128  return (vector signed long long)__builtin_altivec_vperm_4si(
6129  (vector int)__b, (vector int)__a, __d);
6130 #else
6131  return (vector signed long long)__builtin_altivec_vperm_4si(
6132  (vector int)__a, (vector int)__b, __c);
6133 #endif
6134 }
6135 
6136 static __inline__ vector unsigned long long __ATTRS_o_ai
6137 vec_perm(vector unsigned long long __a, vector unsigned long long __b,
6138  vector unsigned char __c) {
6139 #ifdef __LITTLE_ENDIAN__
6140  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
6141  255, 255, 255, 255, 255, 255, 255, 255};
6142  __d = vec_xor(__c, __d);
6143  return (vector unsigned long long)__builtin_altivec_vperm_4si(
6144  (vector int)__b, (vector int)__a, __d);
6145 #else
6146  return (vector unsigned long long)__builtin_altivec_vperm_4si(
6147  (vector int)__a, (vector int)__b, __c);
6148 #endif
6149 }
6150 
6151 static __inline__ vector bool long long __ATTRS_o_ai
6152 vec_perm(vector bool long long __a, vector bool long long __b,
6153  vector unsigned char __c) {
6154 #ifdef __LITTLE_ENDIAN__
6155  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
6156  255, 255, 255, 255, 255, 255, 255, 255};
6157  __d = vec_xor(__c, __d);
6158  return (vector bool long long)__builtin_altivec_vperm_4si(
6159  (vector int)__b, (vector int)__a, __d);
6160 #else
6161  return (vector bool long long)__builtin_altivec_vperm_4si(
6162  (vector int)__a, (vector int)__b, __c);
6163 #endif
6164 }
6165 
6166 static __inline__ vector double __ATTRS_o_ai
6167 vec_perm(vector double __a, vector double __b, vector unsigned char __c) {
6168 #ifdef __LITTLE_ENDIAN__
6169  vector unsigned char __d = {255, 255, 255, 255, 255, 255, 255, 255,
6170  255, 255, 255, 255, 255, 255, 255, 255};
6171  __d = vec_xor(__c, __d);
6172  return (vector double)__builtin_altivec_vperm_4si((vector int)__b,
6173  (vector int)__a, __d);
6174 #else
6175  return (vector double)__builtin_altivec_vperm_4si((vector int)__a,
6176  (vector int)__b, __c);
6177 #endif
6178 }
6179 #endif
6180 
6181 /* vec_vperm */
6182 
6183 static __inline__ vector signed char __ATTRS_o_ai vec_vperm(
6184  vector signed char __a, vector signed char __b, vector unsigned char __c) {
6185  return vec_perm(__a, __b, __c);
6186 }
6187 
6188 static __inline__ vector unsigned char __ATTRS_o_ai
6189 vec_vperm(vector unsigned char __a, vector unsigned char __b,
6190  vector unsigned char __c) {
6191  return vec_perm(__a, __b, __c);
6192 }
6193 
6194 static __inline__ vector bool char __ATTRS_o_ai vec_vperm(
6195  vector bool char __a, vector bool char __b, vector unsigned char __c) {
6196  return vec_perm(__a, __b, __c);
6197 }
6198 
6199 static __inline__ vector short __ATTRS_o_ai
6200 vec_vperm(vector short __a, vector short __b, vector unsigned char __c) {
6201  return vec_perm(__a, __b, __c);
6202 }
6203 
6204 static __inline__ vector unsigned short __ATTRS_o_ai
6205 vec_vperm(vector unsigned short __a, vector unsigned short __b,
6206  vector unsigned char __c) {
6207  return vec_perm(__a, __b, __c);
6208 }
6209 
6210 static __inline__ vector bool short __ATTRS_o_ai vec_vperm(
6211  vector bool short __a, vector bool short __b, vector unsigned char __c) {
6212  return vec_perm(__a, __b, __c);
6213 }
6214 
6215 static __inline__ vector pixel __ATTRS_o_ai
6216 vec_vperm(vector pixel __a, vector pixel __b, vector unsigned char __c) {
6217  return vec_perm(__a, __b, __c);
6218 }
6219 
6220 static __inline__ vector int __ATTRS_o_ai vec_vperm(vector int __a,
6221  vector int __b,
6222  vector unsigned char __c) {
6223  return vec_perm(__a, __b, __c);
6224 }
6225 
6226 static __inline__ vector unsigned int __ATTRS_o_ai
6227 vec_vperm(vector unsigned int __a, vector unsigned int __b,
6228  vector unsigned char __c) {
6229  return vec_perm(__a, __b, __c);
6230 }
6231 
6232 static __inline__ vector bool int __ATTRS_o_ai
6233 vec_vperm(vector bool int __a, vector bool int __b, vector unsigned char __c) {
6234  return vec_perm(__a, __b, __c);
6235 }
6236 
6237 static __inline__ vector float __ATTRS_o_ai
6238 vec_vperm(vector float __a, vector float __b, vector unsigned char __c) {
6239  return vec_perm(__a, __b, __c);
6240 }
6241 
6242 #ifdef __VSX__
6243 static __inline__ vector long long __ATTRS_o_ai vec_vperm(
6244  vector long long __a, vector long long __b, vector unsigned char __c) {
6245  return vec_perm(__a, __b, __c);
6246 }
6247 
6248 static __inline__ vector unsigned long long __ATTRS_o_ai
6249 vec_vperm(vector unsigned long long __a, vector unsigned long long __b,
6250  vector unsigned char __c) {
6251  return vec_perm(__a, __b, __c);
6252 }
6253 
6254 static __inline__ vector double __ATTRS_o_ai
6255 vec_vperm(vector double __a, vector double __b, vector unsigned char __c) {
6256  return vec_perm(__a, __b, __c);
6257 }
6258 #endif
6259 
6260 /* vec_re */
6261 
6262 static __inline__ vector float __ATTRS_o_ai vec_re(vector float __a) {
6263 #ifdef __VSX__
6264  return __builtin_vsx_xvresp(__a);
6265 #else
6266  return __builtin_altivec_vrefp(__a);
6267 #endif
6268 }
6269 
6270 #ifdef __VSX__
6271 static __inline__ vector double __ATTRS_o_ai vec_re(vector double __a) {
6272  return __builtin_vsx_xvredp(__a);
6273 }
6274 #endif
6275 
6276 /* vec_vrefp */
6277 
6278 static __inline__ vector float __attribute__((__always_inline__))
6279 vec_vrefp(vector float __a) {
6280  return __builtin_altivec_vrefp(__a);
6281 }
6282 
6283 /* vec_rl */
6284 
6285 static __inline__ vector signed char __ATTRS_o_ai
6286 vec_rl(vector signed char __a, vector unsigned char __b) {
6287  return (vector signed char)__builtin_altivec_vrlb((vector char)__a, __b);
6288 }
6289 
6290 static __inline__ vector unsigned char __ATTRS_o_ai
6291 vec_rl(vector unsigned char __a, vector unsigned char __b) {
6292  return (vector unsigned char)__builtin_altivec_vrlb((vector char)__a, __b);
6293 }
6294 
6295 static __inline__ vector short __ATTRS_o_ai vec_rl(vector short __a,
6296  vector unsigned short __b) {
6297  return __builtin_altivec_vrlh(__a, __b);
6298 }
6299 
6300 static __inline__ vector unsigned short __ATTRS_o_ai
6301 vec_rl(vector unsigned short __a, vector unsigned short __b) {
6302  return (vector unsigned short)__builtin_altivec_vrlh((vector short)__a, __b);
6303 }
6304 
6305 static __inline__ vector int __ATTRS_o_ai vec_rl(vector int __a,
6306  vector unsigned int __b) {
6307  return __builtin_altivec_vrlw(__a, __b);
6308 }
6309 
6310 static __inline__ vector unsigned int __ATTRS_o_ai
6311 vec_rl(vector unsigned int __a, vector unsigned int __b) {
6312  return (vector unsigned int)__builtin_altivec_vrlw((vector int)__a, __b);
6313 }
6314 
6315 #ifdef __POWER8_VECTOR__
6316 static __inline__ vector signed long long __ATTRS_o_ai
6317 vec_rl(vector signed long long __a, vector unsigned long long __b) {
6318  return __builtin_altivec_vrld(__a, __b);
6319 }
6320 
6321 static __inline__ vector unsigned long long __ATTRS_o_ai
6322 vec_rl(vector unsigned long long __a, vector unsigned long long __b) {
6323  return __builtin_altivec_vrld(__a, __b);
6324 }
6325 #endif
6326 
6327 /* vec_vrlb */
6328 
6329 static __inline__ vector signed char __ATTRS_o_ai
6330 vec_vrlb(vector signed char __a, vector unsigned char __b) {
6331  return (vector signed char)__builtin_altivec_vrlb((vector char)__a, __b);
6332 }
6333 
6334 static __inline__ vector unsigned char __ATTRS_o_ai
6335 vec_vrlb(vector unsigned char __a, vector unsigned char __b) {
6336  return (vector unsigned char)__builtin_altivec_vrlb((vector char)__a, __b);
6337 }
6338 
6339 /* vec_vrlh */
6340 
6341 static __inline__ vector short __ATTRS_o_ai
6342 vec_vrlh(vector short __a, vector unsigned short __b) {
6343  return __builtin_altivec_vrlh(__a, __b);
6344 }
6345 
6346 static __inline__ vector unsigned short __ATTRS_o_ai
6347 vec_vrlh(vector unsigned short __a, vector unsigned short __b) {
6348  return (vector unsigned short)__builtin_altivec_vrlh((vector short)__a, __b);
6349 }
6350 
6351 /* vec_vrlw */
6352 
6353 static __inline__ vector int __ATTRS_o_ai vec_vrlw(vector int __a,
6354  vector unsigned int __b) {
6355  return __builtin_altivec_vrlw(__a, __b);
6356 }
6357 
6358 static __inline__ vector unsigned int __ATTRS_o_ai
6359 vec_vrlw(vector unsigned int __a, vector unsigned int __b) {
6360  return (vector unsigned int)__builtin_altivec_vrlw((vector int)__a, __b);
6361 }
6362 
6363 /* vec_round */
6364 
6365 static __inline__ vector float __ATTRS_o_ai vec_round(vector float __a) {
6366 #ifdef __VSX__
6367  return __builtin_vsx_xvrspi(__a);
6368 #else
6369  return __builtin_altivec_vrfin(__a);
6370 #endif
6371 }
6372 
6373 #ifdef __VSX__
6374 static __inline__ vector double __ATTRS_o_ai vec_round(vector double __a) {
6375  return __builtin_vsx_xvrdpi(__a);
6376 }
6377 
6378 /* vec_rint */
6379 
6380 static __inline__ vector float __ATTRS_o_ai vec_rint(vector float __a) {
6381  return __builtin_vsx_xvrspic(__a);
6382 }
6383 
6384 static __inline__ vector double __ATTRS_o_ai vec_rint(vector double __a) {
6385  return __builtin_vsx_xvrdpic(__a);
6386 }
6387 
6388 /* vec_nearbyint */
6389 
6390 static __inline__ vector float __ATTRS_o_ai vec_nearbyint(vector float __a) {
6391  return __builtin_vsx_xvrspi(__a);
6392 }
6393 
6394 static __inline__ vector double __ATTRS_o_ai vec_nearbyint(vector double __a) {
6395  return __builtin_vsx_xvrdpi(__a);
6396 }
6397 #endif
6398 
6399 /* vec_vrfin */
6400 
6401 static __inline__ vector float __attribute__((__always_inline__))
6402 vec_vrfin(vector float __a) {
6403  return __builtin_altivec_vrfin(__a);
6404 }
6405 
6406 /* vec_sqrt */
6407 
6408 #ifdef __VSX__
6409 static __inline__ vector float __ATTRS_o_ai vec_sqrt(vector float __a) {
6410  return __builtin_vsx_xvsqrtsp(__a);
6411 }
6412 
6413 static __inline__ vector double __ATTRS_o_ai vec_sqrt(vector double __a) {
6414  return __builtin_vsx_xvsqrtdp(__a);
6415 }
6416 #endif
6417 
6418 /* vec_rsqrte */
6419 
6420 static __inline__ vector float __ATTRS_o_ai vec_rsqrte(vector float __a) {
6421 #ifdef __VSX__
6422  return __builtin_vsx_xvrsqrtesp(__a);
6423 #else
6424  return __builtin_altivec_vrsqrtefp(__a);
6425 #endif
6426 }
6427 
6428 #ifdef __VSX__
6429 static __inline__ vector double __ATTRS_o_ai vec_rsqrte(vector double __a) {
6430  return __builtin_vsx_xvrsqrtedp(__a);
6431 }
6432 #endif
6433 
6434 /* vec_vrsqrtefp */
6435 
6436 static __inline__ __vector float __attribute__((__always_inline__))
6437 vec_vrsqrtefp(vector float __a) {
6438  return __builtin_altivec_vrsqrtefp(__a);
6439 }
6440 
6441 /* vec_sel */
6442 
6443 #define __builtin_altivec_vsel_4si vec_sel
6444 
6445 static __inline__ vector signed char __ATTRS_o_ai vec_sel(
6446  vector signed char __a, vector signed char __b, vector unsigned char __c) {
6447  return (__a & ~(vector signed char)__c) | (__b & (vector signed char)__c);
6448 }
6449 
6450 static __inline__ vector signed char __ATTRS_o_ai
6451 vec_sel(vector signed char __a, vector signed char __b, vector bool char __c) {
6452  return (__a & ~(vector signed char)__c) | (__b & (vector signed char)__c);
6453 }
6454 
6455 static __inline__ vector unsigned char __ATTRS_o_ai
6456 vec_sel(vector unsigned char __a, vector unsigned char __b,
6457  vector unsigned char __c) {
6458  return (__a & ~__c) | (__b & __c);
6459 }
6460 
6461 static __inline__ vector unsigned char __ATTRS_o_ai vec_sel(
6462  vector unsigned char __a, vector unsigned char __b, vector bool char __c) {
6463  return (__a & ~(vector unsigned char)__c) | (__b & (vector unsigned char)__c);
6464 }
6465 
6466 static __inline__ vector bool char __ATTRS_o_ai
6467 vec_sel(vector bool char __a, vector bool char __b, vector unsigned char __c) {
6468  return (__a & ~(vector bool char)__c) | (__b & (vector bool char)__c);
6469 }
6470 
6471 static __inline__ vector bool char __ATTRS_o_ai vec_sel(vector bool char __a,
6472  vector bool char __b,
6473  vector bool char __c) {
6474  return (__a & ~__c) | (__b & __c);
6475 }
6476 
6477 static __inline__ vector short __ATTRS_o_ai vec_sel(vector short __a,
6478  vector short __b,
6479  vector unsigned short __c) {
6480  return (__a & ~(vector short)__c) | (__b & (vector short)__c);
6481 }
6482 
6483 static __inline__ vector short __ATTRS_o_ai vec_sel(vector short __a,
6484  vector short __b,
6485  vector bool short __c) {
6486  return (__a & ~(vector short)__c) | (__b & (vector short)__c);
6487 }
6488 
6489 static __inline__ vector unsigned short __ATTRS_o_ai
6490 vec_sel(vector unsigned short __a, vector unsigned short __b,
6491  vector unsigned short __c) {
6492  return (__a & ~__c) | (__b & __c);
6493 }
6494 
6495 static __inline__ vector unsigned short __ATTRS_o_ai
6496 vec_sel(vector unsigned short __a, vector unsigned short __b,
6497  vector bool short __c) {
6498  return (__a & ~(vector unsigned short)__c) |
6499  (__b & (vector unsigned short)__c);
6500 }
6501 
6502 static __inline__ vector bool short __ATTRS_o_ai vec_sel(
6503  vector bool short __a, vector bool short __b, vector unsigned short __c) {
6504  return (__a & ~(vector bool short)__c) | (__b & (vector bool short)__c);
6505 }
6506 
6507 static __inline__ vector bool short __ATTRS_o_ai
6508 vec_sel(vector bool short __a, vector bool short __b, vector bool short __c) {
6509  return (__a & ~__c) | (__b & __c);
6510 }
6511 
6512 static __inline__ vector int __ATTRS_o_ai vec_sel(vector int __a,
6513  vector int __b,
6514  vector unsigned int __c) {
6515  return (__a & ~(vector int)__c) | (__b & (vector int)__c);
6516 }
6517 
6518 static __inline__ vector int __ATTRS_o_ai vec_sel(vector int __a,
6519  vector int __b,
6520  vector bool int __c) {
6521  return (__a & ~(vector int)__c) | (__b & (vector int)__c);
6522 }
6523 
6524 static __inline__ vector unsigned int __ATTRS_o_ai vec_sel(
6525  vector unsigned int __a, vector unsigned int __b, vector unsigned int __c) {
6526  return (__a & ~__c) | (__b & __c);
6527 }
6528 
6529 static __inline__ vector unsigned int __ATTRS_o_ai
6530 vec_sel(vector unsigned int __a, vector unsigned int __b, vector bool int __c) {
6531  return (__a & ~(vector unsigned int)__c) | (__b & (vector unsigned int)__c);
6532 }
6533 
6534 static __inline__ vector bool int __ATTRS_o_ai
6535 vec_sel(vector bool int __a, vector bool int __b, vector unsigned int __c) {
6536  return (__a & ~(vector bool int)__c) | (__b & (vector bool int)__c);
6537 }
6538 
6539 static __inline__ vector bool int __ATTRS_o_ai vec_sel(vector bool int __a,
6540  vector bool int __b,
6541  vector bool int __c) {
6542  return (__a & ~__c) | (__b & __c);
6543 }
6544 
6545 static __inline__ vector float __ATTRS_o_ai vec_sel(vector float __a,
6546  vector float __b,
6547  vector unsigned int __c) {
6548  vector int __res = ((vector int)__a & ~(vector int)__c) |
6549  ((vector int)__b & (vector int)__c);
6550  return (vector float)__res;
6551 }
6552 
6553 static __inline__ vector float __ATTRS_o_ai vec_sel(vector float __a,
6554  vector float __b,
6555  vector bool int __c) {
6556  vector int __res = ((vector int)__a & ~(vector int)__c) |
6557  ((vector int)__b & (vector int)__c);
6558  return (vector float)__res;
6559 }
6560 
6561 #ifdef __VSX__
6562 static __inline__ vector double __ATTRS_o_ai
6563 vec_sel(vector double __a, vector double __b, vector bool long long __c) {
6564  vector long long __res = ((vector long long)__a & ~(vector long long)__c) |
6565  ((vector long long)__b & (vector long long)__c);
6566  return (vector double)__res;
6567 }
6568 
6569 static __inline__ vector double __ATTRS_o_ai
6570 vec_sel(vector double __a, vector double __b, vector unsigned long long __c) {
6571  vector long long __res = ((vector long long)__a & ~(vector long long)__c) |
6572  ((vector long long)__b & (vector long long)__c);
6573  return (vector double)__res;
6574 }
6575 #endif
6576 
6577 /* vec_vsel */
6578 
6579 static __inline__ vector signed char __ATTRS_o_ai vec_vsel(
6580  vector signed char __a, vector signed char __b, vector unsigned char __c) {
6581  return (__a & ~(vector signed char)__c) | (__b & (vector signed char)__c);
6582 }
6583 
6584 static __inline__ vector signed char __ATTRS_o_ai
6585 vec_vsel(vector signed char __a, vector signed char __b, vector bool char __c) {
6586  return (__a & ~(vector signed char)__c) | (__b & (vector signed char)__c);
6587 }
6588 
6589 static __inline__ vector unsigned char __ATTRS_o_ai
6590 vec_vsel(vector unsigned char __a, vector unsigned char __b,
6591  vector unsigned char __c) {
6592  return (__a & ~__c) | (__b & __c);
6593 }
6594 
6595 static __inline__ vector unsigned char __ATTRS_o_ai vec_vsel(
6596  vector unsigned char __a, vector unsigned char __b, vector bool char __c) {
6597  return (__a & ~(vector unsigned char)__c) | (__b & (vector unsigned char)__c);
6598 }
6599 
6600 static __inline__ vector bool char __ATTRS_o_ai
6601 vec_vsel(vector bool char __a, vector bool char __b, vector unsigned char __c) {
6602  return (__a & ~(vector bool char)__c) | (__b & (vector bool char)__c);
6603 }
6604 
6605 static __inline__ vector bool char __ATTRS_o_ai vec_vsel(vector bool char __a,
6606  vector bool char __b,
6607  vector bool char __c) {
6608  return (__a & ~__c) | (__b & __c);
6609 }
6610 
6611 static __inline__ vector short __ATTRS_o_ai
6612 vec_vsel(vector short __a, vector short __b, vector unsigned short __c) {
6613  return (__a & ~(vector short)__c) | (__b & (vector short)__c);
6614 }
6615 
6616 static __inline__ vector short __ATTRS_o_ai vec_vsel(vector short __a,
6617  vector short __b,
6618  vector bool short __c) {
6619  return (__a & ~(vector short)__c) | (__b & (vector short)__c);
6620 }
6621 
6622 static __inline__ vector unsigned short __ATTRS_o_ai
6623 vec_vsel(vector unsigned short __a, vector unsigned short __b,
6624  vector unsigned short __c) {
6625  return (__a & ~__c) | (__b & __c);
6626 }
6627 
6628 static __inline__ vector unsigned short __ATTRS_o_ai
6629 vec_vsel(vector unsigned short __a, vector unsigned short __b,
6630  vector bool short __c) {
6631  return (__a & ~(vector unsigned short)__c) |
6632  (__b & (vector unsigned short)__c);
6633 }
6634 
6635 static __inline__ vector bool short __ATTRS_o_ai vec_vsel(
6636  vector bool short __a, vector bool short __b, vector unsigned short __c) {
6637  return (__a & ~(vector bool short)__c) | (__b & (vector bool short)__c);
6638 }
6639 
6640 static __inline__ vector bool short __ATTRS_o_ai
6641 vec_vsel(vector bool short __a, vector bool short __b, vector bool short __c) {
6642  return (__a & ~__c) | (__b & __c);
6643 }
6644 
6645 static __inline__ vector int __ATTRS_o_ai vec_vsel(vector int __a,
6646  vector int __b,
6647  vector unsigned int __c) {
6648  return (__a & ~(vector int)__c) | (__b & (vector int)__c);
6649 }
6650 
6651 static __inline__ vector int __ATTRS_o_ai vec_vsel(vector int __a,
6652  vector int __b,
6653  vector bool int __c) {
6654  return (__a & ~(vector int)__c) | (__b & (vector int)__c);
6655 }
6656 
6657 static __inline__ vector unsigned int __ATTRS_o_ai vec_vsel(
6658  vector unsigned int __a, vector unsigned int __b, vector unsigned int __c) {
6659  return (__a & ~__c) | (__b & __c);
6660 }
6661 
6662 static __inline__ vector unsigned int __ATTRS_o_ai vec_vsel(
6663  vector unsigned int __a, vector unsigned int __b, vector bool int __c) {
6664  return (__a & ~(vector unsigned int)__c) | (__b & (vector unsigned int)__c);
6665 }
6666 
6667 static __inline__ vector bool int __ATTRS_o_ai
6668 vec_vsel(vector bool int __a, vector bool int __b, vector unsigned int __c) {
6669  return (__a & ~(vector bool int)__c) | (__b & (vector bool int)__c);
6670 }
6671 
6672 static __inline__ vector bool int __ATTRS_o_ai vec_vsel(vector bool int __a,
6673  vector bool int __b,
6674  vector bool int __c) {
6675  return (__a & ~__c) | (__b & __c);
6676 }
6677 
6678 static __inline__ vector float __ATTRS_o_ai vec_vsel(vector float __a,
6679  vector float __b,
6680  vector unsigned int __c) {
6681  vector int __res = ((vector int)__a & ~(vector int)__c) |
6682  ((vector int)__b & (vector int)__c);
6683  return (vector float)__res;
6684 }
6685 
6686 static __inline__ vector float __ATTRS_o_ai vec_vsel(vector float __a,
6687  vector float __b,
6688  vector bool int __c) {
6689  vector int __res = ((vector int)__a & ~(vector int)__c) |
6690  ((vector int)__b & (vector int)__c);
6691  return (vector float)__res;
6692 }
6693 
6694 /* vec_sl */
6695 
6696 static __inline__ vector signed char __ATTRS_o_ai
6697 vec_sl(vector signed char __a, vector unsigned char __b) {
6698  return __a << (vector signed char)__b;
6699 }
6700 
6701 static __inline__ vector unsigned char __ATTRS_o_ai
6702 vec_sl(vector unsigned char __a, vector unsigned char __b) {
6703  return __a << __b;
6704 }
6705 
6706 static __inline__ vector short __ATTRS_o_ai vec_sl(vector short __a,
6707  vector unsigned short __b) {
6708  return __a << (vector short)__b;
6709 }
6710 
6711 static __inline__ vector unsigned short __ATTRS_o_ai
6712 vec_sl(vector unsigned short __a, vector unsigned short __b) {
6713  return __a << __b;
6714 }
6715 
6716 static __inline__ vector int __ATTRS_o_ai vec_sl(vector int __a,
6717  vector unsigned int __b) {
6718  return __a << (vector int)__b;
6719 }
6720 
6721 static __inline__ vector unsigned int __ATTRS_o_ai
6722 vec_sl(vector unsigned int __a, vector unsigned int __b) {
6723  return __a << __b;
6724 }
6725 
6726 #ifdef __POWER8_VECTOR__
6727 static __inline__ vector signed long long __ATTRS_o_ai
6728 vec_sl(vector signed long long __a, vector unsigned long long __b) {
6729  return __a << (vector long long)__b;
6730 }
6731 
6732 static __inline__ vector unsigned long long __ATTRS_o_ai
6733 vec_sl(vector unsigned long long __a, vector unsigned long long __b) {
6734  return __a << __b;
6735 }
6736 #endif
6737 
6738 /* vec_vslb */
6739 
6740 #define __builtin_altivec_vslb vec_vslb
6741 
6742 static __inline__ vector signed char __ATTRS_o_ai
6743 vec_vslb(vector signed char __a, vector unsigned char __b) {
6744  return vec_sl(__a, __b);
6745 }
6746 
6747 static __inline__ vector unsigned char __ATTRS_o_ai
6748 vec_vslb(vector unsigned char __a, vector unsigned char __b) {
6749  return vec_sl(__a, __b);
6750 }
6751 
6752 /* vec_vslh */
6753 
6754 #define __builtin_altivec_vslh vec_vslh
6755 
6756 static __inline__ vector short __ATTRS_o_ai
6757 vec_vslh(vector short __a, vector unsigned short __b) {
6758  return vec_sl(__a, __b);
6759 }
6760 
6761 static __inline__ vector unsigned short __ATTRS_o_ai
6762 vec_vslh(vector unsigned short __a, vector unsigned short __b) {
6763  return vec_sl(__a, __b);
6764 }
6765 
6766 /* vec_vslw */
6767 
6768 #define __builtin_altivec_vslw vec_vslw
6769 
6770 static __inline__ vector int __ATTRS_o_ai vec_vslw(vector int __a,
6771  vector unsigned int __b) {
6772  return vec_sl(__a, __b);
6773 }
6774 
6775 static __inline__ vector unsigned int __ATTRS_o_ai
6776 vec_vslw(vector unsigned int __a, vector unsigned int __b) {
6777  return vec_sl(__a, __b);
6778 }
6779 
6780 /* vec_sld */
6781 
6782 #define __builtin_altivec_vsldoi_4si vec_sld
6783 
6784 static __inline__ vector signed char __ATTRS_o_ai vec_sld(
6785  vector signed char __a, vector signed char __b, unsigned const int __c) {
6786  unsigned char __d = __c & 0x0F;
6787 #ifdef __LITTLE_ENDIAN__
6788  return vec_perm(
6789  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
6790  20 - __d, 21 - __d, 22 - __d, 23 - __d,
6791  24 - __d, 25 - __d, 26 - __d, 27 - __d,
6792  28 - __d, 29 - __d, 30 - __d, 31 - __d));
6793 #else
6794  return vec_perm(
6795  __a, __b,
6796  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
6797  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
6798  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
6799 #endif
6800 }
6801 
6802 static __inline__ vector unsigned char __ATTRS_o_ai
6803 vec_sld(vector unsigned char __a, vector unsigned char __b,
6804  unsigned const int __c) {
6805  unsigned char __d = __c & 0x0F;
6806 #ifdef __LITTLE_ENDIAN__
6807  return vec_perm(
6808  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
6809  20 - __d, 21 - __d, 22 - __d, 23 - __d,
6810  24 - __d, 25 - __d, 26 - __d, 27 - __d,
6811  28 - __d, 29 - __d, 30 - __d, 31 - __d));
6812 #else
6813  return vec_perm(
6814  __a, __b,
6815  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
6816  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
6817  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
6818 #endif
6819 }
6820 
6821 static __inline__ vector bool char __ATTRS_o_ai
6822 vec_sld(vector bool char __a, vector bool char __b, unsigned const int __c) {
6823  unsigned char __d = __c & 0x0F;
6824 #ifdef __LITTLE_ENDIAN__
6825  return vec_perm(
6826  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
6827  20 - __d, 21 - __d, 22 - __d, 23 - __d,
6828  24 - __d, 25 - __d, 26 - __d, 27 - __d,
6829  28 - __d, 29 - __d, 30 - __d, 31 - __d));
6830 #else
6831  return vec_perm(
6832  __a, __b,
6833  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
6834  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
6835  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
6836 #endif
6837 }
6838 
6839 static __inline__ vector signed short __ATTRS_o_ai vec_sld(
6840  vector signed short __a, vector signed short __b, unsigned const int __c) {
6841  unsigned char __d = __c & 0x0F;
6842 #ifdef __LITTLE_ENDIAN__
6843  return vec_perm(
6844  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
6845  20 - __d, 21 - __d, 22 - __d, 23 - __d,
6846  24 - __d, 25 - __d, 26 - __d, 27 - __d,
6847  28 - __d, 29 - __d, 30 - __d, 31 - __d));
6848 #else
6849  return vec_perm(
6850  __a, __b,
6851  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
6852  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
6853  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
6854 #endif
6855 }
6856 
6857 static __inline__ vector unsigned short __ATTRS_o_ai
6858 vec_sld(vector unsigned short __a, vector unsigned short __b,
6859  unsigned const int __c) {
6860  unsigned char __d = __c & 0x0F;
6861 #ifdef __LITTLE_ENDIAN__
6862  return vec_perm(
6863  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
6864  20 - __d, 21 - __d, 22 - __d, 23 - __d,
6865  24 - __d, 25 - __d, 26 - __d, 27 - __d,
6866  28 - __d, 29 - __d, 30 - __d, 31 - __d));
6867 #else
6868  return vec_perm(
6869  __a, __b,
6870  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
6871  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
6872  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
6873 #endif
6874 }
6875 
6876 static __inline__ vector bool short __ATTRS_o_ai
6877 vec_sld(vector bool short __a, vector bool short __b, unsigned const int __c) {
6878  unsigned char __d = __c & 0x0F;
6879 #ifdef __LITTLE_ENDIAN__
6880  return vec_perm(
6881  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
6882  20 - __d, 21 - __d, 22 - __d, 23 - __d,
6883  24 - __d, 25 - __d, 26 - __d, 27 - __d,
6884  28 - __d, 29 - __d, 30 - __d, 31 - __d));
6885 #else
6886  return vec_perm(
6887  __a, __b,
6888  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
6889  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
6890  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
6891 #endif
6892 }
6893 
6894 static __inline__ vector pixel __ATTRS_o_ai vec_sld(vector pixel __a,
6895  vector pixel __b,
6896  unsigned const int __c) {
6897  unsigned char __d = __c & 0x0F;
6898 #ifdef __LITTLE_ENDIAN__
6899  return vec_perm(
6900  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
6901  20 - __d, 21 - __d, 22 - __d, 23 - __d,
6902  24 - __d, 25 - __d, 26 - __d, 27 - __d,
6903  28 - __d, 29 - __d, 30 - __d, 31 - __d));
6904 #else
6905  return vec_perm(
6906  __a, __b,
6907  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
6908  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
6909  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
6910 #endif
6911 }
6912 
6913 static __inline__ vector signed int __ATTRS_o_ai
6914 vec_sld(vector signed int __a, vector signed int __b, unsigned const int __c) {
6915  unsigned char __d = __c & 0x0F;
6916 #ifdef __LITTLE_ENDIAN__
6917  return vec_perm(
6918  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
6919  20 - __d, 21 - __d, 22 - __d, 23 - __d,
6920  24 - __d, 25 - __d, 26 - __d, 27 - __d,
6921  28 - __d, 29 - __d, 30 - __d, 31 - __d));
6922 #else
6923  return vec_perm(
6924  __a, __b,
6925  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
6926  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
6927  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
6928 #endif
6929 }
6930 
6931 static __inline__ vector unsigned int __ATTRS_o_ai vec_sld(
6932  vector unsigned int __a, vector unsigned int __b, unsigned const int __c) {
6933  unsigned char __d = __c & 0x0F;
6934 #ifdef __LITTLE_ENDIAN__
6935  return vec_perm(
6936  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
6937  20 - __d, 21 - __d, 22 - __d, 23 - __d,
6938  24 - __d, 25 - __d, 26 - __d, 27 - __d,
6939  28 - __d, 29 - __d, 30 - __d, 31 - __d));
6940 #else
6941  return vec_perm(
6942  __a, __b,
6943  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
6944  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
6945  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
6946 #endif
6947 }
6948 
6949 static __inline__ vector bool int __ATTRS_o_ai vec_sld(vector bool int __a,
6950  vector bool int __b,
6951  unsigned const int __c) {
6952  unsigned char __d = __c & 0x0F;
6953 #ifdef __LITTLE_ENDIAN__
6954  return vec_perm(
6955  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
6956  20 - __d, 21 - __d, 22 - __d, 23 - __d,
6957  24 - __d, 25 - __d, 26 - __d, 27 - __d,
6958  28 - __d, 29 - __d, 30 - __d, 31 - __d));
6959 #else
6960  return vec_perm(
6961  __a, __b,
6962  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
6963  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
6964  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
6965 #endif
6966 }
6967 
6968 static __inline__ vector float __ATTRS_o_ai vec_sld(vector float __a,
6969  vector float __b,
6970  unsigned const int __c) {
6971  unsigned char __d = __c & 0x0F;
6972 #ifdef __LITTLE_ENDIAN__
6973  return vec_perm(
6974  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
6975  20 - __d, 21 - __d, 22 - __d, 23 - __d,
6976  24 - __d, 25 - __d, 26 - __d, 27 - __d,
6977  28 - __d, 29 - __d, 30 - __d, 31 - __d));
6978 #else
6979  return vec_perm(
6980  __a, __b,
6981  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
6982  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
6983  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
6984 #endif
6985 }
6986 
6987 /* vec_vsldoi */
6988 
6989 static __inline__ vector signed char __ATTRS_o_ai
6990 vec_vsldoi(vector signed char __a, vector signed char __b, unsigned char __c) {
6991  unsigned char __d = __c & 0x0F;
6992 #ifdef __LITTLE_ENDIAN__
6993  return vec_perm(
6994  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
6995  20 - __d, 21 - __d, 22 - __d, 23 - __d,
6996  24 - __d, 25 - __d, 26 - __d, 27 - __d,
6997  28 - __d, 29 - __d, 30 - __d, 31 - __d));
6998 #else
6999  return vec_perm(
7000  __a, __b,
7001  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
7002  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
7003  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
7004 #endif
7005 }
7006 
7007 static __inline__ vector unsigned char __ATTRS_o_ai vec_vsldoi(
7008  vector unsigned char __a, vector unsigned char __b, unsigned char __c) {
7009  unsigned char __d = __c & 0x0F;
7010 #ifdef __LITTLE_ENDIAN__
7011  return vec_perm(
7012  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
7013  20 - __d, 21 - __d, 22 - __d, 23 - __d,
7014  24 - __d, 25 - __d, 26 - __d, 27 - __d,
7015  28 - __d, 29 - __d, 30 - __d, 31 - __d));
7016 #else
7017  return vec_perm(
7018  __a, __b,
7019  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
7020  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
7021  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
7022 #endif
7023 }
7024 
7025 static __inline__ vector short __ATTRS_o_ai vec_vsldoi(vector short __a,
7026  vector short __b,
7027  unsigned char __c) {
7028  unsigned char __d = __c & 0x0F;
7029 #ifdef __LITTLE_ENDIAN__
7030  return vec_perm(
7031  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
7032  20 - __d, 21 - __d, 22 - __d, 23 - __d,
7033  24 - __d, 25 - __d, 26 - __d, 27 - __d,
7034  28 - __d, 29 - __d, 30 - __d, 31 - __d));
7035 #else
7036  return vec_perm(
7037  __a, __b,
7038  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
7039  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
7040  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
7041 #endif
7042 }
7043 
7044 static __inline__ vector unsigned short __ATTRS_o_ai vec_vsldoi(
7045  vector unsigned short __a, vector unsigned short __b, unsigned char __c) {
7046  unsigned char __d = __c & 0x0F;
7047 #ifdef __LITTLE_ENDIAN__
7048  return vec_perm(
7049  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
7050  20 - __d, 21 - __d, 22 - __d, 23 - __d,
7051  24 - __d, 25 - __d, 26 - __d, 27 - __d,
7052  28 - __d, 29 - __d, 30 - __d, 31 - __d));
7053 #else
7054  return vec_perm(
7055  __a, __b,
7056  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
7057  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
7058  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
7059 #endif
7060 }
7061 
7062 static __inline__ vector pixel __ATTRS_o_ai vec_vsldoi(vector pixel __a,
7063  vector pixel __b,
7064  unsigned char __c) {
7065  unsigned char __d = __c & 0x0F;
7066 #ifdef __LITTLE_ENDIAN__
7067  return vec_perm(
7068  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
7069  20 - __d, 21 - __d, 22 - __d, 23 - __d,
7070  24 - __d, 25 - __d, 26 - __d, 27 - __d,
7071  28 - __d, 29 - __d, 30 - __d, 31 - __d));
7072 #else
7073  return vec_perm(
7074  __a, __b,
7075  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
7076  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
7077  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
7078 #endif
7079 }
7080 
7081 static __inline__ vector int __ATTRS_o_ai vec_vsldoi(vector int __a,
7082  vector int __b,
7083  unsigned char __c) {
7084  unsigned char __d = __c & 0x0F;
7085 #ifdef __LITTLE_ENDIAN__
7086  return vec_perm(
7087  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
7088  20 - __d, 21 - __d, 22 - __d, 23 - __d,
7089  24 - __d, 25 - __d, 26 - __d, 27 - __d,
7090  28 - __d, 29 - __d, 30 - __d, 31 - __d));
7091 #else
7092  return vec_perm(
7093  __a, __b,
7094  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
7095  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
7096  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
7097 #endif
7098 }
7099 
7100 static __inline__ vector unsigned int __ATTRS_o_ai vec_vsldoi(
7101  vector unsigned int __a, vector unsigned int __b, unsigned char __c) {
7102  unsigned char __d = __c & 0x0F;
7103 #ifdef __LITTLE_ENDIAN__
7104  return vec_perm(
7105  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
7106  20 - __d, 21 - __d, 22 - __d, 23 - __d,
7107  24 - __d, 25 - __d, 26 - __d, 27 - __d,
7108  28 - __d, 29 - __d, 30 - __d, 31 - __d));
7109 #else
7110  return vec_perm(
7111  __a, __b,
7112  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
7113  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
7114  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
7115 #endif
7116 }
7117 
7118 static __inline__ vector float __ATTRS_o_ai vec_vsldoi(vector float __a,
7119  vector float __b,
7120  unsigned char __c) {
7121  unsigned char __d = __c & 0x0F;
7122 #ifdef __LITTLE_ENDIAN__
7123  return vec_perm(
7124  __b, __a, (vector unsigned char)(16 - __d, 17 - __d, 18 - __d, 19 - __d,
7125  20 - __d, 21 - __d, 22 - __d, 23 - __d,
7126  24 - __d, 25 - __d, 26 - __d, 27 - __d,
7127  28 - __d, 29 - __d, 30 - __d, 31 - __d));
7128 #else
7129  return vec_perm(
7130  __a, __b,
7131  (vector unsigned char)(__d, __d + 1, __d + 2, __d + 3, __d + 4, __d + 5,
7132  __d + 6, __d + 7, __d + 8, __d + 9, __d + 10,
7133  __d + 11, __d + 12, __d + 13, __d + 14, __d + 15));
7134 #endif
7135 }
7136 
7137 /* vec_sll */
7138 
7139 static __inline__ vector signed char __ATTRS_o_ai
7140 vec_sll(vector signed char __a, vector unsigned char __b) {
7141  return (vector signed char)__builtin_altivec_vsl((vector int)__a,
7142  (vector int)__b);
7143 }
7144 
7145 static __inline__ vector signed char __ATTRS_o_ai
7146 vec_sll(vector signed char __a, vector unsigned short __b) {
7147  return (vector signed char)__builtin_altivec_vsl((vector int)__a,
7148  (vector int)__b);
7149 }
7150 
7151 static __inline__ vector signed char __ATTRS_o_ai
7152 vec_sll(vector signed char __a, vector unsigned int __b) {
7153  return (vector signed char)__builtin_altivec_vsl((vector int)__a,
7154  (vector int)__b);
7155 }
7156 
7157 static __inline__ vector unsigned char __ATTRS_o_ai
7158 vec_sll(vector unsigned char __a, vector unsigned char __b) {
7159  return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
7160  (vector int)__b);
7161 }
7162 
7163 static __inline__ vector unsigned char __ATTRS_o_ai
7164 vec_sll(vector unsigned char __a, vector unsigned short __b) {
7165  return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
7166  (vector int)__b);
7167 }
7168 
7169 static __inline__ vector unsigned char __ATTRS_o_ai
7170 vec_sll(vector unsigned char __a, vector unsigned int __b) {
7171  return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
7172  (vector int)__b);
7173 }
7174 
7175 static __inline__ vector bool char __ATTRS_o_ai
7176 vec_sll(vector bool char __a, vector unsigned char __b) {
7177  return (vector bool char)__builtin_altivec_vsl((vector int)__a,
7178  (vector int)__b);
7179 }
7180 
7181 static __inline__ vector bool char __ATTRS_o_ai
7182 vec_sll(vector bool char __a, vector unsigned short __b) {
7183  return (vector bool char)__builtin_altivec_vsl((vector int)__a,
7184  (vector int)__b);
7185 }
7186 
7187 static __inline__ vector bool char __ATTRS_o_ai
7188 vec_sll(vector bool char __a, vector unsigned int __b) {
7189  return (vector bool char)__builtin_altivec_vsl((vector int)__a,
7190  (vector int)__b);
7191 }
7192 
7193 static __inline__ vector short __ATTRS_o_ai vec_sll(vector short __a,
7194  vector unsigned char __b) {
7195  return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
7196 }
7197 
7198 static __inline__ vector short __ATTRS_o_ai vec_sll(vector short __a,
7199  vector unsigned short __b) {
7200  return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
7201 }
7202 
7203 static __inline__ vector short __ATTRS_o_ai vec_sll(vector short __a,
7204  vector unsigned int __b) {
7205  return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
7206 }
7207 
7208 static __inline__ vector unsigned short __ATTRS_o_ai
7209 vec_sll(vector unsigned short __a, vector unsigned char __b) {
7210  return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
7211  (vector int)__b);
7212 }
7213 
7214 static __inline__ vector unsigned short __ATTRS_o_ai
7215 vec_sll(vector unsigned short __a, vector unsigned short __b) {
7216  return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
7217  (vector int)__b);
7218 }
7219 
7220 static __inline__ vector unsigned short __ATTRS_o_ai
7221 vec_sll(vector unsigned short __a, vector unsigned int __b) {
7222  return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
7223  (vector int)__b);
7224 }
7225 
7226 static __inline__ vector bool short __ATTRS_o_ai
7227 vec_sll(vector bool short __a, vector unsigned char __b) {
7228  return (vector bool short)__builtin_altivec_vsl((vector int)__a,
7229  (vector int)__b);
7230 }
7231 
7232 static __inline__ vector bool short __ATTRS_o_ai
7233 vec_sll(vector bool short __a, vector unsigned short __b) {
7234  return (vector bool short)__builtin_altivec_vsl((vector int)__a,
7235  (vector int)__b);
7236 }
7237 
7238 static __inline__ vector bool short __ATTRS_o_ai
7239 vec_sll(vector bool short __a, vector unsigned int __b) {
7240  return (vector bool short)__builtin_altivec_vsl((vector int)__a,
7241  (vector int)__b);
7242 }
7243 
7244 static __inline__ vector pixel __ATTRS_o_ai vec_sll(vector pixel __a,
7245  vector unsigned char __b) {
7246  return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
7247 }
7248 
7249 static __inline__ vector pixel __ATTRS_o_ai vec_sll(vector pixel __a,
7250  vector unsigned short __b) {
7251  return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
7252 }
7253 
7254 static __inline__ vector pixel __ATTRS_o_ai vec_sll(vector pixel __a,
7255  vector unsigned int __b) {
7256  return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
7257 }
7258 
7259 static __inline__ vector int __ATTRS_o_ai vec_sll(vector int __a,
7260  vector unsigned char __b) {
7261  return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
7262 }
7263 
7264 static __inline__ vector int __ATTRS_o_ai vec_sll(vector int __a,
7265  vector unsigned short __b) {
7266  return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
7267 }
7268 
7269 static __inline__ vector int __ATTRS_o_ai vec_sll(vector int __a,
7270  vector unsigned int __b) {
7271  return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
7272 }
7273 
7274 static __inline__ vector unsigned int __ATTRS_o_ai
7275 vec_sll(vector unsigned int __a, vector unsigned char __b) {
7276  return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
7277  (vector int)__b);
7278 }
7279 
7280 static __inline__ vector unsigned int __ATTRS_o_ai
7281 vec_sll(vector unsigned int __a, vector unsigned short __b) {
7282  return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
7283  (vector int)__b);
7284 }
7285 
7286 static __inline__ vector unsigned int __ATTRS_o_ai
7287 vec_sll(vector unsigned int __a, vector unsigned int __b) {
7288  return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
7289  (vector int)__b);
7290 }
7291 
7292 static __inline__ vector bool int __ATTRS_o_ai
7293 vec_sll(vector bool int __a, vector unsigned char __b) {
7294  return (vector bool int)__builtin_altivec_vsl((vector int)__a,
7295  (vector int)__b);
7296 }
7297 
7298 static __inline__ vector bool int __ATTRS_o_ai
7299 vec_sll(vector bool int __a, vector unsigned short __b) {
7300  return (vector bool int)__builtin_altivec_vsl((vector int)__a,
7301  (vector int)__b);
7302 }
7303 
7304 static __inline__ vector bool int __ATTRS_o_ai
7305 vec_sll(vector bool int __a, vector unsigned int __b) {
7306  return (vector bool int)__builtin_altivec_vsl((vector int)__a,
7307  (vector int)__b);
7308 }
7309 
7310 /* vec_vsl */
7311 
7312 static __inline__ vector signed char __ATTRS_o_ai
7313 vec_vsl(vector signed char __a, vector unsigned char __b) {
7314  return (vector signed char)__builtin_altivec_vsl((vector int)__a,
7315  (vector int)__b);
7316 }
7317 
7318 static __inline__ vector signed char __ATTRS_o_ai
7319 vec_vsl(vector signed char __a, vector unsigned short __b) {
7320  return (vector signed char)__builtin_altivec_vsl((vector int)__a,
7321  (vector int)__b);
7322 }
7323 
7324 static __inline__ vector signed char __ATTRS_o_ai
7325 vec_vsl(vector signed char __a, vector unsigned int __b) {
7326  return (vector signed char)__builtin_altivec_vsl((vector int)__a,
7327  (vector int)__b);
7328 }
7329 
7330 static __inline__ vector unsigned char __ATTRS_o_ai
7331 vec_vsl(vector unsigned char __a, vector unsigned char __b) {
7332  return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
7333  (vector int)__b);
7334 }
7335 
7336 static __inline__ vector unsigned char __ATTRS_o_ai
7337 vec_vsl(vector unsigned char __a, vector unsigned short __b) {
7338  return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
7339  (vector int)__b);
7340 }
7341 
7342 static __inline__ vector unsigned char __ATTRS_o_ai
7343 vec_vsl(vector unsigned char __a, vector unsigned int __b) {
7344  return (vector unsigned char)__builtin_altivec_vsl((vector int)__a,
7345  (vector int)__b);
7346 }
7347 
7348 static __inline__ vector bool char __ATTRS_o_ai
7349 vec_vsl(vector bool char __a, vector unsigned char __b) {
7350  return (vector bool char)__builtin_altivec_vsl((vector int)__a,
7351  (vector int)__b);
7352 }
7353 
7354 static __inline__ vector bool char __ATTRS_o_ai
7355 vec_vsl(vector bool char __a, vector unsigned short __b) {
7356  return (vector bool char)__builtin_altivec_vsl((vector int)__a,
7357  (vector int)__b);
7358 }
7359 
7360 static __inline__ vector bool char __ATTRS_o_ai
7361 vec_vsl(vector bool char __a, vector unsigned int __b) {
7362  return (vector bool char)__builtin_altivec_vsl((vector int)__a,
7363  (vector int)__b);
7364 }
7365 
7366 static __inline__ vector short __ATTRS_o_ai vec_vsl(vector short __a,
7367  vector unsigned char __b) {
7368  return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
7369 }
7370 
7371 static __inline__ vector short __ATTRS_o_ai vec_vsl(vector short __a,
7372  vector unsigned short __b) {
7373  return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
7374 }
7375 
7376 static __inline__ vector short __ATTRS_o_ai vec_vsl(vector short __a,
7377  vector unsigned int __b) {
7378  return (vector short)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
7379 }
7380 
7381 static __inline__ vector unsigned short __ATTRS_o_ai
7382 vec_vsl(vector unsigned short __a, vector unsigned char __b) {
7383  return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
7384  (vector int)__b);
7385 }
7386 
7387 static __inline__ vector unsigned short __ATTRS_o_ai
7388 vec_vsl(vector unsigned short __a, vector unsigned short __b) {
7389  return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
7390  (vector int)__b);
7391 }
7392 
7393 static __inline__ vector unsigned short __ATTRS_o_ai
7394 vec_vsl(vector unsigned short __a, vector unsigned int __b) {
7395  return (vector unsigned short)__builtin_altivec_vsl((vector int)__a,
7396  (vector int)__b);
7397 }
7398 
7399 static __inline__ vector bool short __ATTRS_o_ai
7400 vec_vsl(vector bool short __a, vector unsigned char __b) {
7401  return (vector bool short)__builtin_altivec_vsl((vector int)__a,
7402  (vector int)__b);
7403 }
7404 
7405 static __inline__ vector bool short __ATTRS_o_ai
7406 vec_vsl(vector bool short __a, vector unsigned short __b) {
7407  return (vector bool short)__builtin_altivec_vsl((vector int)__a,
7408  (vector int)__b);
7409 }
7410 
7411 static __inline__ vector bool short __ATTRS_o_ai
7412 vec_vsl(vector bool short __a, vector unsigned int __b) {
7413  return (vector bool short)__builtin_altivec_vsl((vector int)__a,
7414  (vector int)__b);
7415 }
7416 
7417 static __inline__ vector pixel __ATTRS_o_ai vec_vsl(vector pixel __a,
7418  vector unsigned char __b) {
7419  return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
7420 }
7421 
7422 static __inline__ vector pixel __ATTRS_o_ai vec_vsl(vector pixel __a,
7423  vector unsigned short __b) {
7424  return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
7425 }
7426 
7427 static __inline__ vector pixel __ATTRS_o_ai vec_vsl(vector pixel __a,
7428  vector unsigned int __b) {
7429  return (vector pixel)__builtin_altivec_vsl((vector int)__a, (vector int)__b);
7430 }
7431 
7432 static __inline__ vector int __ATTRS_o_ai vec_vsl(vector int __a,
7433  vector unsigned char __b) {
7434  return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
7435 }
7436 
7437 static __inline__ vector int __ATTRS_o_ai vec_vsl(vector int __a,
7438  vector unsigned short __b) {
7439  return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
7440 }
7441 
7442 static __inline__ vector int __ATTRS_o_ai vec_vsl(vector int __a,
7443  vector unsigned int __b) {
7444  return (vector int)__builtin_altivec_vsl(__a, (vector int)__b);
7445 }
7446 
7447 static __inline__ vector unsigned int __ATTRS_o_ai
7448 vec_vsl(vector unsigned int __a, vector unsigned char __b) {
7449  return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
7450  (vector int)__b);
7451 }
7452 
7453 static __inline__ vector unsigned int __ATTRS_o_ai
7454 vec_vsl(vector unsigned int __a, vector unsigned short __b) {
7455  return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
7456  (vector int)__b);
7457 }
7458 
7459 static __inline__ vector unsigned int __ATTRS_o_ai
7460 vec_vsl(vector unsigned int __a, vector unsigned int __b) {
7461  return (vector unsigned int)__builtin_altivec_vsl((vector int)__a,
7462  (vector int)__b);
7463 }
7464 
7465 static __inline__ vector bool int __ATTRS_o_ai
7466 vec_vsl(vector bool int __a, vector unsigned char __b) {
7467  return (vector bool int)__builtin_altivec_vsl((vector int)__a,
7468  (vector int)__b);
7469 }
7470 
7471 static __inline__ vector bool int __ATTRS_o_ai
7472 vec_vsl(vector bool int __a, vector unsigned short __b) {
7473  return (vector bool int)__builtin_altivec_vsl((vector int)__a,
7474  (vector int)__b);
7475 }
7476 
7477 static __inline__ vector bool int __ATTRS_o_ai
7478 vec_vsl(vector bool int __a, vector unsigned int __b) {
7479  return (vector bool int)__builtin_altivec_vsl((vector int)__a,
7480  (vector int)__b);
7481 }
7482 
7483 /* vec_slo */
7484 
7485 static __inline__ vector signed char __ATTRS_o_ai
7486 vec_slo(vector signed char __a, vector signed char __b) {
7487  return (vector signed char)__builtin_altivec_vslo((vector int)__a,
7488  (vector int)__b);
7489 }
7490 
7491 static __inline__ vector signed char __ATTRS_o_ai
7492 vec_slo(vector signed char __a, vector unsigned char __b) {
7493  return (vector signed char)__builtin_altivec_vslo((vector int)__a,
7494  (vector int)__b);
7495 }
7496 
7497 static __inline__ vector unsigned char __ATTRS_o_ai
7498 vec_slo(vector unsigned char __a, vector signed char __b) {
7499  return (vector unsigned char)__builtin_altivec_vslo((vector int)__a,
7500  (vector int)__b);
7501 }
7502 
7503 static __inline__ vector unsigned char __ATTRS_o_ai
7504 vec_slo(vector unsigned char __a, vector unsigned char __b) {
7505  return (vector unsigned char)__builtin_altivec_vslo((vector int)__a,
7506  (vector int)__b);
7507 }
7508 
7509 static __inline__ vector short __ATTRS_o_ai vec_slo(vector short __a,
7510  vector signed char __b) {
7511  return (vector short)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
7512 }
7513 
7514 static __inline__ vector short __ATTRS_o_ai vec_slo(vector short __a,
7515  vector unsigned char __b) {
7516  return (vector short)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
7517 }
7518 
7519 static __inline__ vector unsigned short __ATTRS_o_ai
7520 vec_slo(vector unsigned short __a, vector signed char __b) {
7521  return (vector unsigned short)__builtin_altivec_vslo((vector int)__a,
7522  (vector int)__b);
7523 }
7524 
7525 static __inline__ vector unsigned short __ATTRS_o_ai
7526 vec_slo(vector unsigned short __a, vector unsigned char __b) {
7527  return (vector unsigned short)__builtin_altivec_vslo((vector int)__a,
7528  (vector int)__b);
7529 }
7530 
7531 static __inline__ vector pixel __ATTRS_o_ai vec_slo(vector pixel __a,
7532  vector signed char __b) {
7533  return (vector pixel)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
7534 }
7535 
7536 static __inline__ vector pixel __ATTRS_o_ai vec_slo(vector pixel __a,
7537  vector unsigned char __b) {
7538  return (vector pixel)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
7539 }
7540 
7541 static __inline__ vector int __ATTRS_o_ai vec_slo(vector int __a,
7542  vector signed char __b) {
7543  return (vector int)__builtin_altivec_vslo(__a, (vector int)__b);
7544 }
7545 
7546 static __inline__ vector int __ATTRS_o_ai vec_slo(vector int __a,
7547  vector unsigned char __b) {
7548  return (vector int)__builtin_altivec_vslo(__a, (vector int)__b);
7549 }
7550 
7551 static __inline__ vector unsigned int __ATTRS_o_ai
7552 vec_slo(vector unsigned int __a, vector signed char __b) {
7553  return (vector unsigned int)__builtin_altivec_vslo((vector int)__a,
7554  (vector int)__b);
7555 }
7556 
7557 static __inline__ vector unsigned int __ATTRS_o_ai
7558 vec_slo(vector unsigned int __a, vector unsigned char __b) {
7559  return (vector unsigned int)__builtin_altivec_vslo((vector int)__a,
7560  (vector int)__b);
7561 }
7562 
7563 static __inline__ vector float __ATTRS_o_ai vec_slo(vector float __a,
7564  vector signed char __b) {
7565  return (vector float)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
7566 }
7567 
7568 static __inline__ vector float __ATTRS_o_ai vec_slo(vector float __a,
7569  vector unsigned char __b) {
7570  return (vector float)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
7571 }
7572 
7573 /* vec_vslo */
7574 
7575 static __inline__ vector signed char __ATTRS_o_ai
7576 vec_vslo(vector signed char __a, vector signed char __b) {
7577  return (vector signed char)__builtin_altivec_vslo((vector int)__a,
7578  (vector int)__b);
7579 }
7580 
7581 static __inline__ vector signed char __ATTRS_o_ai
7582 vec_vslo(vector signed char __a, vector unsigned char __b) {
7583  return (vector signed char)__builtin_altivec_vslo((vector int)__a,
7584  (vector int)__b);
7585 }
7586 
7587 static __inline__ vector unsigned char __ATTRS_o_ai
7588 vec_vslo(vector unsigned char __a, vector signed char __b) {
7589  return (vector unsigned char)__builtin_altivec_vslo((vector int)__a,
7590  (vector int)__b);
7591 }
7592 
7593 static __inline__ vector unsigned char __ATTRS_o_ai
7594 vec_vslo(vector unsigned char __a, vector unsigned char __b) {
7595  return (vector unsigned char)__builtin_altivec_vslo((vector int)__a,
7596  (vector int)__b);
7597 }
7598 
7599 static __inline__ vector short __ATTRS_o_ai vec_vslo(vector short __a,
7600  vector signed char __b) {
7601  return (vector short)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
7602 }
7603 
7604 static __inline__ vector short __ATTRS_o_ai vec_vslo(vector short __a,
7605  vector unsigned char __b) {
7606  return (vector short)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
7607 }
7608 
7609 static __inline__ vector unsigned short __ATTRS_o_ai
7610 vec_vslo(vector unsigned short __a, vector signed char __b) {
7611  return (vector unsigned short)__builtin_altivec_vslo((vector int)__a,
7612  (vector int)__b);
7613 }
7614 
7615 static __inline__ vector unsigned short __ATTRS_o_ai
7616 vec_vslo(vector unsigned short __a, vector unsigned char __b) {
7617  return (vector unsigned short)__builtin_altivec_vslo((vector int)__a,
7618  (vector int)__b);
7619 }
7620 
7621 static __inline__ vector pixel __ATTRS_o_ai vec_vslo(vector pixel __a,
7622  vector signed char __b) {
7623  return (vector pixel)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
7624 }
7625 
7626 static __inline__ vector pixel __ATTRS_o_ai vec_vslo(vector pixel __a,
7627  vector unsigned char __b) {
7628  return (vector pixel)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
7629 }
7630 
7631 static __inline__ vector int __ATTRS_o_ai vec_vslo(vector int __a,
7632  vector signed char __b) {
7633  return (vector int)__builtin_altivec_vslo(__a, (vector int)__b);
7634 }
7635 
7636 static __inline__ vector int __ATTRS_o_ai vec_vslo(vector int __a,
7637  vector unsigned char __b) {
7638  return (vector int)__builtin_altivec_vslo(__a, (vector int)__b);
7639 }
7640 
7641 static __inline__ vector unsigned int __ATTRS_o_ai
7642 vec_vslo(vector unsigned int __a, vector signed char __b) {
7643  return (vector unsigned int)__builtin_altivec_vslo((vector int)__a,
7644  (vector int)__b);
7645 }
7646 
7647 static __inline__ vector unsigned int __ATTRS_o_ai
7648 vec_vslo(vector unsigned int __a, vector unsigned char __b) {
7649  return (vector unsigned int)__builtin_altivec_vslo((vector int)__a,
7650  (vector int)__b);
7651 }
7652 
7653 static __inline__ vector float __ATTRS_o_ai vec_vslo(vector float __a,
7654  vector signed char __b) {
7655  return (vector float)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
7656 }
7657 
7658 static __inline__ vector float __ATTRS_o_ai vec_vslo(vector float __a,
7659  vector unsigned char __b) {
7660  return (vector float)__builtin_altivec_vslo((vector int)__a, (vector int)__b);
7661 }
7662 
7663 /* vec_splat */
7664 
7665 static __inline__ vector signed char __ATTRS_o_ai
7666 vec_splat(vector signed char __a, unsigned const int __b) {
7667  return vec_perm(__a, __a, (vector unsigned char)(__b & 0x0F));
7668 }
7669 
7670 static __inline__ vector unsigned char __ATTRS_o_ai
7671 vec_splat(vector unsigned char __a, unsigned const int __b) {
7672  return vec_perm(__a, __a, (vector unsigned char)(__b & 0x0F));
7673 }
7674 
7675 static __inline__ vector bool char __ATTRS_o_ai
7676 vec_splat(vector bool char __a, unsigned const int __b) {
7677  return vec_perm(__a, __a, (vector unsigned char)(__b & 0x0F));
7678 }
7679 
7680 static __inline__ vector signed short __ATTRS_o_ai
7681 vec_splat(vector signed short __a, unsigned const int __b) {
7682  unsigned char b0 = (__b & 0x07) * 2;
7683  unsigned char b1 = b0 + 1;
7684  return vec_perm(__a, __a,
7685  (vector unsigned char)(b0, b1, b0, b1, b0, b1, b0, b1, b0, b1,
7686  b0, b1, b0, b1, b0, b1));
7687 }
7688 
7689 static __inline__ vector unsigned short __ATTRS_o_ai
7690 vec_splat(vector unsigned short __a, unsigned const int __b) {
7691  unsigned char b0 = (__b & 0x07) * 2;
7692  unsigned char b1 = b0 + 1;
7693  return vec_perm(__a, __a,
7694  (vector unsigned char)(b0, b1, b0, b1, b0, b1, b0, b1, b0, b1,
7695  b0, b1, b0, b1, b0, b1));
7696 }
7697 
7698 static __inline__ vector bool short __ATTRS_o_ai
7699 vec_splat(vector bool short __a, unsigned const int __b) {
7700  unsigned char b0 = (__b & 0x07) * 2;
7701  unsigned char b1 = b0 + 1;
7702  return vec_perm(__a, __a,
7703  (vector unsigned char)(b0, b1, b0, b1, b0, b1, b0, b1, b0, b1,
7704  b0, b1, b0, b1, b0, b1));
7705 }
7706 
7707 static __inline__ vector pixel __ATTRS_o_ai vec_splat(vector pixel __a,
7708  unsigned const int __b) {
7709  unsigned char b0 = (__b & 0x07) * 2;
7710  unsigned char b1 = b0 + 1;
7711  return vec_perm(__a, __a,
7712  (vector unsigned char)(b0, b1, b0, b1, b0, b1, b0, b1, b0, b1,
7713  b0, b1, b0, b1, b0, b1));
7714 }
7715 
7716 static __inline__ vector signed int __ATTRS_o_ai
7717 vec_splat(vector signed int __a, unsigned const int __b) {
7718  unsigned char b0 = (__b & 0x03) * 4;
7719  unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3;
7720  return vec_perm(__a, __a,
7721  (vector unsigned char)(b0, b1, b2, b3, b0, b1, b2, b3, b0, b1,
7722  b2, b3, b0, b1, b2, b3));
7723 }
7724 
7725 static __inline__ vector unsigned int __ATTRS_o_ai
7726 vec_splat(vector unsigned int __a, unsigned const int __b) {
7727  unsigned char b0 = (__b & 0x03) * 4;
7728  unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3;
7729  return vec_perm(__a, __a,
7730  (vector unsigned char)(b0, b1, b2, b3, b0, b1, b2, b3, b0, b1,
7731  b2, b3, b0, b1, b2, b3));
7732 }
7733 
7734 static __inline__ vector bool int __ATTRS_o_ai
7735 vec_splat(vector bool int __a, unsigned const int __b) {
7736  unsigned char b0 = (__b & 0x03) * 4;
7737  unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3;
7738  return vec_perm(__a, __a,
7739  (vector unsigned char)(b0, b1, b2, b3, b0, b1, b2, b3, b0, b1,
7740  b2, b3, b0, b1, b2, b3));
7741 }
7742 
7743 static __inline__ vector float __ATTRS_o_ai vec_splat(vector float __a,
7744  unsigned const int __b) {
7745  unsigned char b0 = (__b & 0x03) * 4;
7746  unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3;
7747  return vec_perm(__a, __a,
7748  (vector unsigned char)(b0, b1, b2, b3, b0, b1, b2, b3, b0, b1,
7749  b2, b3, b0, b1, b2, b3));
7750 }
7751 
7752 #ifdef __VSX__
7753 static __inline__ vector double __ATTRS_o_ai vec_splat(vector double __a,
7754  unsigned const int __b) {
7755  unsigned char b0 = (__b & 0x01) * 8;
7756  unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3, b4 = b0 + 4, b5 = b0 + 5,
7757  b6 = b0 + 6, b7 = b0 + 7;
7758  return vec_perm(__a, __a,
7759  (vector unsigned char)(b0, b1, b2, b3, b4, b5, b6, b7, b0, b1,
7760  b2, b3, b4, b5, b6, b7));
7761 }
7762 static __inline__ vector bool long long __ATTRS_o_ai
7763 vec_splat(vector bool long long __a, unsigned const int __b) {
7764  unsigned char b0 = (__b & 0x01) * 8;
7765  unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3, b4 = b0 + 4, b5 = b0 + 5,
7766  b6 = b0 + 6, b7 = b0 + 7;
7767  return vec_perm(__a, __a,
7768  (vector unsigned char)(b0, b1, b2, b3, b4, b5, b6, b7, b0, b1,
7769  b2, b3, b4, b5, b6, b7));
7770 }
7771 static __inline__ vector signed long long __ATTRS_o_ai
7772 vec_splat(vector signed long long __a, unsigned const int __b) {
7773  unsigned char b0 = (__b & 0x01) * 8;
7774  unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3, b4 = b0 + 4, b5 = b0 + 5,
7775  b6 = b0 + 6, b7 = b0 + 7;
7776  return vec_perm(__a, __a,
7777  (vector unsigned char)(b0, b1, b2, b3, b4, b5, b6, b7, b0, b1,
7778  b2, b3, b4, b5, b6, b7));
7779 }
7780 static __inline__ vector unsigned long long __ATTRS_o_ai
7781 vec_splat(vector unsigned long long __a, unsigned const int __b) {
7782  unsigned char b0 = (__b & 0x01) * 8;
7783  unsigned char b1 = b0 + 1, b2 = b0 + 2, b3 = b0 + 3, b4 = b0 + 4, b5 = b0 + 5,
7784  b6 = b0 + 6, b7 = b0 + 7;
7785  return vec_perm(__a, __a,
7786  (vector unsigned char)(b0, b1, b2, b3, b4, b5, b6, b7, b0, b1,
7787  b2, b3, b4, b5, b6, b7));
7788 }
7789 #endif
7790 
7791 /* vec_vspltb */
7792 
7793 #define __builtin_altivec_vspltb vec_vspltb
7794 
7795 static __inline__ vector signed char __ATTRS_o_ai
7796 vec_vspltb(vector signed char __a, unsigned char __b) {
7797  return vec_perm(__a, __a, (vector unsigned char)(__b));
7798 }
7799 
7800 static __inline__ vector unsigned char __ATTRS_o_ai
7801 vec_vspltb(vector unsigned char __a, unsigned char __b) {
7802  return vec_perm(__a, __a, (vector unsigned char)(__b));
7803 }
7804 
7805 static __inline__ vector bool char __ATTRS_o_ai vec_vspltb(vector bool char __a,
7806  unsigned char __b) {
7807  return vec_perm(__a, __a, (vector unsigned char)(__b));
7808 }
7809 
7810 /* vec_vsplth */
7811 
7812 #define __builtin_altivec_vsplth vec_vsplth
7813 
7814 static __inline__ vector short __ATTRS_o_ai vec_vsplth(vector short __a,
7815  unsigned char __b) {
7816  __b *= 2;
7817  unsigned char b1 = __b + 1;
7818  return vec_perm(__a, __a,
7819  (vector unsigned char)(__b, b1, __b, b1, __b, b1, __b, b1,
7820  __b, b1, __b, b1, __b, b1, __b, b1));
7821 }
7822 
7823 static __inline__ vector unsigned short __ATTRS_o_ai
7824 vec_vsplth(vector unsigned short __a, unsigned char __b) {
7825  __b *= 2;
7826  unsigned char b1 = __b + 1;
7827  return vec_perm(__a, __a,
7828  (vector unsigned char)(__b, b1, __b, b1, __b, b1, __b, b1,
7829  __b, b1, __b, b1, __b, b1, __b, b1));
7830 }
7831 
7832 static __inline__ vector bool short __ATTRS_o_ai
7833 vec_vsplth(vector bool short __a, unsigned char __b) {
7834  __b *= 2;
7835  unsigned char b1 = __b + 1;
7836  return vec_perm(__a, __a,
7837  (vector unsigned char)(__b, b1, __b, b1, __b, b1, __b, b1,
7838  __b, b1, __b, b1, __b, b1, __b, b1));
7839 }
7840 
7841 static __inline__ vector pixel __ATTRS_o_ai vec_vsplth(vector pixel __a,
7842  unsigned char __b) {
7843  __b *= 2;
7844  unsigned char b1 = __b + 1;
7845  return vec_perm(__a, __a,
7846  (vector unsigned char)(__b, b1, __b, b1, __b, b1, __b, b1,
7847  __b, b1, __b, b1, __b, b1, __b, b1));
7848 }
7849 
7850 /* vec_vspltw */
7851 
7852 #define __builtin_altivec_vspltw vec_vspltw
7853 
7854 static __inline__ vector int __ATTRS_o_ai vec_vspltw(vector int __a,
7855  unsigned char __b) {
7856  __b *= 4;
7857  unsigned char b1 = __b + 1, b2 = __b + 2, b3 = __b + 3;
7858  return vec_perm(__a, __a,
7859  (vector unsigned char)(__b, b1, b2, b3, __b, b1, b2, b3, __b,
7860  b1, b2, b3, __b, b1, b2, b3));
7861 }
7862 
7863 static __inline__ vector unsigned int __ATTRS_o_ai
7864 vec_vspltw(vector unsigned int __a, unsigned char __b) {
7865  __b *= 4;
7866  unsigned char b1 = __b + 1, b2 = __b + 2, b3 = __b + 3;
7867  return vec_perm(__a, __a,
7868  (vector unsigned char)(__b, b1, b2, b3, __b, b1, b2, b3, __b,
7869  b1, b2, b3, __b, b1, b2, b3));
7870 }
7871 
7872 static __inline__ vector bool int __ATTRS_o_ai vec_vspltw(vector bool int __a,
7873  unsigned char __b) {
7874  __b *= 4;
7875  unsigned char b1 = __b + 1, b2 = __b + 2, b3 = __b + 3;
7876  return vec_perm(__a, __a,
7877  (vector unsigned char)(__b, b1, b2, b3, __b, b1, b2, b3, __b,
7878  b1, b2, b3, __b, b1, b2, b3));
7879 }
7880 
7881 static __inline__ vector float __ATTRS_o_ai vec_vspltw(vector float __a,
7882  unsigned char __b) {
7883  __b *= 4;
7884  unsigned char b1 = __b + 1, b2 = __b + 2, b3 = __b + 3;
7885  return vec_perm(__a, __a,
7886  (vector unsigned char)(__b, b1, b2, b3, __b, b1, b2, b3, __b,
7887  b1, b2, b3, __b, b1, b2, b3));
7888 }
7889 
7890 /* vec_splat_s8 */
7891 
7892 #define __builtin_altivec_vspltisb vec_splat_s8
7893 
7894 // FIXME: parameter should be treated as 5-bit signed literal
7895 static __inline__ vector signed char __ATTRS_o_ai
7896 vec_splat_s8(signed char __a) {
7897  return (vector signed char)(__a);
7898 }
7899 
7900 /* vec_vspltisb */
7901 
7902 // FIXME: parameter should be treated as 5-bit signed literal
7903 static __inline__ vector signed char __ATTRS_o_ai
7904 vec_vspltisb(signed char __a) {
7905  return (vector signed char)(__a);
7906 }
7907 
7908 /* vec_splat_s16 */
7909 
7910 #define __builtin_altivec_vspltish vec_splat_s16
7911 
7912 // FIXME: parameter should be treated as 5-bit signed literal
7913 static __inline__ vector short __ATTRS_o_ai vec_splat_s16(signed char __a) {
7914  return (vector short)(__a);
7915 }
7916 
7917 /* vec_vspltish */
7918 
7919 // FIXME: parameter should be treated as 5-bit signed literal
7920 static __inline__ vector short __ATTRS_o_ai vec_vspltish(signed char __a) {
7921  return (vector short)(__a);
7922 }
7923 
7924 /* vec_splat_s32 */
7925 
7926 #define __builtin_altivec_vspltisw vec_splat_s32
7927 
7928 // FIXME: parameter should be treated as 5-bit signed literal
7929 static __inline__ vector int __ATTRS_o_ai vec_splat_s32(signed char __a) {
7930  return (vector int)(__a);
7931 }
7932 
7933 /* vec_vspltisw */
7934 
7935 // FIXME: parameter should be treated as 5-bit signed literal
7936 static __inline__ vector int __ATTRS_o_ai vec_vspltisw(signed char __a) {
7937  return (vector int)(__a);
7938 }
7939 
7940 /* vec_splat_u8 */
7941 
7942 // FIXME: parameter should be treated as 5-bit signed literal
7943 static __inline__ vector unsigned char __ATTRS_o_ai
7944 vec_splat_u8(unsigned char __a) {
7945  return (vector unsigned char)(__a);
7946 }
7947 
7948 /* vec_splat_u16 */
7949 
7950 // FIXME: parameter should be treated as 5-bit signed literal
7951 static __inline__ vector unsigned short __ATTRS_o_ai
7952 vec_splat_u16(signed char __a) {
7953  return (vector unsigned short)(__a);
7954 }
7955 
7956 /* vec_splat_u32 */
7957 
7958 // FIXME: parameter should be treated as 5-bit signed literal
7959 static __inline__ vector unsigned int __ATTRS_o_ai
7960 vec_splat_u32(signed char __a) {
7961  return (vector unsigned int)(__a);
7962 }
7963 
7964 /* vec_sr */
7965 
7966 static __inline__ vector signed char __ATTRS_o_ai
7967 vec_sr(vector signed char __a, vector unsigned char __b) {
7968  vector unsigned char __res = (vector unsigned char)__a >> __b;
7969  return (vector signed char)__res;
7970 }
7971 
7972 static __inline__ vector unsigned char __ATTRS_o_ai
7973 vec_sr(vector unsigned char __a, vector unsigned char __b) {
7974  return __a >> __b;
7975 }
7976 
7977 static __inline__ vector signed short __ATTRS_o_ai
7978 vec_sr(vector signed short __a, vector unsigned short __b) {
7979  vector unsigned short __res = (vector unsigned short)__a >> __b;
7980  return (vector signed short)__res;
7981 }
7982 
7983 static __inline__ vector unsigned short __ATTRS_o_ai
7984 vec_sr(vector unsigned short __a, vector unsigned short __b) {
7985  return __a >> __b;
7986 }
7987 
7988 static __inline__ vector signed int __ATTRS_o_ai
7989 vec_sr(vector signed int __a, vector unsigned int __b) {
7990  vector unsigned int __res = (vector unsigned int)__a >> __b;
7991  return (vector signed int)__res;
7992 }
7993 
7994 static __inline__ vector unsigned int __ATTRS_o_ai
7995 vec_sr(vector unsigned int __a, vector unsigned int __b) {
7996  return __a >> __b;
7997 }
7998 
7999 #ifdef __POWER8_VECTOR__
8000 static __inline__ vector signed long long __ATTRS_o_ai
8001 vec_sr(vector signed long long __a, vector unsigned long long __b) {
8002  vector unsigned long long __res = (vector unsigned long long)__a >> __b;
8003  return (vector signed long long)__res;
8004 }
8005 
8006 static __inline__ vector unsigned long long __ATTRS_o_ai
8007 vec_sr(vector unsigned long long __a, vector unsigned long long __b) {
8008  return __a >> __b;
8009 }
8010 #endif
8011 
8012 /* vec_vsrb */
8013 
8014 #define __builtin_altivec_vsrb vec_vsrb
8015 
8016 static __inline__ vector signed char __ATTRS_o_ai
8017 vec_vsrb(vector signed char __a, vector unsigned char __b) {
8018  return __a >> (vector signed char)__b;
8019 }
8020 
8021 static __inline__ vector unsigned char __ATTRS_o_ai
8022 vec_vsrb(vector unsigned char __a, vector unsigned char __b) {
8023  return __a >> __b;
8024 }
8025 
8026 /* vec_vsrh */
8027 
8028 #define __builtin_altivec_vsrh vec_vsrh
8029 
8030 static __inline__ vector short __ATTRS_o_ai
8031 vec_vsrh(vector short __a, vector unsigned short __b) {
8032  return __a >> (vector short)__b;
8033 }
8034 
8035 static __inline__ vector unsigned short __ATTRS_o_ai
8036 vec_vsrh(vector unsigned short __a, vector unsigned short __b) {
8037  return __a >> __b;
8038 }
8039 
8040 /* vec_vsrw */
8041 
8042 #define __builtin_altivec_vsrw vec_vsrw
8043 
8044 static __inline__ vector int __ATTRS_o_ai vec_vsrw(vector int __a,
8045  vector unsigned int __b) {
8046  return __a >> (vector int)__b;
8047 }
8048 
8049 static __inline__ vector unsigned int __ATTRS_o_ai
8050 vec_vsrw(vector unsigned int __a, vector unsigned int __b) {
8051  return __a >> __b;
8052 }
8053 
8054 /* vec_sra */
8055 
8056 static __inline__ vector signed char __ATTRS_o_ai
8057 vec_sra(vector signed char __a, vector unsigned char __b) {
8058  return (vector signed char)__builtin_altivec_vsrab((vector char)__a, __b);
8059 }
8060 
8061 static __inline__ vector unsigned char __ATTRS_o_ai
8062 vec_sra(vector unsigned char __a, vector unsigned char __b) {
8063  return (vector unsigned char)__builtin_altivec_vsrab((vector char)__a, __b);
8064 }
8065 
8066 static __inline__ vector short __ATTRS_o_ai vec_sra(vector short __a,
8067  vector unsigned short __b) {
8068  return __builtin_altivec_vsrah(__a, (vector unsigned short)__b);
8069 }
8070 
8071 static __inline__ vector unsigned short __ATTRS_o_ai
8072 vec_sra(vector unsigned short __a, vector unsigned short __b) {
8073  return (vector unsigned short)__builtin_altivec_vsrah((vector short)__a, __b);
8074 }
8075 
8076 static __inline__ vector int __ATTRS_o_ai vec_sra(vector int __a,
8077  vector unsigned int __b) {
8078  return __builtin_altivec_vsraw(__a, __b);
8079 }
8080 
8081 static __inline__ vector unsigned int __ATTRS_o_ai
8082 vec_sra(vector unsigned int __a, vector unsigned int __b) {
8083  return (vector unsigned int)__builtin_altivec_vsraw((vector int)__a, __b);
8084 }
8085 
8086 #ifdef __POWER8_VECTOR__
8087 static __inline__ vector signed long long __ATTRS_o_ai
8088 vec_sra(vector signed long long __a, vector unsigned long long __b) {
8089  return __a >> __b;
8090 }
8091 
8092 static __inline__ vector unsigned long long __ATTRS_o_ai
8093 vec_sra(vector unsigned long long __a, vector unsigned long long __b) {
8094  return (vector unsigned long long)((vector signed long long)__a >> __b);
8095 }
8096 #endif
8097 
8098 /* vec_vsrab */
8099 
8100 static __inline__ vector signed char __ATTRS_o_ai
8101 vec_vsrab(vector signed char __a, vector unsigned char __b) {
8102  return (vector signed char)__builtin_altivec_vsrab((vector char)__a, __b);
8103 }
8104 
8105 static __inline__ vector unsigned char __ATTRS_o_ai
8106 vec_vsrab(vector unsigned char __a, vector unsigned char __b) {
8107  return (vector unsigned char)__builtin_altivec_vsrab((vector char)__a, __b);
8108 }
8109 
8110 /* vec_vsrah */
8111 
8112 static __inline__ vector short __ATTRS_o_ai
8113 vec_vsrah(vector short __a, vector unsigned short __b) {
8114  return __builtin_altivec_vsrah(__a, (vector unsigned short)__b);
8115 }
8116 
8117 static __inline__ vector unsigned short __ATTRS_o_ai
8118 vec_vsrah(vector unsigned short __a, vector unsigned short __b) {
8119  return (vector unsigned short)__builtin_altivec_vsrah((vector short)__a, __b);
8120 }
8121 
8122 /* vec_vsraw */
8123 
8124 static __inline__ vector int __ATTRS_o_ai vec_vsraw(vector int __a,
8125  vector unsigned int __b) {
8126  return __builtin_altivec_vsraw(__a, __b);
8127 }
8128 
8129 static __inline__ vector unsigned int __ATTRS_o_ai
8130 vec_vsraw(vector unsigned int __a, vector unsigned int __b) {
8131  return (vector unsigned int)__builtin_altivec_vsraw((vector int)__a, __b);
8132 }
8133 
8134 /* vec_srl */
8135 
8136 static __inline__ vector signed char __ATTRS_o_ai
8137 vec_srl(vector signed char __a, vector unsigned char __b) {
8138  return (vector signed char)__builtin_altivec_vsr((vector int)__a,
8139  (vector int)__b);
8140 }
8141 
8142 static __inline__ vector signed char __ATTRS_o_ai
8143 vec_srl(vector signed char __a, vector unsigned short __b) {
8144  return (vector signed char)__builtin_altivec_vsr((vector int)__a,
8145  (vector int)__b);
8146 }
8147 
8148 static __inline__ vector signed char __ATTRS_o_ai
8149 vec_srl(vector signed char __a, vector unsigned int __b) {
8150  return (vector signed char)__builtin_altivec_vsr((vector int)__a,
8151  (vector int)__b);
8152 }
8153 
8154 static __inline__ vector unsigned char __ATTRS_o_ai
8155 vec_srl(vector unsigned char __a, vector unsigned char __b) {
8156  return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
8157  (vector int)__b);
8158 }
8159 
8160 static __inline__ vector unsigned char __ATTRS_o_ai
8161 vec_srl(vector unsigned char __a, vector unsigned short __b) {
8162  return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
8163  (vector int)__b);
8164 }
8165 
8166 static __inline__ vector unsigned char __ATTRS_o_ai
8167 vec_srl(vector unsigned char __a, vector unsigned int __b) {
8168  return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
8169  (vector int)__b);
8170 }
8171 
8172 static __inline__ vector bool char __ATTRS_o_ai
8173 vec_srl(vector bool char __a, vector unsigned char __b) {
8174  return (vector bool char)__builtin_altivec_vsr((vector int)__a,
8175  (vector int)__b);
8176 }
8177 
8178 static __inline__ vector bool char __ATTRS_o_ai
8179 vec_srl(vector bool char __a, vector unsigned short __b) {
8180  return (vector bool char)__builtin_altivec_vsr((vector int)__a,
8181  (vector int)__b);
8182 }
8183 
8184 static __inline__ vector bool char __ATTRS_o_ai
8185 vec_srl(vector bool char __a, vector unsigned int __b) {
8186  return (vector bool char)__builtin_altivec_vsr((vector int)__a,
8187  (vector int)__b);
8188 }
8189 
8190 static __inline__ vector short __ATTRS_o_ai vec_srl(vector short __a,
8191  vector unsigned char __b) {
8192  return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
8193 }
8194 
8195 static __inline__ vector short __ATTRS_o_ai vec_srl(vector short __a,
8196  vector unsigned short __b) {
8197  return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
8198 }
8199 
8200 static __inline__ vector short __ATTRS_o_ai vec_srl(vector short __a,
8201  vector unsigned int __b) {
8202  return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
8203 }
8204 
8205 static __inline__ vector unsigned short __ATTRS_o_ai
8206 vec_srl(vector unsigned short __a, vector unsigned char __b) {
8207  return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
8208  (vector int)__b);
8209 }
8210 
8211 static __inline__ vector unsigned short __ATTRS_o_ai
8212 vec_srl(vector unsigned short __a, vector unsigned short __b) {
8213  return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
8214  (vector int)__b);
8215 }
8216 
8217 static __inline__ vector unsigned short __ATTRS_o_ai
8218 vec_srl(vector unsigned short __a, vector unsigned int __b) {
8219  return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
8220  (vector int)__b);
8221 }
8222 
8223 static __inline__ vector bool short __ATTRS_o_ai
8224 vec_srl(vector bool short __a, vector unsigned char __b) {
8225  return (vector bool short)__builtin_altivec_vsr((vector int)__a,
8226  (vector int)__b);
8227 }
8228 
8229 static __inline__ vector bool short __ATTRS_o_ai
8230 vec_srl(vector bool short __a, vector unsigned short __b) {
8231  return (vector bool short)__builtin_altivec_vsr((vector int)__a,
8232  (vector int)__b);
8233 }
8234 
8235 static __inline__ vector bool short __ATTRS_o_ai
8236 vec_srl(vector bool short __a, vector unsigned int __b) {
8237  return (vector bool short)__builtin_altivec_vsr((vector int)__a,
8238  (vector int)__b);
8239 }
8240 
8241 static __inline__ vector pixel __ATTRS_o_ai vec_srl(vector pixel __a,
8242  vector unsigned char __b) {
8243  return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
8244 }
8245 
8246 static __inline__ vector pixel __ATTRS_o_ai vec_srl(vector pixel __a,
8247  vector unsigned short __b) {
8248  return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
8249 }
8250 
8251 static __inline__ vector pixel __ATTRS_o_ai vec_srl(vector pixel __a,
8252  vector unsigned int __b) {
8253  return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
8254 }
8255 
8256 static __inline__ vector int __ATTRS_o_ai vec_srl(vector int __a,
8257  vector unsigned char __b) {
8258  return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
8259 }
8260 
8261 static __inline__ vector int __ATTRS_o_ai vec_srl(vector int __a,
8262  vector unsigned short __b) {
8263  return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
8264 }
8265 
8266 static __inline__ vector int __ATTRS_o_ai vec_srl(vector int __a,
8267  vector unsigned int __b) {
8268  return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
8269 }
8270 
8271 static __inline__ vector unsigned int __ATTRS_o_ai
8272 vec_srl(vector unsigned int __a, vector unsigned char __b) {
8273  return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
8274  (vector int)__b);
8275 }
8276 
8277 static __inline__ vector unsigned int __ATTRS_o_ai
8278 vec_srl(vector unsigned int __a, vector unsigned short __b) {
8279  return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
8280  (vector int)__b);
8281 }
8282 
8283 static __inline__ vector unsigned int __ATTRS_o_ai
8284 vec_srl(vector unsigned int __a, vector unsigned int __b) {
8285  return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
8286  (vector int)__b);
8287 }
8288 
8289 static __inline__ vector bool int __ATTRS_o_ai
8290 vec_srl(vector bool int __a, vector unsigned char __b) {
8291  return (vector bool int)__builtin_altivec_vsr((vector int)__a,
8292  (vector int)__b);
8293 }
8294 
8295 static __inline__ vector bool int __ATTRS_o_ai
8296 vec_srl(vector bool int __a, vector unsigned short __b) {
8297  return (vector bool int)__builtin_altivec_vsr((vector int)__a,
8298  (vector int)__b);
8299 }
8300 
8301 static __inline__ vector bool int __ATTRS_o_ai
8302 vec_srl(vector bool int __a, vector unsigned int __b) {
8303  return (vector bool int)__builtin_altivec_vsr((vector int)__a,
8304  (vector int)__b);
8305 }
8306 
8307 /* vec_vsr */
8308 
8309 static __inline__ vector signed char __ATTRS_o_ai
8310 vec_vsr(vector signed char __a, vector unsigned char __b) {
8311  return (vector signed char)__builtin_altivec_vsr((vector int)__a,
8312  (vector int)__b);
8313 }
8314 
8315 static __inline__ vector signed char __ATTRS_o_ai
8316 vec_vsr(vector signed char __a, vector unsigned short __b) {
8317  return (vector signed char)__builtin_altivec_vsr((vector int)__a,
8318  (vector int)__b);
8319 }
8320 
8321 static __inline__ vector signed char __ATTRS_o_ai
8322 vec_vsr(vector signed char __a, vector unsigned int __b) {
8323  return (vector signed char)__builtin_altivec_vsr((vector int)__a,
8324  (vector int)__b);
8325 }
8326 
8327 static __inline__ vector unsigned char __ATTRS_o_ai
8328 vec_vsr(vector unsigned char __a, vector unsigned char __b) {
8329  return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
8330  (vector int)__b);
8331 }
8332 
8333 static __inline__ vector unsigned char __ATTRS_o_ai
8334 vec_vsr(vector unsigned char __a, vector unsigned short __b) {
8335  return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
8336  (vector int)__b);
8337 }
8338 
8339 static __inline__ vector unsigned char __ATTRS_o_ai
8340 vec_vsr(vector unsigned char __a, vector unsigned int __b) {
8341  return (vector unsigned char)__builtin_altivec_vsr((vector int)__a,
8342  (vector int)__b);
8343 }
8344 
8345 static __inline__ vector bool char __ATTRS_o_ai
8346 vec_vsr(vector bool char __a, vector unsigned char __b) {
8347  return (vector bool char)__builtin_altivec_vsr((vector int)__a,
8348  (vector int)__b);
8349 }
8350 
8351 static __inline__ vector bool char __ATTRS_o_ai
8352 vec_vsr(vector bool char __a, vector unsigned short __b) {
8353  return (vector bool char)__builtin_altivec_vsr((vector int)__a,
8354  (vector int)__b);
8355 }
8356 
8357 static __inline__ vector bool char __ATTRS_o_ai
8358 vec_vsr(vector bool char __a, vector unsigned int __b) {
8359  return (vector bool char)__builtin_altivec_vsr((vector int)__a,
8360  (vector int)__b);
8361 }
8362 
8363 static __inline__ vector short __ATTRS_o_ai vec_vsr(vector short __a,
8364  vector unsigned char __b) {
8365  return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
8366 }
8367 
8368 static __inline__ vector short __ATTRS_o_ai vec_vsr(vector short __a,
8369  vector unsigned short __b) {
8370  return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
8371 }
8372 
8373 static __inline__ vector short __ATTRS_o_ai vec_vsr(vector short __a,
8374  vector unsigned int __b) {
8375  return (vector short)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
8376 }
8377 
8378 static __inline__ vector unsigned short __ATTRS_o_ai
8379 vec_vsr(vector unsigned short __a, vector unsigned char __b) {
8380  return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
8381  (vector int)__b);
8382 }
8383 
8384 static __inline__ vector unsigned short __ATTRS_o_ai
8385 vec_vsr(vector unsigned short __a, vector unsigned short __b) {
8386  return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
8387  (vector int)__b);
8388 }
8389 
8390 static __inline__ vector unsigned short __ATTRS_o_ai
8391 vec_vsr(vector unsigned short __a, vector unsigned int __b) {
8392  return (vector unsigned short)__builtin_altivec_vsr((vector int)__a,
8393  (vector int)__b);
8394 }
8395 
8396 static __inline__ vector bool short __ATTRS_o_ai
8397 vec_vsr(vector bool short __a, vector unsigned char __b) {
8398  return (vector bool short)__builtin_altivec_vsr((vector int)__a,
8399  (vector int)__b);
8400 }
8401 
8402 static __inline__ vector bool short __ATTRS_o_ai
8403 vec_vsr(vector bool short __a, vector unsigned short __b) {
8404  return (vector bool short)__builtin_altivec_vsr((vector int)__a,
8405  (vector int)__b);
8406 }
8407 
8408 static __inline__ vector bool short __ATTRS_o_ai
8409 vec_vsr(vector bool short __a, vector unsigned int __b) {
8410  return (vector bool short)__builtin_altivec_vsr((vector int)__a,
8411  (vector int)__b);
8412 }
8413 
8414 static __inline__ vector pixel __ATTRS_o_ai vec_vsr(vector pixel __a,
8415  vector unsigned char __b) {
8416  return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
8417 }
8418 
8419 static __inline__ vector pixel __ATTRS_o_ai vec_vsr(vector pixel __a,
8420  vector unsigned short __b) {
8421  return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
8422 }
8423 
8424 static __inline__ vector pixel __ATTRS_o_ai vec_vsr(vector pixel __a,
8425  vector unsigned int __b) {
8426  return (vector pixel)__builtin_altivec_vsr((vector int)__a, (vector int)__b);
8427 }
8428 
8429 static __inline__ vector int __ATTRS_o_ai vec_vsr(vector int __a,
8430  vector unsigned char __b) {
8431  return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
8432 }
8433 
8434 static __inline__ vector int __ATTRS_o_ai vec_vsr(vector int __a,
8435  vector unsigned short __b) {
8436  return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
8437 }
8438 
8439 static __inline__ vector int __ATTRS_o_ai vec_vsr(vector int __a,
8440  vector unsigned int __b) {
8441  return (vector int)__builtin_altivec_vsr(__a, (vector int)__b);
8442 }
8443 
8444 static __inline__ vector unsigned int __ATTRS_o_ai
8445 vec_vsr(vector unsigned int __a, vector unsigned char __b) {
8446  return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
8447  (vector int)__b);
8448 }
8449 
8450 static __inline__ vector unsigned int __ATTRS_o_ai
8451 vec_vsr(vector unsigned int __a, vector unsigned short __b) {
8452  return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
8453  (vector int)__b);
8454 }
8455 
8456 static __inline__ vector unsigned int __ATTRS_o_ai
8457 vec_vsr(vector unsigned int __a, vector unsigned int __b) {
8458  return (vector unsigned int)__builtin_altivec_vsr((vector int)__a,
8459  (vector int)__b);
8460 }
8461 
8462 static __inline__ vector bool int __ATTRS_o_ai
8463 vec_vsr(vector bool int __a, vector unsigned char __b) {
8464  return (vector bool int)__builtin_altivec_vsr((vector int)__a,
8465  (vector int)__b);
8466 }
8467 
8468 static __inline__ vector bool int __ATTRS_o_ai
8469 vec_vsr(vector bool int __a, vector unsigned short __b) {
8470  return (vector bool int)__builtin_altivec_vsr((vector int)__a,
8471  (vector int)__b);
8472 }
8473 
8474 static __inline__ vector bool int __ATTRS_o_ai
8475 vec_vsr(vector bool int __a, vector unsigned int __b) {
8476  return (vector bool int)__builtin_altivec_vsr((vector int)__a,
8477  (vector int)__b);
8478 }
8479 
8480 /* vec_sro */
8481 
8482 static __inline__ vector signed char __ATTRS_o_ai
8483 vec_sro(vector signed char __a, vector signed char __b) {
8484  return (vector signed char)__builtin_altivec_vsro((vector int)__a,
8485  (vector int)__b);
8486 }
8487 
8488 static __inline__ vector signed char __ATTRS_o_ai
8489 vec_sro(vector signed char __a, vector unsigned char __b) {
8490  return (vector signed char)__builtin_altivec_vsro((vector int)__a,
8491  (vector int)__b);
8492 }
8493 
8494 static __inline__ vector unsigned char __ATTRS_o_ai
8495 vec_sro(vector unsigned char __a, vector signed char __b) {
8496  return (vector unsigned char)__builtin_altivec_vsro((vector int)__a,
8497  (vector int)__b);
8498 }
8499 
8500 static __inline__ vector unsigned char __ATTRS_o_ai
8501 vec_sro(vector unsigned char __a, vector unsigned char __b) {
8502  return (vector unsigned char)__builtin_altivec_vsro((vector int)__a,
8503  (vector int)__b);
8504 }
8505 
8506 static __inline__ vector short __ATTRS_o_ai vec_sro(vector short __a,
8507  vector signed char __b) {
8508  return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
8509 }
8510 
8511 static __inline__ vector short __ATTRS_o_ai vec_sro(vector short __a,
8512  vector unsigned char __b) {
8513  return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
8514 }
8515 
8516 static __inline__ vector unsigned short __ATTRS_o_ai
8517 vec_sro(vector unsigned short __a, vector signed char __b) {
8518  return (vector unsigned short)__builtin_altivec_vsro((vector int)__a,
8519  (vector int)__b);
8520 }
8521 
8522 static __inline__ vector unsigned short __ATTRS_o_ai
8523 vec_sro(vector unsigned short __a, vector unsigned char __b) {
8524  return (vector unsigned short)__builtin_altivec_vsro((vector int)__a,
8525  (vector int)__b);
8526 }
8527 
8528 static __inline__ vector pixel __ATTRS_o_ai vec_sro(vector pixel __a,
8529  vector signed char __b) {
8530  return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
8531 }
8532 
8533 static __inline__ vector pixel __ATTRS_o_ai vec_sro(vector pixel __a,
8534  vector unsigned char __b) {
8535  return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
8536 }
8537 
8538 static __inline__ vector int __ATTRS_o_ai vec_sro(vector int __a,
8539  vector signed char __b) {
8540  return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
8541 }
8542 
8543 static __inline__ vector int __ATTRS_o_ai vec_sro(vector int __a,
8544  vector unsigned char __b) {
8545  return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
8546 }
8547 
8548 static __inline__ vector unsigned int __ATTRS_o_ai
8549 vec_sro(vector unsigned int __a, vector signed char __b) {
8550  return (vector unsigned int)__builtin_altivec_vsro((vector int)__a,
8551  (vector int)__b);
8552 }
8553 
8554 static __inline__ vector unsigned int __ATTRS_o_ai
8555 vec_sro(vector unsigned int __a, vector unsigned char __b) {
8556  return (vector unsigned int)__builtin_altivec_vsro((vector int)__a,
8557  (vector int)__b);
8558 }
8559 
8560 static __inline__ vector float __ATTRS_o_ai vec_sro(vector float __a,
8561  vector signed char __b) {
8562  return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
8563 }
8564 
8565 static __inline__ vector float __ATTRS_o_ai vec_sro(vector float __a,
8566  vector unsigned char __b) {
8567  return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
8568 }
8569 
8570 /* vec_vsro */
8571 
8572 static __inline__ vector signed char __ATTRS_o_ai
8573 vec_vsro(vector signed char __a, vector signed char __b) {
8574  return (vector signed char)__builtin_altivec_vsro((vector int)__a,
8575  (vector int)__b);
8576 }
8577 
8578 static __inline__ vector signed char __ATTRS_o_ai
8579 vec_vsro(vector signed char __a, vector unsigned char __b) {
8580  return (vector signed char)__builtin_altivec_vsro((vector int)__a,
8581  (vector int)__b);
8582 }
8583 
8584 static __inline__ vector unsigned char __ATTRS_o_ai
8585 vec_vsro(vector unsigned char __a, vector signed char __b) {
8586  return (vector unsigned char)__builtin_altivec_vsro((vector int)__a,
8587  (vector int)__b);
8588 }
8589 
8590 static __inline__ vector unsigned char __ATTRS_o_ai
8591 vec_vsro(vector unsigned char __a, vector unsigned char __b) {
8592  return (vector unsigned char)__builtin_altivec_vsro((vector int)__a,
8593  (vector int)__b);
8594 }
8595 
8596 static __inline__ vector short __ATTRS_o_ai vec_vsro(vector short __a,
8597  vector signed char __b) {
8598  return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
8599 }
8600 
8601 static __inline__ vector short __ATTRS_o_ai vec_vsro(vector short __a,
8602  vector unsigned char __b) {
8603  return (vector short)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
8604 }
8605 
8606 static __inline__ vector unsigned short __ATTRS_o_ai
8607 vec_vsro(vector unsigned short __a, vector signed char __b) {
8608  return (vector unsigned short)__builtin_altivec_vsro((vector int)__a,
8609  (vector int)__b);
8610 }
8611 
8612 static __inline__ vector unsigned short __ATTRS_o_ai
8613 vec_vsro(vector unsigned short __a, vector unsigned char __b) {
8614  return (vector unsigned short)__builtin_altivec_vsro((vector int)__a,
8615  (vector int)__b);
8616 }
8617 
8618 static __inline__ vector pixel __ATTRS_o_ai vec_vsro(vector pixel __a,
8619  vector signed char __b) {
8620  return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
8621 }
8622 
8623 static __inline__ vector pixel __ATTRS_o_ai vec_vsro(vector pixel __a,
8624  vector unsigned char __b) {
8625  return (vector pixel)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
8626 }
8627 
8628 static __inline__ vector int __ATTRS_o_ai vec_vsro(vector int __a,
8629  vector signed char __b) {
8630  return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
8631 }
8632 
8633 static __inline__ vector int __ATTRS_o_ai vec_vsro(vector int __a,
8634  vector unsigned char __b) {
8635  return (vector int)__builtin_altivec_vsro(__a, (vector int)__b);
8636 }
8637 
8638 static __inline__ vector unsigned int __ATTRS_o_ai
8639 vec_vsro(vector unsigned int __a, vector signed char __b) {
8640  return (vector unsigned int)__builtin_altivec_vsro((vector int)__a,
8641  (vector int)__b);
8642 }
8643 
8644 static __inline__ vector unsigned int __ATTRS_o_ai
8645 vec_vsro(vector unsigned int __a, vector unsigned char __b) {
8646  return (vector unsigned int)__builtin_altivec_vsro((vector int)__a,
8647  (vector int)__b);
8648 }
8649 
8650 static __inline__ vector float __ATTRS_o_ai vec_vsro(vector float __a,
8651  vector signed char __b) {
8652  return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
8653 }
8654 
8655 static __inline__ vector float __ATTRS_o_ai vec_vsro(vector float __a,
8656  vector unsigned char __b) {
8657  return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
8658 }
8659 
8660 /* vec_st */
8661 
8662 static __inline__ void __ATTRS_o_ai vec_st(vector signed char __a, int __b,
8663  vector signed char *__c) {
8664  __builtin_altivec_stvx((vector int)__a, __b, __c);
8665 }
8666 
8667 static __inline__ void __ATTRS_o_ai vec_st(vector signed char __a, int __b,
8668  signed char *__c) {
8669  __builtin_altivec_stvx((vector int)__a, __b, __c);
8670 }
8671 
8672 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned char __a, int __b,
8673  vector unsigned char *__c) {
8674  __builtin_altivec_stvx((vector int)__a, __b, __c);
8675 }
8676 
8677 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned char __a, int __b,
8678  unsigned char *__c) {
8679  __builtin_altivec_stvx((vector int)__a, __b, __c);
8680 }
8681 
8682 static __inline__ void __ATTRS_o_ai vec_st(vector bool char __a, int __b,
8683  signed char *__c) {
8684  __builtin_altivec_stvx((vector int)__a, __b, __c);
8685 }
8686 
8687 static __inline__ void __ATTRS_o_ai vec_st(vector bool char __a, int __b,
8688  unsigned char *__c) {
8689  __builtin_altivec_stvx((vector int)__a, __b, __c);
8690 }
8691 
8692 static __inline__ void __ATTRS_o_ai vec_st(vector bool char __a, int __b,
8693  vector bool char *__c) {
8694  __builtin_altivec_stvx((vector int)__a, __b, __c);
8695 }
8696 
8697 static __inline__ void __ATTRS_o_ai vec_st(vector short __a, int __b,
8698  vector short *__c) {
8699  __builtin_altivec_stvx((vector int)__a, __b, __c);
8700 }
8701 
8702 static __inline__ void __ATTRS_o_ai vec_st(vector short __a, int __b,
8703  short *__c) {
8704  __builtin_altivec_stvx((vector int)__a, __b, __c);
8705 }
8706 
8707 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned short __a, int __b,
8708  vector unsigned short *__c) {
8709  __builtin_altivec_stvx((vector int)__a, __b, __c);
8710 }
8711 
8712 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned short __a, int __b,
8713  unsigned short *__c) {
8714  __builtin_altivec_stvx((vector int)__a, __b, __c);
8715 }
8716 
8717 static __inline__ void __ATTRS_o_ai vec_st(vector bool short __a, int __b,
8718  short *__c) {
8719  __builtin_altivec_stvx((vector int)__a, __b, __c);
8720 }
8721 
8722 static __inline__ void __ATTRS_o_ai vec_st(vector bool short __a, int __b,
8723  unsigned short *__c) {
8724  __builtin_altivec_stvx((vector int)__a, __b, __c);
8725 }
8726 
8727 static __inline__ void __ATTRS_o_ai vec_st(vector bool short __a, int __b,
8728  vector bool short *__c) {
8729  __builtin_altivec_stvx((vector int)__a, __b, __c);
8730 }
8731 
8732 static __inline__ void __ATTRS_o_ai vec_st(vector pixel __a, int __b,
8733  short *__c) {
8734  __builtin_altivec_stvx((vector int)__a, __b, __c);
8735 }
8736 
8737 static __inline__ void __ATTRS_o_ai vec_st(vector pixel __a, int __b,
8738  unsigned short *__c) {
8739  __builtin_altivec_stvx((vector int)__a, __b, __c);
8740 }
8741 
8742 static __inline__ void __ATTRS_o_ai vec_st(vector pixel __a, int __b,
8743  vector pixel *__c) {
8744  __builtin_altivec_stvx((vector int)__a, __b, __c);
8745 }
8746 
8747 static __inline__ void __ATTRS_o_ai vec_st(vector int __a, int __b,
8748  vector int *__c) {
8749  __builtin_altivec_stvx(__a, __b, __c);
8750 }
8751 
8752 static __inline__ void __ATTRS_o_ai vec_st(vector int __a, int __b, int *__c) {
8753  __builtin_altivec_stvx(__a, __b, __c);
8754 }
8755 
8756 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned int __a, int __b,
8757  vector unsigned int *__c) {
8758  __builtin_altivec_stvx((vector int)__a, __b, __c);
8759 }
8760 
8761 static __inline__ void __ATTRS_o_ai vec_st(vector unsigned int __a, int __b,
8762  unsigned int *__c) {
8763  __builtin_altivec_stvx((vector int)__a, __b, __c);
8764 }
8765 
8766 static __inline__ void __ATTRS_o_ai vec_st(vector bool int __a, int __b,
8767  int *__c) {
8768  __builtin_altivec_stvx((vector int)__a, __b, __c);
8769 }
8770 
8771 static __inline__ void __ATTRS_o_ai vec_st(vector bool int __a, int __b,
8772  unsigned int *__c) {
8773  __builtin_altivec_stvx((vector int)__a, __b, __c);
8774 }
8775 
8776 static __inline__ void __ATTRS_o_ai vec_st(vector bool int __a, int __b,
8777  vector bool int *__c) {
8778  __builtin_altivec_stvx((vector int)__a, __b, __c);
8779 }
8780 
8781 static __inline__ void __ATTRS_o_ai vec_st(vector float __a, int __b,
8782  vector float *__c) {
8783  __builtin_altivec_stvx((vector int)__a, __b, __c);
8784 }
8785 
8786 static __inline__ void __ATTRS_o_ai vec_st(vector float __a, int __b,
8787  float *__c) {
8788  __builtin_altivec_stvx((vector int)__a, __b, __c);
8789 }
8790 
8791 /* vec_stvx */
8792 
8793 static __inline__ void __ATTRS_o_ai vec_stvx(vector signed char __a, int __b,
8794  vector signed char *__c) {
8795  __builtin_altivec_stvx((vector int)__a, __b, __c);
8796 }
8797 
8798 static __inline__ void __ATTRS_o_ai vec_stvx(vector signed char __a, int __b,
8799  signed char *__c) {
8800  __builtin_altivec_stvx((vector int)__a, __b, __c);
8801 }
8802 
8803 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned char __a, int __b,
8804  vector unsigned char *__c) {
8805  __builtin_altivec_stvx((vector int)__a, __b, __c);
8806 }
8807 
8808 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned char __a, int __b,
8809  unsigned char *__c) {
8810  __builtin_altivec_stvx((vector int)__a, __b, __c);
8811 }
8812 
8813 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool char __a, int __b,
8814  signed char *__c) {
8815  __builtin_altivec_stvx((vector int)__a, __b, __c);
8816 }
8817 
8818 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool char __a, int __b,
8819  unsigned char *__c) {
8820  __builtin_altivec_stvx((vector int)__a, __b, __c);
8821 }
8822 
8823 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool char __a, int __b,
8824  vector bool char *__c) {
8825  __builtin_altivec_stvx((vector int)__a, __b, __c);
8826 }
8827 
8828 static __inline__ void __ATTRS_o_ai vec_stvx(vector short __a, int __b,
8829  vector short *__c) {
8830  __builtin_altivec_stvx((vector int)__a, __b, __c);
8831 }
8832 
8833 static __inline__ void __ATTRS_o_ai vec_stvx(vector short __a, int __b,
8834  short *__c) {
8835  __builtin_altivec_stvx((vector int)__a, __b, __c);
8836 }
8837 
8838 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned short __a, int __b,
8839  vector unsigned short *__c) {
8840  __builtin_altivec_stvx((vector int)__a, __b, __c);
8841 }
8842 
8843 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned short __a, int __b,
8844  unsigned short *__c) {
8845  __builtin_altivec_stvx((vector int)__a, __b, __c);
8846 }
8847 
8848 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool short __a, int __b,
8849  short *__c) {
8850  __builtin_altivec_stvx((vector int)__a, __b, __c);
8851 }
8852 
8853 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool short __a, int __b,
8854  unsigned short *__c) {
8855  __builtin_altivec_stvx((vector int)__a, __b, __c);
8856 }
8857 
8858 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool short __a, int __b,
8859  vector bool short *__c) {
8860  __builtin_altivec_stvx((vector int)__a, __b, __c);
8861 }
8862 
8863 static __inline__ void __ATTRS_o_ai vec_stvx(vector pixel __a, int __b,
8864  short *__c) {
8865  __builtin_altivec_stvx((vector int)__a, __b, __c);
8866 }
8867 
8868 static __inline__ void __ATTRS_o_ai vec_stvx(vector pixel __a, int __b,
8869  unsigned short *__c) {
8870  __builtin_altivec_stvx((vector int)__a, __b, __c);
8871 }
8872 
8873 static __inline__ void __ATTRS_o_ai vec_stvx(vector pixel __a, int __b,
8874  vector pixel *__c) {
8875  __builtin_altivec_stvx((vector int)__a, __b, __c);
8876 }
8877 
8878 static __inline__ void __ATTRS_o_ai vec_stvx(vector int __a, int __b,
8879  vector int *__c) {
8880  __builtin_altivec_stvx(__a, __b, __c);
8881 }
8882 
8883 static __inline__ void __ATTRS_o_ai vec_stvx(vector int __a, int __b,
8884  int *__c) {
8885  __builtin_altivec_stvx(__a, __b, __c);
8886 }
8887 
8888 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned int __a, int __b,
8889  vector unsigned int *__c) {
8890  __builtin_altivec_stvx((vector int)__a, __b, __c);
8891 }
8892 
8893 static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned int __a, int __b,
8894  unsigned int *__c) {
8895  __builtin_altivec_stvx((vector int)__a, __b, __c);
8896 }
8897 
8898 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool int __a, int __b,
8899  int *__c) {
8900  __builtin_altivec_stvx((vector int)__a, __b, __c);
8901 }
8902 
8903 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool int __a, int __b,
8904  unsigned int *__c) {
8905  __builtin_altivec_stvx((vector int)__a, __b, __c);
8906 }
8907 
8908 static __inline__ void __ATTRS_o_ai vec_stvx(vector bool int __a, int __b,
8909  vector bool int *__c) {
8910  __builtin_altivec_stvx((vector int)__a, __b, __c);
8911 }
8912 
8913 static __inline__ void __ATTRS_o_ai vec_stvx(vector float __a, int __b,
8914  vector float *__c) {
8915  __builtin_altivec_stvx((vector int)__a, __b, __c);
8916 }
8917 
8918 static __inline__ void __ATTRS_o_ai vec_stvx(vector float __a, int __b,
8919  float *__c) {
8920  __builtin_altivec_stvx((vector int)__a, __b, __c);
8921 }
8922 
8923 /* vec_ste */
8924 
8925 static __inline__ void __ATTRS_o_ai vec_ste(vector signed char __a, int __b,
8926  signed char *__c) {
8927  __builtin_altivec_stvebx((vector char)__a, __b, __c);
8928 }
8929 
8930 static __inline__ void __ATTRS_o_ai vec_ste(vector unsigned char __a, int __b,
8931  unsigned char *__c) {
8932  __builtin_altivec_stvebx((vector char)__a, __b, __c);
8933 }
8934 
8935 static __inline__ void __ATTRS_o_ai vec_ste(vector bool char __a, int __b,
8936  signed char *__c) {
8937  __builtin_altivec_stvebx((vector char)__a, __b, __c);
8938 }
8939 
8940 static __inline__ void __ATTRS_o_ai vec_ste(vector bool char __a, int __b,
8941  unsigned char *__c) {
8942  __builtin_altivec_stvebx((vector char)__a, __b, __c);
8943 }
8944 
8945 static __inline__ void __ATTRS_o_ai vec_ste(vector short __a, int __b,
8946  short *__c) {
8947  __builtin_altivec_stvehx(__a, __b, __c);
8948 }
8949 
8950 static __inline__ void __ATTRS_o_ai vec_ste(vector unsigned short __a, int __b,
8951  unsigned short *__c) {
8952  __builtin_altivec_stvehx((vector short)__a, __b, __c);
8953 }
8954 
8955 static __inline__ void __ATTRS_o_ai vec_ste(vector bool short __a, int __b,
8956  short *__c) {
8957  __builtin_altivec_stvehx((vector short)__a, __b, __c);
8958 }
8959 
8960 static __inline__ void __ATTRS_o_ai vec_ste(vector bool short __a, int __b,
8961  unsigned short *__c) {
8962  __builtin_altivec_stvehx((vector short)__a, __b, __c);
8963 }
8964 
8965 static __inline__ void __ATTRS_o_ai vec_ste(vector pixel __a, int __b,
8966  short *__c) {
8967  __builtin_altivec_stvehx((vector short)__a, __b, __c);
8968 }
8969 
8970 static __inline__ void __ATTRS_o_ai vec_ste(vector pixel __a, int __b,
8971  unsigned short *__c) {
8972  __builtin_altivec_stvehx((vector short)__a, __b, __c);
8973 }
8974 
8975 static __inline__ void __ATTRS_o_ai vec_ste(vector int __a, int __b, int *__c) {
8976  __builtin_altivec_stvewx(__a, __b, __c);
8977 }
8978 
8979 static __inline__ void __ATTRS_o_ai vec_ste(vector unsigned int __a, int __b,
8980  unsigned int *__c) {
8981  __builtin_altivec_stvewx((vector int)__a, __b, __c);
8982 }
8983 
8984 static __inline__ void __ATTRS_o_ai vec_ste(vector bool int __a, int __b,
8985  int *__c) {
8986  __builtin_altivec_stvewx((vector int)__a, __b, __c);
8987 }
8988 
8989 static __inline__ void __ATTRS_o_ai vec_ste(vector bool int __a, int __b,
8990  unsigned int *__c) {
8991  __builtin_altivec_stvewx((vector int)__a, __b, __c);
8992 }
8993 
8994 static __inline__ void __ATTRS_o_ai vec_ste(vector float __a, int __b,
8995  float *__c) {
8996  __builtin_altivec_stvewx((vector int)__a, __b, __c);
8997 }
8998 
8999 /* vec_stvebx */
9000 
9001 static __inline__ void __ATTRS_o_ai vec_stvebx(vector signed char __a, int __b,
9002  signed char *__c) {
9003  __builtin_altivec_stvebx((vector char)__a, __b, __c);
9004 }
9005 
9006 static __inline__ void __ATTRS_o_ai vec_stvebx(vector unsigned char __a,
9007  int __b, unsigned char *__c) {
9008  __builtin_altivec_stvebx((vector char)__a, __b, __c);
9009 }
9010 
9011 static __inline__ void __ATTRS_o_ai vec_stvebx(vector bool char __a, int __b,
9012  signed char *__c) {
9013  __builtin_altivec_stvebx((vector char)__a, __b, __c);
9014 }
9015 
9016 static __inline__ void __ATTRS_o_ai vec_stvebx(vector bool char __a, int __b,
9017  unsigned char *__c) {
9018  __builtin_altivec_stvebx((vector char)__a, __b, __c);
9019 }
9020 
9021 /* vec_stvehx */
9022 
9023 static __inline__ void __ATTRS_o_ai vec_stvehx(vector short __a, int __b,
9024  short *__c) {
9025  __builtin_altivec_stvehx(__a, __b, __c);
9026 }
9027 
9028 static __inline__ void __ATTRS_o_ai vec_stvehx(vector unsigned short __a,
9029  int __b, unsigned short *__c) {
9030  __builtin_altivec_stvehx((vector short)__a, __b, __c);
9031 }
9032 
9033 static __inline__ void __ATTRS_o_ai vec_stvehx(vector bool short __a, int __b,
9034  short *__c) {
9035  __builtin_altivec_stvehx((vector short)__a, __b, __c);
9036 }
9037 
9038 static __inline__ void __ATTRS_o_ai vec_stvehx(vector bool short __a, int __b,
9039  unsigned short *__c) {
9040  __builtin_altivec_stvehx((vector short)__a, __b, __c);
9041 }
9042 
9043 static __inline__ void __ATTRS_o_ai vec_stvehx(vector pixel __a, int __b,
9044  short *__c) {
9045  __builtin_altivec_stvehx((vector short)__a, __b, __c);
9046 }
9047 
9048 static __inline__ void __ATTRS_o_ai vec_stvehx(vector pixel __a, int __b,
9049  unsigned short *__c) {
9050  __builtin_altivec_stvehx((vector short)__a, __b, __c);
9051 }
9052 
9053 /* vec_stvewx */
9054 
9055 static __inline__ void __ATTRS_o_ai vec_stvewx(vector int __a, int __b,
9056  int *__c) {
9057  __builtin_altivec_stvewx(__a, __b, __c);
9058 }
9059 
9060 static __inline__ void __ATTRS_o_ai vec_stvewx(vector unsigned int __a, int __b,
9061  unsigned int *__c) {
9062  __builtin_altivec_stvewx((vector int)__a, __b, __c);
9063 }
9064 
9065 static __inline__ void __ATTRS_o_ai vec_stvewx(vector bool int __a, int __b,
9066  int *__c) {
9067  __builtin_altivec_stvewx((vector int)__a, __b, __c);
9068 }
9069 
9070 static __inline__ void __ATTRS_o_ai vec_stvewx(vector bool int __a, int __b,
9071  unsigned int *__c) {
9072  __builtin_altivec_stvewx((vector int)__a, __b, __c);
9073 }
9074 
9075 static __inline__ void __ATTRS_o_ai vec_stvewx(vector float __a, int __b,
9076  float *__c) {
9077  __builtin_altivec_stvewx((vector int)__a, __b, __c);
9078 }
9079 
9080 /* vec_stl */
9081 
9082 static __inline__ void __ATTRS_o_ai vec_stl(vector signed char __a, int __b,
9083  vector signed char *__c) {
9084  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9085 }
9086 
9087 static __inline__ void __ATTRS_o_ai vec_stl(vector signed char __a, int __b,
9088  signed char *__c) {
9089  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9090 }
9091 
9092 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned char __a, int __b,
9093  vector unsigned char *__c) {
9094  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9095 }
9096 
9097 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned char __a, int __b,
9098  unsigned char *__c) {
9099  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9100 }
9101 
9102 static __inline__ void __ATTRS_o_ai vec_stl(vector bool char __a, int __b,
9103  signed char *__c) {
9104  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9105 }
9106 
9107 static __inline__ void __ATTRS_o_ai vec_stl(vector bool char __a, int __b,
9108  unsigned char *__c) {
9109  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9110 }
9111 
9112 static __inline__ void __ATTRS_o_ai vec_stl(vector bool char __a, int __b,
9113  vector bool char *__c) {
9114  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9115 }
9116 
9117 static __inline__ void __ATTRS_o_ai vec_stl(vector short __a, int __b,
9118  vector short *__c) {
9119  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9120 }
9121 
9122 static __inline__ void __ATTRS_o_ai vec_stl(vector short __a, int __b,
9123  short *__c) {
9124  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9125 }
9126 
9127 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned short __a, int __b,
9128  vector unsigned short *__c) {
9129  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9130 }
9131 
9132 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned short __a, int __b,
9133  unsigned short *__c) {
9134  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9135 }
9136 
9137 static __inline__ void __ATTRS_o_ai vec_stl(vector bool short __a, int __b,
9138  short *__c) {
9139  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9140 }
9141 
9142 static __inline__ void __ATTRS_o_ai vec_stl(vector bool short __a, int __b,
9143  unsigned short *__c) {
9144  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9145 }
9146 
9147 static __inline__ void __ATTRS_o_ai vec_stl(vector bool short __a, int __b,
9148  vector bool short *__c) {
9149  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9150 }
9151 
9152 static __inline__ void __ATTRS_o_ai vec_stl(vector pixel __a, int __b,
9153  short *__c) {
9154  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9155 }
9156 
9157 static __inline__ void __ATTRS_o_ai vec_stl(vector pixel __a, int __b,
9158  unsigned short *__c) {
9159  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9160 }
9161 
9162 static __inline__ void __ATTRS_o_ai vec_stl(vector pixel __a, int __b,
9163  vector pixel *__c) {
9164  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9165 }
9166 
9167 static __inline__ void __ATTRS_o_ai vec_stl(vector int __a, int __b,
9168  vector int *__c) {
9169  __builtin_altivec_stvxl(__a, __b, __c);
9170 }
9171 
9172 static __inline__ void __ATTRS_o_ai vec_stl(vector int __a, int __b, int *__c) {
9173  __builtin_altivec_stvxl(__a, __b, __c);
9174 }
9175 
9176 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned int __a, int __b,
9177  vector unsigned int *__c) {
9178  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9179 }
9180 
9181 static __inline__ void __ATTRS_o_ai vec_stl(vector unsigned int __a, int __b,
9182  unsigned int *__c) {
9183  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9184 }
9185 
9186 static __inline__ void __ATTRS_o_ai vec_stl(vector bool int __a, int __b,
9187  int *__c) {
9188  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9189 }
9190 
9191 static __inline__ void __ATTRS_o_ai vec_stl(vector bool int __a, int __b,
9192  unsigned int *__c) {
9193  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9194 }
9195 
9196 static __inline__ void __ATTRS_o_ai vec_stl(vector bool int __a, int __b,
9197  vector bool int *__c) {
9198  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9199 }
9200 
9201 static __inline__ void __ATTRS_o_ai vec_stl(vector float __a, int __b,
9202  vector float *__c) {
9203  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9204 }
9205 
9206 static __inline__ void __ATTRS_o_ai vec_stl(vector float __a, int __b,
9207  float *__c) {
9208  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9209 }
9210 
9211 /* vec_stvxl */
9212 
9213 static __inline__ void __ATTRS_o_ai vec_stvxl(vector signed char __a, int __b,
9214  vector signed char *__c) {
9215  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9216 }
9217 
9218 static __inline__ void __ATTRS_o_ai vec_stvxl(vector signed char __a, int __b,
9219  signed char *__c) {
9220  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9221 }
9222 
9223 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned char __a, int __b,
9224  vector unsigned char *__c) {
9225  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9226 }
9227 
9228 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned char __a, int __b,
9229  unsigned char *__c) {
9230  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9231 }
9232 
9233 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool char __a, int __b,
9234  signed char *__c) {
9235  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9236 }
9237 
9238 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool char __a, int __b,
9239  unsigned char *__c) {
9240  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9241 }
9242 
9243 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool char __a, int __b,
9244  vector bool char *__c) {
9245  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9246 }
9247 
9248 static __inline__ void __ATTRS_o_ai vec_stvxl(vector short __a, int __b,
9249  vector short *__c) {
9250  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9251 }
9252 
9253 static __inline__ void __ATTRS_o_ai vec_stvxl(vector short __a, int __b,
9254  short *__c) {
9255  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9256 }
9257 
9258 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned short __a,
9259  int __b,
9260  vector unsigned short *__c) {
9261  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9262 }
9263 
9264 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned short __a,
9265  int __b, unsigned short *__c) {
9266  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9267 }
9268 
9269 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool short __a, int __b,
9270  short *__c) {
9271  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9272 }
9273 
9274 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool short __a, int __b,
9275  unsigned short *__c) {
9276  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9277 }
9278 
9279 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool short __a, int __b,
9280  vector bool short *__c) {
9281  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9282 }
9283 
9284 static __inline__ void __ATTRS_o_ai vec_stvxl(vector pixel __a, int __b,
9285  short *__c) {
9286  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9287 }
9288 
9289 static __inline__ void __ATTRS_o_ai vec_stvxl(vector pixel __a, int __b,
9290  unsigned short *__c) {
9291  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9292 }
9293 
9294 static __inline__ void __ATTRS_o_ai vec_stvxl(vector pixel __a, int __b,
9295  vector pixel *__c) {
9296  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9297 }
9298 
9299 static __inline__ void __ATTRS_o_ai vec_stvxl(vector int __a, int __b,
9300  vector int *__c) {
9301  __builtin_altivec_stvxl(__a, __b, __c);
9302 }
9303 
9304 static __inline__ void __ATTRS_o_ai vec_stvxl(vector int __a, int __b,
9305  int *__c) {
9306  __builtin_altivec_stvxl(__a, __b, __c);
9307 }
9308 
9309 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned int __a, int __b,
9310  vector unsigned int *__c) {
9311  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9312 }
9313 
9314 static __inline__ void __ATTRS_o_ai vec_stvxl(vector unsigned int __a, int __b,
9315  unsigned int *__c) {
9316  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9317 }
9318 
9319 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool int __a, int __b,
9320  int *__c) {
9321  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9322 }
9323 
9324 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool int __a, int __b,
9325  unsigned int *__c) {
9326  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9327 }
9328 
9329 static __inline__ void __ATTRS_o_ai vec_stvxl(vector bool int __a, int __b,
9330  vector bool int *__c) {
9331  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9332 }
9333 
9334 static __inline__ void __ATTRS_o_ai vec_stvxl(vector float __a, int __b,
9335  vector float *__c) {
9336  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9337 }
9338 
9339 static __inline__ void __ATTRS_o_ai vec_stvxl(vector float __a, int __b,
9340  float *__c) {
9341  __builtin_altivec_stvxl((vector int)__a, __b, __c);
9342 }
9343 
9344 /* vec_sub */
9345 
9346 static __inline__ vector signed char __ATTRS_o_ai
9347 vec_sub(vector signed char __a, vector signed char __b) {
9348  return __a - __b;
9349 }
9350 
9351 static __inline__ vector signed char __ATTRS_o_ai
9352 vec_sub(vector bool char __a, vector signed char __b) {
9353  return (vector signed char)__a - __b;
9354 }
9355 
9356 static __inline__ vector signed char __ATTRS_o_ai
9357 vec_sub(vector signed char __a, vector bool char __b) {
9358  return __a - (vector signed char)__b;
9359 }
9360 
9361 static __inline__ vector unsigned char __ATTRS_o_ai
9362 vec_sub(vector unsigned char __a, vector unsigned char __b) {
9363  return __a - __b;
9364 }
9365 
9366 static __inline__ vector unsigned char __ATTRS_o_ai
9367 vec_sub(vector bool char __a, vector unsigned char __b) {
9368  return (vector unsigned char)__a - __b;
9369 }
9370 
9371 static __inline__ vector unsigned char __ATTRS_o_ai
9372 vec_sub(vector unsigned char __a, vector bool char __b) {
9373  return __a - (vector unsigned char)__b;
9374 }
9375 
9376 static __inline__ vector short __ATTRS_o_ai vec_sub(vector short __a,
9377  vector short __b) {
9378  return __a - __b;
9379 }
9380 
9381 static __inline__ vector short __ATTRS_o_ai vec_sub(vector bool short __a,
9382  vector short __b) {
9383  return (vector short)__a - __b;
9384 }
9385 
9386 static __inline__ vector short __ATTRS_o_ai vec_sub(vector short __a,
9387  vector bool short __b) {
9388  return __a - (vector short)__b;
9389 }
9390 
9391 static __inline__ vector unsigned short __ATTRS_o_ai
9392 vec_sub(vector unsigned short __a, vector unsigned short __b) {
9393  return __a - __b;
9394 }
9395 
9396 static __inline__ vector unsigned short __ATTRS_o_ai
9397 vec_sub(vector bool short __a, vector unsigned short __b) {
9398  return (vector unsigned short)__a - __b;
9399 }
9400 
9401 static __inline__ vector unsigned short __ATTRS_o_ai
9402 vec_sub(vector unsigned short __a, vector bool short __b) {
9403  return __a - (vector unsigned short)__b;
9404 }
9405 
9406 static __inline__ vector int __ATTRS_o_ai vec_sub(vector int __a,
9407  vector int __b) {
9408  return __a - __b;
9409 }
9410 
9411 static __inline__ vector int __ATTRS_o_ai vec_sub(vector bool int __a,
9412  vector int __b) {
9413  return (vector int)__a - __b;
9414 }
9415 
9416 static __inline__ vector int __ATTRS_o_ai vec_sub(vector int __a,
9417  vector bool int __b) {
9418  return __a - (vector int)__b;
9419 }
9420 
9421 static __inline__ vector unsigned int __ATTRS_o_ai
9422 vec_sub(vector unsigned int __a, vector unsigned int __b) {
9423  return __a - __b;
9424 }
9425 
9426 static __inline__ vector unsigned int __ATTRS_o_ai
9427 vec_sub(vector bool int __a, vector unsigned int __b) {
9428  return (vector unsigned int)__a - __b;
9429 }
9430 
9431 static __inline__ vector unsigned int __ATTRS_o_ai
9432 vec_sub(vector unsigned int __a, vector bool int __b) {
9433  return __a - (vector unsigned int)__b;
9434 }
9435 
9436 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
9437 static __inline__ vector signed __int128 __ATTRS_o_ai
9438 vec_sub(vector signed __int128 __a, vector signed __int128 __b) {
9439  return __a - __b;
9440 }
9441 
9442 static __inline__ vector unsigned __int128 __ATTRS_o_ai
9443 vec_sub(vector unsigned __int128 __a, vector unsigned __int128 __b) {
9444  return __a - __b;
9445 }
9446 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
9447 
9448 #ifdef __VSX__
9449 static __inline__ vector signed long long __ATTRS_o_ai
9450 vec_sub(vector signed long long __a, vector signed long long __b) {
9451  return __a - __b;
9452 }
9453 
9454 static __inline__ vector unsigned long long __ATTRS_o_ai
9455 vec_sub(vector unsigned long long __a, vector unsigned long long __b) {
9456  return __a - __b;
9457 }
9458 
9459 static __inline__ vector double __ATTRS_o_ai vec_sub(vector double __a,
9460  vector double __b) {
9461  return __a - __b;
9462 }
9463 #endif
9464 
9465 static __inline__ vector float __ATTRS_o_ai vec_sub(vector float __a,
9466  vector float __b) {
9467  return __a - __b;
9468 }
9469 
9470 /* vec_vsububm */
9471 
9472 #define __builtin_altivec_vsububm vec_vsububm
9473 
9474 static __inline__ vector signed char __ATTRS_o_ai
9475 vec_vsububm(vector signed char __a, vector signed char __b) {
9476  return __a - __b;
9477 }
9478 
9479 static __inline__ vector signed char __ATTRS_o_ai
9480 vec_vsububm(vector bool char __a, vector signed char __b) {
9481  return (vector signed char)__a - __b;
9482 }
9483 
9484 static __inline__ vector signed char __ATTRS_o_ai
9485 vec_vsububm(vector signed char __a, vector bool char __b) {
9486  return __a - (vector signed char)__b;
9487 }
9488 
9489 static __inline__ vector unsigned char __ATTRS_o_ai
9490 vec_vsububm(vector unsigned char __a, vector unsigned char __b) {
9491  return __a - __b;
9492 }
9493 
9494 static __inline__ vector unsigned char __ATTRS_o_ai
9495 vec_vsububm(vector bool char __a, vector unsigned char __b) {
9496  return (vector unsigned char)__a - __b;
9497 }
9498 
9499 static __inline__ vector unsigned char __ATTRS_o_ai
9500 vec_vsububm(vector unsigned char __a, vector bool char __b) {
9501  return __a - (vector unsigned char)__b;
9502 }
9503 
9504 /* vec_vsubuhm */
9505 
9506 #define __builtin_altivec_vsubuhm vec_vsubuhm
9507 
9508 static __inline__ vector short __ATTRS_o_ai vec_vsubuhm(vector short __a,
9509  vector short __b) {
9510  return __a - __b;
9511 }
9512 
9513 static __inline__ vector short __ATTRS_o_ai vec_vsubuhm(vector bool short __a,
9514  vector short __b) {
9515  return (vector short)__a - __b;
9516 }
9517 
9518 static __inline__ vector short __ATTRS_o_ai vec_vsubuhm(vector short __a,
9519  vector bool short __b) {
9520  return __a - (vector short)__b;
9521 }
9522 
9523 static __inline__ vector unsigned short __ATTRS_o_ai
9524 vec_vsubuhm(vector unsigned short __a, vector unsigned short __b) {
9525  return __a - __b;
9526 }
9527 
9528 static __inline__ vector unsigned short __ATTRS_o_ai
9529 vec_vsubuhm(vector bool short __a, vector unsigned short __b) {
9530  return (vector unsigned short)__a - __b;
9531 }
9532 
9533 static __inline__ vector unsigned short __ATTRS_o_ai
9534 vec_vsubuhm(vector unsigned short __a, vector bool short __b) {
9535  return __a - (vector unsigned short)__b;
9536 }
9537 
9538 /* vec_vsubuwm */
9539 
9540 #define __builtin_altivec_vsubuwm vec_vsubuwm
9541 
9542 static __inline__ vector int __ATTRS_o_ai vec_vsubuwm(vector int __a,
9543  vector int __b) {
9544  return __a - __b;
9545 }
9546 
9547 static __inline__ vector int __ATTRS_o_ai vec_vsubuwm(vector bool int __a,
9548  vector int __b) {
9549  return (vector int)__a - __b;
9550 }
9551 
9552 static __inline__ vector int __ATTRS_o_ai vec_vsubuwm(vector int __a,
9553  vector bool int __b) {
9554  return __a - (vector int)__b;
9555 }
9556 
9557 static __inline__ vector unsigned int __ATTRS_o_ai
9558 vec_vsubuwm(vector unsigned int __a, vector unsigned int __b) {
9559  return __a - __b;
9560 }
9561 
9562 static __inline__ vector unsigned int __ATTRS_o_ai
9563 vec_vsubuwm(vector bool int __a, vector unsigned int __b) {
9564  return (vector unsigned int)__a - __b;
9565 }
9566 
9567 static __inline__ vector unsigned int __ATTRS_o_ai
9568 vec_vsubuwm(vector unsigned int __a, vector bool int __b) {
9569  return __a - (vector unsigned int)__b;
9570 }
9571 
9572 /* vec_vsubfp */
9573 
9574 #define __builtin_altivec_vsubfp vec_vsubfp
9575 
9576 static __inline__ vector float __attribute__((__always_inline__))
9577 vec_vsubfp(vector float __a, vector float __b) {
9578  return __a - __b;
9579 }
9580 
9581 /* vec_subc */
9582 
9583 static __inline__ vector unsigned int __ATTRS_o_ai
9584 vec_subc(vector unsigned int __a, vector unsigned int __b) {
9585  return __builtin_altivec_vsubcuw(__a, __b);
9586 }
9587 
9588 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
9589 static __inline__ vector unsigned __int128 __ATTRS_o_ai
9590 vec_subc(vector unsigned __int128 __a, vector unsigned __int128 __b) {
9591  return __builtin_altivec_vsubcuq(__a, __b);
9592 }
9593 
9594 static __inline__ vector signed __int128 __ATTRS_o_ai
9595 vec_subc(vector signed __int128 __a, vector signed __int128 __b) {
9596  return __builtin_altivec_vsubcuq(__a, __b);
9597 }
9598 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
9599 
9600 /* vec_vsubcuw */
9601 
9602 static __inline__ vector unsigned int __attribute__((__always_inline__))
9603 vec_vsubcuw(vector unsigned int __a, vector unsigned int __b) {
9604  return __builtin_altivec_vsubcuw(__a, __b);
9605 }
9606 
9607 /* vec_subs */
9608 
9609 static __inline__ vector signed char __ATTRS_o_ai
9610 vec_subs(vector signed char __a, vector signed char __b) {
9611  return __builtin_altivec_vsubsbs(__a, __b);
9612 }
9613 
9614 static __inline__ vector signed char __ATTRS_o_ai
9615 vec_subs(vector bool char __a, vector signed char __b) {
9616  return __builtin_altivec_vsubsbs((vector signed char)__a, __b);
9617 }
9618 
9619 static __inline__ vector signed char __ATTRS_o_ai
9620 vec_subs(vector signed char __a, vector bool char __b) {
9621  return __builtin_altivec_vsubsbs(__a, (vector signed char)__b);
9622 }
9623 
9624 static __inline__ vector unsigned char __ATTRS_o_ai
9625 vec_subs(vector unsigned char __a, vector unsigned char __b) {
9626  return __builtin_altivec_vsububs(__a, __b);
9627 }
9628 
9629 static __inline__ vector unsigned char __ATTRS_o_ai
9630 vec_subs(vector bool char __a, vector unsigned char __b) {
9631  return __builtin_altivec_vsububs((vector unsigned char)__a, __b);
9632 }
9633 
9634 static __inline__ vector unsigned char __ATTRS_o_ai
9635 vec_subs(vector unsigned char __a, vector bool char __b) {
9636  return __builtin_altivec_vsububs(__a, (vector unsigned char)__b);
9637 }
9638 
9639 static __inline__ vector short __ATTRS_o_ai vec_subs(vector short __a,
9640  vector short __b) {
9641  return __builtin_altivec_vsubshs(__a, __b);
9642 }
9643 
9644 static __inline__ vector short __ATTRS_o_ai vec_subs(vector bool short __a,
9645  vector short __b) {
9646  return __builtin_altivec_vsubshs((vector short)__a, __b);
9647 }
9648 
9649 static __inline__ vector short __ATTRS_o_ai vec_subs(vector short __a,
9650  vector bool short __b) {
9651  return __builtin_altivec_vsubshs(__a, (vector short)__b);
9652 }
9653 
9654 static __inline__ vector unsigned short __ATTRS_o_ai
9655 vec_subs(vector unsigned short __a, vector unsigned short __b) {
9656  return __builtin_altivec_vsubuhs(__a, __b);
9657 }
9658 
9659 static __inline__ vector unsigned short __ATTRS_o_ai
9660 vec_subs(vector bool short __a, vector unsigned short __b) {
9661  return __builtin_altivec_vsubuhs((vector unsigned short)__a, __b);
9662 }
9663 
9664 static __inline__ vector unsigned short __ATTRS_o_ai
9665 vec_subs(vector unsigned short __a, vector bool short __b) {
9666  return __builtin_altivec_vsubuhs(__a, (vector unsigned short)__b);
9667 }
9668 
9669 static __inline__ vector int __ATTRS_o_ai vec_subs(vector int __a,
9670  vector int __b) {
9671  return __builtin_altivec_vsubsws(__a, __b);
9672 }
9673 
9674 static __inline__ vector int __ATTRS_o_ai vec_subs(vector bool int __a,
9675  vector int __b) {
9676  return __builtin_altivec_vsubsws((vector int)__a, __b);
9677 }
9678 
9679 static __inline__ vector int __ATTRS_o_ai vec_subs(vector int __a,
9680  vector bool int __b) {
9681  return __builtin_altivec_vsubsws(__a, (vector int)__b);
9682 }
9683 
9684 static __inline__ vector unsigned int __ATTRS_o_ai
9685 vec_subs(vector unsigned int __a, vector unsigned int __b) {
9686  return __builtin_altivec_vsubuws(__a, __b);
9687 }
9688 
9689 static __inline__ vector unsigned int __ATTRS_o_ai
9690 vec_subs(vector bool int __a, vector unsigned int __b) {
9691  return __builtin_altivec_vsubuws((vector unsigned int)__a, __b);
9692 }
9693 
9694 static __inline__ vector unsigned int __ATTRS_o_ai
9695 vec_subs(vector unsigned int __a, vector bool int __b) {
9696  return __builtin_altivec_vsubuws(__a, (vector unsigned int)__b);
9697 }
9698 
9699 /* vec_vsubsbs */
9700 
9701 static __inline__ vector signed char __ATTRS_o_ai
9702 vec_vsubsbs(vector signed char __a, vector signed char __b) {
9703  return __builtin_altivec_vsubsbs(__a, __b);
9704 }
9705 
9706 static __inline__ vector signed char __ATTRS_o_ai
9707 vec_vsubsbs(vector bool char __a, vector signed char __b) {
9708  return __builtin_altivec_vsubsbs((vector signed char)__a, __b);
9709 }
9710 
9711 static __inline__ vector signed char __ATTRS_o_ai
9712 vec_vsubsbs(vector signed char __a, vector bool char __b) {
9713  return __builtin_altivec_vsubsbs(__a, (vector signed char)__b);
9714 }
9715 
9716 /* vec_vsububs */
9717 
9718 static __inline__ vector unsigned char __ATTRS_o_ai
9719 vec_vsububs(vector unsigned char __a, vector unsigned char __b) {
9720  return __builtin_altivec_vsububs(__a, __b);
9721 }
9722 
9723 static __inline__ vector unsigned char __ATTRS_o_ai
9724 vec_vsububs(vector bool char __a, vector unsigned char __b) {
9725  return __builtin_altivec_vsububs((vector unsigned char)__a, __b);
9726 }
9727 
9728 static __inline__ vector unsigned char __ATTRS_o_ai
9729 vec_vsububs(vector unsigned char __a, vector bool char __b) {
9730  return __builtin_altivec_vsububs(__a, (vector unsigned char)__b);
9731 }
9732 
9733 /* vec_vsubshs */
9734 
9735 static __inline__ vector short __ATTRS_o_ai vec_vsubshs(vector short __a,
9736  vector short __b) {
9737  return __builtin_altivec_vsubshs(__a, __b);
9738 }
9739 
9740 static __inline__ vector short __ATTRS_o_ai vec_vsubshs(vector bool short __a,
9741  vector short __b) {
9742  return __builtin_altivec_vsubshs((vector short)__a, __b);
9743 }
9744 
9745 static __inline__ vector short __ATTRS_o_ai vec_vsubshs(vector short __a,
9746  vector bool short __b) {
9747  return __builtin_altivec_vsubshs(__a, (vector short)__b);
9748 }
9749 
9750 /* vec_vsubuhs */
9751 
9752 static __inline__ vector unsigned short __ATTRS_o_ai
9753 vec_vsubuhs(vector unsigned short __a, vector unsigned short __b) {
9754  return __builtin_altivec_vsubuhs(__a, __b);
9755 }
9756 
9757 static __inline__ vector unsigned short __ATTRS_o_ai
9758 vec_vsubuhs(vector bool short __a, vector unsigned short __b) {
9759  return __builtin_altivec_vsubuhs((vector unsigned short)__a, __b);
9760 }
9761 
9762 static __inline__ vector unsigned short __ATTRS_o_ai
9763 vec_vsubuhs(vector unsigned short __a, vector bool short __b) {
9764  return __builtin_altivec_vsubuhs(__a, (vector unsigned short)__b);
9765 }
9766 
9767 /* vec_vsubsws */
9768 
9769 static __inline__ vector int __ATTRS_o_ai vec_vsubsws(vector int __a,
9770  vector int __b) {
9771  return __builtin_altivec_vsubsws(__a, __b);
9772 }
9773 
9774 static __inline__ vector int __ATTRS_o_ai vec_vsubsws(vector bool int __a,
9775  vector int __b) {
9776  return __builtin_altivec_vsubsws((vector int)__a, __b);
9777 }
9778 
9779 static __inline__ vector int __ATTRS_o_ai vec_vsubsws(vector int __a,
9780  vector bool int __b) {
9781  return __builtin_altivec_vsubsws(__a, (vector int)__b);
9782 }
9783 
9784 /* vec_vsubuws */
9785 
9786 static __inline__ vector unsigned int __ATTRS_o_ai
9787 vec_vsubuws(vector unsigned int __a, vector unsigned int __b) {
9788  return __builtin_altivec_vsubuws(__a, __b);
9789 }
9790 
9791 static __inline__ vector unsigned int __ATTRS_o_ai
9792 vec_vsubuws(vector bool int __a, vector unsigned int __b) {
9793  return __builtin_altivec_vsubuws((vector unsigned int)__a, __b);
9794 }
9795 
9796 static __inline__ vector unsigned int __ATTRS_o_ai
9797 vec_vsubuws(vector unsigned int __a, vector bool int __b) {
9798  return __builtin_altivec_vsubuws(__a, (vector unsigned int)__b);
9799 }
9800 
9801 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
9802 /* vec_vsubuqm */
9803 
9804 static __inline__ vector signed __int128 __ATTRS_o_ai
9805 vec_vsubuqm(vector signed __int128 __a, vector signed __int128 __b) {
9806  return __a - __b;
9807 }
9808 
9809 static __inline__ vector unsigned __int128 __ATTRS_o_ai
9810 vec_vsubuqm(vector unsigned __int128 __a, vector unsigned __int128 __b) {
9811  return __a - __b;
9812 }
9813 
9814 /* vec_vsubeuqm */
9815 
9816 static __inline__ vector signed __int128 __ATTRS_o_ai
9817 vec_vsubeuqm(vector signed __int128 __a, vector signed __int128 __b,
9818  vector signed __int128 __c) {
9819  return __builtin_altivec_vsubeuqm(__a, __b, __c);
9820 }
9821 
9822 static __inline__ vector unsigned __int128 __ATTRS_o_ai
9823 vec_vsubeuqm(vector unsigned __int128 __a, vector unsigned __int128 __b,
9824  vector unsigned __int128 __c) {
9825  return __builtin_altivec_vsubeuqm(__a, __b, __c);
9826 }
9827 
9828 /* vec_vsubcuq */
9829 
9830 static __inline__ vector signed __int128 __ATTRS_o_ai
9831 vec_vsubcuq(vector signed __int128 __a, vector signed __int128 __b) {
9832  return __builtin_altivec_vsubcuq(__a, __b);
9833 }
9834 
9835 static __inline__ vector unsigned __int128 __ATTRS_o_ai
9836 vec_vsubcuq(vector unsigned __int128 __a, vector unsigned __int128 __b) {
9837  return __builtin_altivec_vsubcuq(__a, __b);
9838 }
9839 
9840 /* vec_vsubecuq */
9841 
9842 static __inline__ vector signed __int128 __ATTRS_o_ai
9843 vec_vsubecuq(vector signed __int128 __a, vector signed __int128 __b,
9844  vector signed __int128 __c) {
9845  return __builtin_altivec_vsubecuq(__a, __b, __c);
9846 }
9847 
9848 static __inline__ vector unsigned __int128 __ATTRS_o_ai
9849 vec_vsubecuq(vector unsigned __int128 __a, vector unsigned __int128 __b,
9850  vector unsigned __int128 __c) {
9851  return __builtin_altivec_vsubecuq(__a, __b, __c);
9852 }
9853 #endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
9854 
9855 /* vec_sum4s */
9856 
9857 static __inline__ vector int __ATTRS_o_ai vec_sum4s(vector signed char __a,
9858  vector int __b) {
9859  return __builtin_altivec_vsum4sbs(__a, __b);
9860 }
9861 
9862 static __inline__ vector unsigned int __ATTRS_o_ai
9863 vec_sum4s(vector unsigned char __a, vector unsigned int __b) {
9864  return __builtin_altivec_vsum4ubs(__a, __b);
9865 }
9866 
9867 static __inline__ vector int __ATTRS_o_ai vec_sum4s(vector signed short __a,
9868  vector int __b) {
9869  return __builtin_altivec_vsum4shs(__a, __b);
9870 }
9871 
9872 /* vec_vsum4sbs */
9873 
9874 static __inline__ vector int __attribute__((__always_inline__))
9875 vec_vsum4sbs(vector signed char __a, vector int __b) {
9876  return __builtin_altivec_vsum4sbs(__a, __b);
9877 }
9878 
9879 /* vec_vsum4ubs */
9880 
9881 static __inline__ vector unsigned int __attribute__((__always_inline__))
9882 vec_vsum4ubs(vector unsigned char __a, vector unsigned int __b) {
9883  return __builtin_altivec_vsum4ubs(__a, __b);
9884 }
9885 
9886 /* vec_vsum4shs */
9887 
9888 static __inline__ vector int __attribute__((__always_inline__))
9889 vec_vsum4shs(vector signed short __a, vector int __b) {
9890  return __builtin_altivec_vsum4shs(__a, __b);
9891 }
9892 
9893 /* vec_sum2s */
9894 
9895 /* The vsum2sws instruction has a big-endian bias, so that the second
9896  input vector and the result always reference big-endian elements
9897  1 and 3 (little-endian element 0 and 2). For ease of porting the
9898  programmer wants elements 1 and 3 in both cases, so for little
9899  endian we must perform some permutes. */
9900 
9901 static __inline__ vector signed int __attribute__((__always_inline__))
9902 vec_sum2s(vector int __a, vector int __b) {
9903 #ifdef __LITTLE_ENDIAN__
9904  vector int __c = (vector signed int)vec_perm(
9905  __b, __b, (vector unsigned char)(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15,
9906  8, 9, 10, 11));
9907  __c = __builtin_altivec_vsum2sws(__a, __c);
9908  return (vector signed int)vec_perm(
9909  __c, __c, (vector unsigned char)(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15,
9910  8, 9, 10, 11));
9911 #else
9912  return __builtin_altivec_vsum2sws(__a, __b);
9913 #endif
9914 }
9915 
9916 /* vec_vsum2sws */
9917 
9918 static __inline__ vector signed int __attribute__((__always_inline__))
9919 vec_vsum2sws(vector int __a, vector int __b) {
9920 #ifdef __LITTLE_ENDIAN__
9921  vector int __c = (vector signed int)vec_perm(
9922  __b, __b, (vector unsigned char)(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15,
9923  8, 9, 10, 11));
9924  __c = __builtin_altivec_vsum2sws(__a, __c);
9925  return (vector signed int)vec_perm(
9926  __c, __c, (vector unsigned char)(4, 5, 6, 7, 0, 1, 2, 3, 12, 13, 14, 15,
9927  8, 9, 10, 11));
9928 #else
9929  return __builtin_altivec_vsum2sws(__a, __b);
9930 #endif
9931 }
9932 
9933 /* vec_sums */
9934 
9935 /* The vsumsws instruction has a big-endian bias, so that the second
9936  input vector and the result always reference big-endian element 3
9937  (little-endian element 0). For ease of porting the programmer
9938  wants element 3 in both cases, so for little endian we must perform
9939  some permutes. */
9940 
9941 static __inline__ vector signed int __attribute__((__always_inline__))
9942 vec_sums(vector signed int __a, vector signed int __b) {
9943 #ifdef __LITTLE_ENDIAN__
9944  __b = (vector signed int)vec_splat(__b, 3);
9945  __b = __builtin_altivec_vsumsws(__a, __b);
9946  return (vector signed int)(0, 0, 0, __b[0]);
9947 #else
9948  return __builtin_altivec_vsumsws(__a, __b);
9949 #endif
9950 }
9951 
9952 /* vec_vsumsws */
9953 
9954 static __inline__ vector signed int __attribute__((__always_inline__))
9955 vec_vsumsws(vector signed int __a, vector signed int __b) {
9956 #ifdef __LITTLE_ENDIAN__
9957  __b = (vector signed int)vec_splat(__b, 3);
9958  __b = __builtin_altivec_vsumsws(__a, __b);
9959  return (vector signed int)(0, 0, 0, __b[0]);
9960 #else
9961  return __builtin_altivec_vsumsws(__a, __b);
9962 #endif
9963 }
9964 
9965 /* vec_trunc */
9966 
9967 static __inline__ vector float __ATTRS_o_ai vec_trunc(vector float __a) {
9968 #ifdef __VSX__
9969  return __builtin_vsx_xvrspiz(__a);
9970 #else
9971  return __builtin_altivec_vrfiz(__a);
9972 #endif
9973 }
9974 
9975 #ifdef __VSX__
9976 static __inline__ vector double __ATTRS_o_ai vec_trunc(vector double __a) {
9977  return __builtin_vsx_xvrdpiz(__a);
9978 }
9979 #endif
9980 
9981 /* vec_vrfiz */
9982 
9983 static __inline__ vector float __attribute__((__always_inline__))
9984 vec_vrfiz(vector float __a) {
9985  return __builtin_altivec_vrfiz(__a);
9986 }
9987 
9988 /* vec_unpackh */
9989 
9990 /* The vector unpack instructions all have a big-endian bias, so for
9991  little endian we must reverse the meanings of "high" and "low." */
9992 
9993 static __inline__ vector short __ATTRS_o_ai
9994 vec_unpackh(vector signed char __a) {
9995 #ifdef __LITTLE_ENDIAN__
9996  return __builtin_altivec_vupklsb((vector char)__a);
9997 #else
9998  return __builtin_altivec_vupkhsb((vector char)__a);
9999 #endif
10000 }
10001 
10002 static __inline__ vector bool short __ATTRS_o_ai
10003 vec_unpackh(vector bool char __a) {
10004 #ifdef __LITTLE_ENDIAN__
10005  return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
10006 #else
10007  return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
10008 #endif
10009 }
10010 
10011 static __inline__ vector int __ATTRS_o_ai vec_unpackh(vector short __a) {
10012 #ifdef __LITTLE_ENDIAN__
10013  return __builtin_altivec_vupklsh(__a);
10014 #else
10015  return __builtin_altivec_vupkhsh(__a);
10016 #endif
10017 }
10018 
10019 static __inline__ vector bool int __ATTRS_o_ai
10020 vec_unpackh(vector bool short __a) {
10021 #ifdef __LITTLE_ENDIAN__
10022  return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
10023 #else
10024  return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
10025 #endif
10026 }
10027 
10028 static __inline__ vector unsigned int __ATTRS_o_ai
10029 vec_unpackh(vector pixel __a) {
10030 #ifdef __LITTLE_ENDIAN__
10031  return (vector unsigned int)__builtin_altivec_vupklpx((vector short)__a);
10032 #else
10033  return (vector unsigned int)__builtin_altivec_vupkhpx((vector short)__a);
10034 #endif
10035 }
10036 
10037 #ifdef __POWER8_VECTOR__
10038 static __inline__ vector long long __ATTRS_o_ai vec_unpackh(vector int __a) {
10039 #ifdef __LITTLE_ENDIAN__
10040  return __builtin_altivec_vupklsw(__a);
10041 #else
10042  return __builtin_altivec_vupkhsw(__a);
10043 #endif
10044 }
10045 
10046 static __inline__ vector bool long long __ATTRS_o_ai
10047 vec_unpackh(vector bool int __a) {
10048 #ifdef __LITTLE_ENDIAN__
10049  return (vector bool long long)__builtin_altivec_vupklsw((vector int)__a);
10050 #else
10051  return (vector bool long long)__builtin_altivec_vupkhsw((vector int)__a);
10052 #endif
10053 }
10054 #endif
10055 
10056 /* vec_vupkhsb */
10057 
10058 static __inline__ vector short __ATTRS_o_ai
10059 vec_vupkhsb(vector signed char __a) {
10060 #ifdef __LITTLE_ENDIAN__
10061  return __builtin_altivec_vupklsb((vector char)__a);
10062 #else
10063  return __builtin_altivec_vupkhsb((vector char)__a);
10064 #endif
10065 }
10066 
10067 static __inline__ vector bool short __ATTRS_o_ai
10068 vec_vupkhsb(vector bool char __a) {
10069 #ifdef __LITTLE_ENDIAN__
10070  return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
10071 #else
10072  return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
10073 #endif
10074 }
10075 
10076 /* vec_vupkhsh */
10077 
10078 static __inline__ vector int __ATTRS_o_ai vec_vupkhsh(vector short __a) {
10079 #ifdef __LITTLE_ENDIAN__
10080  return __builtin_altivec_vupklsh(__a);
10081 #else
10082  return __builtin_altivec_vupkhsh(__a);
10083 #endif
10084 }
10085 
10086 static __inline__ vector bool int __ATTRS_o_ai
10087 vec_vupkhsh(vector bool short __a) {
10088 #ifdef __LITTLE_ENDIAN__
10089  return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
10090 #else
10091  return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
10092 #endif
10093 }
10094 
10095 static __inline__ vector unsigned int __ATTRS_o_ai
10096 vec_vupkhsh(vector pixel __a) {
10097 #ifdef __LITTLE_ENDIAN__
10098  return (vector unsigned int)__builtin_altivec_vupklpx((vector short)__a);
10099 #else
10100  return (vector unsigned int)__builtin_altivec_vupkhpx((vector short)__a);
10101 #endif
10102 }
10103 
10104 /* vec_vupkhsw */
10105 
10106 #ifdef __POWER8_VECTOR__
10107 static __inline__ vector long long __ATTRS_o_ai vec_vupkhsw(vector int __a) {
10108 #ifdef __LITTLE_ENDIAN__
10109  return __builtin_altivec_vupklsw(__a);
10110 #else
10111  return __builtin_altivec_vupkhsw(__a);
10112 #endif
10113 }
10114 
10115 static __inline__ vector bool long long __ATTRS_o_ai
10116 vec_vupkhsw(vector bool int __a) {
10117 #ifdef __LITTLE_ENDIAN__
10118  return (vector bool long long)__builtin_altivec_vupklsw((vector int)__a);
10119 #else
10120  return (vector bool long long)__builtin_altivec_vupkhsw((vector int)__a);
10121 #endif
10122 }
10123 #endif
10124 
10125 /* vec_unpackl */
10126 
10127 static __inline__ vector short __ATTRS_o_ai
10128 vec_unpackl(vector signed char __a) {
10129 #ifdef __LITTLE_ENDIAN__
10130  return __builtin_altivec_vupkhsb((vector char)__a);
10131 #else
10132  return __builtin_altivec_vupklsb((vector char)__a);
10133 #endif
10134 }
10135 
10136 static __inline__ vector bool short __ATTRS_o_ai
10137 vec_unpackl(vector bool char __a) {
10138 #ifdef __LITTLE_ENDIAN__
10139  return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
10140 #else
10141  return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
10142 #endif
10143 }
10144 
10145 static __inline__ vector int __ATTRS_o_ai vec_unpackl(vector short __a) {
10146 #ifdef __LITTLE_ENDIAN__
10147  return __builtin_altivec_vupkhsh(__a);
10148 #else
10149  return __builtin_altivec_vupklsh(__a);
10150 #endif
10151 }
10152 
10153 static __inline__ vector bool int __ATTRS_o_ai
10154 vec_unpackl(vector bool short __a) {
10155 #ifdef __LITTLE_ENDIAN__
10156  return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
10157 #else
10158  return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
10159 #endif
10160 }
10161 
10162 static __inline__ vector unsigned int __ATTRS_o_ai
10163 vec_unpackl(vector pixel __a) {
10164 #ifdef __LITTLE_ENDIAN__
10165  return (vector unsigned int)__builtin_altivec_vupkhpx((vector short)__a);
10166 #else
10167  return (vector unsigned int)__builtin_altivec_vupklpx((vector short)__a);
10168 #endif
10169 }
10170 
10171 #ifdef __POWER8_VECTOR__
10172 static __inline__ vector long long __ATTRS_o_ai vec_unpackl(vector int __a) {
10173 #ifdef __LITTLE_ENDIAN__
10174  return __builtin_altivec_vupkhsw(__a);
10175 #else
10176  return __builtin_altivec_vupklsw(__a);
10177 #endif
10178 }
10179 
10180 static __inline__ vector bool long long __ATTRS_o_ai
10181 vec_unpackl(vector bool int __a) {
10182 #ifdef __LITTLE_ENDIAN__
10183  return (vector bool long long)__builtin_altivec_vupkhsw((vector int)__a);
10184 #else
10185  return (vector bool long long)__builtin_altivec_vupklsw((vector int)__a);
10186 #endif
10187 }
10188 #endif
10189 
10190 /* vec_vupklsb */
10191 
10192 static __inline__ vector short __ATTRS_o_ai
10193 vec_vupklsb(vector signed char __a) {
10194 #ifdef __LITTLE_ENDIAN__
10195  return __builtin_altivec_vupkhsb((vector char)__a);
10196 #else
10197  return __builtin_altivec_vupklsb((vector char)__a);
10198 #endif
10199 }
10200 
10201 static __inline__ vector bool short __ATTRS_o_ai
10202 vec_vupklsb(vector bool char __a) {
10203 #ifdef __LITTLE_ENDIAN__
10204  return (vector bool short)__builtin_altivec_vupkhsb((vector char)__a);
10205 #else
10206  return (vector bool short)__builtin_altivec_vupklsb((vector char)__a);
10207 #endif
10208 }
10209 
10210 /* vec_vupklsh */
10211 
10212 static __inline__ vector int __ATTRS_o_ai vec_vupklsh(vector short __a) {
10213 #ifdef __LITTLE_ENDIAN__
10214  return __builtin_altivec_vupkhsh(__a);
10215 #else
10216  return __builtin_altivec_vupklsh(__a);
10217 #endif
10218 }
10219 
10220 static __inline__ vector bool int __ATTRS_o_ai
10221 vec_vupklsh(vector bool short __a) {
10222 #ifdef __LITTLE_ENDIAN__
10223  return (vector bool int)__builtin_altivec_vupkhsh((vector short)__a);
10224 #else
10225  return (vector bool int)__builtin_altivec_vupklsh((vector short)__a);
10226 #endif
10227 }
10228 
10229 static __inline__ vector unsigned int __ATTRS_o_ai
10230 vec_vupklsh(vector pixel __a) {
10231 #ifdef __LITTLE_ENDIAN__
10232  return (vector unsigned int)__builtin_altivec_vupkhpx((vector short)__a);
10233 #else
10234  return (vector unsigned int)__builtin_altivec_vupklpx((vector short)__a);
10235 #endif
10236 }
10237 
10238 /* vec_vupklsw */
10239 
10240 #ifdef __POWER8_VECTOR__
10241 static __inline__ vector long long __ATTRS_o_ai vec_vupklsw(vector int __a) {
10242 #ifdef __LITTLE_ENDIAN__
10243  return __builtin_altivec_vupkhsw(__a);
10244 #else
10245  return __builtin_altivec_vupklsw(__a);
10246 #endif
10247 }
10248 
10249 static __inline__ vector bool long long __ATTRS_o_ai
10250 vec_vupklsw(vector bool int __a) {
10251 #ifdef __LITTLE_ENDIAN__
10252  return (vector bool long long)__builtin_altivec_vupkhsw((vector int)__a);
10253 #else
10254  return (vector bool long long)__builtin_altivec_vupklsw((vector int)__a);
10255 #endif
10256 }
10257 #endif
10258 
10259 /* vec_vsx_ld */
10260 
10261 #ifdef __VSX__
10262 
10263 static __inline__ vector bool int __ATTRS_o_ai
10264 vec_vsx_ld(int __a, const vector bool int *__b) {
10265  return (vector bool int)__builtin_vsx_lxvw4x(__a, __b);
10266 }
10267 
10268 static __inline__ vector signed int __ATTRS_o_ai
10269 vec_vsx_ld(int __a, const vector signed int *__b) {
10270  return (vector signed int)__builtin_vsx_lxvw4x(__a, __b);
10271 }
10272 
10273 static __inline__ vector signed int __ATTRS_o_ai
10274 vec_vsx_ld(int __a, const signed int *__b) {
10275  return (vector signed int)__builtin_vsx_lxvw4x(__a, __b);
10276 }
10277 
10278 static __inline__ vector unsigned int __ATTRS_o_ai
10279 vec_vsx_ld(int __a, const vector unsigned int *__b) {
10280  return (vector unsigned int)__builtin_vsx_lxvw4x(__a, __b);
10281 }
10282 
10283 static __inline__ vector unsigned int __ATTRS_o_ai
10284 vec_vsx_ld(int __a, const unsigned int *__b) {
10285  return (vector unsigned int)__builtin_vsx_lxvw4x(__a, __b);
10286 }
10287 
10288 static __inline__ vector float __ATTRS_o_ai
10289 vec_vsx_ld(int __a, const vector float *__b) {
10290  return (vector float)__builtin_vsx_lxvw4x(__a, __b);
10291 }
10292 
10293 static __inline__ vector float __ATTRS_o_ai vec_vsx_ld(int __a,
10294  const float *__b) {
10295  return (vector float)__builtin_vsx_lxvw4x(__a, __b);
10296 }
10297 
10298 static __inline__ vector signed long long __ATTRS_o_ai
10299 vec_vsx_ld(int __a, const vector signed long long *__b) {
10300  return (vector signed long long)__builtin_vsx_lxvd2x(__a, __b);
10301 }
10302 
10303 static __inline__ vector unsigned long long __ATTRS_o_ai
10304 vec_vsx_ld(int __a, const vector unsigned long long *__b) {
10305  return (vector unsigned long long)__builtin_vsx_lxvd2x(__a, __b);
10306 }
10307 
10308 static __inline__ vector double __ATTRS_o_ai
10309 vec_vsx_ld(int __a, const vector double *__b) {
10310  return (vector double)__builtin_vsx_lxvd2x(__a, __b);
10311 }
10312 
10313 static __inline__ vector double __ATTRS_o_ai
10314 vec_vsx_ld(int __a, const double *__b) {
10315  return (vector double)__builtin_vsx_lxvd2x(__a, __b);
10316 }
10317 
10318 static __inline__ vector bool short __ATTRS_o_ai
10319 vec_vsx_ld(int __a, const vector bool short *__b) {
10320  return (vector bool short)__builtin_vsx_lxvw4x(__a, __b);
10321 }
10322 
10323 static __inline__ vector signed short __ATTRS_o_ai
10324 vec_vsx_ld(int __a, const vector signed short *__b) {
10325  return (vector signed short)__builtin_vsx_lxvw4x(__a, __b);
10326 }
10327 
10328 static __inline__ vector signed short __ATTRS_o_ai
10329 vec_vsx_ld(int __a, const signed short *__b) {
10330  return (vector signed short)__builtin_vsx_lxvw4x(__a, __b);
10331 }
10332 
10333 static __inline__ vector unsigned short __ATTRS_o_ai
10334 vec_vsx_ld(int __a, const vector unsigned short *__b) {
10335  return (vector unsigned short)__builtin_vsx_lxvw4x(__a, __b);
10336 }
10337 
10338 static __inline__ vector unsigned short __ATTRS_o_ai
10339 vec_vsx_ld(int __a, const unsigned short *__b) {
10340  return (vector unsigned short)__builtin_vsx_lxvw4x(__a, __b);
10341 }
10342 
10343 static __inline__ vector bool char __ATTRS_o_ai
10344 vec_vsx_ld(int __a, const vector bool char *__b) {
10345  return (vector bool char)__builtin_vsx_lxvw4x(__a, __b);
10346 }
10347 
10348 static __inline__ vector signed char __ATTRS_o_ai
10349 vec_vsx_ld(int __a, const vector signed char *__b) {
10350  return (vector signed char)__builtin_vsx_lxvw4x(__a, __b);
10351 }
10352 
10353 static __inline__ vector signed char __ATTRS_o_ai
10354 vec_vsx_ld(int __a, const signed char *__b) {
10355  return (vector signed char)__builtin_vsx_lxvw4x(__a, __b);
10356 }
10357 
10358 static __inline__ vector unsigned char __ATTRS_o_ai
10359 vec_vsx_ld(int __a, const vector unsigned char *__b) {
10360  return (vector unsigned char)__builtin_vsx_lxvw4x(__a, __b);
10361 }
10362 
10363 static __inline__ vector unsigned char __ATTRS_o_ai
10364 vec_vsx_ld(int __a, const unsigned char *__b) {
10365  return (vector unsigned char)__builtin_vsx_lxvw4x(__a, __b);
10366 }
10367 
10368 #endif
10369 
10370 /* vec_vsx_st */
10371 
10372 #ifdef __VSX__
10373 
10374 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool int __a, int __b,
10375  vector bool int *__c) {
10376  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
10377 }
10378 
10379 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool int __a, int __b,
10380  signed int *__c) {
10381  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
10382 }
10383 
10384 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool int __a, int __b,
10385  unsigned int *__c) {
10386  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
10387 }
10388 
10389 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed int __a, int __b,
10390  vector signed int *__c) {
10391  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
10392 }
10393 
10394 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed int __a, int __b,
10395  signed int *__c) {
10396  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
10397 }
10398 
10399 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned int __a, int __b,
10400  vector unsigned int *__c) {
10401  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
10402 }
10403 
10404 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned int __a, int __b,
10405  unsigned int *__c) {
10406  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
10407 }
10408 
10409 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector float __a, int __b,
10410  vector float *__c) {
10411  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
10412 }
10413 
10414 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector float __a, int __b,
10415  float *__c) {
10416  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
10417 }
10418 
10419 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed long long __a,
10420  int __b,
10421  vector signed long long *__c) {
10422  __builtin_vsx_stxvd2x((vector double)__a, __b, __c);
10423 }
10424 
10425 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned long long __a,
10426  int __b,
10427  vector unsigned long long *__c) {
10428  __builtin_vsx_stxvd2x((vector double)__a, __b, __c);
10429 }
10430 
10431 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector double __a, int __b,
10432  vector double *__c) {
10433  __builtin_vsx_stxvd2x((vector double)__a, __b, __c);
10434 }
10435 
10436 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector double __a, int __b,
10437  double *__c) {
10438  __builtin_vsx_stxvd2x((vector double)__a, __b, __c);
10439 }
10440 
10441 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool short __a, int __b,
10442  vector bool short *__c) {
10443  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
10444 }
10445 
10446 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool short __a, int __b,
10447  signed short *__c) {
10448  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
10449 }
10450 
10451 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool short __a, int __b,
10452  unsigned short *__c) {
10453  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
10454 }
10455 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed short __a, int __b,
10456  vector signed short *__c) {
10457  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
10458 }
10459 
10460 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed short __a, int __b,
10461  signed short *__c) {
10462  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
10463 }
10464 
10465 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned short __a,
10466  int __b,
10467  vector unsigned short *__c) {
10468  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
10469 }
10470 
10471 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned short __a,
10472  int __b, unsigned short *__c) {
10473  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
10474 }
10475 
10476 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool char __a, int __b,
10477  vector bool char *__c) {
10478  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
10479 }
10480 
10481 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool char __a, int __b,
10482  signed char *__c) {
10483  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
10484 }
10485 
10486 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector bool char __a, int __b,
10487  unsigned char *__c) {
10488  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
10489 }
10490 
10491 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed char __a, int __b,
10492  vector signed char *__c) {
10493  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
10494 }
10495 
10496 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector signed char __a, int __b,
10497  signed char *__c) {
10498  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
10499 }
10500 
10501 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned char __a,
10502  int __b,
10503  vector unsigned char *__c) {
10504  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
10505 }
10506 
10507 static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned char __a,
10508  int __b, unsigned char *__c) {
10509  __builtin_vsx_stxvw4x((vector int)__a, __b, __c);
10510 }
10511 
10512 #endif
10513 
10514 /* vec_xor */
10515 
10516 #define __builtin_altivec_vxor vec_xor
10517 
10518 static __inline__ vector signed char __ATTRS_o_ai
10519 vec_xor(vector signed char __a, vector signed char __b) {
10520  return __a ^ __b;
10521 }
10522 
10523 static __inline__ vector signed char __ATTRS_o_ai
10524 vec_xor(vector bool char __a, vector signed char __b) {
10525  return (vector signed char)__a ^ __b;
10526 }
10527 
10528 static __inline__ vector signed char __ATTRS_o_ai
10529 vec_xor(vector signed char __a, vector bool char __b) {
10530  return __a ^ (vector signed char)__b;
10531 }
10532 
10533 static __inline__ vector unsigned char __ATTRS_o_ai
10534 vec_xor(vector unsigned char __a, vector unsigned char __b) {
10535  return __a ^ __b;
10536 }
10537 
10538 static __inline__ vector unsigned char __ATTRS_o_ai
10539 vec_xor(vector bool char __a, vector unsigned char __b) {
10540  return (vector unsigned char)__a ^ __b;
10541 }
10542 
10543 static __inline__ vector unsigned char __ATTRS_o_ai
10544 vec_xor(vector unsigned char __a, vector bool char __b) {
10545  return __a ^ (vector unsigned char)__b;
10546 }
10547 
10548 static __inline__ vector bool char __ATTRS_o_ai vec_xor(vector bool char __a,
10549  vector bool char __b) {
10550  return __a ^ __b;
10551 }
10552 
10553 static __inline__ vector short __ATTRS_o_ai vec_xor(vector short __a,
10554  vector short __b) {
10555  return __a ^ __b;
10556 }
10557 
10558 static __inline__ vector short __ATTRS_o_ai vec_xor(vector bool short __a,
10559  vector short __b) {
10560  return (vector short)__a ^ __b;
10561 }
10562 
10563 static __inline__ vector short __ATTRS_o_ai vec_xor(vector short __a,
10564  vector bool short __b) {
10565  return __a ^ (vector short)__b;
10566 }
10567 
10568 static __inline__ vector unsigned short __ATTRS_o_ai
10569 vec_xor(vector unsigned short __a, vector unsigned short __b) {
10570  return __a ^ __b;
10571 }
10572 
10573 static __inline__ vector unsigned short __ATTRS_o_ai
10574 vec_xor(vector bool short __a, vector unsigned short __b) {
10575  return (vector unsigned short)__a ^ __b;
10576 }
10577 
10578 static __inline__ vector unsigned short __ATTRS_o_ai
10579 vec_xor(vector unsigned short __a, vector bool short __b) {
10580  return __a ^ (vector unsigned short)__b;
10581 }
10582 
10583 static __inline__ vector bool short __ATTRS_o_ai
10584 vec_xor(vector bool short __a, vector bool short __b) {
10585  return __a ^ __b;
10586 }
10587 
10588 static __inline__ vector int __ATTRS_o_ai vec_xor(vector int __a,
10589  vector int __b) {
10590  return __a ^ __b;
10591 }
10592 
10593 static __inline__ vector int __ATTRS_o_ai vec_xor(vector bool int __a,
10594  vector int __b) {
10595  return (vector int)__a ^ __b;
10596 }
10597 
10598 static __inline__ vector int __ATTRS_o_ai vec_xor(vector int __a,
10599  vector bool int __b) {
10600  return __a ^ (vector int)__b;
10601 }
10602 
10603 static __inline__ vector unsigned int __ATTRS_o_ai
10604 vec_xor(vector unsigned int __a, vector unsigned int __b) {
10605  return __a ^ __b;
10606 }
10607 
10608 static __inline__ vector unsigned int __ATTRS_o_ai
10609 vec_xor(vector bool int __a, vector unsigned int __b) {
10610  return (vector unsigned int)__a ^ __b;
10611 }
10612 
10613 static __inline__ vector unsigned int __ATTRS_o_ai
10614 vec_xor(vector unsigned int __a, vector bool int __b) {
10615  return __a ^ (vector unsigned int)__b;
10616 }
10617 
10618 static __inline__ vector bool int __ATTRS_o_ai vec_xor(vector bool int __a,
10619  vector bool int __b) {
10620  return __a ^ __b;
10621 }
10622 
10623 static __inline__ vector float __ATTRS_o_ai vec_xor(vector float __a,
10624  vector float __b) {
10625  vector unsigned int __res =
10626  (vector unsigned int)__a ^ (vector unsigned int)__b;
10627  return (vector float)__res;
10628 }
10629 
10630 static __inline__ vector float __ATTRS_o_ai vec_xor(vector bool int __a,
10631  vector float __b) {
10632  vector unsigned int __res =
10633  (vector unsigned int)__a ^ (vector unsigned int)__b;
10634  return (vector float)__res;
10635 }
10636 
10637 static __inline__ vector float __ATTRS_o_ai vec_xor(vector float __a,
10638  vector bool int __b) {
10639  vector unsigned int __res =
10640  (vector unsigned int)__a ^ (vector unsigned int)__b;
10641  return (vector float)__res;
10642 }
10643 
10644 #ifdef __VSX__
10645 static __inline__ vector signed long long __ATTRS_o_ai
10646 vec_xor(vector signed long long __a, vector signed long long __b) {
10647  return __a ^ __b;
10648 }
10649 
10650 static __inline__ vector signed long long __ATTRS_o_ai
10651 vec_xor(vector bool long long __a, vector signed long long __b) {
10652  return (vector signed long long)__a ^ __b;
10653 }
10654 
10655 static __inline__ vector signed long long __ATTRS_o_ai
10656 vec_xor(vector signed long long __a, vector bool long long __b) {
10657  return __a ^ (vector signed long long)__b;
10658 }
10659 
10660 static __inline__ vector unsigned long long __ATTRS_o_ai
10661 vec_xor(vector unsigned long long __a, vector unsigned long long __b) {
10662  return __a ^ __b;
10663 }
10664 
10665 static __inline__ vector unsigned long long __ATTRS_o_ai
10666 vec_xor(vector bool long long __a, vector unsigned long long __b) {
10667  return (vector unsigned long long)__a ^ __b;
10668 }
10669 
10670 static __inline__ vector unsigned long long __ATTRS_o_ai
10671 vec_xor(vector unsigned long long __a, vector bool long long __b) {
10672  return __a ^ (vector unsigned long long)__b;
10673 }
10674 
10675 static __inline__ vector bool long long __ATTRS_o_ai
10676 vec_xor(vector bool long long __a, vector bool long long __b) {
10677  return __a ^ __b;
10678 }
10679 
10680 static __inline__ vector double __ATTRS_o_ai vec_xor(vector double __a,
10681  vector double __b) {
10682  return (vector double)((vector unsigned long long)__a ^
10683  (vector unsigned long long)__b);
10684 }
10685 
10686 static __inline__ vector double __ATTRS_o_ai
10687 vec_xor(vector double __a, vector bool long long __b) {
10688  return (vector double)((vector unsigned long long)__a ^
10689  (vector unsigned long long)__b);
10690 }
10691 
10692 static __inline__ vector double __ATTRS_o_ai vec_xor(vector bool long long __a,
10693  vector double __b) {
10694  return (vector double)((vector unsigned long long)__a ^
10695  (vector unsigned long long)__b);
10696 }
10697 #endif
10698 
10699 /* vec_vxor */
10700 
10701 static __inline__ vector signed char __ATTRS_o_ai
10702 vec_vxor(vector signed char __a, vector signed char __b) {
10703  return __a ^ __b;
10704 }
10705 
10706 static __inline__ vector signed char __ATTRS_o_ai
10707 vec_vxor(vector bool char __a, vector signed char __b) {
10708  return (vector signed char)__a ^ __b;
10709 }
10710 
10711 static __inline__ vector signed char __ATTRS_o_ai
10712 vec_vxor(vector signed char __a, vector bool char __b) {
10713  return __a ^ (vector signed char)__b;
10714 }
10715 
10716 static __inline__ vector unsigned char __ATTRS_o_ai
10717 vec_vxor(vector unsigned char __a, vector unsigned char __b) {
10718  return __a ^ __b;
10719 }
10720 
10721 static __inline__ vector unsigned char __ATTRS_o_ai
10722 vec_vxor(vector bool char __a, vector unsigned char __b) {
10723  return (vector unsigned char)__a ^ __b;
10724 }
10725 
10726 static __inline__ vector unsigned char __ATTRS_o_ai
10727 vec_vxor(vector unsigned char __a, vector bool char __b) {
10728  return __a ^ (vector unsigned char)__b;
10729 }
10730 
10731 static __inline__ vector bool char __ATTRS_o_ai vec_vxor(vector bool char __a,
10732  vector bool char __b) {
10733  return __a ^ __b;
10734 }
10735 
10736 static __inline__ vector short __ATTRS_o_ai vec_vxor(vector short __a,
10737  vector short __b) {
10738  return __a ^ __b;
10739 }
10740 
10741 static __inline__ vector short __ATTRS_o_ai vec_vxor(vector bool short __a,
10742  vector short __b) {
10743  return (vector short)__a ^ __b;
10744 }
10745 
10746 static __inline__ vector short __ATTRS_o_ai vec_vxor(vector short __a,
10747  vector bool short __b) {
10748  return __a ^ (vector short)__b;
10749 }
10750 
10751 static __inline__ vector unsigned short __ATTRS_o_ai
10752 vec_vxor(vector unsigned short __a, vector unsigned short __b) {
10753  return __a ^ __b;
10754 }
10755 
10756 static __inline__ vector unsigned short __ATTRS_o_ai
10757 vec_vxor(vector bool short __a, vector unsigned short __b) {
10758  return (vector unsigned short)__a ^ __b;
10759 }
10760 
10761 static __inline__ vector unsigned short __ATTRS_o_ai
10762 vec_vxor(vector unsigned short __a, vector bool short __b) {
10763  return __a ^ (vector unsigned short)__b;
10764 }
10765 
10766 static __inline__ vector bool short __ATTRS_o_ai
10767 vec_vxor(vector bool short __a, vector bool short __b) {
10768  return __a ^ __b;
10769 }
10770 
10771 static __inline__ vector int __ATTRS_o_ai vec_vxor(vector int __a,
10772  vector int __b) {
10773  return __a ^ __b;
10774 }
10775 
10776 static __inline__ vector int __ATTRS_o_ai vec_vxor(vector bool int __a,
10777  vector int __b) {
10778  return (vector int)__a ^ __b;
10779 }
10780 
10781 static __inline__ vector int __ATTRS_o_ai vec_vxor(vector int __a,
10782  vector bool int __b) {
10783  return __a ^ (vector int)__b;
10784 }
10785 
10786 static __inline__ vector unsigned int __ATTRS_o_ai
10787 vec_vxor(vector unsigned int __a, vector unsigned int __b) {
10788  return __a ^ __b;
10789 }
10790 
10791 static __inline__ vector unsigned int __ATTRS_o_ai
10792 vec_vxor(vector bool int __a, vector unsigned int __b) {
10793  return (vector unsigned int)__a ^ __b;
10794 }
10795 
10796 static __inline__ vector unsigned int __ATTRS_o_ai
10797 vec_vxor(vector unsigned int __a, vector bool int __b) {
10798  return __a ^ (vector unsigned int)__b;
10799 }
10800 
10801 static __inline__ vector bool int __ATTRS_o_ai vec_vxor(vector bool int __a,
10802  vector bool int __b) {
10803  return __a ^ __b;
10804 }
10805 
10806 static __inline__ vector float __ATTRS_o_ai vec_vxor(vector float __a,
10807  vector float __b) {
10808  vector unsigned int __res =
10809  (vector unsigned int)__a ^ (vector unsigned int)__b;
10810  return (vector float)__res;
10811 }
10812 
10813 static __inline__ vector float __ATTRS_o_ai vec_vxor(vector bool int __a,
10814  vector float __b) {
10815  vector unsigned int __res =
10816  (vector unsigned int)__a ^ (vector unsigned int)__b;
10817  return (vector float)__res;
10818 }
10819 
10820 static __inline__ vector float __ATTRS_o_ai vec_vxor(vector float __a,
10821  vector bool int __b) {
10822  vector unsigned int __res =
10823  (vector unsigned int)__a ^ (vector unsigned int)__b;
10824  return (vector float)__res;
10825 }
10826 
10827 #ifdef __VSX__
10828 static __inline__ vector signed long long __ATTRS_o_ai
10829 vec_vxor(vector signed long long __a, vector signed long long __b) {
10830  return __a ^ __b;
10831 }
10832 
10833 static __inline__ vector signed long long __ATTRS_o_ai
10834 vec_vxor(vector bool long long __a, vector signed long long __b) {
10835  return (vector signed long long)__a ^ __b;
10836 }
10837 
10838 static __inline__ vector signed long long __ATTRS_o_ai
10839 vec_vxor(vector signed long long __a, vector bool long long __b) {
10840  return __a ^ (vector signed long long)__b;
10841 }
10842 
10843 static __inline__ vector unsigned long long __ATTRS_o_ai
10844 vec_vxor(vector unsigned long long __a, vector unsigned long long __b) {
10845  return __a ^ __b;
10846 }
10847 
10848 static __inline__ vector unsigned long long __ATTRS_o_ai
10849 vec_vxor(vector bool long long __a, vector unsigned long long __b) {
10850  return (vector unsigned long long)__a ^ __b;
10851 }
10852 
10853 static __inline__ vector unsigned long long __ATTRS_o_ai
10854 vec_vxor(vector unsigned long long __a, vector bool long long __b) {
10855  return __a ^ (vector unsigned long long)__b;
10856 }
10857 
10858 static __inline__ vector bool long long __ATTRS_o_ai
10859 vec_vxor(vector bool long long __a, vector bool long long __b) {
10860  return __a ^ __b;
10861 }
10862 #endif
10863 
10864 /* ------------------------ extensions for CBEA ----------------------------- */
10865 
10866 /* vec_extract */
10867 
10868 static __inline__ signed char __ATTRS_o_ai vec_extract(vector signed char __a,
10869  int __b) {
10870  return __a[__b];
10871 }
10872 
10873 static __inline__ unsigned char __ATTRS_o_ai
10874 vec_extract(vector unsigned char __a, int __b) {
10875  return __a[__b];
10876 }
10877 
10878 static __inline__ unsigned char __ATTRS_o_ai vec_extract(vector bool char __a,
10879  int __b) {
10880  return __a[__b];
10881 }
10882 
10883 static __inline__ signed short __ATTRS_o_ai vec_extract(vector signed short __a,
10884  int __b) {
10885  return __a[__b];
10886 }
10887 
10888 static __inline__ unsigned short __ATTRS_o_ai
10889 vec_extract(vector unsigned short __a, int __b) {
10890  return __a[__b];
10891 }
10892 
10893 static __inline__ unsigned short __ATTRS_o_ai vec_extract(vector bool short __a,
10894  int __b) {
10895  return __a[__b];
10896 }
10897 
10898 static __inline__ signed int __ATTRS_o_ai vec_extract(vector signed int __a,
10899  int __b) {
10900  return __a[__b];
10901 }
10902 
10903 static __inline__ unsigned int __ATTRS_o_ai vec_extract(vector unsigned int __a,
10904  int __b) {
10905  return __a[__b];
10906 }
10907 
10908 static __inline__ unsigned int __ATTRS_o_ai vec_extract(vector bool int __a,
10909  int __b) {
10910  return __a[__b];
10911 }
10912 
10913 #ifdef __VSX__
10914 static __inline__ signed long long __ATTRS_o_ai
10915 vec_extract(vector signed long long __a, int __b) {
10916  return __a[__b];
10917 }
10918 
10919 static __inline__ unsigned long long __ATTRS_o_ai
10920 vec_extract(vector unsigned long long __a, int __b) {
10921  return __a[__b];
10922 }
10923 
10924 static __inline__ unsigned long long __ATTRS_o_ai
10925 vec_extract(vector bool long long __a, int __b) {
10926  return __a[__b];
10927 }
10928 
10929 static __inline__ double __ATTRS_o_ai vec_extract(vector double __a, int __b) {
10930  return __a[__b];
10931 }
10932 #endif
10933 
10934 static __inline__ float __ATTRS_o_ai vec_extract(vector float __a, int __b) {
10935  return __a[__b];
10936 }
10937 
10938 /* vec_insert */
10939 
10940 static __inline__ vector signed char __ATTRS_o_ai
10941 vec_insert(signed char __a, vector signed char __b, int __c) {
10942  __b[__c] = __a;
10943  return __b;
10944 }
10945 
10946 static __inline__ vector unsigned char __ATTRS_o_ai
10947 vec_insert(unsigned char __a, vector unsigned char __b, int __c) {
10948  __b[__c] = __a;
10949  return __b;
10950 }
10951 
10952 static __inline__ vector bool char __ATTRS_o_ai vec_insert(unsigned char __a,
10953  vector bool char __b,
10954  int __c) {
10955  __b[__c] = __a;
10956  return __b;
10957 }
10958 
10959 static __inline__ vector signed short __ATTRS_o_ai
10960 vec_insert(signed short __a, vector signed short __b, int __c) {
10961  __b[__c] = __a;
10962  return __b;
10963 }
10964 
10965 static __inline__ vector unsigned short __ATTRS_o_ai
10966 vec_insert(unsigned short __a, vector unsigned short __b, int __c) {
10967  __b[__c] = __a;
10968  return __b;
10969 }
10970 
10971 static __inline__ vector bool short __ATTRS_o_ai
10972 vec_insert(unsigned short __a, vector bool short __b, int __c) {
10973  __b[__c] = __a;
10974  return __b;
10975 }
10976 
10977 static __inline__ vector signed int __ATTRS_o_ai
10978 vec_insert(signed int __a, vector signed int __b, int __c) {
10979  __b[__c] = __a;
10980  return __b;
10981 }
10982 
10983 static __inline__ vector unsigned int __ATTRS_o_ai
10984 vec_insert(unsigned int __a, vector unsigned int __b, int __c) {
10985  __b[__c] = __a;
10986  return __b;
10987 }
10988 
10989 static __inline__ vector bool int __ATTRS_o_ai vec_insert(unsigned int __a,
10990  vector bool int __b,
10991  int __c) {
10992  __b[__c] = __a;
10993  return __b;
10994 }
10995 
10996 #ifdef __VSX__
10997 static __inline__ vector signed long long __ATTRS_o_ai
10998 vec_insert(signed long long __a, vector signed long long __b, int __c) {
10999  __b[__c] = __a;
11000  return __b;
11001 }
11002 
11003 static __inline__ vector unsigned long long __ATTRS_o_ai
11004 vec_insert(unsigned long long __a, vector unsigned long long __b, int __c) {
11005  __b[__c] = __a;
11006  return __b;
11007 }
11008 
11009 static __inline__ vector bool long long __ATTRS_o_ai
11010 vec_insert(unsigned long long __a, vector bool long long __b, int __c) {
11011  __b[__c] = __a;
11012  return __b;
11013 }
11014 static __inline__ vector double __ATTRS_o_ai vec_insert(double __a,
11015  vector double __b,
11016  int __c) {
11017  __b[__c] = __a;
11018  return __b;
11019 }
11020 #endif
11021 
11022 static __inline__ vector float __ATTRS_o_ai vec_insert(float __a,
11023  vector float __b,
11024  int __c) {
11025  __b[__c] = __a;
11026  return __b;
11027 }
11028 
11029 /* vec_lvlx */
11030 
11031 static __inline__ vector signed char __ATTRS_o_ai
11032 vec_lvlx(int __a, const signed char *__b) {
11033  return vec_perm(vec_ld(__a, __b), (vector signed char)(0),
11034  vec_lvsl(__a, __b));
11035 }
11036 
11037 static __inline__ vector signed char __ATTRS_o_ai
11038 vec_lvlx(int __a, const vector signed char *__b) {
11039  return vec_perm(vec_ld(__a, __b), (vector signed char)(0),
11040  vec_lvsl(__a, (unsigned char *)__b));
11041 }
11042 
11043 static __inline__ vector unsigned char __ATTRS_o_ai
11044 vec_lvlx(int __a, const unsigned char *__b) {
11045  return vec_perm(vec_ld(__a, __b), (vector unsigned char)(0),
11046  vec_lvsl(__a, __b));
11047 }
11048 
11049 static __inline__ vector unsigned char __ATTRS_o_ai
11050 vec_lvlx(int __a, const vector unsigned char *__b) {
11051  return vec_perm(vec_ld(__a, __b), (vector unsigned char)(0),
11052  vec_lvsl(__a, (unsigned char *)__b));
11053 }
11054 
11055 static __inline__ vector bool char __ATTRS_o_ai
11056 vec_lvlx(int __a, const vector bool char *__b) {
11057  return vec_perm(vec_ld(__a, __b), (vector bool char)(0),
11058  vec_lvsl(__a, (unsigned char *)__b));
11059 }
11060 
11061 static __inline__ vector short __ATTRS_o_ai vec_lvlx(int __a,
11062  const short *__b) {
11063  return vec_perm(vec_ld(__a, __b), (vector short)(0), vec_lvsl(__a, __b));
11064 }
11065 
11066 static __inline__ vector short __ATTRS_o_ai vec_lvlx(int __a,
11067  const vector short *__b) {
11068  return vec_perm(vec_ld(__a, __b), (vector short)(0),
11069  vec_lvsl(__a, (unsigned char *)__b));
11070 }
11071 
11072 static __inline__ vector unsigned short __ATTRS_o_ai
11073 vec_lvlx(int __a, const unsigned short *__b) {
11074  return vec_perm(vec_ld(__a, __b), (vector unsigned short)(0),
11075  vec_lvsl(__a, __b));
11076 }
11077 
11078 static __inline__ vector unsigned short __ATTRS_o_ai
11079 vec_lvlx(int __a, const vector unsigned short *__b) {
11080  return vec_perm(vec_ld(__a, __b), (vector unsigned short)(0),
11081  vec_lvsl(__a, (unsigned char *)__b));
11082 }
11083 
11084 static __inline__ vector bool short __ATTRS_o_ai
11085 vec_lvlx(int __a, const vector bool short *__b) {
11086  return vec_perm(vec_ld(__a, __b), (vector bool short)(0),
11087  vec_lvsl(__a, (unsigned char *)__b));
11088 }
11089 
11090 static __inline__ vector pixel __ATTRS_o_ai vec_lvlx(int __a,
11091  const vector pixel *__b) {
11092  return vec_perm(vec_ld(__a, __b), (vector pixel)(0),
11093  vec_lvsl(__a, (unsigned char *)__b));
11094 }
11095 
11096 static __inline__ vector int __ATTRS_o_ai vec_lvlx(int __a, const int *__b) {
11097  return vec_perm(vec_ld(__a, __b), (vector int)(0), vec_lvsl(__a, __b));
11098 }
11099 
11100 static __inline__ vector int __ATTRS_o_ai vec_lvlx(int __a,
11101  const vector int *__b) {
11102  return vec_perm(vec_ld(__a, __b), (vector int)(0),
11103  vec_lvsl(__a, (unsigned char *)__b));
11104 }
11105 
11106 static __inline__ vector unsigned int __ATTRS_o_ai
11107 vec_lvlx(int __a, const unsigned int *__b) {
11108  return vec_perm(vec_ld(__a, __b), (vector unsigned int)(0),
11109  vec_lvsl(__a, __b));
11110 }
11111 
11112 static __inline__ vector unsigned int __ATTRS_o_ai
11113 vec_lvlx(int __a, const vector unsigned int *__b) {
11114  return vec_perm(vec_ld(__a, __b), (vector unsigned int)(0),
11115  vec_lvsl(__a, (unsigned char *)__b));
11116 }
11117 
11118 static __inline__ vector bool int __ATTRS_o_ai
11119 vec_lvlx(int __a, const vector bool int *__b) {
11120  return vec_perm(vec_ld(__a, __b), (vector bool int)(0),
11121  vec_lvsl(__a, (unsigned char *)__b));
11122 }
11123 
11124 static __inline__ vector float __ATTRS_o_ai vec_lvlx(int __a,
11125  const float *__b) {
11126  return vec_perm(vec_ld(__a, __b), (vector float)(0), vec_lvsl(__a, __b));
11127 }
11128 
11129 static __inline__ vector float __ATTRS_o_ai vec_lvlx(int __a,
11130  const vector float *__b) {
11131  return vec_perm(vec_ld(__a, __b), (vector float)(0),
11132  vec_lvsl(__a, (unsigned char *)__b));
11133 }
11134 
11135 /* vec_lvlxl */
11136 
11137 static __inline__ vector signed char __ATTRS_o_ai
11138 vec_lvlxl(int __a, const signed char *__b) {
11139  return vec_perm(vec_ldl(__a, __b), (vector signed char)(0),
11140  vec_lvsl(__a, __b));
11141 }
11142 
11143 static __inline__ vector signed char __ATTRS_o_ai
11144 vec_lvlxl(int __a, const vector signed char *__b) {
11145  return vec_perm(vec_ldl(__a, __b), (vector signed char)(0),
11146  vec_lvsl(__a, (unsigned char *)__b));
11147 }
11148 
11149 static __inline__ vector unsigned char __ATTRS_o_ai
11150 vec_lvlxl(int __a, const unsigned char *__b) {
11151  return vec_perm(vec_ldl(__a, __b), (vector unsigned char)(0),
11152  vec_lvsl(__a, __b));
11153 }
11154 
11155 static __inline__ vector unsigned char __ATTRS_o_ai
11156 vec_lvlxl(int __a, const vector unsigned char *__b) {
11157  return vec_perm(vec_ldl(__a, __b), (vector unsigned char)(0),
11158  vec_lvsl(__a, (unsigned char *)__b));
11159 }
11160 
11161 static __inline__ vector bool char __ATTRS_o_ai
11162 vec_lvlxl(int __a, const vector bool char *__b) {
11163  return vec_perm(vec_ldl(__a, __b), (vector bool char)(0),
11164  vec_lvsl(__a, (unsigned char *)__b));
11165 }
11166 
11167 static __inline__ vector short __ATTRS_o_ai vec_lvlxl(int __a,
11168  const short *__b) {
11169  return vec_perm(vec_ldl(__a, __b), (vector short)(0), vec_lvsl(__a, __b));
11170 }
11171 
11172 static __inline__ vector short __ATTRS_o_ai vec_lvlxl(int __a,
11173  const vector short *__b) {
11174  return vec_perm(vec_ldl(__a, __b), (vector short)(0),
11175  vec_lvsl(__a, (unsigned char *)__b));
11176 }
11177 
11178 static __inline__ vector unsigned short __ATTRS_o_ai
11179 vec_lvlxl(int __a, const unsigned short *__b) {
11180  return vec_perm(vec_ldl(__a, __b), (vector unsigned short)(0),
11181  vec_lvsl(__a, __b));
11182 }
11183 
11184 static __inline__ vector unsigned short __ATTRS_o_ai
11185 vec_lvlxl(int __a, const vector unsigned short *__b) {
11186  return vec_perm(vec_ldl(__a, __b), (vector unsigned short)(0),
11187  vec_lvsl(__a, (unsigned char *)__b));
11188 }
11189 
11190 static __inline__ vector bool short __ATTRS_o_ai
11191 vec_lvlxl(int __a, const vector bool short *__b) {
11192  return vec_perm(vec_ldl(__a, __b), (vector bool short)(0),
11193  vec_lvsl(__a, (unsigned char *)__b));
11194 }
11195 
11196 static __inline__ vector pixel __ATTRS_o_ai vec_lvlxl(int __a,
11197  const vector pixel *__b) {
11198  return vec_perm(vec_ldl(__a, __b), (vector pixel)(0),
11199  vec_lvsl(__a, (unsigned char *)__b));
11200 }
11201 
11202 static __inline__ vector int __ATTRS_o_ai vec_lvlxl(int __a, const int *__b) {
11203  return vec_perm(vec_ldl(__a, __b), (vector int)(0), vec_lvsl(__a, __b));
11204 }
11205 
11206 static __inline__ vector int __ATTRS_o_ai vec_lvlxl(int __a,
11207  const vector int *__b) {
11208  return vec_perm(vec_ldl(__a, __b), (vector int)(0),
11209  vec_lvsl(__a, (unsigned char *)__b));
11210 }
11211 
11212 static __inline__ vector unsigned int __ATTRS_o_ai
11213 vec_lvlxl(int __a, const unsigned int *__b) {
11214  return vec_perm(vec_ldl(__a, __b), (vector unsigned int)(0),
11215  vec_lvsl(__a, __b));
11216 }
11217 
11218 static __inline__ vector unsigned int __ATTRS_o_ai
11219 vec_lvlxl(int __a, const vector unsigned int *__b) {
11220  return vec_perm(vec_ldl(__a, __b), (vector unsigned int)(0),
11221  vec_lvsl(__a, (unsigned char *)__b));
11222 }
11223 
11224 static __inline__ vector bool int __ATTRS_o_ai
11225 vec_lvlxl(int __a, const vector bool int *__b) {
11226  return vec_perm(vec_ldl(__a, __b), (vector bool int)(0),
11227  vec_lvsl(__a, (unsigned char *)__b));
11228 }
11229 
11230 static __inline__ vector float __ATTRS_o_ai vec_lvlxl(int __a,
11231  const float *__b) {
11232  return vec_perm(vec_ldl(__a, __b), (vector float)(0), vec_lvsl(__a, __b));
11233 }
11234 
11235 static __inline__ vector float __ATTRS_o_ai vec_lvlxl(int __a,
11236  vector float *__b) {
11237  return vec_perm(vec_ldl(__a, __b), (vector float)(0),
11238  vec_lvsl(__a, (unsigned char *)__b));
11239 }
11240 
11241 /* vec_lvrx */
11242 
11243 static __inline__ vector signed char __ATTRS_o_ai
11244 vec_lvrx(int __a, const signed char *__b) {
11245  return vec_perm((vector signed char)(0), vec_ld(__a, __b),
11246  vec_lvsl(__a, __b));
11247 }
11248 
11249 static __inline__ vector signed char __ATTRS_o_ai
11250 vec_lvrx(int __a, const vector signed char *__b) {
11251  return vec_perm((vector signed char)(0), vec_ld(__a, __b),
11252  vec_lvsl(__a, (unsigned char *)__b));
11253 }
11254 
11255 static __inline__ vector unsigned char __ATTRS_o_ai
11256 vec_lvrx(int __a, const unsigned char *__b) {
11257  return vec_perm((vector unsigned char)(0), vec_ld(__a, __b),
11258  vec_lvsl(__a, __b));
11259 }
11260 
11261 static __inline__ vector unsigned char __ATTRS_o_ai
11262 vec_lvrx(int __a, const vector unsigned char *__b) {
11263  return vec_perm((vector unsigned char)(0), vec_ld(__a, __b),
11264  vec_lvsl(__a, (unsigned char *)__b));
11265 }
11266 
11267 static __inline__ vector bool char __ATTRS_o_ai
11268 vec_lvrx(int __a, const vector bool char *__b) {
11269  return vec_perm((vector bool char)(0), vec_ld(__a, __b),
11270  vec_lvsl(__a, (unsigned char *)__b));
11271 }
11272 
11273 static __inline__ vector short __ATTRS_o_ai vec_lvrx(int __a,
11274  const short *__b) {
11275  return vec_perm((vector short)(0), vec_ld(__a, __b), vec_lvsl(__a, __b));
11276 }
11277 
11278 static __inline__ vector short __ATTRS_o_ai vec_lvrx(int __a,
11279  const vector short *__b) {
11280  return vec_perm((vector short)(0), vec_ld(__a, __b),
11281  vec_lvsl(__a, (unsigned char *)__b));
11282 }
11283 
11284 static __inline__ vector unsigned short __ATTRS_o_ai
11285 vec_lvrx(int __a, const unsigned short *__b) {
11286  return vec_perm((vector unsigned short)(0), vec_ld(__a, __b),
11287  vec_lvsl(__a, __b));
11288 }
11289 
11290 static __inline__ vector unsigned short __ATTRS_o_ai
11291 vec_lvrx(int __a, const vector unsigned short *__b) {
11292  return vec_perm((vector unsigned short)(0), vec_ld(__a, __b),
11293  vec_lvsl(__a, (unsigned char *)__b));
11294 }
11295 
11296 static __inline__ vector bool short __ATTRS_o_ai
11297 vec_lvrx(int __a, const vector bool short *__b) {
11298  return vec_perm((vector bool short)(0), vec_ld(__a, __b),
11299  vec_lvsl(__a, (unsigned char *)__b));
11300 }
11301 
11302 static __inline__ vector pixel __ATTRS_o_ai vec_lvrx(int __a,
11303  const vector pixel *__b) {
11304  return vec_perm((vector pixel)(0), vec_ld(__a, __b),
11305  vec_lvsl(__a, (unsigned char *)__b));
11306 }
11307 
11308 static __inline__ vector int __ATTRS_o_ai vec_lvrx(int __a, const int *__b) {
11309  return vec_perm((vector int)(0), vec_ld(__a, __b), vec_lvsl(__a, __b));
11310 }
11311 
11312 static __inline__ vector int __ATTRS_o_ai vec_lvrx(int __a,
11313  const vector int *__b) {
11314  return vec_perm((vector int)(0), vec_ld(__a, __b),
11315  vec_lvsl(__a, (unsigned char *)__b));
11316 }
11317 
11318 static __inline__ vector unsigned int __ATTRS_o_ai
11319 vec_lvrx(int __a, const unsigned int *__b) {
11320  return vec_perm((vector unsigned int)(0), vec_ld(__a, __b),
11321  vec_lvsl(__a, __b));
11322 }
11323 
11324 static __inline__ vector unsigned int __ATTRS_o_ai
11325 vec_lvrx(int __a, const vector unsigned int *__b) {
11326  return vec_perm((vector unsigned int)(0), vec_ld(__a, __b),
11327  vec_lvsl(__a, (unsigned char *)__b));
11328 }
11329 
11330 static __inline__ vector bool int __ATTRS_o_ai
11331 vec_lvrx(int __a, const vector bool int *__b) {
11332  return vec_perm((vector bool int)(0), vec_ld(__a, __b),
11333  vec_lvsl(__a, (unsigned char *)__b));
11334 }
11335 
11336 static __inline__ vector float __ATTRS_o_ai vec_lvrx(int __a,
11337  const float *__b) {
11338  return vec_perm((vector float)(0), vec_ld(__a, __b), vec_lvsl(__a, __b));
11339 }
11340 
11341 static __inline__ vector float __ATTRS_o_ai vec_lvrx(int __a,
11342  const vector float *__b) {
11343  return vec_perm((vector float)(0), vec_ld(__a, __b),
11344  vec_lvsl(__a, (unsigned char *)__b));
11345 }
11346 
11347 /* vec_lvrxl */
11348 
11349 static __inline__ vector signed char __ATTRS_o_ai
11350 vec_lvrxl(int __a, const signed char *__b) {
11351  return vec_perm((vector signed char)(0), vec_ldl(__a, __b),
11352  vec_lvsl(__a, __b));
11353 }
11354 
11355 static __inline__ vector signed char __ATTRS_o_ai
11356 vec_lvrxl(int __a, const vector signed char *__b) {
11357  return vec_perm((vector signed char)(0), vec_ldl(__a, __b),
11358  vec_lvsl(__a, (unsigned char *)__b));
11359 }
11360 
11361 static __inline__ vector unsigned char __ATTRS_o_ai
11362 vec_lvrxl(int __a, const unsigned char *__b) {
11363  return vec_perm((vector unsigned char)(0), vec_ldl(__a, __b),
11364  vec_lvsl(__a, __b));
11365 }
11366 
11367 static __inline__ vector unsigned char __ATTRS_o_ai
11368 vec_lvrxl(int __a, const vector unsigned char *__b) {
11369  return vec_perm((vector unsigned char)(0), vec_ldl(__a, __b),
11370  vec_lvsl(__a, (unsigned char *)__b));
11371 }
11372 
11373 static __inline__ vector bool char __ATTRS_o_ai
11374 vec_lvrxl(int __a, const vector bool char *__b) {
11375  return vec_perm((vector bool char)(0), vec_ldl(__a, __b),
11376  vec_lvsl(__a, (unsigned char *)__b));
11377 }
11378 
11379 static __inline__ vector short __ATTRS_o_ai vec_lvrxl(int __a,
11380  const short *__b) {
11381  return vec_perm((vector short)(0), vec_ldl(__a, __b), vec_lvsl(__a, __b));
11382 }
11383 
11384 static __inline__ vector short __ATTRS_o_ai vec_lvrxl(int __a,
11385  const vector short *__b) {
11386  return vec_perm((vector short)(0), vec_ldl(__a, __b),
11387  vec_lvsl(__a, (unsigned char *)__b));
11388 }
11389 
11390 static __inline__ vector unsigned short __ATTRS_o_ai
11391 vec_lvrxl(int __a, const unsigned short *__b) {
11392  return vec_perm((vector unsigned short)(0), vec_ldl(__a, __b),
11393  vec_lvsl(__a, __b));
11394 }
11395 
11396 static __inline__ vector unsigned short __ATTRS_o_ai
11397 vec_lvrxl(int __a, const vector unsigned short *__b) {
11398  return vec_perm((vector unsigned short)(0), vec_ldl(__a, __b),
11399  vec_lvsl(__a, (unsigned char *)__b));
11400 }
11401 
11402 static __inline__ vector bool short __ATTRS_o_ai
11403 vec_lvrxl(int __a, const vector bool short *__b) {
11404  return vec_perm((vector bool short)(0), vec_ldl(__a, __b),
11405  vec_lvsl(__a, (unsigned char *)__b));
11406 }
11407 
11408 static __inline__ vector pixel __ATTRS_o_ai vec_lvrxl(int __a,
11409  const vector pixel *__b) {
11410  return vec_perm((vector pixel)(0), vec_ldl(__a, __b),
11411  vec_lvsl(__a, (unsigned char *)__b));
11412 }
11413 
11414 static __inline__ vector int __ATTRS_o_ai vec_lvrxl(int __a, const int *__b) {
11415  return vec_perm((vector int)(0), vec_ldl(__a, __b), vec_lvsl(__a, __b));
11416 }
11417 
11418 static __inline__ vector int __ATTRS_o_ai vec_lvrxl(int __a,
11419  const vector int *__b) {
11420  return vec_perm((vector int)(0), vec_ldl(__a, __b),
11421  vec_lvsl(__a, (unsigned char *)__b));
11422 }
11423 
11424 static __inline__ vector unsigned int __ATTRS_o_ai
11425 vec_lvrxl(int __a, const unsigned int *__b) {
11426  return vec_perm((vector unsigned int)(0), vec_ldl(__a, __b),
11427  vec_lvsl(__a, __b));
11428 }
11429 
11430 static __inline__ vector unsigned int __ATTRS_o_ai
11431 vec_lvrxl(int __a, const vector unsigned int *__b) {
11432  return vec_perm((vector unsigned int)(0), vec_ldl(__a, __b),
11433  vec_lvsl(__a, (unsigned char *)__b));
11434 }
11435 
11436 static __inline__ vector bool int __ATTRS_o_ai
11437 vec_lvrxl(int __a, const vector bool int *__b) {
11438  return vec_perm((vector bool int)(0), vec_ldl(__a, __b),
11439  vec_lvsl(__a, (unsigned char *)__b));
11440 }
11441 
11442 static __inline__ vector float __ATTRS_o_ai vec_lvrxl(int __a,
11443  const float *__b) {
11444  return vec_perm((vector float)(0), vec_ldl(__a, __b), vec_lvsl(__a, __b));
11445 }
11446 
11447 static __inline__ vector float __ATTRS_o_ai vec_lvrxl(int __a,
11448  const vector float *__b) {
11449  return vec_perm((vector float)(0), vec_ldl(__a, __b),
11450  vec_lvsl(__a, (unsigned char *)__b));
11451 }
11452 
11453 /* vec_stvlx */
11454 
11455 static __inline__ void __ATTRS_o_ai vec_stvlx(vector signed char __a, int __b,
11456  signed char *__c) {
11457  return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
11458  __c);
11459 }
11460 
11461 static __inline__ void __ATTRS_o_ai vec_stvlx(vector signed char __a, int __b,
11462  vector signed char *__c) {
11463  return vec_st(
11464  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
11465  __b, __c);
11466 }
11467 
11468 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned char __a, int __b,
11469  unsigned char *__c) {
11470  return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
11471  __c);
11472 }
11473 
11474 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned char __a, int __b,
11475  vector unsigned char *__c) {
11476  return vec_st(
11477  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
11478  __b, __c);
11479 }
11480 
11481 static __inline__ void __ATTRS_o_ai vec_stvlx(vector bool char __a, int __b,
11482  vector bool char *__c) {
11483  return vec_st(
11484  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
11485  __b, __c);
11486 }
11487 
11488 static __inline__ void __ATTRS_o_ai vec_stvlx(vector short __a, int __b,
11489  short *__c) {
11490  return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
11491  __c);
11492 }
11493 
11494 static __inline__ void __ATTRS_o_ai vec_stvlx(vector short __a, int __b,
11495  vector short *__c) {
11496  return vec_st(
11497  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
11498  __b, __c);
11499 }
11500 
11501 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned short __a,
11502  int __b, unsigned short *__c) {
11503  return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
11504  __c);
11505 }
11506 
11507 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned short __a,
11508  int __b,
11509  vector unsigned short *__c) {
11510  return vec_st(
11511  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
11512  __b, __c);
11513 }
11514 
11515 static __inline__ void __ATTRS_o_ai vec_stvlx(vector bool short __a, int __b,
11516  vector bool short *__c) {
11517  return vec_st(
11518  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
11519  __b, __c);
11520 }
11521 
11522 static __inline__ void __ATTRS_o_ai vec_stvlx(vector pixel __a, int __b,
11523  vector pixel *__c) {
11524  return vec_st(
11525  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
11526  __b, __c);
11527 }
11528 
11529 static __inline__ void __ATTRS_o_ai vec_stvlx(vector int __a, int __b,
11530  int *__c) {
11531  return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
11532  __c);
11533 }
11534 
11535 static __inline__ void __ATTRS_o_ai vec_stvlx(vector int __a, int __b,
11536  vector int *__c) {
11537  return vec_st(
11538  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
11539  __b, __c);
11540 }
11541 
11542 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned int __a, int __b,
11543  unsigned int *__c) {
11544  return vec_st(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
11545  __c);
11546 }
11547 
11548 static __inline__ void __ATTRS_o_ai vec_stvlx(vector unsigned int __a, int __b,
11549  vector unsigned int *__c) {
11550  return vec_st(
11551  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
11552  __b, __c);
11553 }
11554 
11555 static __inline__ void __ATTRS_o_ai vec_stvlx(vector bool int __a, int __b,
11556  vector bool int *__c) {
11557  return vec_st(
11558  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
11559  __b, __c);
11560 }
11561 
11562 static __inline__ void __ATTRS_o_ai vec_stvlx(vector float __a, int __b,
11563  vector float *__c) {
11564  return vec_st(
11565  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
11566  __b, __c);
11567 }
11568 
11569 /* vec_stvlxl */
11570 
11571 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector signed char __a, int __b,
11572  signed char *__c) {
11573  return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
11574  __c);
11575 }
11576 
11577 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector signed char __a, int __b,
11578  vector signed char *__c) {
11579  return vec_stl(
11580  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
11581  __b, __c);
11582 }
11583 
11584 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned char __a,
11585  int __b, unsigned char *__c) {
11586  return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
11587  __c);
11588 }
11589 
11590 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned char __a,
11591  int __b,
11592  vector unsigned char *__c) {
11593  return vec_stl(
11594  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
11595  __b, __c);
11596 }
11597 
11598 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector bool char __a, int __b,
11599  vector bool char *__c) {
11600  return vec_stl(
11601  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
11602  __b, __c);
11603 }
11604 
11605 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector short __a, int __b,
11606  short *__c) {
11607  return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
11608  __c);
11609 }
11610 
11611 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector short __a, int __b,
11612  vector short *__c) {
11613  return vec_stl(
11614  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
11615  __b, __c);
11616 }
11617 
11618 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned short __a,
11619  int __b, unsigned short *__c) {
11620  return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
11621  __c);
11622 }
11623 
11624 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned short __a,
11625  int __b,
11626  vector unsigned short *__c) {
11627  return vec_stl(
11628  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
11629  __b, __c);
11630 }
11631 
11632 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector bool short __a, int __b,
11633  vector bool short *__c) {
11634  return vec_stl(
11635  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
11636  __b, __c);
11637 }
11638 
11639 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector pixel __a, int __b,
11640  vector pixel *__c) {
11641  return vec_stl(
11642  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
11643  __b, __c);
11644 }
11645 
11646 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector int __a, int __b,
11647  int *__c) {
11648  return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
11649  __c);
11650 }
11651 
11652 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector int __a, int __b,
11653  vector int *__c) {
11654  return vec_stl(
11655  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
11656  __b, __c);
11657 }
11658 
11659 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned int __a, int __b,
11660  unsigned int *__c) {
11661  return vec_stl(vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, __c)), __b,
11662  __c);
11663 }
11664 
11665 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector unsigned int __a, int __b,
11666  vector unsigned int *__c) {
11667  return vec_stl(
11668  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
11669  __b, __c);
11670 }
11671 
11672 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector bool int __a, int __b,
11673  vector bool int *__c) {
11674  return vec_stl(
11675  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
11676  __b, __c);
11677 }
11678 
11679 static __inline__ void __ATTRS_o_ai vec_stvlxl(vector float __a, int __b,
11680  vector float *__c) {
11681  return vec_stl(
11682  vec_perm(vec_lvrx(__b, __c), __a, vec_lvsr(__b, (unsigned char *)__c)),
11683  __b, __c);
11684 }
11685 
11686 /* vec_stvrx */
11687 
11688 static __inline__ void __ATTRS_o_ai vec_stvrx(vector signed char __a, int __b,
11689  signed char *__c) {
11690  return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
11691  __c);
11692 }
11693 
11694 static __inline__ void __ATTRS_o_ai vec_stvrx(vector signed char __a, int __b,
11695  vector signed char *__c) {
11696  return vec_st(
11697  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
11698  __b, __c);
11699 }
11700 
11701 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned char __a, int __b,
11702  unsigned char *__c) {
11703  return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
11704  __c);
11705 }
11706 
11707 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned char __a, int __b,
11708  vector unsigned char *__c) {
11709  return vec_st(
11710  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
11711  __b, __c);
11712 }
11713 
11714 static __inline__ void __ATTRS_o_ai vec_stvrx(vector bool char __a, int __b,
11715  vector bool char *__c) {
11716  return vec_st(
11717  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
11718  __b, __c);
11719 }
11720 
11721 static __inline__ void __ATTRS_o_ai vec_stvrx(vector short __a, int __b,
11722  short *__c) {
11723  return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
11724  __c);
11725 }
11726 
11727 static __inline__ void __ATTRS_o_ai vec_stvrx(vector short __a, int __b,
11728  vector short *__c) {
11729  return vec_st(
11730  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
11731  __b, __c);
11732 }
11733 
11734 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned short __a,
11735  int __b, unsigned short *__c) {
11736  return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
11737  __c);
11738 }
11739 
11740 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned short __a,
11741  int __b,
11742  vector unsigned short *__c) {
11743  return vec_st(
11744  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
11745  __b, __c);
11746 }
11747 
11748 static __inline__ void __ATTRS_o_ai vec_stvrx(vector bool short __a, int __b,
11749  vector bool short *__c) {
11750  return vec_st(
11751  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
11752  __b, __c);
11753 }
11754 
11755 static __inline__ void __ATTRS_o_ai vec_stvrx(vector pixel __a, int __b,
11756  vector pixel *__c) {
11757  return vec_st(
11758  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
11759  __b, __c);
11760 }
11761 
11762 static __inline__ void __ATTRS_o_ai vec_stvrx(vector int __a, int __b,
11763  int *__c) {
11764  return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
11765  __c);
11766 }
11767 
11768 static __inline__ void __ATTRS_o_ai vec_stvrx(vector int __a, int __b,
11769  vector int *__c) {
11770  return vec_st(
11771  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
11772  __b, __c);
11773 }
11774 
11775 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned int __a, int __b,
11776  unsigned int *__c) {
11777  return vec_st(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
11778  __c);
11779 }
11780 
11781 static __inline__ void __ATTRS_o_ai vec_stvrx(vector unsigned int __a, int __b,
11782  vector unsigned int *__c) {
11783  return vec_st(
11784  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
11785  __b, __c);
11786 }
11787 
11788 static __inline__ void __ATTRS_o_ai vec_stvrx(vector bool int __a, int __b,
11789  vector bool int *__c) {
11790  return vec_st(
11791  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
11792  __b, __c);
11793 }
11794 
11795 static __inline__ void __ATTRS_o_ai vec_stvrx(vector float __a, int __b,
11796  vector float *__c) {
11797  return vec_st(
11798  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
11799  __b, __c);
11800 }
11801 
11802 /* vec_stvrxl */
11803 
11804 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector signed char __a, int __b,
11805  signed char *__c) {
11806  return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
11807  __c);
11808 }
11809 
11810 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector signed char __a, int __b,
11811  vector signed char *__c) {
11812  return vec_stl(
11813  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
11814  __b, __c);
11815 }
11816 
11817 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned char __a,
11818  int __b, unsigned char *__c) {
11819  return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
11820  __c);
11821 }
11822 
11823 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned char __a,
11824  int __b,
11825  vector unsigned char *__c) {
11826  return vec_stl(
11827  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
11828  __b, __c);
11829 }
11830 
11831 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector bool char __a, int __b,
11832  vector bool char *__c) {
11833  return vec_stl(
11834  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
11835  __b, __c);
11836 }
11837 
11838 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector short __a, int __b,
11839  short *__c) {
11840  return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
11841  __c);
11842 }
11843 
11844 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector short __a, int __b,
11845  vector short *__c) {
11846  return vec_stl(
11847  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
11848  __b, __c);
11849 }
11850 
11851 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned short __a,
11852  int __b, unsigned short *__c) {
11853  return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
11854  __c);
11855 }
11856 
11857 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned short __a,
11858  int __b,
11859  vector unsigned short *__c) {
11860  return vec_stl(
11861  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
11862  __b, __c);
11863 }
11864 
11865 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector bool short __a, int __b,
11866  vector bool short *__c) {
11867  return vec_stl(
11868  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
11869  __b, __c);
11870 }
11871 
11872 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector pixel __a, int __b,
11873  vector pixel *__c) {
11874  return vec_stl(
11875  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
11876  __b, __c);
11877 }
11878 
11879 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector int __a, int __b,
11880  int *__c) {
11881  return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
11882  __c);
11883 }
11884 
11885 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector int __a, int __b,
11886  vector int *__c) {
11887  return vec_stl(
11888  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
11889  __b, __c);
11890 }
11891 
11892 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned int __a, int __b,
11893  unsigned int *__c) {
11894  return vec_stl(vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, __c)), __b,
11895  __c);
11896 }
11897 
11898 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector unsigned int __a, int __b,
11899  vector unsigned int *__c) {
11900  return vec_stl(
11901  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
11902  __b, __c);
11903 }
11904 
11905 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector bool int __a, int __b,
11906  vector bool int *__c) {
11907  return vec_stl(
11908  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
11909  __b, __c);
11910 }
11911 
11912 static __inline__ void __ATTRS_o_ai vec_stvrxl(vector float __a, int __b,
11913  vector float *__c) {
11914  return vec_stl(
11915  vec_perm(__a, vec_lvlx(__b, __c), vec_lvsr(__b, (unsigned char *)__c)),
11916  __b, __c);
11917 }
11918 
11919 /* vec_promote */
11920 
11921 static __inline__ vector signed char __ATTRS_o_ai vec_promote(signed char __a,
11922  int __b) {
11923  vector signed char __res = (vector signed char)(0);
11924  __res[__b] = __a;
11925  return __res;
11926 }
11927 
11928 static __inline__ vector unsigned char __ATTRS_o_ai
11929 vec_promote(unsigned char __a, int __b) {
11930  vector unsigned char __res = (vector unsigned char)(0);
11931  __res[__b] = __a;
11932  return __res;
11933 }
11934 
11935 static __inline__ vector short __ATTRS_o_ai vec_promote(short __a, int __b) {
11936  vector short __res = (vector short)(0);
11937  __res[__b] = __a;
11938  return __res;
11939 }
11940 
11941 static __inline__ vector unsigned short __ATTRS_o_ai
11942 vec_promote(unsigned short __a, int __b) {
11943  vector unsigned short __res = (vector unsigned short)(0);
11944  __res[__b] = __a;
11945  return __res;
11946 }
11947 
11948 static __inline__ vector int __ATTRS_o_ai vec_promote(int __a, int __b) {
11949  vector int __res = (vector int)(0);
11950  __res[__b] = __a;
11951  return __res;
11952 }
11953 
11954 static __inline__ vector unsigned int __ATTRS_o_ai vec_promote(unsigned int __a,
11955  int __b) {
11956  vector unsigned int __res = (vector unsigned int)(0);
11957  __res[__b] = __a;
11958  return __res;
11959 }
11960 
11961 static __inline__ vector float __ATTRS_o_ai vec_promote(float __a, int __b) {
11962  vector float __res = (vector float)(0);
11963  __res[__b] = __a;
11964  return __res;
11965 }
11966 
11967 /* vec_splats */
11968 
11969 static __inline__ vector signed char __ATTRS_o_ai vec_splats(signed char __a) {
11970  return (vector signed char)(__a);
11971 }
11972 
11973 static __inline__ vector unsigned char __ATTRS_o_ai
11974 vec_splats(unsigned char __a) {
11975  return (vector unsigned char)(__a);
11976 }
11977 
11978 static __inline__ vector short __ATTRS_o_ai vec_splats(short __a) {
11979  return (vector short)(__a);
11980 }
11981 
11982 static __inline__ vector unsigned short __ATTRS_o_ai
11983 vec_splats(unsigned short __a) {
11984  return (vector unsigned short)(__a);
11985 }
11986 
11987 static __inline__ vector int __ATTRS_o_ai vec_splats(int __a) {
11988  return (vector int)(__a);
11989 }
11990 
11991 static __inline__ vector unsigned int __ATTRS_o_ai
11992 vec_splats(unsigned int __a) {
11993  return (vector unsigned int)(__a);
11994 }
11995 
11996 #ifdef __VSX__
11997 static __inline__ vector signed long long __ATTRS_o_ai
11998 vec_splats(signed long long __a) {
11999  return (vector signed long long)(__a);
12000 }
12001 
12002 static __inline__ vector unsigned long long __ATTRS_o_ai
12003 vec_splats(unsigned long long __a) {
12004  return (vector unsigned long long)(__a);
12005 }
12006 
12007 #if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
12008 static __inline__ vector signed __int128 __ATTRS_o_ai
12009 vec_splats(signed __int128 __a) {
12010  return (vector signed __int128)(__a);
12011 }
12012 
12013 static __inline__ vector unsigned __int128 __ATTRS_o_ai
12014 vec_splats(unsigned __int128 __a) {
12015  return (vector unsigned __int128)(__a);
12016 }
12017 
12018 #endif
12019 
12020 static __inline__ vector double __ATTRS_o_ai vec_splats(double __a) {
12021  return (vector double)(__a);
12022 }
12023 #endif
12024 
12025 static __inline__ vector float __ATTRS_o_ai vec_splats(float __a) {
12026  return (vector float)(__a);
12027 }
12028 
12029 /* ----------------------------- predicates --------------------------------- */
12030 
12031 /* vec_all_eq */
12032 
12033 static __inline__ int __ATTRS_o_ai vec_all_eq(vector signed char __a,
12034  vector signed char __b) {
12035  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
12036  (vector char)__b);
12037 }
12038 
12039 static __inline__ int __ATTRS_o_ai vec_all_eq(vector signed char __a,
12040  vector bool char __b) {
12041  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
12042  (vector char)__b);
12043 }
12044 
12045 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned char __a,
12046  vector unsigned char __b) {
12047  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
12048  (vector char)__b);
12049 }
12050 
12051 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned char __a,
12052  vector bool char __b) {
12053  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
12054  (vector char)__b);
12055 }
12056 
12057 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool char __a,
12058  vector signed char __b) {
12059  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
12060  (vector char)__b);
12061 }
12062 
12063 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool char __a,
12064  vector unsigned char __b) {
12065  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
12066  (vector char)__b);
12067 }
12068 
12069 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool char __a,
12070  vector bool char __b) {
12071  return __builtin_altivec_vcmpequb_p(__CR6_LT, (vector char)__a,
12072  (vector char)__b);
12073 }
12074 
12075 static __inline__ int __ATTRS_o_ai vec_all_eq(vector short __a,
12076  vector short __b) {
12077  return __builtin_altivec_vcmpequh_p(__CR6_LT, __a, __b);
12078 }
12079 
12080 static __inline__ int __ATTRS_o_ai vec_all_eq(vector short __a,
12081  vector bool short __b) {
12082  return __builtin_altivec_vcmpequh_p(__CR6_LT, __a, (vector short)__b);
12083 }
12084 
12085 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned short __a,
12086  vector unsigned short __b) {
12087  return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
12088  (vector short)__b);
12089 }
12090 
12091 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned short __a,
12092  vector bool short __b) {
12093  return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
12094  (vector short)__b);
12095 }
12096 
12097 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool short __a,
12098  vector short __b) {
12099  return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
12100  (vector short)__b);
12101 }
12102 
12103 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool short __a,
12104  vector unsigned short __b) {
12105  return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
12106  (vector short)__b);
12107 }
12108 
12109 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool short __a,
12110  vector bool short __b) {
12111  return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
12112  (vector short)__b);
12113 }
12114 
12115 static __inline__ int __ATTRS_o_ai vec_all_eq(vector pixel __a,
12116  vector pixel __b) {
12117  return __builtin_altivec_vcmpequh_p(__CR6_LT, (vector short)__a,
12118  (vector short)__b);
12119 }
12120 
12121 static __inline__ int __ATTRS_o_ai vec_all_eq(vector int __a, vector int __b) {
12122  return __builtin_altivec_vcmpequw_p(__CR6_LT, __a, __b);
12123 }
12124 
12125 static __inline__ int __ATTRS_o_ai vec_all_eq(vector int __a,
12126  vector bool int __b) {
12127  return __builtin_altivec_vcmpequw_p(__CR6_LT, __a, (vector int)__b);
12128 }
12129 
12130 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned int __a,
12131  vector unsigned int __b) {
12132  return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
12133  (vector int)__b);
12134 }
12135 
12136 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned int __a,
12137  vector bool int __b) {
12138  return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
12139  (vector int)__b);
12140 }
12141 
12142 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool int __a,
12143  vector int __b) {
12144  return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
12145  (vector int)__b);
12146 }
12147 
12148 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool int __a,
12149  vector unsigned int __b) {
12150  return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
12151  (vector int)__b);
12152 }
12153 
12154 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool int __a,
12155  vector bool int __b) {
12156  return __builtin_altivec_vcmpequw_p(__CR6_LT, (vector int)__a,
12157  (vector int)__b);
12158 }
12159 
12160 #ifdef __POWER8_VECTOR__
12161 static __inline__ int __ATTRS_o_ai vec_all_eq(vector signed long long __a,
12162  vector signed long long __b) {
12163  return __builtin_altivec_vcmpequd_p(__CR6_LT, __a, __b);
12164 }
12165 
12166 static __inline__ int __ATTRS_o_ai vec_all_eq(vector long long __a,
12167  vector bool long long __b) {
12168  return __builtin_altivec_vcmpequd_p(__CR6_LT, __a, (vector long long)__b);
12169 }
12170 
12171 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned long long __a,
12172  vector unsigned long long __b) {
12173  return __builtin_altivec_vcmpequd_p(__CR6_LT, (vector long long)__a,
12174  (vector long long)__b);
12175 }
12176 
12177 static __inline__ int __ATTRS_o_ai vec_all_eq(vector unsigned long long __a,
12178  vector bool long long __b) {
12179  return __builtin_altivec_vcmpequd_p(__CR6_LT, (vector long long)__a,
12180  (vector long long)__b);
12181 }
12182 
12183 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool long long __a,
12184  vector long long __b) {
12185  return __builtin_altivec_vcmpequd_p(__CR6_LT, (vector long long)__a,
12186  (vector long long)__b);
12187 }
12188 
12189 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool long long __a,
12190  vector unsigned long long __b) {
12191  return __builtin_altivec_vcmpequd_p(__CR6_LT, (vector long long)__a,
12192  (vector long long)__b);
12193 }
12194 
12195 static __inline__ int __ATTRS_o_ai vec_all_eq(vector bool long long __a,
12196  vector bool long long __b) {
12197  return __builtin_altivec_vcmpequd_p(__CR6_LT, (vector long long)__a,
12198  (vector long long)__b);
12199 }
12200 #endif
12201 
12202 static __inline__ int __ATTRS_o_ai vec_all_eq(vector float __a,
12203  vector float __b) {
12204 #ifdef __VSX__
12205  return __builtin_vsx_xvcmpeqsp_p(__CR6_LT, __a, __b);
12206 #else
12207  return __builtin_altivec_vcmpeqfp_p(__CR6_LT, __a, __b);
12208 #endif
12209 }
12210 
12211 #ifdef __VSX__
12212 static __inline__ int __ATTRS_o_ai vec_all_eq(vector double __a,
12213  vector double __b) {
12214  return __builtin_vsx_xvcmpeqdp_p(__CR6_LT, __a, __b);
12215 }
12216 #endif
12217 
12218 /* vec_all_ge */
12219 
12220 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed char __a,
12221  vector signed char __b) {
12222  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, __b, __a);
12223 }
12224 
12225 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed char __a,
12226  vector bool char __b) {
12227  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, (vector signed char)__b, __a);
12228 }
12229 
12230 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned char __a,
12231  vector unsigned char __b) {
12232  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __b, __a);
12233 }
12234 
12235 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned char __a,
12236  vector bool char __b) {
12237  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__b, __a);
12238 }
12239 
12240 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool char __a,
12241  vector signed char __b) {
12242  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__b,
12243  (vector unsigned char)__a);
12244 }
12245 
12246 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool char __a,
12247  vector unsigned char __b) {
12248  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __b, (vector unsigned char)__a);
12249 }
12250 
12251 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool char __a,
12252  vector bool char __b) {
12253  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__b,
12254  (vector unsigned char)__a);
12255 }
12256 
12257 static __inline__ int __ATTRS_o_ai vec_all_ge(vector short __a,
12258  vector short __b) {
12259  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, __b, __a);
12260 }
12261 
12262 static __inline__ int __ATTRS_o_ai vec_all_ge(vector short __a,
12263  vector bool short __b) {
12264  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, (vector short)__b, __a);
12265 }
12266 
12267 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned short __a,
12268  vector unsigned short __b) {
12269  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __b, __a);
12270 }
12271 
12272 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned short __a,
12273  vector bool short __b) {
12274  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__b,
12275  __a);
12276 }
12277 
12278 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool short __a,
12279  vector short __b) {
12280  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__b,
12281  (vector unsigned short)__a);
12282 }
12283 
12284 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool short __a,
12285  vector unsigned short __b) {
12286  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __b,
12287  (vector unsigned short)__a);
12288 }
12289 
12290 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool short __a,
12291  vector bool short __b) {
12292  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__b,
12293  (vector unsigned short)__a);
12294 }
12295 
12296 static __inline__ int __ATTRS_o_ai vec_all_ge(vector int __a, vector int __b) {
12297  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, __b, __a);
12298 }
12299 
12300 static __inline__ int __ATTRS_o_ai vec_all_ge(vector int __a,
12301  vector bool int __b) {
12302  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, (vector int)__b, __a);
12303 }
12304 
12305 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned int __a,
12306  vector unsigned int __b) {
12307  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __b, __a);
12308 }
12309 
12310 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned int __a,
12311  vector bool int __b) {
12312  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__b, __a);
12313 }
12314 
12315 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool int __a,
12316  vector int __b) {
12317  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__b,
12318  (vector unsigned int)__a);
12319 }
12320 
12321 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool int __a,
12322  vector unsigned int __b) {
12323  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __b, (vector unsigned int)__a);
12324 }
12325 
12326 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool int __a,
12327  vector bool int __b) {
12328  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__b,
12329  (vector unsigned int)__a);
12330 }
12331 
12332 #ifdef __POWER8_VECTOR__
12333 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed long long __a,
12334  vector signed long long __b) {
12335  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, __b, __a);
12336 }
12337 static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed long long __a,
12338  vector bool long long __b) {
12339  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, (vector signed long long)__b,
12340  __a);
12341 }
12342 
12343 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned long long __a,
12344  vector unsigned long long __b) {
12345  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __b, __a);
12346 }
12347 
12348 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned long long __a,
12349  vector bool long long __b) {
12350  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__b,
12351  __a);
12352 }
12353 
12354 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool long long __a,
12355  vector signed long long __b) {
12356  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__b,
12357  (vector unsigned long long)__a);
12358 }
12359 
12360 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool long long __a,
12361  vector unsigned long long __b) {
12362  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __b,
12363  (vector unsigned long long)__a);
12364 }
12365 
12366 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool long long __a,
12367  vector bool long long __b) {
12368  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__b,
12369  (vector unsigned long long)__a);
12370 }
12371 #endif
12372 
12373 static __inline__ int __ATTRS_o_ai vec_all_ge(vector float __a,
12374  vector float __b) {
12375 #ifdef __VSX__
12376  return __builtin_vsx_xvcmpgesp_p(__CR6_LT, __a, __b);
12377 #else
12378  return __builtin_altivec_vcmpgefp_p(__CR6_LT, __a, __b);
12379 #endif
12380 }
12381 
12382 #ifdef __VSX__
12383 static __inline__ int __ATTRS_o_ai vec_all_ge(vector double __a,
12384  vector double __b) {
12385  return __builtin_vsx_xvcmpgedp_p(__CR6_LT, __a, __b);
12386 }
12387 #endif
12388 
12389 /* vec_all_gt */
12390 
12391 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed char __a,
12392  vector signed char __b) {
12393  return __builtin_altivec_vcmpgtsb_p(__CR6_LT, __a, __b);
12394 }
12395 
12396 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed char __a,
12397  vector bool char __b) {
12398  return __builtin_altivec_vcmpgtsb_p(__CR6_LT, __a, (vector signed char)__b);
12399 }
12400 
12401 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned char __a,
12402  vector unsigned char __b) {
12403  return __builtin_altivec_vcmpgtub_p(__CR6_LT, __a, __b);
12404 }
12405 
12406 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned char __a,
12407  vector bool char __b) {
12408  return __builtin_altivec_vcmpgtub_p(__CR6_LT, __a, (vector unsigned char)__b);
12409 }
12410 
12411 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool char __a,
12412  vector signed char __b) {
12413  return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__a,
12414  (vector unsigned char)__b);
12415 }
12416 
12417 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool char __a,
12418  vector unsigned char __b) {
12419  return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__a, __b);
12420 }
12421 
12422 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool char __a,
12423  vector bool char __b) {
12424  return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__a,
12425  (vector unsigned char)__b);
12426 }
12427 
12428 static __inline__ int __ATTRS_o_ai vec_all_gt(vector short __a,
12429  vector short __b) {
12430  return __builtin_altivec_vcmpgtsh_p(__CR6_LT, __a, __b);
12431 }
12432 
12433 static __inline__ int __ATTRS_o_ai vec_all_gt(vector short __a,
12434  vector bool short __b) {
12435  return __builtin_altivec_vcmpgtsh_p(__CR6_LT, __a, (vector short)__b);
12436 }
12437 
12438 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned short __a,
12439  vector unsigned short __b) {
12440  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __a, __b);
12441 }
12442 
12443 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned short __a,
12444  vector bool short __b) {
12445  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __a,
12446  (vector unsigned short)__b);
12447 }
12448 
12449 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool short __a,
12450  vector short __b) {
12451  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__a,
12452  (vector unsigned short)__b);
12453 }
12454 
12455 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool short __a,
12456  vector unsigned short __b) {
12457  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__a,
12458  __b);
12459 }
12460 
12461 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool short __a,
12462  vector bool short __b) {
12463  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__a,
12464  (vector unsigned short)__b);
12465 }
12466 
12467 static __inline__ int __ATTRS_o_ai vec_all_gt(vector int __a, vector int __b) {
12468  return __builtin_altivec_vcmpgtsw_p(__CR6_LT, __a, __b);
12469 }
12470 
12471 static __inline__ int __ATTRS_o_ai vec_all_gt(vector int __a,
12472  vector bool int __b) {
12473  return __builtin_altivec_vcmpgtsw_p(__CR6_LT, __a, (vector int)__b);
12474 }
12475 
12476 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned int __a,
12477  vector unsigned int __b) {
12478  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __a, __b);
12479 }
12480 
12481 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned int __a,
12482  vector bool int __b) {
12483  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __a, (vector unsigned int)__b);
12484 }
12485 
12486 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool int __a,
12487  vector int __b) {
12488  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__a,
12489  (vector unsigned int)__b);
12490 }
12491 
12492 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool int __a,
12493  vector unsigned int __b) {
12494  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__a, __b);
12495 }
12496 
12497 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool int __a,
12498  vector bool int __b) {
12499  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__a,
12500  (vector unsigned int)__b);
12501 }
12502 
12503 #ifdef __POWER8_VECTOR__
12504 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed long long __a,
12505  vector signed long long __b) {
12506  return __builtin_altivec_vcmpgtsd_p(__CR6_LT, __a, __b);
12507 }
12508 static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed long long __a,
12509  vector bool long long __b) {
12510  return __builtin_altivec_vcmpgtsd_p(__CR6_LT, __a,
12511  (vector signed long long)__b);
12512 }
12513 
12514 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned long long __a,
12515  vector unsigned long long __b) {
12516  return __builtin_altivec_vcmpgtud_p(__CR6_LT, __a, __b);
12517 }
12518 
12519 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned long long __a,
12520  vector bool long long __b) {
12521  return __builtin_altivec_vcmpgtud_p(__CR6_LT, __a,
12522  (vector unsigned long long)__b);
12523 }
12524 
12525 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool long long __a,
12526  vector signed long long __b) {
12527  return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__a,
12528  (vector unsigned long long)__b);
12529 }
12530 
12531 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool long long __a,
12532  vector unsigned long long __b) {
12533  return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__a,
12534  __b);
12535 }
12536 
12537 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool long long __a,
12538  vector bool long long __b) {
12539  return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__a,
12540  (vector unsigned long long)__b);
12541 }
12542 #endif
12543 
12544 static __inline__ int __ATTRS_o_ai vec_all_gt(vector float __a,
12545  vector float __b) {
12546 #ifdef __VSX__
12547  return __builtin_vsx_xvcmpgtsp_p(__CR6_LT, __a, __b);
12548 #else
12549  return __builtin_altivec_vcmpgtfp_p(__CR6_LT, __a, __b);
12550 #endif
12551 }
12552 
12553 #ifdef __VSX__
12554 static __inline__ int __ATTRS_o_ai vec_all_gt(vector double __a,
12555  vector double __b) {
12556  return __builtin_vsx_xvcmpgtdp_p(__CR6_LT, __a, __b);
12557 }
12558 #endif
12559 
12560 /* vec_all_in */
12561 
12562 static __inline__ int __attribute__((__always_inline__))
12563 vec_all_in(vector float __a, vector float __b) {
12564  return __builtin_altivec_vcmpbfp_p(__CR6_EQ, __a, __b);
12565 }
12566 
12567 /* vec_all_le */
12568 
12569 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed char __a,
12570  vector signed char __b) {
12571  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, __a, __b);
12572 }
12573 
12574 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed char __a,
12575  vector bool char __b) {
12576  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, __a, (vector signed char)__b);
12577 }
12578 
12579 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned char __a,
12580  vector unsigned char __b) {
12581  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __a, __b);
12582 }
12583 
12584 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned char __a,
12585  vector bool char __b) {
12586  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __a, (vector unsigned char)__b);
12587 }
12588 
12589 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool char __a,
12590  vector signed char __b) {
12591  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__a,
12592  (vector unsigned char)__b);
12593 }
12594 
12595 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool char __a,
12596  vector unsigned char __b) {
12597  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__a, __b);
12598 }
12599 
12600 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool char __a,
12601  vector bool char __b) {
12602  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__a,
12603  (vector unsigned char)__b);
12604 }
12605 
12606 static __inline__ int __ATTRS_o_ai vec_all_le(vector short __a,
12607  vector short __b) {
12608  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, __a, __b);
12609 }
12610 
12611 static __inline__ int __ATTRS_o_ai vec_all_le(vector short __a,
12612  vector bool short __b) {
12613  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, __a, (vector short)__b);
12614 }
12615 
12616 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned short __a,
12617  vector unsigned short __b) {
12618  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __a, __b);
12619 }
12620 
12621 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned short __a,
12622  vector bool short __b) {
12623  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __a,
12624  (vector unsigned short)__b);
12625 }
12626 
12627 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool short __a,
12628  vector short __b) {
12629  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__a,
12630  (vector unsigned short)__b);
12631 }
12632 
12633 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool short __a,
12634  vector unsigned short __b) {
12635  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__a,
12636  __b);
12637 }
12638 
12639 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool short __a,
12640  vector bool short __b) {
12641  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__a,
12642  (vector unsigned short)__b);
12643 }
12644 
12645 static __inline__ int __ATTRS_o_ai vec_all_le(vector int __a, vector int __b) {
12646  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, __a, __b);
12647 }
12648 
12649 static __inline__ int __ATTRS_o_ai vec_all_le(vector int __a,
12650  vector bool int __b) {
12651  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, __a, (vector int)__b);
12652 }
12653 
12654 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned int __a,
12655  vector unsigned int __b) {
12656  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __a, __b);
12657 }
12658 
12659 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned int __a,
12660  vector bool int __b) {
12661  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __a, (vector unsigned int)__b);
12662 }
12663 
12664 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool int __a,
12665  vector int __b) {
12666  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__a,
12667  (vector unsigned int)__b);
12668 }
12669 
12670 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool int __a,
12671  vector unsigned int __b) {
12672  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__a, __b);
12673 }
12674 
12675 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool int __a,
12676  vector bool int __b) {
12677  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__a,
12678  (vector unsigned int)__b);
12679 }
12680 
12681 #ifdef __POWER8_VECTOR__
12682 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed long long __a,
12683  vector signed long long __b) {
12684  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, __a, __b);
12685 }
12686 
12687 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned long long __a,
12688  vector unsigned long long __b) {
12689  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __a, __b);
12690 }
12691 
12692 static __inline__ int __ATTRS_o_ai vec_all_le(vector signed long long __a,
12693  vector bool long long __b) {
12694  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, __a,
12695  (vector signed long long)__b);
12696 }
12697 
12698 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned long long __a,
12699  vector bool long long __b) {
12700  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __a,
12701  (vector unsigned long long)__b);
12702 }
12703 
12704 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool long long __a,
12705  vector signed long long __b) {
12706  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__a,
12707  (vector unsigned long long)__b);
12708 }
12709 
12710 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool long long __a,
12711  vector unsigned long long __b) {
12712  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__a,
12713  __b);
12714 }
12715 
12716 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool long long __a,
12717  vector bool long long __b) {
12718  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__a,
12719  (vector unsigned long long)__b);
12720 }
12721 #endif
12722 
12723 static __inline__ int __ATTRS_o_ai vec_all_le(vector float __a,
12724  vector float __b) {
12725 #ifdef __VSX__
12726  return __builtin_vsx_xvcmpgesp_p(__CR6_LT, __b, __a);
12727 #else
12728  return __builtin_altivec_vcmpgefp_p(__CR6_LT, __b, __a);
12729 #endif
12730 }
12731 
12732 #ifdef __VSX__
12733 static __inline__ int __ATTRS_o_ai vec_all_le(vector double __a,
12734  vector double __b) {
12735  return __builtin_vsx_xvcmpgedp_p(__CR6_LT, __b, __a);
12736 }
12737 #endif
12738 
12739 /* vec_all_lt */
12740 
12741 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed char __a,
12742  vector signed char __b) {
12743  return __builtin_altivec_vcmpgtsb_p(__CR6_LT, __b, __a);
12744 }
12745 
12746 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed char __a,
12747  vector bool char __b) {
12748  return __builtin_altivec_vcmpgtsb_p(__CR6_LT, (vector signed char)__b, __a);
12749 }
12750 
12751 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned char __a,
12752  vector unsigned char __b) {
12753  return __builtin_altivec_vcmpgtub_p(__CR6_LT, __b, __a);
12754 }
12755 
12756 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned char __a,
12757  vector bool char __b) {
12758  return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__b, __a);
12759 }
12760 
12761 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool char __a,
12762  vector signed char __b) {
12763  return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__b,
12764  (vector unsigned char)__a);
12765 }
12766 
12767 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool char __a,
12768  vector unsigned char __b) {
12769  return __builtin_altivec_vcmpgtub_p(__CR6_LT, __b, (vector unsigned char)__a);
12770 }
12771 
12772 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool char __a,
12773  vector bool char __b) {
12774  return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__b,
12775  (vector unsigned char)__a);
12776 }
12777 
12778 static __inline__ int __ATTRS_o_ai vec_all_lt(vector short __a,
12779  vector short __b) {
12780  return __builtin_altivec_vcmpgtsh_p(__CR6_LT, __b, __a);
12781 }
12782 
12783 static __inline__ int __ATTRS_o_ai vec_all_lt(vector short __a,
12784  vector bool short __b) {
12785  return __builtin_altivec_vcmpgtsh_p(__CR6_LT, (vector short)__b, __a);
12786 }
12787 
12788 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned short __a,
12789  vector unsigned short __b) {
12790  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __b, __a);
12791 }
12792 
12793 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned short __a,
12794  vector bool short __b) {
12795  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__b,
12796  __a);
12797 }
12798 
12799 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool short __a,
12800  vector short __b) {
12801  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__b,
12802  (vector unsigned short)__a);
12803 }
12804 
12805 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool short __a,
12806  vector unsigned short __b) {
12807  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __b,
12808  (vector unsigned short)__a);
12809 }
12810 
12811 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool short __a,
12812  vector bool short __b) {
12813  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__b,
12814  (vector unsigned short)__a);
12815 }
12816 
12817 static __inline__ int __ATTRS_o_ai vec_all_lt(vector int __a, vector int __b) {
12818  return __builtin_altivec_vcmpgtsw_p(__CR6_LT, __b, __a);
12819 }
12820 
12821 static __inline__ int __ATTRS_o_ai vec_all_lt(vector int __a,
12822  vector bool int __b) {
12823  return __builtin_altivec_vcmpgtsw_p(__CR6_LT, (vector int)__b, __a);
12824 }
12825 
12826 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned int __a,
12827  vector unsigned int __b) {
12828  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __b, __a);
12829 }
12830 
12831 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned int __a,
12832  vector bool int __b) {
12833  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__b, __a);
12834 }
12835 
12836 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool int __a,
12837  vector int __b) {
12838  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__b,
12839  (vector unsigned int)__a);
12840 }
12841 
12842 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool int __a,
12843  vector unsigned int __b) {
12844  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __b, (vector unsigned int)__a);
12845 }
12846 
12847 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool int __a,
12848  vector bool int __b) {
12849  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__b,
12850  (vector unsigned int)__a);
12851 }
12852 
12853 #ifdef __POWER8_VECTOR__
12854 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed long long __a,
12855  vector signed long long __b) {
12856  return __builtin_altivec_vcmpgtsd_p(__CR6_LT, __b, __a);
12857 }
12858 
12859 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned long long __a,
12860  vector unsigned long long __b) {
12861  return __builtin_altivec_vcmpgtud_p(__CR6_LT, __b, __a);
12862 }
12863 
12864 static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed long long __a,
12865  vector bool long long __b) {
12866  return __builtin_altivec_vcmpgtsd_p(__CR6_LT, (vector signed long long)__b,
12867  __a);
12868 }
12869 
12870 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned long long __a,
12871  vector bool long long __b) {
12872  return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__b,
12873  __a);
12874 }
12875 
12876 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool long long __a,
12877  vector signed long long __b) {
12878  return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__b,
12879  (vector unsigned long long)__a);
12880 }
12881 
12882 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool long long __a,
12883  vector unsigned long long __b) {
12884  return __builtin_altivec_vcmpgtud_p(__CR6_LT, __b,
12885  (vector unsigned long long)__a);
12886 }
12887 
12888 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool long long __a,
12889  vector bool long long __b) {
12890  return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__b,
12891  (vector unsigned long long)__a);
12892 }
12893 #endif
12894 
12895 static __inline__ int __ATTRS_o_ai vec_all_lt(vector float __a,
12896  vector float __b) {
12897 #ifdef __VSX__
12898  return __builtin_vsx_xvcmpgtsp_p(__CR6_LT, __b, __a);
12899 #else
12900  return __builtin_altivec_vcmpgtfp_p(__CR6_LT, __b, __a);
12901 #endif
12902 }
12903 
12904 #ifdef __VSX__
12905 static __inline__ int __ATTRS_o_ai vec_all_lt(vector double __a,
12906  vector double __b) {
12907  return __builtin_vsx_xvcmpgtdp_p(__CR6_LT, __b, __a);
12908 }
12909 #endif
12910 
12911 /* vec_all_nan */
12912 
12913 static __inline__ int __ATTRS_o_ai vec_all_nan(vector float __a) {
12914 #ifdef __VSX__
12915  return __builtin_vsx_xvcmpeqsp_p(__CR6_EQ, __a, __a);
12916 #else
12917  return __builtin_altivec_vcmpeqfp_p(__CR6_EQ, __a, __a);
12918 #endif
12919 }
12920 
12921 #ifdef __VSX__
12922 static __inline__ int __ATTRS_o_ai vec_all_nan(vector double __a) {
12923  return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ, __a, __a);
12924 }
12925 #endif
12926 
12927 /* vec_all_ne */
12928 
12929 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed char __a,
12930  vector signed char __b) {
12931  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
12932  (vector char)__b);
12933 }
12934 
12935 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed char __a,
12936  vector bool char __b) {
12937  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
12938  (vector char)__b);
12939 }
12940 
12941 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned char __a,
12942  vector unsigned char __b) {
12943  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
12944  (vector char)__b);
12945 }
12946 
12947 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned char __a,
12948  vector bool char __b) {
12949  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
12950  (vector char)__b);
12951 }
12952 
12953 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool char __a,
12954  vector signed char __b) {
12955  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
12956  (vector char)__b);
12957 }
12958 
12959 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool char __a,
12960  vector unsigned char __b) {
12961  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
12962  (vector char)__b);
12963 }
12964 
12965 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool char __a,
12966  vector bool char __b) {
12967  return __builtin_altivec_vcmpequb_p(__CR6_EQ, (vector char)__a,
12968  (vector char)__b);
12969 }
12970 
12971 static __inline__ int __ATTRS_o_ai vec_all_ne(vector short __a,
12972  vector short __b) {
12973  return __builtin_altivec_vcmpequh_p(__CR6_EQ, __a, __b);
12974 }
12975 
12976 static __inline__ int __ATTRS_o_ai vec_all_ne(vector short __a,
12977  vector bool short __b) {
12978  return __builtin_altivec_vcmpequh_p(__CR6_EQ, __a, (vector short)__b);
12979 }
12980 
12981 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned short __a,
12982  vector unsigned short __b) {
12983  return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
12984  (vector short)__b);
12985 }
12986 
12987 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned short __a,
12988  vector bool short __b) {
12989  return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
12990  (vector short)__b);
12991 }
12992 
12993 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool short __a,
12994  vector short __b) {
12995  return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
12996  (vector short)__b);
12997 }
12998 
12999 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool short __a,
13000  vector unsigned short __b) {
13001  return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
13002  (vector short)__b);
13003 }
13004 
13005 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool short __a,
13006  vector bool short __b) {
13007  return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
13008  (vector short)__b);
13009 }
13010 
13011 static __inline__ int __ATTRS_o_ai vec_all_ne(vector pixel __a,
13012  vector pixel __b) {
13013  return __builtin_altivec_vcmpequh_p(__CR6_EQ, (vector short)__a,
13014  (vector short)__b);
13015 }
13016 
13017 static __inline__ int __ATTRS_o_ai vec_all_ne(vector int __a, vector int __b) {
13018  return __builtin_altivec_vcmpequw_p(__CR6_EQ, __a, __b);
13019 }
13020 
13021 static __inline__ int __ATTRS_o_ai vec_all_ne(vector int __a,
13022  vector bool int __b) {
13023  return __builtin_altivec_vcmpequw_p(__CR6_EQ, __a, (vector int)__b);
13024 }
13025 
13026 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned int __a,
13027  vector unsigned int __b) {
13028  return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
13029  (vector int)__b);
13030 }
13031 
13032 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned int __a,
13033  vector bool int __b) {
13034  return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
13035  (vector int)__b);
13036 }
13037 
13038 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool int __a,
13039  vector int __b) {
13040  return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
13041  (vector int)__b);
13042 }
13043 
13044 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool int __a,
13045  vector unsigned int __b) {
13046  return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
13047  (vector int)__b);
13048 }
13049 
13050 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool int __a,
13051  vector bool int __b) {
13052  return __builtin_altivec_vcmpequw_p(__CR6_EQ, (vector int)__a,
13053  (vector int)__b);
13054 }
13055 
13056 #ifdef __POWER8_VECTOR__
13057 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed long long __a,
13058  vector signed long long __b) {
13059  return __builtin_altivec_vcmpequd_p(__CR6_EQ, __a, __b);
13060 }
13061 
13062 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned long long __a,
13063  vector unsigned long long __b) {
13064  return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector long long)__a,
13065  (vector long long)__b);
13066 }
13067 
13068 static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed long long __a,
13069  vector bool long long __b) {
13070  return __builtin_altivec_vcmpequd_p(__CR6_EQ, __a,
13071  (vector signed long long)__b);
13072 }
13073 
13074 static __inline__ int __ATTRS_o_ai vec_all_ne(vector unsigned long long __a,
13075  vector bool long long __b) {
13076  return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector signed long long)__a,
13077  (vector signed long long)__b);
13078 }
13079 
13080 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool long long __a,
13081  vector signed long long __b) {
13082  return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector signed long long)__a,
13083  (vector signed long long)__b);
13084 }
13085 
13086 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool long long __a,
13087  vector unsigned long long __b) {
13088  return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector signed long long)__a,
13089  (vector signed long long)__b);
13090 }
13091 
13092 static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool long long __a,
13093  vector bool long long __b) {
13094  return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector signed long long)__a,
13095  (vector signed long long)__b);
13096 }
13097 #endif
13098 
13099 static __inline__ int __ATTRS_o_ai vec_all_ne(vector float __a,
13100  vector float __b) {
13101 #ifdef __VSX__
13102  return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ, __a, __b);
13103 #else
13104  return __builtin_altivec_vcmpeqfp_p(__CR6_EQ, __a, __b);
13105 #endif
13106 }
13107 
13108 #ifdef __VSX__
13109 static __inline__ int __ATTRS_o_ai vec_all_ne(vector double __a,
13110  vector double __b) {
13111  return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ, __a, __b);
13112 }
13113 #endif
13114 
13115 /* vec_all_nge */
13116 
13117 static __inline__ int __ATTRS_o_ai vec_all_nge(vector float __a,
13118  vector float __b) {
13119 #ifdef __VSX__
13120  return __builtin_vsx_xvcmpgesp_p(__CR6_EQ, __a, __b);
13121 #else
13122  return __builtin_altivec_vcmpgefp_p(__CR6_EQ, __a, __b);
13123 #endif
13124 }
13125 
13126 #ifdef __VSX__
13127 static __inline__ int __ATTRS_o_ai vec_all_nge(vector double __a,
13128  vector double __b) {
13129  return __builtin_vsx_xvcmpgedp_p(__CR6_EQ, __a, __b);
13130 }
13131 #endif
13132 
13133 /* vec_all_ngt */
13134 
13135 static __inline__ int __ATTRS_o_ai vec_all_ngt(vector float __a,
13136  vector float __b) {
13137 #ifdef __VSX__
13138  return __builtin_vsx_xvcmpgtsp_p(__CR6_EQ, __a, __b);
13139 #else
13140  return __builtin_altivec_vcmpgtfp_p(__CR6_EQ, __a, __b);
13141 #endif
13142 }
13143 
13144 #ifdef __VSX__
13145 static __inline__ int __ATTRS_o_ai vec_all_ngt(vector double __a,
13146  vector double __b) {
13147  return __builtin_vsx_xvcmpgtdp_p(__CR6_EQ, __a, __b);
13148 }
13149 #endif
13150 
13151 /* vec_all_nle */
13152 
13153 static __inline__ int __attribute__((__always_inline__))
13154 vec_all_nle(vector float __a, vector float __b) {
13155  return __builtin_altivec_vcmpgefp_p(__CR6_EQ, __b, __a);
13156 }
13157 
13158 /* vec_all_nlt */
13159 
13160 static __inline__ int __attribute__((__always_inline__))
13161 vec_all_nlt(vector float __a, vector float __b) {
13162  return __builtin_altivec_vcmpgtfp_p(__CR6_EQ, __b, __a);
13163 }
13164 
13165 /* vec_all_numeric */
13166 
13167 static __inline__ int __attribute__((__always_inline__))
13168 vec_all_numeric(vector float __a) {
13169  return __builtin_altivec_vcmpeqfp_p(__CR6_LT, __a, __a);
13170 }
13171 
13172 /* vec_any_eq */
13173 
13174 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed char __a,
13175  vector signed char __b) {
13176  return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
13177  (vector char)__b);
13178 }
13179 
13180 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed char __a,
13181  vector bool char __b) {
13182  return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
13183  (vector char)__b);
13184 }
13185 
13186 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned char __a,
13187  vector unsigned char __b) {
13188  return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
13189  (vector char)__b);
13190 }
13191 
13192 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned char __a,
13193  vector bool char __b) {
13194  return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
13195  (vector char)__b);
13196 }
13197 
13198 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool char __a,
13199  vector signed char __b) {
13200  return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
13201  (vector char)__b);
13202 }
13203 
13204 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool char __a,
13205  vector unsigned char __b) {
13206  return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
13207  (vector char)__b);
13208 }
13209 
13210 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool char __a,
13211  vector bool char __b) {
13212  return __builtin_altivec_vcmpequb_p(__CR6_EQ_REV, (vector char)__a,
13213  (vector char)__b);
13214 }
13215 
13216 static __inline__ int __ATTRS_o_ai vec_any_eq(vector short __a,
13217  vector short __b) {
13218  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, __a, __b);
13219 }
13220 
13221 static __inline__ int __ATTRS_o_ai vec_any_eq(vector short __a,
13222  vector bool short __b) {
13223  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, __a, (vector short)__b);
13224 }
13225 
13226 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned short __a,
13227  vector unsigned short __b) {
13228  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
13229  (vector short)__b);
13230 }
13231 
13232 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned short __a,
13233  vector bool short __b) {
13234  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
13235  (vector short)__b);
13236 }
13237 
13238 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool short __a,
13239  vector short __b) {
13240  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
13241  (vector short)__b);
13242 }
13243 
13244 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool short __a,
13245  vector unsigned short __b) {
13246  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
13247  (vector short)__b);
13248 }
13249 
13250 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool short __a,
13251  vector bool short __b) {
13252  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
13253  (vector short)__b);
13254 }
13255 
13256 static __inline__ int __ATTRS_o_ai vec_any_eq(vector pixel __a,
13257  vector pixel __b) {
13258  return __builtin_altivec_vcmpequh_p(__CR6_EQ_REV, (vector short)__a,
13259  (vector short)__b);
13260 }
13261 
13262 static __inline__ int __ATTRS_o_ai vec_any_eq(vector int __a, vector int __b) {
13263  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, __a, __b);
13264 }
13265 
13266 static __inline__ int __ATTRS_o_ai vec_any_eq(vector int __a,
13267  vector bool int __b) {
13268  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, __a, (vector int)__b);
13269 }
13270 
13271 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned int __a,
13272  vector unsigned int __b) {
13273  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
13274  (vector int)__b);
13275 }
13276 
13277 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned int __a,
13278  vector bool int __b) {
13279  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
13280  (vector int)__b);
13281 }
13282 
13283 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool int __a,
13284  vector int __b) {
13285  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
13286  (vector int)__b);
13287 }
13288 
13289 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool int __a,
13290  vector unsigned int __b) {
13291  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
13292  (vector int)__b);
13293 }
13294 
13295 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool int __a,
13296  vector bool int __b) {
13297  return __builtin_altivec_vcmpequw_p(__CR6_EQ_REV, (vector int)__a,
13298  (vector int)__b);
13299 }
13300 
13301 #ifdef __POWER8_VECTOR__
13302 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed long long __a,
13303  vector signed long long __b) {
13304  return __builtin_altivec_vcmpequd_p(__CR6_EQ_REV, __a, __b);
13305 }
13306 
13307 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned long long __a,
13308  vector unsigned long long __b) {
13309  return __builtin_altivec_vcmpequd_p(__CR6_EQ_REV, (vector long long)__a,
13310  (vector long long)__b);
13311 }
13312 
13313 static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed long long __a,
13314  vector bool long long __b) {
13315  return __builtin_altivec_vcmpequd_p(__CR6_EQ_REV, __a,
13316  (vector signed long long)__b);
13317 }
13318 
13319 static __inline__ int __ATTRS_o_ai vec_any_eq(vector unsigned long long __a,
13320  vector bool long long __b) {
13321  return __builtin_altivec_vcmpequd_p(
13322  __CR6_EQ_REV, (vector signed long long)__a, (vector signed long long)__b);
13323 }
13324 
13325 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool long long __a,
13326  vector signed long long __b) {
13327  return __builtin_altivec_vcmpequd_p(
13328  __CR6_EQ_REV, (vector signed long long)__a, (vector signed long long)__b);
13329 }
13330 
13331 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool long long __a,
13332  vector unsigned long long __b) {
13333  return __builtin_altivec_vcmpequd_p(
13334  __CR6_EQ_REV, (vector signed long long)__a, (vector signed long long)__b);
13335 }
13336 
13337 static __inline__ int __ATTRS_o_ai vec_any_eq(vector bool long long __a,
13338  vector bool long long __b) {
13339  return __builtin_altivec_vcmpequd_p(
13340  __CR6_EQ_REV, (vector signed long long)__a, (vector signed long long)__b);
13341 }
13342 #endif
13343 
13344 static __inline__ int __ATTRS_o_ai vec_any_eq(vector float __a,
13345  vector float __b) {
13346 #ifdef __VSX__
13347  return __builtin_vsx_xvcmpeqsp_p(__CR6_EQ_REV, __a, __b);
13348 #else
13349  return __builtin_altivec_vcmpeqfp_p(__CR6_EQ_REV, __a, __b);
13350 #endif
13351 }
13352 
13353 #ifdef __VSX__
13354 static __inline__ int __ATTRS_o_ai vec_any_eq(vector double __a,
13355  vector double __b) {
13356  return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ_REV, __a, __b);
13357 }
13358 #endif
13359 
13360 /* vec_any_ge */
13361 
13362 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed char __a,
13363  vector signed char __b) {
13364  return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, __b, __a);
13365 }
13366 
13367 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed char __a,
13368  vector bool char __b) {
13369  return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, (vector signed char)__b,
13370  __a);
13371 }
13372 
13373 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned char __a,
13374  vector unsigned char __b) {
13375  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __b, __a);
13376 }
13377 
13378 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned char __a,
13379  vector bool char __b) {
13380  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__b,
13381  __a);
13382 }
13383 
13384 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool char __a,
13385  vector signed char __b) {
13386  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__b,
13387  (vector unsigned char)__a);
13388 }
13389 
13390 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool char __a,
13391  vector unsigned char __b) {
13392  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __b,
13393  (vector unsigned char)__a);
13394 }
13395 
13396 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool char __a,
13397  vector bool char __b) {
13398  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__b,
13399  (vector unsigned char)__a);
13400 }
13401 
13402 static __inline__ int __ATTRS_o_ai vec_any_ge(vector short __a,
13403  vector short __b) {
13404  return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, __b, __a);
13405 }
13406 
13407 static __inline__ int __ATTRS_o_ai vec_any_ge(vector short __a,
13408  vector bool short __b) {
13409  return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, (vector short)__b, __a);
13410 }
13411 
13412 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned short __a,
13413  vector unsigned short __b) {
13414  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __b, __a);
13415 }
13416 
13417 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned short __a,
13418  vector bool short __b) {
13419  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__b,
13420  __a);
13421 }
13422 
13423 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool short __a,
13424  vector short __b) {
13425  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__b,
13426  (vector unsigned short)__a);
13427 }
13428 
13429 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool short __a,
13430  vector unsigned short __b) {
13431  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __b,
13432  (vector unsigned short)__a);
13433 }
13434 
13435 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool short __a,
13436  vector bool short __b) {
13437  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__b,
13438  (vector unsigned short)__a);
13439 }
13440 
13441 static __inline__ int __ATTRS_o_ai vec_any_ge(vector int __a, vector int __b) {
13442  return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, __b, __a);
13443 }
13444 
13445 static __inline__ int __ATTRS_o_ai vec_any_ge(vector int __a,
13446  vector bool int __b) {
13447  return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, (vector int)__b, __a);
13448 }
13449 
13450 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned int __a,
13451  vector unsigned int __b) {
13452  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __b, __a);
13453 }
13454 
13455 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned int __a,
13456  vector bool int __b) {
13457  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__b,
13458  __a);
13459 }
13460 
13461 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool int __a,
13462  vector int __b) {
13463  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__b,
13464  (vector unsigned int)__a);
13465 }
13466 
13467 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool int __a,
13468  vector unsigned int __b) {
13469  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __b,
13470  (vector unsigned int)__a);
13471 }
13472 
13473 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool int __a,
13474  vector bool int __b) {
13475  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__b,
13476  (vector unsigned int)__a);
13477 }
13478 
13479 #ifdef __POWER8_VECTOR__
13480 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed long long __a,
13481  vector signed long long __b) {
13482  return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV, __b, __a);
13483 }
13484 
13485 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned long long __a,
13486  vector unsigned long long __b) {
13487  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __b, __a);
13488 }
13489 
13490 static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed long long __a,
13491  vector bool long long __b) {
13492  return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV,
13493  (vector signed long long)__b, __a);
13494 }
13495 
13496 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned long long __a,
13497  vector bool long long __b) {
13498  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
13499  (vector unsigned long long)__b, __a);
13500 }
13501 
13502 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool long long __a,
13503  vector signed long long __b) {
13504  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
13505  (vector unsigned long long)__b,
13506  (vector unsigned long long)__a);
13507 }
13508 
13509 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool long long __a,
13510  vector unsigned long long __b) {
13511  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __b,
13512  (vector unsigned long long)__a);
13513 }
13514 
13515 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool long long __a,
13516  vector bool long long __b) {
13517  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
13518  (vector unsigned long long)__b,
13519  (vector unsigned long long)__a);
13520 }
13521 #endif
13522 
13523 static __inline__ int __ATTRS_o_ai vec_any_ge(vector float __a,
13524  vector float __b) {
13525 #ifdef __VSX__
13526  return __builtin_vsx_xvcmpgesp_p(__CR6_EQ_REV, __a, __b);
13527 #else
13528  return __builtin_altivec_vcmpgefp_p(__CR6_EQ_REV, __a, __b);
13529 #endif
13530 }
13531 
13532 #ifdef __VSX__
13533 static __inline__ int __ATTRS_o_ai vec_any_ge(vector double __a,
13534  vector double __b) {
13535  return __builtin_vsx_xvcmpgedp_p(__CR6_EQ_REV, __a, __b);
13536 }
13537 #endif
13538 
13539 /* vec_any_gt */
13540 
13541 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed char __a,
13542  vector signed char __b) {
13543  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, __a, __b);
13544 }
13545 
13546 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed char __a,
13547  vector bool char __b) {
13548  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, __a,
13549  (vector signed char)__b);
13550 }
13551 
13552 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned char __a,
13553  vector unsigned char __b) {
13554  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __a, __b);
13555 }
13556 
13557 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned char __a,
13558  vector bool char __b) {
13559  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __a,
13560  (vector unsigned char)__b);
13561 }
13562 
13563 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool char __a,
13564  vector signed char __b) {
13565  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__a,
13566  (vector unsigned char)__b);
13567 }
13568 
13569 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool char __a,
13570  vector unsigned char __b) {
13571  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__a,
13572  __b);
13573 }
13574 
13575 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool char __a,
13576  vector bool char __b) {
13577  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__a,
13578  (vector unsigned char)__b);
13579 }
13580 
13581 static __inline__ int __ATTRS_o_ai vec_any_gt(vector short __a,
13582  vector short __b) {
13583  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, __a, __b);
13584 }
13585 
13586 static __inline__ int __ATTRS_o_ai vec_any_gt(vector short __a,
13587  vector bool short __b) {
13588  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, __a, (vector short)__b);
13589 }
13590 
13591 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned short __a,
13592  vector unsigned short __b) {
13593  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __a, __b);
13594 }
13595 
13596 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned short __a,
13597  vector bool short __b) {
13598  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __a,
13599  (vector unsigned short)__b);
13600 }
13601 
13602 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool short __a,
13603  vector short __b) {
13604  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__a,
13605  (vector unsigned short)__b);
13606 }
13607 
13608 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool short __a,
13609  vector unsigned short __b) {
13610  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__a,
13611  __b);
13612 }
13613 
13614 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool short __a,
13615  vector bool short __b) {
13616  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__a,
13617  (vector unsigned short)__b);
13618 }
13619 
13620 static __inline__ int __ATTRS_o_ai vec_any_gt(vector int __a, vector int __b) {
13621  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, __a, __b);
13622 }
13623 
13624 static __inline__ int __ATTRS_o_ai vec_any_gt(vector int __a,
13625  vector bool int __b) {
13626  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, __a, (vector int)__b);
13627 }
13628 
13629 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned int __a,
13630  vector unsigned int __b) {
13631  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __a, __b);
13632 }
13633 
13634 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned int __a,
13635  vector bool int __b) {
13636  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __a,
13637  (vector unsigned int)__b);
13638 }
13639 
13640 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool int __a,
13641  vector int __b) {
13642  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__a,
13643  (vector unsigned int)__b);
13644 }
13645 
13646 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool int __a,
13647  vector unsigned int __b) {
13648  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__a,
13649  __b);
13650 }
13651 
13652 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool int __a,
13653  vector bool int __b) {
13654  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__a,
13655  (vector unsigned int)__b);
13656 }
13657 
13658 #ifdef __POWER8_VECTOR__
13659 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed long long __a,
13660  vector signed long long __b) {
13661  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV, __a, __b);
13662 }
13663 
13664 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned long long __a,
13665  vector unsigned long long __b) {
13666  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __a, __b);
13667 }
13668 
13669 static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed long long __a,
13670  vector bool long long __b) {
13671  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV, __a,
13672  (vector signed long long)__b);
13673 }
13674 
13675 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned long long __a,
13676  vector bool long long __b) {
13677  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __a,
13678  (vector unsigned long long)__b);
13679 }
13680 
13681 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool long long __a,
13682  vector signed long long __b) {
13683  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
13684  (vector unsigned long long)__a,
13685  (vector unsigned long long)__b);
13686 }
13687 
13688 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool long long __a,
13689  vector unsigned long long __b) {
13690  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
13691  (vector unsigned long long)__a, __b);
13692 }
13693 
13694 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool long long __a,
13695  vector bool long long __b) {
13696  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
13697  (vector unsigned long long)__a,
13698  (vector unsigned long long)__b);
13699 }
13700 #endif
13701 
13702 static __inline__ int __ATTRS_o_ai vec_any_gt(vector float __a,
13703  vector float __b) {
13704 #ifdef __VSX__
13705  return __builtin_vsx_xvcmpgtsp_p(__CR6_EQ_REV, __a, __b);
13706 #else
13707  return __builtin_altivec_vcmpgtfp_p(__CR6_EQ_REV, __a, __b);
13708 #endif
13709 }
13710 
13711 #ifdef __VSX__
13712 static __inline__ int __ATTRS_o_ai vec_any_gt(vector double __a,
13713  vector double __b) {
13714  return __builtin_vsx_xvcmpgtdp_p(__CR6_EQ_REV, __a, __b);
13715 }
13716 #endif
13717 
13718 /* vec_any_le */
13719 
13720 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed char __a,
13721  vector signed char __b) {
13722  return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, __a, __b);
13723 }
13724 
13725 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed char __a,
13726  vector bool char __b) {
13727  return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, __a,
13728  (vector signed char)__b);
13729 }
13730 
13731 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned char __a,
13732  vector unsigned char __b) {
13733  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __a, __b);
13734 }
13735 
13736 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned char __a,
13737  vector bool char __b) {
13738  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __a,
13739  (vector unsigned char)__b);
13740 }
13741 
13742 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool char __a,
13743  vector signed char __b) {
13744  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__a,
13745  (vector unsigned char)__b);
13746 }
13747 
13748 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool char __a,
13749  vector unsigned char __b) {
13750  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__a,
13751  __b);
13752 }
13753 
13754 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool char __a,
13755  vector bool char __b) {
13756  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__a,
13757  (vector unsigned char)__b);
13758 }
13759 
13760 static __inline__ int __ATTRS_o_ai vec_any_le(vector short __a,
13761  vector short __b) {
13762  return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, __a, __b);
13763 }
13764 
13765 static __inline__ int __ATTRS_o_ai vec_any_le(vector short __a,
13766  vector bool short __b) {
13767  return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, __a, (vector short)__b);
13768 }
13769 
13770 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned short __a,
13771  vector unsigned short __b) {
13772  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __a, __b);
13773 }
13774 
13775 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned short __a,
13776  vector bool short __b) {
13777  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __a,
13778  (vector unsigned short)__b);
13779 }
13780 
13781 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool short __a,
13782  vector short __b) {
13783  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__a,
13784  (vector unsigned short)__b);
13785 }
13786 
13787 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool short __a,
13788  vector unsigned short __b) {
13789  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__a,
13790  __b);
13791 }
13792 
13793 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool short __a,
13794  vector bool short __b) {
13795  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__a,
13796  (vector unsigned short)__b);
13797 }
13798 
13799 static __inline__ int __ATTRS_o_ai vec_any_le(vector int __a, vector int __b) {
13800  return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, __a, __b);
13801 }
13802 
13803 static __inline__ int __ATTRS_o_ai vec_any_le(vector int __a,
13804  vector bool int __b) {
13805  return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, __a, (vector int)__b);
13806 }
13807 
13808 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned int __a,
13809  vector unsigned int __b) {
13810  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __a, __b);
13811 }
13812 
13813 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned int __a,
13814  vector bool int __b) {
13815  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __a,
13816  (vector unsigned int)__b);
13817 }
13818 
13819 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool int __a,
13820  vector int __b) {
13821  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__a,
13822  (vector unsigned int)__b);
13823 }
13824 
13825 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool int __a,
13826  vector unsigned int __b) {
13827  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__a,
13828  __b);
13829 }
13830 
13831 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool int __a,
13832  vector bool int __b) {
13833  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__a,
13834  (vector unsigned int)__b);
13835 }
13836 
13837 #ifdef __POWER8_VECTOR__
13838 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed long long __a,
13839  vector signed long long __b) {
13840  return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV, __a, __b);
13841 }
13842 
13843 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned long long __a,
13844  vector unsigned long long __b) {
13845  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __a, __b);
13846 }
13847 
13848 static __inline__ int __ATTRS_o_ai vec_any_le(vector signed long long __a,
13849  vector bool long long __b) {
13850  return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV, __a,
13851  (vector signed long long)__b);
13852 }
13853 
13854 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned long long __a,
13855  vector bool long long __b) {
13856  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __a,
13857  (vector unsigned long long)__b);
13858 }
13859 
13860 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool long long __a,
13861  vector signed long long __b) {
13862  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
13863  (vector unsigned long long)__a,
13864  (vector unsigned long long)__b);
13865 }
13866 
13867 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool long long __a,
13868  vector unsigned long long __b) {
13869  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
13870  (vector unsigned long long)__a, __b);
13871 }
13872 
13873 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool long long __a,
13874  vector bool long long __b) {
13875  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
13876  (vector unsigned long long)__a,
13877  (vector unsigned long long)__b);
13878 }
13879 #endif
13880 
13881 static __inline__ int __ATTRS_o_ai vec_any_le(vector float __a,
13882  vector float __b) {
13883 #ifdef __VSX__
13884  return __builtin_vsx_xvcmpgesp_p(__CR6_EQ_REV, __b, __a);
13885 #else
13886  return __builtin_altivec_vcmpgefp_p(__CR6_EQ_REV, __b, __a);
13887 #endif
13888 }
13889 
13890 #ifdef __VSX__
13891 static __inline__ int __ATTRS_o_ai vec_any_le(vector double __a,
13892  vector double __b) {
13893  return __builtin_vsx_xvcmpgedp_p(__CR6_EQ_REV, __b, __a);
13894 }
13895 #endif
13896 
13897 /* vec_any_lt */
13898 
13899 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed char __a,
13900  vector signed char __b) {
13901  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, __b, __a);
13902 }
13903 
13904 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed char __a,
13905  vector bool char __b) {
13906  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, (vector signed char)__b,
13907  __a);
13908 }
13909 
13910 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned char __a,
13911  vector unsigned char __b) {
13912  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __b, __a);
13913 }
13914 
13915 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned char __a,
13916  vector bool char __b) {
13917  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__b,
13918  __a);
13919 }
13920 
13921 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool char __a,
13922  vector signed char __b) {
13923  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__b,
13924  (vector unsigned char)__a);
13925 }
13926 
13927 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool char __a,
13928  vector unsigned char __b) {
13929  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __b,
13930  (vector unsigned char)__a);
13931 }
13932 
13933 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool char __a,
13934  vector bool char __b) {
13935  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__b,
13936  (vector unsigned char)__a);
13937 }
13938 
13939 static __inline__ int __ATTRS_o_ai vec_any_lt(vector short __a,
13940  vector short __b) {
13941  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, __b, __a);
13942 }
13943 
13944 static __inline__ int __ATTRS_o_ai vec_any_lt(vector short __a,
13945  vector bool short __b) {
13946  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, (vector short)__b, __a);
13947 }
13948 
13949 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned short __a,
13950  vector unsigned short __b) {
13951  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __b, __a);
13952 }
13953 
13954 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned short __a,
13955  vector bool short __b) {
13956  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__b,
13957  __a);
13958 }
13959 
13960 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool short __a,
13961  vector short __b) {
13962  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__b,
13963  (vector unsigned short)__a);
13964 }
13965 
13966 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool short __a,
13967  vector unsigned short __b) {
13968  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __b,
13969  (vector unsigned short)__a);
13970 }
13971 
13972 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool short __a,
13973  vector bool short __b) {
13974  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__b,
13975  (vector unsigned short)__a);
13976 }
13977 
13978 static __inline__ int __ATTRS_o_ai vec_any_lt(vector int __a, vector int __b) {
13979  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, __b, __a);
13980 }
13981 
13982 static __inline__ int __ATTRS_o_ai vec_any_lt(vector int __a,
13983  vector bool int __b) {
13984  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, (vector int)__b, __a);
13985 }
13986 
13987 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned int __a,
13988  vector unsigned int __b) {
13989  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __b, __a);
13990 }
13991 
13992 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned int __a,
13993  vector bool int __b) {
13994  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__b,
13995  __a);
13996 }
13997 
13998 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool int __a,
13999  vector int __b) {
14000  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__b,
14001  (vector unsigned int)__a);
14002 }
14003 
14004 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool int __a,
14005  vector unsigned int __b) {
14006  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __b,
14007  (vector unsigned int)__a);
14008 }
14009 
14010 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool int __a,
14011  vector bool int __b) {
14012  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__b,
14013  (vector unsigned int)__a);
14014 }
14015 
14016 #ifdef __POWER8_VECTOR__
14017 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed long long __a,
14018  vector signed long long __b) {
14019  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV, __b, __a);
14020 }
14021 
14022 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned long long __a,
14023  vector unsigned long long __b) {
14024  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __b, __a);
14025 }
14026 
14027 static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed long long __a,
14028  vector bool long long __b) {
14029  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV,
14030  (vector signed long long)__b, __a);
14031 }
14032 
14033 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned long long __a,
14034  vector bool long long __b) {
14035  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
14036  (vector unsigned long long)__b, __a);
14037 }
14038 
14039 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool long long __a,
14040  vector signed long long __b) {
14041  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
14042  (vector unsigned long long)__b,
14043  (vector unsigned long long)__a);
14044 }
14045 
14046 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool long long __a,
14047  vector unsigned long long __b) {
14048  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __b,
14049  (vector unsigned long long)__a);
14050 }
14051 
14052 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool long long __a,
14053  vector bool long long __b) {
14054  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
14055  (vector unsigned long long)__b,
14056  (vector unsigned long long)__a);
14057 }
14058 #endif
14059 
14060 static __inline__ int __ATTRS_o_ai vec_any_lt(vector float __a,
14061  vector float __b) {
14062 #ifdef __VSX__
14063  return __builtin_vsx_xvcmpgtsp_p(__CR6_EQ_REV, __b, __a);
14064 #else
14065  return __builtin_altivec_vcmpgtfp_p(__CR6_EQ_REV, __b, __a);
14066 #endif
14067 }
14068 
14069 #ifdef __VSX__
14070 static __inline__ int __ATTRS_o_ai vec_any_lt(vector double __a,
14071  vector double __b) {
14072  return __builtin_vsx_xvcmpgtdp_p(__CR6_EQ_REV, __b, __a);
14073 }
14074 #endif
14075 
14076 /* vec_any_nan */
14077 
14078 static __inline__ int __attribute__((__always_inline__))
14079 vec_any_nan(vector float __a) {
14080  return __builtin_altivec_vcmpeqfp_p(__CR6_LT_REV, __a, __a);
14081 }
14082 
14083 /* vec_any_ne */
14084 
14085 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed char __a,
14086  vector signed char __b) {
14087  return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
14088  (vector char)__b);
14089 }
14090 
14091 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed char __a,
14092  vector bool char __b) {
14093  return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
14094  (vector char)__b);
14095 }
14096 
14097 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned char __a,
14098  vector unsigned char __b) {
14099  return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
14100  (vector char)__b);
14101 }
14102 
14103 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned char __a,
14104  vector bool char __b) {
14105  return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
14106  (vector char)__b);
14107 }
14108 
14109 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool char __a,
14110  vector signed char __b) {
14111  return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
14112  (vector char)__b);
14113 }
14114 
14115 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool char __a,
14116  vector unsigned char __b) {
14117  return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
14118  (vector char)__b);
14119 }
14120 
14121 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool char __a,
14122  vector bool char __b) {
14123  return __builtin_altivec_vcmpequb_p(__CR6_LT_REV, (vector char)__a,
14124  (vector char)__b);
14125 }
14126 
14127 static __inline__ int __ATTRS_o_ai vec_any_ne(vector short __a,
14128  vector short __b) {
14129  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, __a, __b);
14130 }
14131 
14132 static __inline__ int __ATTRS_o_ai vec_any_ne(vector short __a,
14133  vector bool short __b) {
14134  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, __a, (vector short)__b);
14135 }
14136 
14137 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned short __a,
14138  vector unsigned short __b) {
14139  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
14140  (vector short)__b);
14141 }
14142 
14143 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned short __a,
14144  vector bool short __b) {
14145  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
14146  (vector short)__b);
14147 }
14148 
14149 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool short __a,
14150  vector short __b) {
14151  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
14152  (vector short)__b);
14153 }
14154 
14155 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool short __a,
14156  vector unsigned short __b) {
14157  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
14158  (vector short)__b);
14159 }
14160 
14161 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool short __a,
14162  vector bool short __b) {
14163  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
14164  (vector short)__b);
14165 }
14166 
14167 static __inline__ int __ATTRS_o_ai vec_any_ne(vector pixel __a,
14168  vector pixel __b) {
14169  return __builtin_altivec_vcmpequh_p(__CR6_LT_REV, (vector short)__a,
14170  (vector short)__b);
14171 }
14172 
14173 static __inline__ int __ATTRS_o_ai vec_any_ne(vector int __a, vector int __b) {
14174  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, __a, __b);
14175 }
14176 
14177 static __inline__ int __ATTRS_o_ai vec_any_ne(vector int __a,
14178  vector bool int __b) {
14179  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, __a, (vector int)__b);
14180 }
14181 
14182 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned int __a,
14183  vector unsigned int __b) {
14184  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
14185  (vector int)__b);
14186 }
14187 
14188 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned int __a,
14189  vector bool int __b) {
14190  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
14191  (vector int)__b);
14192 }
14193 
14194 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool int __a,
14195  vector int __b) {
14196  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
14197  (vector int)__b);
14198 }
14199 
14200 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool int __a,
14201  vector unsigned int __b) {
14202  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
14203  (vector int)__b);
14204 }
14205 
14206 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool int __a,
14207  vector bool int __b) {
14208  return __builtin_altivec_vcmpequw_p(__CR6_LT_REV, (vector int)__a,
14209  (vector int)__b);
14210 }
14211 
14212 #ifdef __POWER8_VECTOR__
14213 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed long long __a,
14214  vector signed long long __b) {
14215  return __builtin_altivec_vcmpequd_p(__CR6_LT_REV, __a, __b);
14216 }
14217 
14218 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned long long __a,
14219  vector unsigned long long __b) {
14220  return __builtin_altivec_vcmpequd_p(__CR6_LT_REV, (vector long long)__a,
14221  (vector long long)__b);
14222 }
14223 
14224 static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed long long __a,
14225  vector bool long long __b) {
14226  return __builtin_altivec_vcmpequd_p(__CR6_LT_REV, __a,
14227  (vector signed long long)__b);
14228 }
14229 
14230 static __inline__ int __ATTRS_o_ai vec_any_ne(vector unsigned long long __a,
14231  vector bool long long __b) {
14232  return __builtin_altivec_vcmpequd_p(
14233  __CR6_LT_REV, (vector signed long long)__a, (vector signed long long)__b);
14234 }
14235 
14236 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool long long __a,
14237  vector signed long long __b) {
14238  return __builtin_altivec_vcmpequd_p(
14239  __CR6_LT_REV, (vector signed long long)__a, (vector signed long long)__b);
14240 }
14241 
14242 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool long long __a,
14243  vector unsigned long long __b) {
14244  return __builtin_altivec_vcmpequd_p(
14245  __CR6_LT_REV, (vector signed long long)__a, (vector signed long long)__b);
14246 }
14247 
14248 static __inline__ int __ATTRS_o_ai vec_any_ne(vector bool long long __a,
14249  vector bool long long __b) {
14250  return __builtin_altivec_vcmpequd_p(
14251  __CR6_LT_REV, (vector signed long long)__a, (vector signed long long)__b);
14252 }
14253 #endif
14254 
14255 static __inline__ int __ATTRS_o_ai vec_any_ne(vector float __a,
14256  vector float __b) {
14257 #ifdef __VSX__
14258  return __builtin_vsx_xvcmpeqsp_p(__CR6_LT_REV, __a, __b);
14259 #else
14260  return __builtin_altivec_vcmpeqfp_p(__CR6_LT_REV, __a, __b);
14261 #endif
14262 }
14263 
14264 #ifdef __VSX__
14265 static __inline__ int __ATTRS_o_ai vec_any_ne(vector double __a,
14266  vector double __b) {
14267  return __builtin_vsx_xvcmpeqdp_p(__CR6_LT_REV, __a, __b);
14268 }
14269 #endif
14270 
14271 /* vec_any_nge */
14272 
14273 static __inline__ int __attribute__((__always_inline__))
14274 vec_any_nge(vector float __a, vector float __b) {
14275  return __builtin_altivec_vcmpgefp_p(__CR6_LT_REV, __a, __b);
14276 }
14277 
14278 /* vec_any_ngt */
14279 
14280 static __inline__ int __attribute__((__always_inline__))
14281 vec_any_ngt(vector float __a, vector float __b) {
14282  return __builtin_altivec_vcmpgtfp_p(__CR6_LT_REV, __a, __b);
14283 }
14284 
14285 /* vec_any_nle */
14286 
14287 static __inline__ int __attribute__((__always_inline__))
14288 vec_any_nle(vector float __a, vector float __b) {
14289  return __builtin_altivec_vcmpgefp_p(__CR6_LT_REV, __b, __a);
14290 }
14291 
14292 /* vec_any_nlt */
14293 
14294 static __inline__ int __attribute__((__always_inline__))
14295 vec_any_nlt(vector float __a, vector float __b) {
14296  return __builtin_altivec_vcmpgtfp_p(__CR6_LT_REV, __b, __a);
14297 }
14298 
14299 /* vec_any_numeric */
14300 
14301 static __inline__ int __attribute__((__always_inline__))
14302 vec_any_numeric(vector float __a) {
14303  return __builtin_altivec_vcmpeqfp_p(__CR6_EQ_REV, __a, __a);
14304 }
14305 
14306 /* vec_any_out */
14307 
14308 static __inline__ int __attribute__((__always_inline__))
14309 vec_any_out(vector float __a, vector float __b) {
14310  return __builtin_altivec_vcmpbfp_p(__CR6_EQ_REV, __a, __b);
14311 }
14312 
14313 /* Power 8 Crypto functions
14314 Note: We diverge from the current GCC implementation with regard
14315 to cryptography and related functions as follows:
14316 - Only the SHA and AES instructions and builtins are disabled by -mno-crypto
14317 - The remaining ones are only available on Power8 and up so
14318  require -mpower8-vector
14319 The justification for this is that export requirements require that
14320 Category:Vector.Crypto is optional (i.e. compliant hardware may not provide
14321 support). As a result, we need to be able to turn off support for those.
14322 The remaining ones (currently controlled by -mcrypto for GCC) still
14323 need to be provided on compliant hardware even if Vector.Crypto is not
14324 provided.
14325 */
14326 #ifdef __CRYPTO__
14327 #define vec_sbox_be __builtin_altivec_crypto_vsbox
14328 #define vec_cipher_be __builtin_altivec_crypto_vcipher
14329 #define vec_cipherlast_be __builtin_altivec_crypto_vcipherlast
14330 #define vec_ncipher_be __builtin_altivec_crypto_vncipher
14331 #define vec_ncipherlast_be __builtin_altivec_crypto_vncipherlast
14332 
14333 static __inline__ vector unsigned long long __attribute__((__always_inline__))
14334 __builtin_crypto_vsbox(vector unsigned long long __a) {
14335  return __builtin_altivec_crypto_vsbox(__a);
14336 }
14337 
14338 static __inline__ vector unsigned long long __attribute__((__always_inline__))
14339 __builtin_crypto_vcipher(vector unsigned long long __a,
14340  vector unsigned long long __b) {
14341  return __builtin_altivec_crypto_vcipher(__a, __b);
14342 }
14343 
14344 static __inline__ vector unsigned long long __attribute__((__always_inline__))
14345 __builtin_crypto_vcipherlast(vector unsigned long long __a,
14346  vector unsigned long long __b) {
14347  return __builtin_altivec_crypto_vcipherlast(__a, __b);
14348 }
14349 
14350 static __inline__ vector unsigned long long __attribute__((__always_inline__))
14351 __builtin_crypto_vncipher(vector unsigned long long __a,
14352  vector unsigned long long __b) {
14353  return __builtin_altivec_crypto_vncipher(__a, __b);
14354 }
14355 
14356 static __inline__ vector unsigned long long __attribute__((__always_inline__))
14357 __builtin_crypto_vncipherlast(vector unsigned long long __a,
14358  vector unsigned long long __b) {
14359  return __builtin_altivec_crypto_vncipherlast(__a, __b);
14360 }
14361 
14362 #define __builtin_crypto_vshasigmad __builtin_altivec_crypto_vshasigmad
14363 #define __builtin_crypto_vshasigmaw __builtin_altivec_crypto_vshasigmaw
14364 
14365 #define vec_shasigma_be(X, Y, Z) \
14366  _Generic((X), vector unsigned int \
14367  : __builtin_crypto_vshasigmaw, vector unsigned long long \
14368  : __builtin_crypto_vshasigmad)((X), (Y), (Z))
14369 #endif
14370 
14371 #ifdef __POWER8_VECTOR__
14372 static __inline__ vector unsigned char __ATTRS_o_ai
14373 __builtin_crypto_vpermxor(vector unsigned char __a, vector unsigned char __b,
14374  vector unsigned char __c) {
14375  return __builtin_altivec_crypto_vpermxor(__a, __b, __c);
14376 }
14377 
14378 static __inline__ vector unsigned short __ATTRS_o_ai
14379 __builtin_crypto_vpermxor(vector unsigned short __a, vector unsigned short __b,
14380  vector unsigned short __c) {
14381  return (vector unsigned short)__builtin_altivec_crypto_vpermxor(
14382  (vector unsigned char)__a, (vector unsigned char)__b,
14383  (vector unsigned char)__c);
14384 }
14385 
14386 static __inline__ vector unsigned int __ATTRS_o_ai __builtin_crypto_vpermxor(
14387  vector unsigned int __a, vector unsigned int __b, vector unsigned int __c) {
14388  return (vector unsigned int)__builtin_altivec_crypto_vpermxor(
14389  (vector unsigned char)__a, (vector unsigned char)__b,
14390  (vector unsigned char)__c);
14391 }
14392 
14393 static __inline__ vector unsigned long long __ATTRS_o_ai
14394 __builtin_crypto_vpermxor(vector unsigned long long __a,
14395  vector unsigned long long __b,
14396  vector unsigned long long __c) {
14397  return (vector unsigned long long)__builtin_altivec_crypto_vpermxor(
14398  (vector unsigned char)__a, (vector unsigned char)__b,
14399  (vector unsigned char)__c);
14400 }
14401 
14402 static __inline__ vector unsigned char __ATTRS_o_ai
14403 __builtin_crypto_vpmsumb(vector unsigned char __a, vector unsigned char __b) {
14404  return __builtin_altivec_crypto_vpmsumb(__a, __b);
14405 }
14406 
14407 static __inline__ vector unsigned short __ATTRS_o_ai
14408 __builtin_crypto_vpmsumb(vector unsigned short __a, vector unsigned short __b) {
14409  return __builtin_altivec_crypto_vpmsumh(__a, __b);
14410 }
14411 
14412 static __inline__ vector unsigned int __ATTRS_o_ai
14413 __builtin_crypto_vpmsumb(vector unsigned int __a, vector unsigned int __b) {
14414  return __builtin_altivec_crypto_vpmsumw(__a, __b);
14415 }
14416 
14417 static __inline__ vector unsigned long long __ATTRS_o_ai
14418 __builtin_crypto_vpmsumb(vector unsigned long long __a,
14419  vector unsigned long long __b) {
14420  return __builtin_altivec_crypto_vpmsumd(__a, __b);
14421 }
14422 
14423 static __inline__ vector signed char __ATTRS_o_ai
14424 vec_vgbbd(vector signed char __a) {
14425  return __builtin_altivec_vgbbd((vector unsigned char)__a);
14426 }
14427 
14428 #define vec_pmsum_be __builtin_crypto_vpmsumb
14429 #define vec_gb __builtin_altivec_vgbbd
14430 
14431 static __inline__ vector unsigned char __ATTRS_o_ai
14432 vec_vgbbd(vector unsigned char __a) {
14433  return __builtin_altivec_vgbbd(__a);
14434 }
14435 
14436 static __inline__ vector long long __ATTRS_o_ai
14437 vec_vbpermq(vector signed char __a, vector signed char __b) {
14438  return __builtin_altivec_vbpermq((vector unsigned char)__a,
14439  (vector unsigned char)__b);
14440 }
14441 
14442 static __inline__ vector long long __ATTRS_o_ai
14443 vec_vbpermq(vector unsigned char __a, vector unsigned char __b) {
14444  return __builtin_altivec_vbpermq(__a, __b);
14445 }
14446 
14447 #ifdef __powerpc64__
14448 static __inline__ vector unsigned long long __attribute__((__always_inline__))
14449 vec_bperm(vector unsigned __int128 __a, vector unsigned char __b) {
14450  return __builtin_altivec_vbpermq((vector unsigned char)__a,
14451  (vector unsigned char)__b);
14452 }
14453 #endif
14454 #endif
14455 
14456 #undef __ATTRS_o_ai
14457 
14458 #endif /* __ALTIVEC_H */
static __inline__ vector int __ATTRS_o_ai vec_vupkhsh(vector short __a)
Definition: altivec.h:10078
#define __CR6_LT_REV
Definition: altivec.h:35
static __inline__ vector short __ATTRS_o_ai vec_vsrh(vector short __a, vector unsigned short __b)
Definition: altivec.h:8031
static __inline__ void __ATTRS_o_ai vec_stvehx(vector short __a, int __b, short *__c)
Definition: altivec.h:9023
static __inline__ vector signed char __ATTRS_o_ai vec_srl(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:8137
static __inline__ vector unsigned int __ATTRS_o_ai vec_vmaxuw(vector unsigned int __a, vector unsigned int __b)
Definition: altivec.h:3253
static __inline__ vector signed char __ATTRS_o_ai vec_rl(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:6286
static __inline__ int __ATTRS_o_ai vec_any_le(vector signed char __a, vector signed char __b)
Definition: altivec.h:13720
static __inline__ vector int __ATTRS_o_ai vec_sum4s(vector signed char __a, vector int __b)
Definition: altivec.h:9857
static __inline__ vector int __ATTRS_o_ai vec_msums(vector short __a, vector short __b, vector int __c)
Definition: altivec.h:4249
static __inline__ vector int __ATTRS_o_ai vec_vupklsh(vector short __a)
Definition: altivec.h:10212
static __inline__ vector signed char __ATTRS_o_ai vec_packs(vector short __a, vector short __b)
Definition: altivec.h:5714
static __inline__ vector signed char __ATTRS_o_ai vec_vsr(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:8310
static __inline__ vector unsigned char __ATTRS_o_ai vec_vpkshus(vector short __a, vector short __b)
Definition: altivec.h:5901
static __inline__ vector unsigned int __ATTRS_o_ai vec_vadduws(vector unsigned int __a, vector unsigned int __b)
Definition: altivec.h:648
static __inline__ vector unsigned int __ATTRS_o_ai vec_vminuw(vector unsigned int __a, vector unsigned int __b)
Definition: altivec.h:4101
static __inline__ vector signed char __ATTRS_o_ai vec_ld(int __a, const vector signed char *__b)
Definition: altivec.h:2251
static __inline__ vector float __ATTRS_o_ai vec_ceil(vector float __a)
Definition: altivec.h:1498
static __inline__ vector float __ATTRS_o_ai vec_trunc(vector float __a)
Definition: altivec.h:9967
static __inline__ vector int __ATTRS_o_ai vec_vsrw(vector int __a, vector unsigned int __b)
Definition: altivec.h:8044
static __inline__ vector unsigned char __ATTRS_o_ai vec_packsu(vector short __a, vector short __b)
Definition: altivec.h:5843
static __inline__ vector unsigned int __ATTRS_o_ai vec_vsubuws(vector unsigned int __a, vector unsigned int __b)
Definition: altivec.h:9787
static __inline__ vector bool char __ATTRS_o_ai vec_cmple(vector signed char __a, vector signed char __b)
Definition: altivec.h:1777
static __inline__ int __ATTRS_o_ai vec_any_eq(vector signed char __a, vector signed char __b)
Definition: altivec.h:13174
static __inline__ vector signed char __ATTRS_o_ai vec_vand(vector signed char __a, vector signed char __b)
Definition: altivec.h:907
static __inline__ vector signed char __ATTRS_o_ai vec_vandc(vector signed char __a, vector signed char __b)
Definition: altivec.h:1260
static __inline__ vector unsigned int __ATTRS_o_ai vec_ctu(vector float __a, int __b)
Definition: altivec.h:1999
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:6445
static __inline__ vector int __ATTRS_o_ai vec_lvewx(int __a, const int *__b)
Definition: altivec.h:2486
static __inline__ vector signed char __ATTRS_o_ai vec_vspltisb(signed char __a)
Definition: altivec.h:7904
static __inline__ vector short __ATTRS_o_ai vec_vadduhm(vector short __a, vector short __b)
Definition: altivec.h:362
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:6183
static __inline__ vector signed char __ATTRS_o_ai vec_mergel(vector signed char __a, vector signed char __b)
Definition: altivec.h:3551
static __inline__ vector signed char __ATTRS_o_ai vec_abss(vector signed char __a)
Definition: altivec.h:149
static __inline__ vector int __ATTRS_o_ai vec_cts(vector float __a, int __b)
Definition: altivec.h:1978
static __inline__ vector signed char __ATTRS_o_ai vec_div(vector signed char __a, vector signed char __b)
Definition: altivec.h:2041
static __inline__ vector signed char __ATTRS_o_ai vec_adds(vector signed char __a, vector signed char __b)
Definition: altivec.h:471
static __inline__ vector short __ATTRS_o_ai vec_mulo(vector signed char __a, vector signed char __b)
Definition: altivec.h:4489
static __inline__ vector signed char __ATTRS_o_ai vec_lde(int __a, const signed char *__b)
Definition: altivec.h:2429
static __inline__ vector signed char __ATTRS_o_ai vec_vsububm(vector signed char __a, vector signed char __b)
Definition: altivec.h:9475
static __inline__ vector signed char __ATTRS_o_ai vec_nor(vector signed char __a, vector signed char __b)
Definition: altivec.h:4777
static __inline__ vector unsigned short __ATTRS_o_ai vec_vadduhs(vector unsigned short __a, vector unsigned short __b)
Definition: altivec.h:614
static __inline__ vector signed char __ATTRS_o_ai vec_splat(vector signed char __a, unsigned const int __b)
Definition: altivec.h:7666
static __inline__ vector signed char __ATTRS_o_ai vec_vaddubm(vector signed char __a, vector signed char __b)
Definition: altivec.h:329
static __inline__ vector bool char __ATTRS_o_ai vec_cmplt(vector signed char __a, vector signed char __b)
Definition: altivec.h:1833
static __inline__ void __ATTRS_o_ai vec_mtvscr(vector signed char __a)
Definition: altivec.h:4278
static __inline__ vector signed char __ATTRS_o_ai vec_sll(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:7140
static __inline__ vector int __ATTRS_o_ai vec_vmrglw(vector int __a, vector int __b)
Definition: altivec.h:3779
static __inline__ vector short __ATTRS_o_ai vec_vsubuhm(vector short __a, vector short __b)
Definition: altivec.h:9508
static __inline__ vector signed char __ATTRS_o_ai vec_sr(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:7967
static __inline__ vector signed char __ATTRS_o_ai vec_vnor(vector signed char __a, vector signed char __b)
Definition: altivec.h:4840
static __inline__ vector signed char __ATTRS_o_ai vec_and(vector signed char __a, vector signed char __b)
Definition: altivec.h:721
static __inline__ vector signed char __ATTRS_o_ai vec_add(vector signed char __a, vector signed char __b)
Definition: altivec.h:169
static __inline__ vector int __ATTRS_o_ai vec_msum(vector signed char __a, vector unsigned char __b, vector int __c)
Definition: altivec.h:4193
static __inline__ int __ATTRS_o_ai vec_all_ge(vector signed char __a, vector signed char __b)
Definition: altivec.h:12220
static __inline__ vector short __ATTRS_o_ai vec_vmrglh(vector short __a, vector short __b)
Definition: altivec.h:3743
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:6579
static __inline__ int __ATTRS_o_ai vec_any_ne(vector signed char __a, vector signed char __b)
Definition: altivec.h:14085
#define __CR6_EQ_REV
Definition: altivec.h:33
static __inline__ vector signed short __ATTRS_o_ai vec_mladd(vector signed short, vector signed short, vector signed short)
static __inline__ void __ATTRS_o_ai vec_stvewx(vector int __a, int __b, int *__c)
Definition: altivec.h:9055
static __inline__ vector unsigned char __ATTRS_o_ai vec_xor(vector unsigned char __a, vector unsigned char __b)
Definition: altivec.h:10534
static __inline__ vector signed char __ATTRS_o_ai vec_sro(vector signed char __a, vector signed char __b)
Definition: altivec.h:8483
static __inline__ vector short __ATTRS_o_ai vec_vsplth(vector short __a, unsigned char __b)
Definition: altivec.h:7814
static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsl(int __a, const signed char *__b)
Definition: altivec.h:2708
#define __CR6_LT
Definition: altivec.h:34
static __inline__ vector signed char __ATTRS_o_ai vec_vminsb(vector signed char __a, vector signed char __b)
Definition: altivec.h:4016
static __inline__ vector signed char __ATTRS_o_ai vec_insert(signed char __a, vector signed char __b, int __c)
Definition: altivec.h:10941
static __inline__ vector signed char __ATTRS_o_ai vec_lvrxl(int __a, const signed char *__b)
Definition: altivec.h:11350
static __inline__ vector signed char __ATTRS_o_ai vec_vpkuhum(vector signed short __a, vector signed short __b)
Definition: altivec.h:5546
static __inline__ vector float __ATTRS_o_ai vec_rsqrte(vector float __a)
Definition: altivec.h:6420
static __inline__ int __ATTRS_o_ai vec_any_lt(vector signed char __a, vector signed char __b)
Definition: altivec.h:13899
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:2946
static __inline__ int __ATTRS_o_ai vec_all_nge(vector float __a, vector float __b)
Definition: altivec.h:13117
static __inline__ int __ATTRS_o_ai vec_all_gt(vector signed char __a, vector signed char __b)
Definition: altivec.h:12391
static __inline__ vector unsigned char __ATTRS_o_ai vec_vmaxub(vector unsigned char __a, vector unsigned char __b)
Definition: altivec.h:3185
static __inline__ vector signed char __ATTRS_o_ai vec_subs(vector signed char __a, vector signed char __b)
Definition: altivec.h:9610
static __inline__ vector signed char __ATTRS_o_ai vec_mul(vector signed char __a, vector signed char __b)
Definition: altivec.h:4329
static __inline__ vector int __ATTRS_o_ai vec_vadduwm(vector int __a, vector int __b)
Definition: altivec.h:396
static __inline__ vector float __ATTRS_o_ai vec_floor(vector float __a)
Definition: altivec.h:2227
static __inline__ vector signed char __ATTRS_o_ai vec_or(vector signed char __a, vector signed char __b)
Definition: altivec.h:4913
static __inline__ vector signed char __ATTRS_o_ai vec_andc(vector signed char __a, vector signed char __b)
Definition: altivec.h:1074
static __inline__ int __ATTRS_o_ai vec_any_ge(vector signed char __a, vector signed char __b)
Definition: altivec.h:13362
static __inline__ vector unsigned char __ATTRS_o_ai vec_vsububs(vector unsigned char __a, vector unsigned char __b)
Definition: altivec.h:9719
static __inline__ vector short __ATTRS_o_ai vec_vaddshs(vector short __a, vector short __b)
Definition: altivec.h:596
static __inline__ vector signed char __ATTRS_o_ai vec_slo(vector signed char __a, vector signed char __b)
Definition: altivec.h:7486
static __inline__ vector unsigned short __ATTRS_o_ai vec_vpkswus(vector int __a, vector int __b)
Definition: altivec.h:5921
static __inline__ vector signed char __ATTRS_o_ai vec_vsrab(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:8101
static __inline__ vector bool char __ATTRS_o_ai vec_cmpeq(vector signed char __a, vector signed char __b)
Definition: altivec.h:1536
static __inline__ vector signed char __ATTRS_o_ai vec_splats(signed char __a)
Definition: altivec.h:11969
static __inline__ void __ATTRS_o_ai vec_stvlx(vector signed char __a, int __b, signed char *__c)
Definition: altivec.h:11455
static __inline__ vector signed char __ATTRS_o_ai vec_sub(vector signed char __a, vector signed char __b)
Definition: altivec.h:9347
static __inline__ vector signed char __ATTRS_o_ai vec_sra(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:8057
static __inline__ void __ATTRS_o_ai vec_stvx(vector signed char __a, int __b, vector signed char *__c)
Definition: altivec.h:8793
static __inline__ vector int __ATTRS_o_ai vec_vmrghw(vector int __a, vector int __b)
Definition: altivec.h:3516
static __inline__ vector int __ATTRS_o_ai vec_vspltw(vector int __a, unsigned char __b)
Definition: altivec.h:7854
static __inline__ vector signed char __ATTRS_o_ai vec_max(vector signed char __a, vector signed char __b)
Definition: altivec.h:3028
static __inline__ vector signed char __ATTRS_o_ai vec_vmaxsb(vector signed char __a, vector signed char __b)
Definition: altivec.h:3168
static __inline__ vector signed char __ATTRS_o_ai vec_vor(vector signed char __a, vector signed char __b)
Definition: altivec.h:5237
static __inline__ vector int __ATTRS_o_ai vec_vminsw(vector int __a, vector int __b)
Definition: altivec.h:4083
static __inline__ vector unsigned short __ATTRS_o_ai vec_vmaxuh(vector unsigned short __a, vector unsigned short __b)
Definition: altivec.h:3219
static __inline__ vector short __ATTRS_o_ai vec_vslh(vector short __a, vector unsigned short __b)
Definition: altivec.h:6757
static __inline__ vector signed char __ATTRS_o_ai vec_vmrglb(vector signed char __a, vector signed char __b)
Definition: altivec.h:3716
static __inline__ vector float vector float __b
Definition: altivec.h:431
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:5961
static __inline__ vector signed char __ATTRS_o_ai vec_sl(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:6697
static __inline__ void __ATTRS_o_ai vec_stvlxl(vector signed char __a, int __b, signed char *__c)
Definition: altivec.h:11571
static __inline__ vector short __ATTRS_o_ai vec_vupklsb(vector signed char __a)
Definition: altivec.h:10193
static __inline__ vector bool char __ATTRS_o_ai vec_cmpge(vector signed char __a, vector signed char __b)
Definition: altivec.h:1661
static __inline__ vector signed char __ATTRS_o_ai vec_vsl(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:7313
static __inline__ vector short __ATTRS_o_ai vec_unpackh(vector signed char __a)
Definition: altivec.h:9994
static __inline__ int __ATTRS_o_ai vec_all_ne(vector signed char __a, vector signed char __b)
Definition: altivec.h:12929
static __inline__ int __ATTRS_o_ai vec_all_lt(vector signed char __a, vector signed char __b)
Definition: altivec.h:12741
static __inline__ vector int __ATTRS_o_ai vec_vsraw(vector int __a, vector unsigned int __b)
Definition: altivec.h:8124
static __inline__ vector signed char __ATTRS_o_ai vec_lvrx(int __a, const signed char *__b)
Definition: altivec.h:11244
static __inline__ vector signed char __ATTRS_o_ai vec_vmrghb(vector signed char __a, vector signed char __b)
Definition: altivec.h:3453
static __inline__ vector short __ATTRS_o_ai vec_vmladduhm(vector short __a, vector short __b, vector short __c)
Definition: altivec.h:4155
static __inline__ vector unsigned short __ATTRS_o_ai vec_vminuh(vector unsigned short __a, vector unsigned short __b)
Definition: altivec.h:4067
static __inline__ vector signed char __ATTRS_o_ai vec_lvlxl(int __a, const signed char *__b)
Definition: altivec.h:11138
static __inline__ vector short __ATTRS_o_ai vec_lvehx(int __a, const short *__b)
Definition: altivec.h:2474
static __inline__ vector signed char __ATTRS_o_ai vec_vslo(vector signed char __a, vector signed char __b)
Definition: altivec.h:7576
static __inline__ vector unsigned char __ATTRS_o_ai vec_vaddubs(vector unsigned char __a, vector unsigned char __b)
Definition: altivec.h:580
#define __CR6_EQ
Definition: altivec.h:32
static __inline__ vector short __ATTRS_o_ai vec_vsrah(vector short __a, vector unsigned short __b)
Definition: altivec.h:8113
static __inline__ vector int __ATTRS_o_ai vec_splat_s32(signed char __a)
Definition: altivec.h:7929
static __inline__ vector signed char __ATTRS_o_ai vec_splat_s8(signed char __a)
Definition: altivec.h:7896
static __inline__ vector signed char __ATTRS_o_ai vec_vslb(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:6743
static __inline__ vector signed char __ATTRS_o_ai vec_lvxl(int __a, const vector signed char *__b)
Definition: altivec.h:2592
static __inline__ vector signed int __ATTRS_o_ai vec_addc(vector signed int __a, vector signed int __b)
Definition: altivec.h:438
static __inline__ vector bool char __ATTRS_o_ai vec_cmpgt(vector signed char __a, vector signed char __b)
Definition: altivec.h:1601
static __inline__ vector signed char __ATTRS_o_ai vec_vspltb(vector signed char __a, unsigned char __b)
Definition: altivec.h:7796
static __inline__ vector float __ATTRS_o_ai vec_nmsub(vector float __a, vector float __b, vector float __c)
Definition: altivec.h:4747
static __inline__ vector signed char __ATTRS_o_ai vec_vxor(vector signed char __a, vector signed char __b)
Definition: altivec.h:10702
static __inline__ vector unsigned char __ATTRS_o_ai vec_splat_u8(unsigned char __a)
Definition: altivec.h:7944
static __inline__ vector unsigned short __ATTRS_o_ai vec_splat_u16(signed char __a)
Definition: altivec.h:7952
static __inline__ vector unsigned char __ATTRS_o_ai vec_vminub(vector unsigned char __a, vector unsigned char __b)
Definition: altivec.h:4033
static __inline__ vector short __ATTRS_o_ai vec_vupkhsb(vector signed char __a)
Definition: altivec.h:10059
static __inline__ void __ATTRS_o_ai vec_stl(vector signed char __a, int __b, vector signed char *__c)
Definition: altivec.h:9082
static __inline__ void __ATTRS_o_ai vec_stvrxl(vector signed char __a, int __b, signed char *__c)
Definition: altivec.h:11804
static __inline__ vector signed char __ATTRS_o_ai vec_promote(signed char __a, int __b)
Definition: altivec.h:11921
static __inline__ void __ATTRS_o_ai vec_st(vector signed char __a, int __b, vector signed char *__c)
Definition: altivec.h:8662
static __inline__ void __ATTRS_o_ai vec_ste(vector signed char __a, int __b, signed char *__c)
Definition: altivec.h:8925
static __inline__ vector signed char __ATTRS_o_ai vec_avg(vector signed char __a, vector signed char __b)
Definition: altivec.h:1425
static __inline__ vector unsigned int __ATTRS_o_ai vec_splat_u32(signed char __a)
Definition: altivec.h:7960
static __inline__ int __ATTRS_o_ai vec_any_gt(vector signed char __a, vector signed char __b)
Definition: altivec.h:13541
static __inline__ vector signed char __ATTRS_o_ai vec_lvlx(int __a, const signed char *__b)
Definition: altivec.h:11032
static __inline__ vector short __ATTRS_o_ai vec_vminsh(vector short __a, vector short __b)
Definition: altivec.h:4049
static __inline__ vector int __ATTRS_o_ai vec_vsubuwm(vector int __a, vector int __b)
Definition: altivec.h:9542
static __inline__ vector short __ATTRS_o_ai vec_vmaxsh(vector short __a, vector short __b)
Definition: altivec.h:3201
static __inline__ vector signed char __ATTRS_o_ai vec_pack(vector signed short __a, vector signed short __b)
Definition: altivec.h:5405
static __inline__ vector float __ATTRS_o_ai vec_re(vector float __a)
Definition: altivec.h:6262
static __inline__ vector unsigned short __ATTRS_o_ai vec_vsubuhs(vector unsigned short __a, vector unsigned short __b)
Definition: altivec.h:9753
static __inline__ vector short __ATTRS_o_ai vec_mule(vector signed char __a, vector signed char __b)
Definition: altivec.h:4387
static __inline__ vector signed char __ATTRS_o_ai vec_vsro(vector signed char __a, vector signed char __b)
Definition: altivec.h:8573
static __inline__ vector short __ATTRS_o_ai vec_vspltish(signed char __a)
Definition: altivec.h:7920
static __inline__ vector int __ATTRS_o_ai vec_vspltisw(signed char __a)
Definition: altivec.h:7936
static __inline__ vector signed char __ATTRS_o_ai vec_ldl(int __a, const vector signed char *__b)
Definition: altivec.h:2503
static __inline__ signed char __ATTRS_o_ai vec_extract(vector signed char __a, int __b)
Definition: altivec.h:10868
static __inline__ vector float __attribute__((__always_inline__)) vec_vaddfp(vector float __a
Definition: altivec.h:1514
static __inline__ vector signed char __ATTRS_o_ai vec_lvebx(int __a, const signed char *__b)
Definition: altivec.h:2463
static __inline__ void __ATTRS_o_ai vec_stvebx(vector signed char __a, int __b, signed char *__c)
Definition: altivec.h:9001
static __inline__ vector int __ATTRS_o_ai vec_vrlw(vector int __a, vector unsigned int __b)
Definition: altivec.h:6353
static __inline__ int __ATTRS_o_ai vec_all_nan(vector float __a)
Definition: altivec.h:12913
static __inline__ vector signed char __ATTRS_o_ai vec_sld(vector signed char __a, vector signed char __b, unsigned const int __c)
Definition: altivec.h:6784
static __inline__ void __ATTRS_o_ai vec_stvrx(vector signed char __a, int __b, signed char *__c)
Definition: altivec.h:11688
static __inline__ vector short __ATTRS_o_ai vec_vrlh(vector short __a, vector unsigned short __b)
Definition: altivec.h:6342
static __inline__ vector int __ATTRS_o_ai vec_vmaxsw(vector int __a, vector int __b)
Definition: altivec.h:3235
#define __ATTRS_o_ai
Definition: altivec.h:37
static __inline__ vector short __ATTRS_o_ai vec_vmrghh(vector short __a, vector short __b)
Definition: altivec.h:3480
static __inline__ vector signed char __ATTRS_o_ai vec_vsrb(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:8017
static __inline__ vector signed char __ATTRS_o_ai vec_abs(vector signed char __a)
Definition: altivec.h:106
static __inline__ vector signed char __ATTRS_o_ai vec_lvx(int __a, const vector signed char *__b)
Definition: altivec.h:2340
static __inline__ vector float __ATTRS_o_ai vec_ctf(vector int __a, int __b)
Definition: altivec.h:1937
static __inline__ vector float __ATTRS_o_ai vec_round(vector float __a)
Definition: altivec.h:6365
static __inline__ vector short __ATTRS_o_ai vec_unpackl(vector signed char __a)
Definition: altivec.h:10128
static __inline__ void __ATTRS_o_ai vec_stvxl(vector signed char __a, int __b, vector signed char *__c)
Definition: altivec.h:9213
static __inline__ int __ATTRS_o_ai vec_all_ngt(vector float __a, vector float __b)
Definition: altivec.h:13135
static __inline__ vector signed char __ATTRS_o_ai vec_vsldoi(vector signed char __a, vector signed char __b, unsigned char __c)
Definition: altivec.h:6990
static __inline__ int __ATTRS_o_ai vec_all_le(vector signed char __a, vector signed char __b)
Definition: altivec.h:12569
static __inline__ vector signed char __ATTRS_o_ai vec_vsubsbs(vector signed char __a, vector signed char __b)
Definition: altivec.h:9702
static __inline__ vector signed char __ATTRS_o_ai vec_mergeh(vector signed char __a, vector signed char __b)
Definition: altivec.h:3281
static __inline__ vector short __ATTRS_o_ai vec_splat_s16(signed char __a)
Definition: altivec.h:7913
static __inline__ vector int __ATTRS_o_ai vec_vslw(vector int __a, vector unsigned int __b)
Definition: altivec.h:6770
static __inline__ vector signed char __ATTRS_o_ai vec_min(vector signed char __a, vector signed char __b)
Definition: altivec.h:3876
static __inline__ vector short __ATTRS_o_ai vec_vsubshs(vector short __a, vector short __b)
Definition: altivec.h:9735
static __inline__ vector float vector float vector float __c
Definition: altivec.h:2990
static __inline__ vector unsigned int __ATTRS_o_ai vec_subc(vector unsigned int __a, vector unsigned int __b)
Definition: altivec.h:9584
static __inline__ vector signed char __ATTRS_o_ai vec_vrlb(vector signed char __a, vector unsigned char __b)
Definition: altivec.h:6330
static __inline__ vector signed char __ATTRS_o_ai vec_vaddsbs(vector signed char __a, vector signed char __b)
Definition: altivec.h:563
static __inline__ vector unsigned char __ATTRS_o_ai vec_lvsr(int __a, const signed char *__b)
Definition: altivec.h:2829
static __inline__ vector int __ATTRS_o_ai vec_vaddsws(vector int __a, vector int __b)
Definition: altivec.h:630
static __inline__ vector short __ATTRS_o_ai vec_vpkuwum(vector int __a, vector int __b)
Definition: altivec.h:5594
static __inline__ int __ATTRS_o_ai vec_all_eq(vector signed char __a, vector signed char __b)
Definition: altivec.h:12033
static __inline__ vector int __ATTRS_o_ai vec_vsubsws(vector int __a, vector int __b)
Definition: altivec.h:9769