Google Git
Sign in
fuchsia / third_party / swift-clang / a40ea3abe6e2f0b338d00c38fe7d724241c5af97 / . / lib / Headers / altivec.h
blob: c39156eff8e5c21788feb368bf12352b7da841bf [file] [log] [blame]
/*===---- altivec.h - Standard header for type generic math ---------------===*\
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
\*===----------------------------------------------------------------------===*/
#ifndef __ALTIVEC_H
#define __ALTIVEC_H
#ifndef __ALTIVEC__
#error "AltiVec support not enabled"
#endif
/* constants for mapping CR6 bits to predicate result. */
#define __CR6_EQ 0
#define __CR6_EQ_REV 1
#define __CR6_LT 2
#define __CR6_LT_REV 3
#define __ATTRS_o_ai __attribute__((__overloadable__, __always_inline__))
static vector signed char __ATTRS_o_ai vec_perm(vector signed char __a,
vector signed char __b,
vector unsigned char __c);
static vector unsigned char __ATTRS_o_ai vec_perm(vector unsigned char __a,
vector unsigned char __b,
vector unsigned char __c);
static vector bool char __ATTRS_o_ai vec_perm(vector bool char __a,
vector bool char __b,
vector unsigned char __c);
static vector short __ATTRS_o_ai vec_perm(vector signed short __a,
vector signed short __b,
vector unsigned char __c);
static vector unsigned short __ATTRS_o_ai vec_perm(vector unsigned short __a,
vector unsigned short __b,
vector unsigned char __c);
static vector bool short __ATTRS_o_ai vec_perm(vector bool short __a,
vector bool short __b,
vector unsigned char __c);
static vector pixel __ATTRS_o_ai vec_perm(vector pixel __a, vector pixel __b,
vector unsigned char __c);
static vector int __ATTRS_o_ai vec_perm(vector signed int __a,
vector signed int __b,
vector unsigned char __c);
static vector unsigned int __ATTRS_o_ai vec_perm(vector unsigned int __a,
vector unsigned int __b,
vector unsigned char __c);
static vector bool int __ATTRS_o_ai vec_perm(vector bool int __a,
vector bool int __b,
vector unsigned char __c);
static vector float __ATTRS_o_ai vec_perm(vector float __a, vector float __b,
vector unsigned char __c);
#ifdef __VSX__
static vector long long __ATTRS_o_ai vec_perm(vector signed long long __a,
vector signed long long __b,
vector unsigned char __c);
static vector unsigned long long __ATTRS_o_ai
vec_perm(vector unsigned long long __a, vector unsigned long long __b,
vector unsigned char __c);
static vector bool long long __ATTRS_o_ai
vec_perm(vector bool long long __a, vector bool long long __b,
vector unsigned char __c);
static vector double __ATTRS_o_ai vec_perm(vector double __a, vector double __b,
vector unsigned char __c);
#endif
static vector unsigned char __ATTRS_o_ai vec_xor(vector unsigned char __a,
vector unsigned char __b);
/* vec_abs */
#define __builtin_altivec_abs_v16qi vec_abs
#define __builtin_altivec_abs_v8hi vec_abs
#define __builtin_altivec_abs_v4si vec_abs
static vector signed char __ATTRS_o_ai vec_abs(vector signed char __a) {
return __builtin_altivec_vmaxsb(__a, -__a);
}
static vector signed short __ATTRS_o_ai vec_abs(vector signed short __a) {
return __builtin_altivec_vmaxsh(__a, -__a);
}
static vector signed int __ATTRS_o_ai vec_abs(vector signed int __a) {
return __builtin_altivec_vmaxsw(__a, -__a);
}
#if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
static vector signed long long __ATTRS_o_ai
vec_abs(vector signed long long __a) {
return __builtin_altivec_vmaxsd(__a, -__a);
}
#endif
static vector float __ATTRS_o_ai vec_abs(vector float __a) {
vector unsigned int __res =
(vector unsigned int)__a & (vector unsigned int)(0x7FFFFFFF);
return (vector float)__res;
}
#if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
static vector double __ATTRS_o_ai vec_abs(vector double __a) {
vector unsigned long long __res = { 0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFF };
__res &= (vector unsigned int)__a;
return (vector double)__res;
}
#endif
/* vec_abss */
#define __builtin_altivec_abss_v16qi vec_abss
#define __builtin_altivec_abss_v8hi vec_abss
#define __builtin_altivec_abss_v4si vec_abss
static vector signed char __ATTRS_o_ai vec_abss(vector signed char __a) {
return __builtin_altivec_vmaxsb(
__a, __builtin_altivec_vsubsbs((vector signed char)(0), __a));
}
static vector signed short __ATTRS_o_ai vec_abss(vector signed short __a) {
return __builtin_altivec_vmaxsh(
__a, __builtin_altivec_vsubshs((vector signed short)(0), __a));
}
static vector signed int __ATTRS_o_ai vec_abss(vector signed int __a) {
return __builtin_altivec_vmaxsw(
__a, __builtin_altivec_vsubsws((vector signed int)(0), __a));
}
/* vec_add */
static vector signed char __ATTRS_o_ai vec_add(vector signed char __a,
vector signed char __b) {
return __a + __b;
}
static vector signed char __ATTRS_o_ai vec_add(vector bool char __a,
vector signed char __b) {
return (vector signed char)__a + __b;
}
static vector signed char __ATTRS_o_ai vec_add(vector signed char __a,
vector bool char __b) {
return __a + (vector signed char)__b;
}
static vector unsigned char __ATTRS_o_ai vec_add(vector unsigned char __a,
vector unsigned char __b) {
return __a + __b;
}
static vector unsigned char __ATTRS_o_ai vec_add(vector bool char __a,
vector unsigned char __b) {
return (vector unsigned char)__a + __b;
}
static vector unsigned char __ATTRS_o_ai vec_add(vector unsigned char __a,
vector bool char __b) {
return __a + (vector unsigned char)__b;
}
static vector short __ATTRS_o_ai vec_add(vector short __a, vector short __b) {
return __a + __b;
}
static vector short __ATTRS_o_ai vec_add(vector bool short __a,
vector short __b) {
return (vector short)__a + __b;
}
static vector short __ATTRS_o_ai vec_add(vector short __a,
vector bool short __b) {
return __a + (vector short)__b;
}
static vector unsigned short __ATTRS_o_ai vec_add(vector unsigned short __a,
vector unsigned short __b) {
return __a + __b;
}
static vector unsigned short __ATTRS_o_ai vec_add(vector bool short __a,
vector unsigned short __b) {
return (vector unsigned short)__a + __b;
}
static vector unsigned short __ATTRS_o_ai vec_add(vector unsigned short __a,
vector bool short __b) {
return __a + (vector unsigned short)__b;
}
static vector int __ATTRS_o_ai vec_add(vector int __a, vector int __b) {
return __a + __b;
}
static vector int __ATTRS_o_ai vec_add(vector bool int __a, vector int __b) {
return (vector int)__a + __b;
}
static vector int __ATTRS_o_ai vec_add(vector int __a, vector bool int __b) {
return __a + (vector int)__b;
}
static vector unsigned int __ATTRS_o_ai vec_add(vector unsigned int __a,
vector unsigned int __b) {
return __a + __b;
}
static vector unsigned int __ATTRS_o_ai vec_add(vector bool int __a,
vector unsigned int __b) {
return (vector unsigned int)__a + __b;
}
static vector unsigned int __ATTRS_o_ai vec_add(vector unsigned int __a,
vector bool int __b) {
return __a + (vector unsigned int)__b;
}
#if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
static vector signed long long __ATTRS_o_ai
vec_add(vector signed long long __a, vector signed long long __b) {
return __a + __b;
}
static vector unsigned long long __ATTRS_o_ai
vec_add(vector unsigned long long __a, vector unsigned long long __b) {
return __a + __b;
}
static vector signed __int128 __ATTRS_o_ai vec_add(vector signed __int128 __a,
vector signed __int128 __b) {
return __a + __b;
}
static vector unsigned __int128 __ATTRS_o_ai
vec_add(vector unsigned __int128 __a, vector unsigned __int128 __b) {
return __a + __b;
}
#endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
static vector float __ATTRS_o_ai vec_add(vector float __a, vector float __b) {
return __a + __b;
}
#ifdef __VSX__
static vector double __ATTRS_o_ai
vec_add(vector double __a, vector double __b) {
return __a + __b;
}
#endif // __VSX__
/* vec_adde */
#if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
static vector signed __int128 __ATTRS_o_ai
vec_adde(vector signed __int128 __a, vector signed __int128 __b,
vector signed __int128 __c) {
return __builtin_altivec_vaddeuqm(__a, __b, __c);
}
static vector unsigned __int128 __ATTRS_o_ai
vec_adde(vector unsigned __int128 __a, vector unsigned __int128 __b,
vector unsigned __int128 __c) {
return __builtin_altivec_vaddeuqm(__a, __b, __c);
}
#endif
/* vec_addec */
#if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
static vector signed __int128 __ATTRS_o_ai
vec_addec(vector signed __int128 __a, vector signed __int128 __b,
vector signed __int128 __c) {
return __builtin_altivec_vaddecuq(__a, __b, __c);
}
static vector unsigned __int128 __ATTRS_o_ai
vec_addec(vector unsigned __int128 __a, vector unsigned __int128 __b,
vector unsigned __int128 __c) {
return __builtin_altivec_vaddecuq(__a, __b, __c);
}
#endif
/* vec_vaddubm */
#define __builtin_altivec_vaddubm vec_vaddubm
static vector signed char __ATTRS_o_ai vec_vaddubm(vector signed char __a,
vector signed char __b) {
return __a + __b;
}
static vector signed char __ATTRS_o_ai vec_vaddubm(vector bool char __a,
vector signed char __b) {
return (vector signed char)__a + __b;
}
static vector signed char __ATTRS_o_ai vec_vaddubm(vector signed char __a,
vector bool char __b) {
return __a + (vector signed char)__b;
}
static vector unsigned char __ATTRS_o_ai vec_vaddubm(vector unsigned char __a,
vector unsigned char __b) {
return __a + __b;
}
static vector unsigned char __ATTRS_o_ai vec_vaddubm(vector bool char __a,
vector unsigned char __b) {
return (vector unsigned char)__a + __b;
}
static vector unsigned char __ATTRS_o_ai vec_vaddubm(vector unsigned char __a,
vector bool char __b) {
return __a + (vector unsigned char)__b;
}
/* vec_vadduhm */
#define __builtin_altivec_vadduhm vec_vadduhm
static vector short __ATTRS_o_ai vec_vadduhm(vector short __a,
vector short __b) {
return __a + __b;
}
static vector short __ATTRS_o_ai vec_vadduhm(vector bool short __a,
vector short __b) {
return (vector short)__a + __b;
}
static vector short __ATTRS_o_ai vec_vadduhm(vector short __a,
vector bool short __b) {
return __a + (vector short)__b;
}
static vector unsigned short __ATTRS_o_ai
vec_vadduhm(vector unsigned short __a, vector unsigned short __b) {
return __a + __b;
}
static vector unsigned short __ATTRS_o_ai
vec_vadduhm(vector bool short __a, vector unsigned short __b) {
return (vector unsigned short)__a + __b;
}
static vector unsigned short __ATTRS_o_ai vec_vadduhm(vector unsigned short __a,
vector bool short __b) {
return __a + (vector unsigned short)__b;
}
/* vec_vadduwm */
#define __builtin_altivec_vadduwm vec_vadduwm
static vector int __ATTRS_o_ai vec_vadduwm(vector int __a, vector int __b) {
return __a + __b;
}
static vector int __ATTRS_o_ai vec_vadduwm(vector bool int __a,
vector int __b) {
return (vector int)__a + __b;
}
static vector int __ATTRS_o_ai vec_vadduwm(vector int __a,
vector bool int __b) {
return __a + (vector int)__b;
}
static vector unsigned int __ATTRS_o_ai vec_vadduwm(vector unsigned int __a,
vector unsigned int __b) {
return __a + __b;
}
static vector unsigned int __ATTRS_o_ai vec_vadduwm(vector bool int __a,
vector unsigned int __b) {
return (vector unsigned int)__a + __b;
}
static vector unsigned int __ATTRS_o_ai vec_vadduwm(vector unsigned int __a,
vector bool int __b) {
return __a + (vector unsigned int)__b;
}
/* vec_vaddfp */
#define __builtin_altivec_vaddfp vec_vaddfp
static vector float __attribute__((__always_inline__))
vec_vaddfp(vector float __a, vector float __b) {
return __a + __b;
}
/* vec_addc */
static vector signed int __ATTRS_o_ai vec_addc(vector signed int __a,
vector signed int __b) {
return (vector signed int)__builtin_altivec_vaddcuw((vector unsigned int)__a,
(vector unsigned int)__b);
}
static vector unsigned int __ATTRS_o_ai vec_addc(vector unsigned int __a,
vector unsigned int __b) {
return __builtin_altivec_vaddcuw(__a, __b);
}
#if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
static vector signed __int128 __ATTRS_o_ai
vec_addc(vector signed __int128 __a, vector signed __int128 __b) {
return (vector signed __int128)__builtin_altivec_vaddcuq(
(vector unsigned __int128)__a,
(vector unsigned __int128)__b);
}
static vector unsigned __int128 __ATTRS_o_ai
vec_addc(vector unsigned __int128 __a, vector unsigned __int128 __b) {
return __builtin_altivec_vaddcuq(__a, __b);
}
#endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
/* vec_vaddcuw */
static vector unsigned int __attribute__((__always_inline__))
vec_vaddcuw(vector unsigned int __a, vector unsigned int __b) {
return __builtin_altivec_vaddcuw(__a, __b);
}
/* vec_adds */
static vector signed char __ATTRS_o_ai vec_adds(vector signed char __a,
vector signed char __b) {
return __builtin_altivec_vaddsbs(__a, __b);
}
static vector signed char __ATTRS_o_ai vec_adds(vector bool char __a,
vector signed char __b) {
return __builtin_altivec_vaddsbs((vector signed char)__a, __b);
}
static vector signed char __ATTRS_o_ai vec_adds(vector signed char __a,
vector bool char __b) {
return __builtin_altivec_vaddsbs(__a, (vector signed char)__b);
}
static vector unsigned char __ATTRS_o_ai vec_adds(vector unsigned char __a,
vector unsigned char __b) {
return __builtin_altivec_vaddubs(__a, __b);
}
static vector unsigned char __ATTRS_o_ai vec_adds(vector bool char __a,
vector unsigned char __b) {
return __builtin_altivec_vaddubs((vector unsigned char)__a, __b);
}
static vector unsigned char __ATTRS_o_ai vec_adds(vector unsigned char __a,
vector bool char __b) {
return __builtin_altivec_vaddubs(__a, (vector unsigned char)__b);
}
static vector short __ATTRS_o_ai vec_adds(vector short __a, vector short __b) {
return __builtin_altivec_vaddshs(__a, __b);
}
static vector short __ATTRS_o_ai vec_adds(vector bool short __a,
vector short __b) {
return __builtin_altivec_vaddshs((vector short)__a, __b);
}
static vector short __ATTRS_o_ai vec_adds(vector short __a,
vector bool short __b) {
return __builtin_altivec_vaddshs(__a, (vector short)__b);
}
static vector unsigned short __ATTRS_o_ai vec_adds(vector unsigned short __a,
vector unsigned short __b) {
return __builtin_altivec_vadduhs(__a, __b);
}
static vector unsigned short __ATTRS_o_ai vec_adds(vector bool short __a,
vector unsigned short __b) {
return __builtin_altivec_vadduhs((vector unsigned short)__a, __b);
}
static vector unsigned short __ATTRS_o_ai vec_adds(vector unsigned short __a,
vector bool short __b) {
return __builtin_altivec_vadduhs(__a, (vector unsigned short)__b);
}
static vector int __ATTRS_o_ai vec_adds(vector int __a, vector int __b) {
return __builtin_altivec_vaddsws(__a, __b);
}
static vector int __ATTRS_o_ai vec_adds(vector bool int __a, vector int __b) {
return __builtin_altivec_vaddsws((vector int)__a, __b);
}
static vector int __ATTRS_o_ai vec_adds(vector int __a, vector bool int __b) {
return __builtin_altivec_vaddsws(__a, (vector int)__b);
}
static vector unsigned int __ATTRS_o_ai vec_adds(vector unsigned int __a,
vector unsigned int __b) {
return __builtin_altivec_vadduws(__a, __b);
}
static vector unsigned int __ATTRS_o_ai vec_adds(vector bool int __a,
vector unsigned int __b) {
return __builtin_altivec_vadduws((vector unsigned int)__a, __b);
}
static vector unsigned int __ATTRS_o_ai vec_adds(vector unsigned int __a,
vector bool int __b) {
return __builtin_altivec_vadduws(__a, (vector unsigned int)__b);
}
/* vec_vaddsbs */
static vector signed char __ATTRS_o_ai vec_vaddsbs(vector signed char __a,
vector signed char __b) {
return __builtin_altivec_vaddsbs(__a, __b);
}
static vector signed char __ATTRS_o_ai vec_vaddsbs(vector bool char __a,
vector signed char __b) {
return __builtin_altivec_vaddsbs((vector signed char)__a, __b);
}
static vector signed char __ATTRS_o_ai vec_vaddsbs(vector signed char __a,
vector bool char __b) {
return __builtin_altivec_vaddsbs(__a, (vector signed char)__b);
}
/* vec_vaddubs */
static vector unsigned char __ATTRS_o_ai vec_vaddubs(vector unsigned char __a,
vector unsigned char __b) {
return __builtin_altivec_vaddubs(__a, __b);
}
static vector unsigned char __ATTRS_o_ai vec_vaddubs(vector bool char __a,
vector unsigned char __b) {
return __builtin_altivec_vaddubs((vector unsigned char)__a, __b);
}
static vector unsigned char __ATTRS_o_ai vec_vaddubs(vector unsigned char __a,
vector bool char __b) {
return __builtin_altivec_vaddubs(__a, (vector unsigned char)__b);
}
/* vec_vaddshs */
static vector short __ATTRS_o_ai vec_vaddshs(vector short __a,
vector short __b) {
return __builtin_altivec_vaddshs(__a, __b);
}
static vector short __ATTRS_o_ai vec_vaddshs(vector bool short __a,
vector short __b) {
return __builtin_altivec_vaddshs((vector short)__a, __b);
}
static vector short __ATTRS_o_ai vec_vaddshs(vector short __a,
vector bool short __b) {
return __builtin_altivec_vaddshs(__a, (vector short)__b);
}
/* vec_vadduhs */
static vector unsigned short __ATTRS_o_ai
vec_vadduhs(vector unsigned short __a, vector unsigned short __b) {
return __builtin_altivec_vadduhs(__a, __b);
}
static vector unsigned short __ATTRS_o_ai
vec_vadduhs(vector bool short __a, vector unsigned short __b) {
return __builtin_altivec_vadduhs((vector unsigned short)__a, __b);
}
static vector unsigned short __ATTRS_o_ai vec_vadduhs(vector unsigned short __a,
vector bool short __b) {
return __builtin_altivec_vadduhs(__a, (vector unsigned short)__b);
}
/* vec_vaddsws */
static vector int __ATTRS_o_ai vec_vaddsws(vector int __a, vector int __b) {
return __builtin_altivec_vaddsws(__a, __b);
}
static vector int __ATTRS_o_ai vec_vaddsws(vector bool int __a,
vector int __b) {
return __builtin_altivec_vaddsws((vector int)__a, __b);
}
static vector int __ATTRS_o_ai vec_vaddsws(vector int __a,
vector bool int __b) {
return __builtin_altivec_vaddsws(__a, (vector int)__b);
}
/* vec_vadduws */
static vector unsigned int __ATTRS_o_ai vec_vadduws(vector unsigned int __a,
vector unsigned int __b) {
return __builtin_altivec_vadduws(__a, __b);
}
static vector unsigned int __ATTRS_o_ai vec_vadduws(vector bool int __a,
vector unsigned int __b) {
return __builtin_altivec_vadduws((vector unsigned int)__a, __b);
}
static vector unsigned int __ATTRS_o_ai vec_vadduws(vector unsigned int __a,
vector bool int __b) {
return __builtin_altivec_vadduws(__a, (vector unsigned int)__b);
}
#if defined(__POWER8_VECTOR__) && defined(__powerpc64__)
/* vec_vadduqm */
static vector signed __int128 __ATTRS_o_ai
vec_vadduqm(vector signed __int128 __a, vector signed __int128 __b) {
return __a + __b;
}
static vector unsigned __int128 __ATTRS_o_ai
vec_vadduqm(vector unsigned __int128 __a, vector unsigned __int128 __b) {
return __a + __b;
}
/* vec_vaddeuqm */
static vector signed __int128 __ATTRS_o_ai
vec_vaddeuqm(vector signed __int128 __a, vector signed __int128 __b,
vector signed __int128 __c) {
return __builtin_altivec_vaddeuqm(__a, __b, __c);
}
static vector unsigned __int128 __ATTRS_o_ai
vec_vaddeuqm(vector unsigned __int128 __a, vector unsigned __int128 __b,
vector unsigned __int128 __c) {
return __builtin_altivec_vaddeuqm(__a, __b, __c);
}
/* vec_vaddcuq */
static vector signed __int128 __ATTRS_o_ai
vec_vaddcuq(vector signed __int128 __a, vector signed __int128 __b) {
return __builtin_altivec_vaddcuq(__a, __b);
}
static vector unsigned __int128 __ATTRS_o_ai
vec_vaddcuq(vector unsigned __int128 __a, vector unsigned __int128 __b) {
return __builtin_altivec_vaddcuq(__a, __b);
}
/* vec_vaddecuq */
static vector signed __int128 __ATTRS_o_ai
vec_vaddecuq(vector signed __int128 __a, vector signed __int128 __b,
vector signed __int128 __c) {
return __builtin_altivec_vaddecuq(__a, __b, __c);
}
static vector unsigned __int128 __ATTRS_o_ai
vec_vaddecuq(vector unsigned __int128 __a, vector unsigned __int128 __b,
vector unsigned __int128 __c) {
return __builtin_altivec_vaddecuq(__a, __b, __c);
}
#endif // defined(__POWER8_VECTOR__) && defined(__powerpc64__)
/* vec_and */
#define __builtin_altivec_vand vec_and
static vector signed char __ATTRS_o_ai vec_and(vector signed char __a,
vector signed char __b) {
return __a & __b;
}
static vector signed char __ATTRS_o_ai vec_and(vector bool char __a,
vector signed char __b) {
return (vector signed char)__a & __b;
}
static vector signed char __ATTRS_o_ai vec_and(vector signed char __a,
vector bool char __b) {
return __a & (vector signed char)__b;
}
static vector unsigned char __ATTRS_o_ai vec_and(vector unsigned char __a,
vector unsigned char __b) {
return __a & __b;
}
static vector unsigned char __ATTRS_o_ai vec_and(vector bool char __a,
vector unsigned char __b) {
return (vector unsigned char)__a & __b;
}
static vector unsigned char __ATTRS_o_ai vec_and(vector unsigned char __a,
vector bool char __b) {
return __a & (vector unsigned char)__b;
}
static vector bool char __ATTRS_o_ai vec_and(vector bool char __a,
vector bool char __b) {
return __a & __b;
}
static vector short __ATTRS_o_ai vec_and(vector short __a, vector short __b) {
return __a & __b;
}
static vector short __ATTRS_o_ai vec_and(vector bool short __a,
vector short __b) {
return (vector short)__a & __b;
}
static vector short __ATTRS_o_ai vec_and(vector short __a,
vector bool short __b) {
return __a & (vector short)__b;
}
static vector unsigned short __ATTRS_o_ai vec_and(vector unsigned short __a,
vector unsigned short __b) {
return __a & __b;
}
static vector unsigned short __ATTRS_o_ai vec_and(vector bool short __a,
vector unsigned short __b) {
return (vector unsigned short)__a & __b;
}
static vector unsigned short __ATTRS_o_ai vec_and(vector unsigned short __a,
vector bool short __b) {
return __a & (vector unsigned short)__b;
}
static vector bool short __ATTRS_o_ai vec_and(vector bool short __a,
vector bool short __b) {
return __a & __b;
}
static vector int __ATTRS_o_ai vec_and(vector int __a, vector int __b) {
return __a & __b;
}
static vector int __ATTRS_o_ai vec_and(vector bool int __a, vector int __b) {
return (vector int)__a & __b;
}
static vector int __ATTRS_o_ai vec_and(vector int __a, vector bool int __b) {
return __a & (vector int)__b;
}
static vector unsigned int __ATTRS_o_ai vec_and(vector unsigned int __a,
vector unsigned int __b) {
return __a & __b;
}
static vector unsigned int __ATTRS_o_ai vec_and(vector bool int __a,
vector unsigned int __b) {
return (vector unsigned int)__a & __b;
}
static vector unsigned int __ATTRS_o_ai vec_and(vector unsigned int __a,
vector bool int __b) {
return __a & (vector unsigned int)__b;
}
static vector bool int __ATTRS_o_ai vec_and(vector bool int __a,
vector bool int __b) {
return __a & __b;
}
static vector float __ATTRS_o_ai vec_and(vector float __a, vector float __b) {
vector unsigned int __res =
(vector unsigned int)__a & (vector unsigned int)__b;
return (vector float)__res;
}
static vector float __ATTRS_o_ai vec_and(vector bool int __a,
vector float __b) {
vector unsigned int __res =
(vector unsigned int)__a & (vector unsigned int)__b;
return (vector float)__res;
}
static vector float __ATTRS_o_ai vec_and(vector float __a,
vector bool int __b) {
vector unsigned int __res =
(vector unsigned int)__a & (vector unsigned int)__b;
return (vector float)__res;
}
#ifdef __VSX__
static vector double __ATTRS_o_ai vec_and(vector bool long long __a, vector double __b) {
vector unsigned long long __res =
(vector unsigned long long)__a & (vector unsigned long long)__b;
return (vector double)__res;
}
static vector double __ATTRS_o_ai vec_and(vector double __a, vector bool long long __b) {
vector unsigned long long __res =
(vector unsigned long long)__a & (vector unsigned long long)__b;
return (vector double)__res;
}
static vector double __ATTRS_o_ai vec_and(vector double __a, vector double __b) {
vector unsigned long long __res =
(vector unsigned long long)__a & (vector unsigned long long)__b;
return (vector double)__res;
}
static vector signed long long __ATTRS_o_ai
vec_and(vector signed long long __a, vector signed long long __b) {
return __a & __b;
}
static vector signed long long __ATTRS_o_ai
vec_and(vector bool long long __a, vector signed long long __b) {
return (vector signed long long)__a & __b;
}
static vector signed long long __ATTRS_o_ai vec_and(vector signed long long __a,
vector bool long long __b) {
return __a & (vector signed long long)__b;
}
static vector unsigned long long __ATTRS_o_ai
vec_and(vector unsigned long long __a, vector unsigned long long __b) {
return __a & __b;
}
static vector unsigned long long __ATTRS_o_ai
vec_and(vector bool long long __a, vector unsigned long long __b) {
return (vector unsigned long long)__a & __b;
}
static vector unsigned long long __ATTRS_o_ai
vec_and(vector unsigned long long __a, vector bool long long __b) {
return __a & (vector unsigned long long)__b;
}
static vector bool long long __ATTRS_o_ai vec_and(vector bool long long __a,
vector bool long long __b) {
return __a & __b;
}
#endif
/* vec_vand */
static vector signed char __ATTRS_o_ai vec_vand(vector signed char __a,
vector signed char __b) {
return __a & __b;
}
static vector signed char __ATTRS_o_ai vec_vand(vector bool char __a,
vector signed char __b) {
return (vector signed char)__a & __b;
}
static vector signed char __ATTRS_o_ai vec_vand(vector signed char __a,
vector bool char __b) {
return __a & (vector signed char)__b;
}
static vector unsigned char __ATTRS_o_ai vec_vand(vector unsigned char __a,
vector unsigned char __b) {
return __a & __b;
}
static vector unsigned char __ATTRS_o_ai vec_vand(vector bool char __a,
vector unsigned char __b) {
return (vector unsigned char)__a & __b;
}
static vector unsigned char __ATTRS_o_ai vec_vand(vector unsigned char __a,
vector bool char __b) {
return __a & (vector unsigned char)__b;
}
static vector bool char __ATTRS_o_ai vec_vand(vector bool char __a,
vector bool char __b) {
return __a & __b;
}
static vector short __ATTRS_o_ai vec_vand(vector short __a, vector short __b) {
return __a & __b;
}
static vector short __ATTRS_o_ai vec_vand(vector bool short __a,
vector short __b) {
return (vector short)__a & __b;
}
static vector short __ATTRS_o_ai vec_vand(vector short __a,
vector bool short __b) {
return __a & (vector short)__b;
}
static vector unsigned short __ATTRS_o_ai vec_vand(vector unsigned short __a,
vector unsigned short __b) {
return __a & __b;
}
static vector unsigned short __ATTRS_o_ai vec_vand(vector bool short __a,
vector unsigned short __b) {
return (vector unsigned short)__a & __b;
}
static vector unsigned short __ATTRS_o_ai vec_vand(vector unsigned short __a,
vector bool short __b) {
return __a & (vector unsigned short)__b;
}
static vector bool short __ATTRS_o_ai vec_vand(vector bool short __a,
vector bool short __b) {
return __a & __b;
}
static vector int __ATTRS_o_ai vec_vand(vector int __a, vector int __b) {
return __a & __b;
}
static vector int __ATTRS_o_ai vec_vand(vector bool int __a, vector int __b) {
return (vector int)__a & __b;
}
static vector int __ATTRS_o_ai vec_vand(vector int __a, vector bool int __b) {
return __a & (vector int)__b;
}
static vector unsigned int __ATTRS_o_ai vec_vand(vector unsigned int __a,
vector unsigned int __b) {
return __a & __b;
}
static vector unsigned int __ATTRS_o_ai vec_vand(vector bool int __a,
vector unsigned int __b) {
return (vector unsigned int)__a & __b;
}
static vector unsigned int __ATTRS_o_ai vec_vand(vector unsigned int __a,
vector bool int __b) {
return __a & (vector unsigned int)__b;
}
static vector bool int __ATTRS_o_ai vec_vand(vector bool int __a,
vector bool int __b) {
return __a & __b;
}
static vector float __ATTRS_o_ai vec_vand(vector float __a, vector float __b) {
vector unsigned int __res =
(vector unsigned int)__a & (vector unsigned int)__b;
return (vector float)__res;
}
static vector float __ATTRS_o_ai vec_vand(vector bool int __a,
vector float __b) {
vector unsigned int __res =
(vector unsigned int)__a & (vector unsigned int)__b;
return (vector float)__res;
}
static vector float __ATTRS_o_ai vec_vand(vector float __a,
vector bool int __b) {
vector unsigned int __res =
(vector unsigned int)__a & (vector unsigned int)__b;
return (vector float)__res;
}
#ifdef __VSX__
static vector signed long long __ATTRS_o_ai
vec_vand(vector signed long long __a, vector signed long long __b) {
return __a & __b;
}
static vector signed long long __ATTRS_o_ai
vec_vand(vector bool long long __a, vector signed long long __b) {
return (vector signed long long)__a & __b;
}
static vector signed long long __ATTRS_o_ai
vec_vand(vector signed long long __a, vector bool long long __b) {
return __a & (vector signed long long)__b;
}
static vector unsigned long long __ATTRS_o_ai
vec_vand(vector unsigned long long __a, vector unsigned long long __b) {
return __a & __b;
}
static vector unsigned long long __ATTRS_o_ai
vec_vand(vector bool long long __a, vector unsigned long long __b) {
return (vector unsigned long long)__a & __b;
}
static vector unsigned long long __ATTRS_o_ai
vec_vand(vector unsigned long long __a, vector bool long long __b) {
return __a & (vector unsigned long long)__b;
}
static vector bool long long __ATTRS_o_ai vec_vand(vector bool long long __a,
vector bool long long __b) {
return __a & __b;
}
#endif
/* vec_andc */
#define __builtin_altivec_vandc vec_andc
static vector signed char __ATTRS_o_ai vec_andc(vector signed char __a,
vector signed char __b) {
return __a & ~__b;
}
static vector signed char __ATTRS_o_ai vec_andc(vector bool char __a,
vector signed char __b) {
return (vector signed char)__a & ~__b;
}
static vector signed char __ATTRS_o_ai vec_andc(vector signed char __a,
vector bool char __b) {
return __a & ~(vector signed char)__b;
}
static vector unsigned char __ATTRS_o_ai vec_andc(vector unsigned char __a,
vector unsigned char __b) {
return __a & ~__b;
}
static vector unsigned char __ATTRS_o_ai vec_andc(vector bool char __a,
vector unsigned char __b) {
return (vector unsigned char)__a & ~__b;
}
static vector unsigned char __ATTRS_o_ai vec_andc(vector unsigned char __a,
vector bool char __b) {
return __a & ~(vector unsigned char)__b;
}
static vector bool char __ATTRS_o_ai vec_andc(vector bool char __a,
vector bool char __b) {
return __a & ~__b;
}
static vector short __ATTRS_o_ai vec_andc(vector short __a, vector short __b) {
return __a & ~__b;
}
static vector short __ATTRS_o_ai vec_andc(vector bool short __a,
vector short __b) {
return (vector short)__a & ~__b;
}
static vector short __ATTRS_o_ai vec_andc(vector short __a,
vector bool short __b) {
return __a & ~(vector short)__b;
}
static vector unsigned short __ATTRS_o_ai vec_andc(vector unsigned short __a,
vector unsigned short __b) {
return __a & ~__b;
}
static vector unsigned short __ATTRS_o_ai vec_andc(vector bool short __a,
vector unsigned short __b) {
return (vector unsigned short)__a & ~__b;
}
static vector unsigned short __ATTRS_o_ai vec_andc(vector unsigned short __a,
vector bool short __b) {
return __a & ~(vector unsigned short)__b;
}
static vector bool short __ATTRS_o_ai vec_andc(vector bool short __a,
vector bool short __b) {
return __a & ~__b;
}
static vector int __ATTRS_o_ai vec_andc(vector int __a, vector int __b) {
return __a & ~__b;
}
static vector int __ATTRS_o_ai vec_andc(vector bool int __a, vector int __b) {
return (vector int)__a & ~__b;
}
static vector int __ATTRS_o_ai vec_andc(vector int __a, vector bool int __b) {
return __a & ~(vector int)__b;
}
static vector unsigned int __ATTRS_o_ai vec_andc(vector unsigned int __a,
vector unsigned int __b) {
return __a & ~__b;
}
static vector unsigned int __ATTRS_o_ai vec_andc(vector bool int __a,
vector unsigned int __b) {
return (vector unsigned int)__a & ~__b;
}
static vector unsigned int __ATTRS_o_ai vec_andc(vector unsigned int __a,
vector bool int __b) {
return __a & ~(vector unsigned int)__b;
}
static vector bool int __ATTRS_o_ai vec_andc(vector bool int __a,
vector bool int __b) {
return __a & ~__b;
}
static vector float __ATTRS_o_ai vec_andc(vector float __a, vector float __b) {
vector unsigned int __res =
(vector unsigned int)__a & ~(vector unsigned int)__b;
return (vector float)__res;
}
static vector float __ATTRS_o_ai vec_andc(vector bool int __a,
vector float __b) {
vector unsigned int __res =
(vector unsigned int)__a & ~(vector unsigned int)__b;
return (vector float)__res;
}
static vector float __ATTRS_o_ai vec_andc(vector float __a,
vector bool int __b) {
vector unsigned int __res =
(vector unsigned int)__a & ~(vector unsigned int)__b;
return (vector float)__res;
}
#ifdef __VSX__
static vector double __ATTRS_o_ai
vec_andc(vector bool long long __a, vector double __b) {
vector unsigned long long __res =
(vector unsigned long long)__a & ~(vector unsigned long long)__b;
return (vector double)__res;
}
static vector double __ATTRS_o_ai
vec_andc(vector double __a, vector bool long long __b) {
vector unsigned long long __res =
(vector unsigned long long)__a & ~(vector unsigned long long)__b;
return (vector double)__res;
}
static vector double __ATTRS_o_ai vec_andc(vector double __a, vector double __b) {
vector unsigned long long __res =
(vector unsigned long long)__a & ~(vector unsigned long long)__b;
return (vector double)__res;
}
static vector signed long long __ATTRS_o_ai
vec_andc(vector signed long long __a, vector signed long long __b) {
return __a & ~__b;
}
static vector signed long long __ATTRS_o_ai
vec_andc(vector bool long long __a, vector signed long long __b) {
return (vector signed long long)__a & ~__b;
}
static vector signed long long __ATTRS_o_ai
vec_andc(vector signed long long __a, vector bool long long __b) {
return __a & ~(vector signed long long)__b;
}
static vector unsigned long long __ATTRS_o_ai
vec_andc(vector unsigned long long __a, vector unsigned long long __b) {
return __a & ~__b;
}
static vector unsigned long long __ATTRS_o_ai
vec_andc(vector bool long long __a, vector unsigned long long __b) {
return (vector unsigned long long)__a & ~__b;
}
static vector unsigned long long __ATTRS_o_ai
vec_andc(vector unsigned long long __a, vector bool long long __b) {
return __a & ~(vector unsigned long long)__b;
}
static vector bool long long __ATTRS_o_ai vec_andc(vector bool long long __a,
vector bool long long __b) {
return __a & ~__b;
}
#endif
/* vec_vandc */
static vector signed char __ATTRS_o_ai vec_vandc(vector signed char __a,
vector signed char __b) {
return __a & ~__b;
}
static vector signed char __ATTRS_o_ai vec_vandc(vector bool char __a,
vector signed char __b) {
return (vector signed char)__a & ~__b;
}
static vector signed char __ATTRS_o_ai vec_vandc(vector signed char __a,
vector bool char __b) {
return __a & ~(vector signed char)__b;
}
static vector unsigned char __ATTRS_o_ai vec_vandc(vector unsigned char __a,
vector unsigned char __b) {
return __a & ~__b;
}
static vector unsigned char __ATTRS_o_ai vec_vandc(vector bool char __a,
vector unsigned char __b) {
return (vector unsigned char)__a & ~__b;
}
static vector unsigned char __ATTRS_o_ai vec_vandc(vector unsigned char __a,
vector bool char __b) {
return __a & ~(vector unsigned char)__b;
}
static vector bool char __ATTRS_o_ai vec_vandc(vector bool char __a,
vector bool char __b) {
return __a & ~__b;
}
static vector short __ATTRS_o_ai vec_vandc(vector short __a, vector short __b) {
return __a & ~__b;
}
static vector short __ATTRS_o_ai vec_vandc(vector bool short __a,
vector short __b) {
return (vector short)__a & ~__b;
}
static vector short __ATTRS_o_ai vec_vandc(vector short __a,
vector bool short __b) {
return __a & ~(vector short)__b;
}
static vector unsigned short __ATTRS_o_ai vec_vandc(vector unsigned short __a,
vector unsigned short __b) {
return __a & ~__b;
}
static vector unsigned short __ATTRS_o_ai vec_vandc(vector bool short __a,
vector unsigned short __b) {
return (vector unsigned short)__a & ~__b;
}
static vector unsigned short __ATTRS_o_ai vec_vandc(vector unsigned short __a,
vector bool short __b) {
return __a & ~(vector unsigned short)__b;
}
static vector bool short __ATTRS_o_ai vec_vandc(vector bool short __a,
vector bool short __b) {
return __a & ~__b;
}
static vector int __ATTRS_o_ai vec_vandc(vector int __a, vector int __b) {
return __a & ~__b;
}
static vector int __ATTRS_o_ai vec_vandc(vector bool int __a, vector int __b) {
return (vector int)__a & ~__b;
}
static vector int __ATTRS_o_ai vec_vandc(vector int __a, vector bool int __b) {
return __a & ~(vector int)__b;
}
static vector unsigned int __ATTRS_o_ai vec_vandc(vector unsigned int __a,
vector unsigned int __b) {
return __a & ~__b;
}
static vector unsigned int __ATTRS_o_ai vec_vandc(vector bool int __a,
vector unsigned int __b) {
return (vector unsigned int)__a & ~__b;
}
static vector unsigned int __ATTRS_o_ai vec_vandc(vector unsigned int __a,
vector bool int __b) {
return __a & ~(vector unsigned int)__b;
}
static vector bool int __ATTRS_o_ai vec_vandc(vector bool int __a,
vector bool int __b) {
return __a & ~__b;
}
static vector float __ATTRS_o_ai vec_vandc(vector float __a, vector float __b) {
vector unsigned int __res =
(vector unsigned int)__a & ~(vector unsigned int)__b;
return (vector float)__res;
}
static vector float __ATTRS_o_ai vec_vandc(vector bool int __a,
vector float __b) {
vector unsigned int __res =
(vector unsigned int)__a & ~(vector unsigned int)__b;
return (vector float)__res;
}
static vector float __ATTRS_o_ai vec_vandc(vector float __a,
vector bool int __b) {
vector unsigned int __res =
(vector unsigned int)__a & ~(vector unsigned int)__b;
return (vector float)__res;
}
#ifdef __VSX__
static vector signed long long __ATTRS_o_ai
vec_vandc(vector signed long long __a, vector signed long long __b) {
return __a & ~__b;
}
static vector signed long long __ATTRS_o_ai
vec_vandc(vector bool long long __a, vector signed long long __b) {
return (vector signed long long)__a & ~__b;
}
static vector signed long long __ATTRS_o_ai
vec_vandc(vector signed long long __a, vector bool long long __b) {
return __a & ~(vector signed long long)__b;
}
static vector unsigned long long __ATTRS_o_ai
vec_vandc(vector unsigned long long __a, vector unsigned long long __b) {
return __a & ~__b;
}
static vector unsigned long long __ATTRS_o_ai
vec_vandc(vector bool long long __a, vector unsigned long long __b) {
return (vector unsigned long long)__a & ~__b;
}
static vector unsigned long long __ATTRS_o_ai
vec_vandc(vector unsigned long long __a, vector bool long long __b) {
return __a & ~(vector unsigned long long)__b;
}
static vector bool long long __ATTRS_o_ai vec_vandc(vector bool long long __a,
vector bool long long __b) {
return __a & ~__b;
}
#endif
/* vec_avg */
static vector signed char __ATTRS_o_ai vec_avg(vector signed char __a,
vector signed char __b) {
return __builtin_altivec_vavgsb(__a, __b);
}
static vector unsigned char __ATTRS_o_ai vec_avg(vector unsigned char __a,
vector unsigned char __b) {
return __builtin_altivec_vavgub(__a, __b);
}
static vector short __ATTRS_o_ai vec_avg(vector short __a, vector short __b) {
return __builtin_altivec_vavgsh(__a, __b);
}
static vector unsigned short __ATTRS_o_ai vec_avg(vector unsigned short __a,
vector unsigned short __b) {
return __builtin_altivec_vavguh(__a, __b);
}
static vector int __ATTRS_o_ai vec_avg(vector int __a, vector int __b) {
return __builtin_altivec_vavgsw(__a, __b);
}
static vector unsigned int __ATTRS_o_ai vec_avg(vector unsigned int __a,
vector unsigned int __b) {
return __builtin_altivec_vavguw(__a, __b);
}
/* vec_vavgsb */
static vector signed char __attribute__((__always_inline__))
vec_vavgsb(vector signed char __a, vector signed char __b) {
return __builtin_altivec_vavgsb(__a, __b);
}
/* vec_vavgub */
static vector unsigned char __attribute__((__always_inline__))
vec_vavgub(vector unsigned char __a, vector unsigned char __b) {
return __builtin_altivec_vavgub(__a, __b);
}
/* vec_vavgsh */
static vector short __attribute__((__always_inline__))
vec_vavgsh(vector short __a, vector short __b) {
return __builtin_altivec_vavgsh(__a, __b);
}
/* vec_vavguh */
static vector unsigned short __attribute__((__always_inline__))
vec_vavguh(vector unsigned short __a, vector unsigned short __b) {
return __builtin_altivec_vavguh(__a, __b);
}
/* vec_vavgsw */
static vector int __attribute__((__always_inline__))
vec_vavgsw(vector int __a, vector int __b) {
return __builtin_altivec_vavgsw(__a, __b);
}
/* vec_vavguw */
static vector unsigned int __attribute__((__always_inline__))
vec_vavguw(vector unsigned int __a, vector unsigned int __b) {
return __builtin_altivec_vavguw(__a, __b);
}
/* vec_ceil */
static vector float __ATTRS_o_ai vec_ceil(vector float __a) {
#ifdef __VSX__
return __builtin_vsx_xvrspip(__a);
#else
return __builtin_altivec_vrfip(__a);
#endif
}
#ifdef __VSX__
static vector double __ATTRS_o_ai vec_ceil(vector double __a) {
return __builtin_vsx_xvrdpip(__a);
}
#endif
/* vec_vrfip */
static vector float __attribute__((__always_inline__))
vec_vrfip(vector float __a) {
return __builtin_altivec_vrfip(__a);
}
/* vec_cmpb */
static vector int __attribute__((__always_inline__))
vec_cmpb(vector float __a, vector float __b) {
return __builtin_altivec_vcmpbfp(__a, __b);
}
/* vec_vcmpbfp */
static vector int __attribute__((__always_inline__))
vec_vcmpbfp(vector float __a, vector float __b) {
return __builtin_altivec_vcmpbfp(__a, __b);
}
/* vec_cmpeq */
static vector bool char __ATTRS_o_ai vec_cmpeq(vector signed char __a,
vector signed char __b) {
return (vector bool char)__builtin_altivec_vcmpequb((vector char)__a,
(vector char)__b);
}
static vector bool char __ATTRS_o_ai vec_cmpeq(vector unsigned char __a,
vector unsigned char __b) {
return (vector bool char)__builtin_altivec_vcmpequb((vector char)__a,
(vector char)__b);
}
static vector bool short __ATTRS_o_ai vec_cmpeq(vector short __a,
vector short __b) {
return (vector bool short)__builtin_altivec_vcmpequh(__a, __b);
}
static vector bool short __ATTRS_o_ai vec_cmpeq(vector unsigned short __a,
vector unsigned short __b) {
return (vector bool short)__builtin_altivec_vcmpequh((vector short)__a,
(vector short)__b);
}
static vector bool int __ATTRS_o_ai vec_cmpeq(vector int __a, vector int __b) {
return (vector bool int)__builtin_altivec_vcmpequw(__a, __b);
}
static vector bool int __ATTRS_o_ai vec_cmpeq(vector unsigned int __a,
vector unsigned int __b) {
return (vector bool int)__builtin_altivec_vcmpequw((vector int)__a,
(vector int)__b);
}
#ifdef __POWER8_VECTOR__
static vector bool long long __ATTRS_o_ai
vec_cmpeq(vector signed long long __a, vector signed long long __b) {
return (vector bool long long)__builtin_altivec_vcmpequd(__a, __b);
}
static vector bool long long __ATTRS_o_ai
vec_cmpeq(vector unsigned long long __a, vector unsigned long long __b) {
return (vector bool long long)__builtin_altivec_vcmpequd(
(vector long long)__a, (vector long long)__b);
}
#endif
static vector bool int __ATTRS_o_ai vec_cmpeq(vector float __a,
vector float __b) {
#ifdef __VSX__
return (vector bool int)__builtin_vsx_xvcmpeqsp(__a, __b);
#else
return (vector bool int)__builtin_altivec_vcmpeqfp(__a, __b);
#endif
}
#ifdef __VSX__
static vector bool long long __ATTRS_o_ai
vec_cmpeq(vector double __a, vector double __b) {
return (vector bool long long)__builtin_vsx_xvcmpeqdp(__a, __b);
}
#endif
/* vec_cmpgt */
static vector bool char __ATTRS_o_ai vec_cmpgt(vector signed char __a,
vector signed char __b) {
return (vector bool char)__builtin_altivec_vcmpgtsb(__a, __b);
}
static vector bool char __ATTRS_o_ai vec_cmpgt(vector unsigned char __a,
vector unsigned char __b) {
return (vector bool char)__builtin_altivec_vcmpgtub(__a, __b);
}
static vector bool short __ATTRS_o_ai vec_cmpgt(vector short __a,
vector short __b) {
return (vector bool short)__builtin_altivec_vcmpgtsh(__a, __b);
}
static vector bool short __ATTRS_o_ai vec_cmpgt(vector unsigned short __a,
vector unsigned short __b) {
return (vector bool short)__builtin_altivec_vcmpgtuh(__a, __b);
}
static vector bool int __ATTRS_o_ai vec_cmpgt(vector int __a, vector int __b) {
return (vector bool int)__builtin_altivec_vcmpgtsw(__a, __b);
}
static vector bool int __ATTRS_o_ai vec_cmpgt(vector unsigned int __a,
vector unsigned int __b) {
return (vector bool int)__builtin_altivec_vcmpgtuw(__a, __b);
}
#ifdef __POWER8_VECTOR__
static vector bool long long __ATTRS_o_ai
vec_cmpgt(vector signed long long __a, vector signed long long __b) {
return (vector bool long long)__builtin_altivec_vcmpgtsd(__a, __b);
}
static vector bool long long __ATTRS_o_ai
vec_cmpgt(vector unsigned long long __a, vector unsigned long long __b) {
return (vector bool long long)__builtin_altivec_vcmpgtud(__a, __b);
}
#endif
static vector bool int __ATTRS_o_ai vec_cmpgt(vector float __a,
vector float __b) {
#ifdef __VSX__
return (vector bool int)__builtin_vsx_xvcmpgtsp(__a, __b);
#else
return (vector bool int)__builtin_altivec_vcmpgtfp(__a, __b);
#endif
}
#ifdef __VSX__
static vector bool long long __ATTRS_o_ai
vec_cmpgt(vector double __a, vector double __b) {
return (vector bool long long)__builtin_vsx_xvcmpgtdp(__a, __b);
}
#endif
/* vec_cmpge */
static vector bool char __ATTRS_o_ai
vec_cmpge (vector signed char __a, vector signed char __b) {
return ~(vec_cmpgt(__b, __a));
}
static vector bool char __ATTRS_o_ai
vec_cmpge (vector unsigned char __a, vector unsigned char __b) {
return ~(vec_cmpgt(__b, __a));
}
static vector bool short __ATTRS_o_ai
vec_cmpge (vector signed short __a, vector signed short __b) {
return ~(vec_cmpgt(__b, __a));
}
static vector bool short __ATTRS_o_ai
vec_cmpge (vector unsigned short __a, vector unsigned short __b) {
return ~(vec_cmpgt(__b, __a));
}
static vector bool int __ATTRS_o_ai
vec_cmpge (vector signed int __a, vector signed int __b) {
return ~(vec_cmpgt(__b, __a));
}
static vector bool int __ATTRS_o_ai
vec_cmpge (vector unsigned int __a, vector unsigned int __b) {
return ~(vec_cmpgt(__b, __a));
}
static vector bool int __ATTRS_o_ai
vec_cmpge(vector float __a, vector float __b) {
#ifdef __VSX__
return (vector bool int)__builtin_vsx_xvcmpgesp(__a, __b);
#else
return (vector bool int)__builtin_altivec_vcmpgefp(__a, __b);
#endif
}
#ifdef __VSX__
static vector bool long long __ATTRS_o_ai
vec_cmpge(vector double __a, vector double __b) {
return (vector bool long long)__builtin_vsx_xvcmpgedp(__a, __b);
}
#endif
#ifdef __POWER8_VECTOR__
static vector bool long long __ATTRS_o_ai
vec_cmpge(vector signed long long __a, vector signed long long __b) {
return ~(vec_cmpgt(__b, __a));
}
static vector bool long long __ATTRS_o_ai
vec_cmpge(vector unsigned long long __a, vector unsigned long long __b) {
return ~(vec_cmpgt(__b, __a));
}
#endif
/* vec_vcmpgefp */
static vector bool int __attribute__((__always_inline__))
vec_vcmpgefp(vector float __a, vector float __b) {
return (vector bool int)__builtin_altivec_vcmpgefp(__a, __b);
}
/* vec_vcmpgtsb */
static vector bool char __attribute__((__always_inline__))
vec_vcmpgtsb(vector signed char __a, vector signed char __b) {
return (vector bool char)__builtin_altivec_vcmpgtsb(__a, __b);
}
/* vec_vcmpgtub */
static vector bool char __attribute__((__always_inline__))
vec_vcmpgtub(vector unsigned char __a, vector unsigned char __b) {
return (vector bool char)__builtin_altivec_vcmpgtub(__a, __b);
}
/* vec_vcmpgtsh */
static vector bool short __attribute__((__always_inline__))
vec_vcmpgtsh(vector short __a, vector short __b) {
return (vector bool short)__builtin_altivec_vcmpgtsh(__a, __b);
}
/* vec_vcmpgtuh */
static vector bool short __attribute__((__always_inline__))
vec_vcmpgtuh(vector unsigned short __a, vector unsigned short __b) {
return (vector bool short)__builtin_altivec_vcmpgtuh(__a, __b);
}
/* vec_vcmpgtsw */
static vector bool int __attribute__((__always_inline__))
vec_vcmpgtsw(vector int __a, vector int __b) {
return (vector bool int)__builtin_altivec_vcmpgtsw(__a, __b);
}
/* vec_vcmpgtuw */
static vector bool int __attribute__((__always_inline__))
vec_vcmpgtuw(vector unsigned int __a, vector unsigned int __b) {
return (vector bool int)__builtin_altivec_vcmpgtuw(__a, __b);
}
/* vec_vcmpgtfp */
static vector bool int __attribute__((__always_inline__))
vec_vcmpgtfp(vector float __a, vector float __b) {
return (vector bool int)__builtin_altivec_vcmpgtfp(__a, __b);
}
/* vec_cmple */
static vector bool char __ATTRS_o_ai
vec_cmple (vector signed char __a, vector signed char __b) {
return vec_cmpge(__b, __a);
}
static vector bool char __ATTRS_o_ai
vec_cmple (vector unsigned char __a, vector unsigned char __b) {
return vec_cmpge(__b, __a);
}
static vector bool short __ATTRS_o_ai
vec_cmple (vector signed short __a, vector signed short __b) {
return vec_cmpge(__b, __a);
}
static vector bool short __ATTRS_o_ai
vec_cmple (vector unsigned short __a, vector unsigned short __b) {
return vec_cmpge(__b, __a);
}
static vector bool int __ATTRS_o_ai
vec_cmple (vector signed int __a, vector signed int __b) {
return vec_cmpge(__b, __a);
}
static vector bool int __ATTRS_o_ai
vec_cmple (vector unsigned int __a, vector unsigned int __b) {
return vec_cmpge(__b, __a);
}
static vector bool int __ATTRS_o_ai
vec_cmple(vector float __a, vector float __b) {
return vec_cmpge(__b, __a);
}
#ifdef __VSX__
static vector bool long long __ATTRS_o_ai
vec_cmple(vector double __a, vector double __b) {
return vec_cmpge(__b, __a);
}
#endif
#ifdef __POWER8_VECTOR__
static vector bool long long __ATTRS_o_ai
vec_cmple(vector signed long long __a, vector signed long long __b) {
return vec_cmpge(__b, __a);
}
static vector bool long long __ATTRS_o_ai
vec_cmple(vector unsigned long long __a, vector unsigned long long __b) {
return vec_cmpge(__b, __a);
}
#endif
/* vec_cmplt */
static vector bool char __ATTRS_o_ai vec_cmplt(vector signed char __a,
vector signed char __b) {
return vec_cmpgt(__b, __a);
}
static vector bool char __ATTRS_o_ai vec_cmplt(vector unsigned char __a,
vector unsigned char __b) {
return vec_cmpgt(__b, __a);
}
static vector bool short __ATTRS_o_ai vec_cmplt(vector short __a,
vector short __b) {
return vec_cmpgt(__b, __a);
}
static vector bool short __ATTRS_o_ai vec_cmplt(vector unsigned short __a,
vector unsigned short __b) {
return vec_cmpgt(__b, __a);
}
static vector bool int __ATTRS_o_ai vec_cmplt(vector int __a, vector int __b) {
return vec_cmpgt(__b, __a);
}
static vector bool int __ATTRS_o_ai vec_cmplt(vector unsigned int __a,
vector unsigned int __b) {
return vec_cmpgt(__b, __a);
}
static vector bool int __ATTRS_o_ai vec_cmplt(vector float __a,
vector float __b) {
return vec_cmpgt(__b, __a);
}
#ifdef __VSX__
static vector bool long long __ATTRS_o_ai
vec_cmplt(vector double __a, vector double __b) {
return vec_cmpgt(__b, __a);
}
#endif
#ifdef __POWER8_VECTOR__
static vector bool long long __ATTRS_o_ai
vec_cmplt(vector signed long long __a, vector signed long long __b) {
return vec_cmpgt(__b, __a);
}
static vector bool long long __ATTRS_o_ai
vec_cmplt(vector unsigned long long __a, vector unsigned long long __b) {
return vec_cmpgt(__b, __a);
}
/* vec_cntlz */
static vector signed char __ATTRS_o_ai vec_cntlz(vector signed char __a) {
return __builtin_altivec_vclzb(__a);
}
static vector unsigned char __ATTRS_o_ai vec_cntlz(vector unsigned char __a) {
return __builtin_altivec_vclzb(__a);
}
static vector signed short __ATTRS_o_ai vec_cntlz(vector signed short __a) {
return __builtin_altivec_vclzh(__a);
}
static vector unsigned short __ATTRS_o_ai vec_cntlz(vector unsigned short __a) {
return __builtin_altivec_vclzh(__a);
}
static vector signed int __ATTRS_o_ai vec_cntlz(vector signed int __a) {
return __builtin_altivec_vclzw(__a);
}
static vector unsigned int __ATTRS_o_ai vec_cntlz(vector unsigned int __a) {
return __builtin_altivec_vclzw(__a);
}
static vector signed long long __ATTRS_o_ai
vec_cntlz(vector signed long long __a) {
return __builtin_altivec_vclzd(__a);
}
static vector unsigned long long __ATTRS_o_ai
vec_cntlz(vector unsigned long long __a) {
return __builtin_altivec_vclzd(__a);
}
#endif
/* vec_cpsgn */
#ifdef __VSX__
static vector float __ATTRS_o_ai vec_cpsgn(vector float __a, vector float __b) {
return __builtin_vsx_xvcpsgnsp(__a, __b);
}
static vector double __ATTRS_o_ai vec_cpsgn(vector double __a,
vector double __b) {
return __builtin_vsx_xvcpsgndp(__a, __b);
}
#endif
/* vec_ctf */
static vector float __ATTRS_o_ai vec_ctf(vector int __a, int __b) {
return __builtin_altivec_vcfsx(__a, __b);
}
static vector float __ATTRS_o_ai vec_ctf(vector unsigned int __a, int __b) {
return __builtin_altivec_vcfux((vector int)__a, __b);
}
/* vec_vcfsx */
static vector float __attribute__((__always_inline__))
vec_vcfsx(vector int __a, int __b) {
return __builtin_altivec_vcfsx(__a, __b);
}
/* vec_vcfux */
static vector float __attribute__((__always_inline__))
vec_vcfux(vector unsigned int __a, int __b) {
return __builtin_altivec_vcfux((vector int)__a, __b);
}
/* vec_cts */
static vector int __attribute__((__always_inline__))
vec_cts(vector float __a, int __b) {
return __builtin_altivec_vctsxs(__a, __b);
}
/* vec_vctsxs */
static vector int __attribute__((__always_inline__))
vec_vctsxs(vector float __a, int __b) {
return __builtin_altivec_vctsxs(__a, __b);
}
/* vec_ctu */
static vector unsigned int __attribute__((__always_inline__))
vec_ctu(vector float __a, int __b) {
return __builtin_altivec_vctuxs(__a, __b);
}
/* vec_vctuxs */
static vector unsigned int __attribute__((__always_inline__))
vec_vctuxs(vector float __a, int __b) {
return __builtin_altivec_vctuxs(__a, __b);
}
/* vec_double */
#ifdef __VSX__
static vector double __ATTRS_o_ai vec_double (vector signed long long __a) {
vector double __ret = { __a[0], __a[1] };
return __ret;
}
static vector double __ATTRS_o_ai vec_double (vector unsigned long long __a) {
vector double __ret = { __a[0], __a[1] };
return __ret;
}
#endif
/* vec_div */
/* Integer vector divides (vectors are scalarized, elements divided
and the vectors reassembled).
*/
static vector signed char __ATTRS_o_ai vec_div(vector signed char __a,
vector signed char __b) {
return __a / __b;
}
static vector unsigned char __ATTRS_o_ai vec_div(vector unsigned char __a,
vector unsigned char __b) {
return __a / __b;
}
static vector signed short __ATTRS_o_ai vec_div(vector signed short __a,
vector signed short __b) {
return __a / __b;
}
static vector unsigned short __ATTRS_o_ai vec_div(vector unsigned short __a,
vector unsigned short __b) {
return __a / __b;
}
static vector signed int __ATTRS_o_ai vec_div(vector signed int __a,
vector signed int __b) {
return __a / __b;
}
static vector unsigned int __ATTRS_o_ai vec_div(vector unsigned int __a,
vector unsigned int __b) {
return __a / __b;
}
#ifdef __VSX__
static vector signed long long __ATTRS_o_ai
vec_div(vector signed long long __a, vector signed long long __b) {
return __a / __b;
}
static vector unsigned long long __ATTRS_o_ai
vec_div(vector unsigned long long __a, vector unsigned long long __b) {
return __a / __b;
}
static vector float __ATTRS_o_ai vec_div(vector float __a, vector float __b) {
return __a / __b;
}
static vector double __ATTRS_o_ai vec_div(vector double __a,
vector double __b) {
return __a / __b;
}
#endif
/* vec_dss */
static void __attribute__((__always_inline__)) vec_dss(int __a) {
__builtin_altivec_dss(__a);
}
/* vec_dssall */
static void __attribute__((__always_inline__)) vec_dssall(void) {
__builtin_altivec_dssall();
}
/* vec_dst */
static void __attribute__((__always_inline__))
vec_dst(const void *__a, int __b, int __c) {
__builtin_altivec_dst(__a, __b, __c);
}
/* vec_dstst */
static void __attribute__((__always_inline__))
vec_dstst(const void *__a, int __b, int __c) {
__builtin_altivec_dstst(__a, __b, __c);
}
/* vec_dststt */
static void __attribute__((__always_inline__))
vec_dststt(const void *__a, int __b, int __c) {
__builtin_altivec_dststt(__a, __b, __c);
}
/* vec_dstt */
static void __attribute__((__always_inline__))
vec_dstt(const void *__a, int __b, int __c) {
__builtin_altivec_dstt(__a, __b, __c);
}
/* vec_eqv */
#ifdef __POWER8_VECTOR__
static vector signed char __ATTRS_o_ai vec_eqv(vector signed char __a,
vector signed char __b) {
return (vector signed char)__builtin_vsx_xxleqv((vector unsigned int)__a,
(vector unsigned int)__b);
}
static vector unsigned char __ATTRS_o_ai vec_eqv(vector unsigned char __a,
vector unsigned char __b) {
return (vector unsigned char)__builtin_vsx_xxleqv((vector unsigned int)__a,
(vector unsigned int)__b);
}
static vector bool char __ATTRS_o_ai vec_eqv(vector bool char __a,
vector bool char __b) {
return (vector bool char)__builtin_vsx_xxleqv((vector unsigned int)__a,
(vector unsigned int)__b);
}
static vector signed short __ATTRS_o_ai vec_eqv(vector signed short __a,
vector signed short __b) {
return (vector signed short)__builtin_vsx_xxleqv((vector unsigned int)__a,
(vector unsigned int)__b);
}
static vector unsigned short __ATTRS_o_ai vec_eqv(vector unsigned short __a,
vector unsigned short __b) {
return (vector unsigned short)__builtin_vsx_xxleqv((vector unsigned int)__a,
(vector unsigned int)__b);
}
static vector bool short __ATTRS_o_ai vec_eqv(vector bool short __a,
vector bool short __b) {
return (vector bool short)__builtin_vsx_xxleqv((vector unsigned int)__a,
(vector unsigned int)__b);
}
static vector signed int __ATTRS_o_ai vec_eqv(vector signed int __a,
vector signed int __b) {
return (vector signed int)__builtin_vsx_xxleqv((vector unsigned int)__a,
(vector unsigned int)__b);
}
static vector unsigned int __ATTRS_o_ai vec_eqv(vector unsigned int __a,
vector unsigned int __b) {
return __builtin_vsx_xxleqv(__a, __b);
}
static vector bool int __ATTRS_o_ai vec_eqv(vector bool int __a,
vector bool int __b) {
return (vector bool int)__builtin_vsx_xxleqv((vector unsigned int)__a,
(vector unsigned int)__b);
}
static vector signed long long __ATTRS_o_ai
vec_eqv(vector signed long long __a, vector signed long long __b) {
return (vector signed long long)
__builtin_vsx_xxleqv((vector unsigned int)__a, (vector unsigned int)__b);
}
static vector unsigned long long __ATTRS_o_ai
vec_eqv(vector unsigned long long __a, vector unsigned long long __b) {
return (vector unsigned long long)
__builtin_vsx_xxleqv((vector unsigned int)__a, (vector unsigned int)__b);
}
static vector bool long long __ATTRS_o_ai
vec_eqv(vector bool long long __a, vector bool long long __b) {
return (vector bool long long)
__builtin_vsx_xxleqv((vector unsigned int)__a, (vector unsigned int)__b);
}
static vector float __ATTRS_o_ai vec_eqv(vector float __a, vector float __b) {
return (vector float)__builtin_vsx_xxleqv((vector unsigned int)__a,
(vector unsigned int)__b);
}
static vector double __ATTRS_o_ai vec_eqv(vector double __a,
vector double __b) {
return (vector double)__builtin_vsx_xxleqv((vector unsigned int)__a,
(vector unsigned int)__b);
}
#endif
/* vec_expte */
static vector float __attribute__((__always_inline__))
vec_expte(vector float __a) {
return __builtin_altivec_vexptefp(__a);
}
/* vec_vexptefp */
static vector float __attribute__((__always_inline__))
vec_vexptefp(vector float __a) {
return __builtin_altivec_vexptefp(__a);
}
/* vec_floor */
static vector float __ATTRS_o_ai vec_floor(vector float __a) {
#ifdef __VSX__
return __builtin_vsx_xvrspim(__a);
#else
return __builtin_altivec_vrfim(__a);
#endif
}
#ifdef __VSX__
static vector double __ATTRS_o_ai vec_floor(vector double __a) {
return __builtin_vsx_xvrdpim(__a);
}
#endif
/* vec_vrfim */
static vector float __attribute__((__always_inline__))
vec_vrfim(vector float __a) {
return __builtin_altivec_vrfim(__a);
}
/* vec_ld */
static vector signed char __ATTRS_o_ai vec_ld(int __a,
const vector signed char *__b) {
return (vector signed char)__builtin_altivec_lvx(__a, __b);
}
static vector signed char __ATTRS_o_ai vec_ld(int __a, const signed char *__b) {
return (vector signed char)__builtin_altivec_lvx(__a, __b);
}
static vector unsigned char __ATTRS_o_ai
vec_ld(int __a, const vector unsigned char *__b) {
return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
}
static vector unsigned char __ATTRS_o_ai vec_ld(int __a,
const unsigned char *__b) {
return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
}
static vector bool char __ATTRS_o_ai vec_ld(int __a,
const vector bool char *__b) {
return (vector bool char)__builtin_altivec_lvx(__a, __b);
}
static vector short __ATTRS_o_ai vec_ld(int __a, const vector short *__b) {
return (vector short)__builtin_altivec_lvx(__a, __b);
}
static vector short __ATTRS_o_ai vec_ld(int __a, const short *__b) {
return (vector short)__builtin_altivec_lvx(__a, __b);
}
static vector unsigned short __ATTRS_o_ai
vec_ld(int __a, const vector unsigned short *__b) {
return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
}
static vector unsigned short __ATTRS_o_ai vec_ld(int __a,
const unsigned short *__b) {
return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
}
static vector bool short __ATTRS_o_ai vec_ld(int __a,
const vector bool short *__b) {
return (vector bool short)__builtin_altivec_lvx(__a, __b);
}
static vector pixel __ATTRS_o_ai vec_ld(int __a, const vector pixel *__b) {
return (vector pixel)__builtin_altivec_lvx(__a, __b);
}
static vector int __ATTRS_o_ai vec_ld(int __a, const vector int *__b) {
return (vector int)__builtin_altivec_lvx(__a, __b);
}
static vector int __ATTRS_o_ai vec_ld(int __a, const int *__b) {
return (vector int)__builtin_altivec_lvx(__a, __b);
}
static vector unsigned int __ATTRS_o_ai vec_ld(int __a,
const vector unsigned int *__b) {
return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
}
static vector unsigned int __ATTRS_o_ai vec_ld(int __a,
const unsigned int *__b) {
return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
}
static vector bool int __ATTRS_o_ai vec_ld(int __a,
const vector bool int *__b) {
return (vector bool int)__builtin_altivec_lvx(__a, __b);
}
static vector float __ATTRS_o_ai vec_ld(int __a, const vector float *__b) {
return (vector float)__builtin_altivec_lvx(__a, __b);
}
static vector float __ATTRS_o_ai vec_ld(int __a, const float *__b) {
return (vector float)__builtin_altivec_lvx(__a, __b);
}
/* vec_lvx */
static vector signed char __ATTRS_o_ai vec_lvx(int __a,
const vector signed char *__b) {
return (vector signed char)__builtin_altivec_lvx(__a, __b);
}
static vector signed char __ATTRS_o_ai vec_lvx(int __a,
const signed char *__b) {
return (vector signed char)__builtin_altivec_lvx(__a, __b);
}
static vector unsigned char __ATTRS_o_ai
vec_lvx(int __a, const vector unsigned char *__b) {
return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
}
static vector unsigned char __ATTRS_o_ai vec_lvx(int __a,
const unsigned char *__b) {
return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
}
static vector bool char __ATTRS_o_ai vec_lvx(int __a,
const vector bool char *__b) {
return (vector bool char)__builtin_altivec_lvx(__a, __b);
}
static vector short __ATTRS_o_ai vec_lvx(int __a, const vector short *__b) {
return (vector short)__builtin_altivec_lvx(__a, __b);
}
static vector short __ATTRS_o_ai vec_lvx(int __a, const short *__b) {
return (vector short)__builtin_altivec_lvx(__a, __b);
}
static vector unsigned short __ATTRS_o_ai
vec_lvx(int __a, const vector unsigned short *__b) {
return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
}
static vector unsigned short __ATTRS_o_ai vec_lvx(int __a,
const unsigned short *__b) {
return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
}
static vector bool short __ATTRS_o_ai vec_lvx(int __a,
const vector bool short *__b) {
return (vector bool short)__builtin_altivec_lvx(__a, __b);
}
static vector pixel __ATTRS_o_ai vec_lvx(int __a, const vector pixel *__b) {
return (vector pixel)__builtin_altivec_lvx(__a, __b);
}
static vector int __ATTRS_o_ai vec_lvx(int __a, const vector int *__b) {
return (vector int)__builtin_altivec_lvx(__a, __b);
}
static vector int __ATTRS_o_ai vec_lvx(int __a, const int *__b) {
return (vector int)__builtin_altivec_lvx(__a, __b);
}
static vector unsigned int __ATTRS_o_ai
vec_lvx(int __a, const vector unsigned int *__b) {
return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
}
static vector unsigned int __ATTRS_o_ai vec_lvx(int __a,
const unsigned int *__b) {
return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
}
static vector bool int __ATTRS_o_ai vec_lvx(int __a,
const vector bool int *__b) {
return (vector bool int)__builtin_altivec_lvx(__a, __b);
}
static vector float __ATTRS_o_ai vec_lvx(int __a, const vector float *__b) {
return (vector float)__builtin_altivec_lvx(__a, __b);
}
static vector float __ATTRS_o_ai vec_lvx(int __a, const float *__b) {
return (vector float)__builtin_altivec_lvx(__a, __b);
}
/* vec_lde */
static vector signed char __ATTRS_o_ai vec_lde(int __a,
const signed char *__b) {
return (vector signed char)__builtin_altivec_lvebx(__a, __b);
}
static vector unsigned char __ATTRS_o_ai vec_lde(int __a,
const unsigned char *__b) {
return (vector unsigned char)__builtin_altivec_lvebx(__a, __b);
}
static vector short __ATTRS_o_ai vec_lde(int __a, const short *__b) {
return (vector short)__builtin_altivec_lvehx(__a, __b);
}
static vector unsigned short __ATTRS_o_ai vec_lde(int __a,
const unsigned short *__b) {
return (vector unsigned short)__builtin_altivec_lvehx(__a, __b);
}
static vector int __ATTRS_o_ai vec_lde(int __a, const int *__b) {
return (vector int)__builtin_altivec_lvewx(__a, __b);
}
static vector unsigned int __ATTRS_o_ai vec_lde(int __a,
const unsigned int *__b) {
return (vector unsigned int)__builtin_altivec_lvewx(__a, __b);
}
static vector float __ATTRS_o_ai vec_lde(int __a, const float *__b) {
return (vector float)__builtin_altivec_lvewx(__a, __b);
}
/* vec_lvebx */
static vector signed char __ATTRS_o_ai vec_lvebx(int __a,
const signed char *__b) {
return (vector signed char)__builtin_altivec_lvebx(__a, __b);
}
static vector unsigned char __ATTRS_o_ai vec_lvebx(int __a,
const unsigned char *__b) {
return (vector unsigned char)__builtin_altivec_lvebx(__a, __b);
}
/* vec_lvehx */
static vector short __ATTRS_o_ai vec_lvehx(int __a, const short *__b) {
return (vector short)__builtin_altivec_lvehx(__a, __b);
}
static vector unsigned short __ATTRS_o_ai vec_lvehx(int __a,
const unsigned short *__b) {
return (vector unsigned short)__builtin_altivec_lvehx(__a, __b);
}
/* vec_lvewx */
static vector int __ATTRS_o_ai vec_lvewx(int __a, const int *__b) {
return (vector int)__builtin_altivec_lvewx(__a, __b);
}
static vector unsigned int __ATTRS_o_ai vec_lvewx(int __a,
const unsigned int *__b) {
return (vector unsigned int)__builtin_altivec_lvewx(__a, __b);
}
static vector float __ATTRS_o_ai vec_lvewx(int __a, const float *__b) {
return (vector float)__builtin_altivec_lvewx(__a, __b);
}
/* vec_ldl */
static vector signed char __ATTRS_o_ai vec_ldl(int __a,
const vector signed char *__b) {
return (vector signed char)__builtin_altivec_lvxl(__a, __b);
}
static vector signed char __ATTRS_o_ai vec_ldl(int __a,
const signed char *__b) {
return (vector signed char)__builtin_altivec_lvxl(__a, __b);
}
static vector unsigned char __ATTRS_o_ai
vec_ldl(int __a, const vector unsigned char *__b) {
return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
}
static vector unsigned char __ATTRS_o_ai vec_ldl(int __a,
const unsigned char *__b) {
return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
}
static vector bool char __ATTRS_o_ai vec_ldl(int __a,
const vector bool char *__b) {
return (vector bool char)__builtin_altivec_lvxl(__a, __b);
}
static vector short __ATTRS_o_ai vec_ldl(int __a, const vector short *__b) {
return (vector short)__builtin_altivec_lvxl(__a, __b);
}
static vector short __ATTRS_o_ai vec_ldl(int __a, const short *__b) {
return (vector short)__builtin_altivec_lvxl(__a, __b);
}
static vector unsigned short __ATTRS_o_ai
vec_ldl(int __a, const vector unsigned short *__b) {
return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
}
static vector unsigned short __ATTRS_o_ai vec_ldl(int __a,
const unsigned short *__b) {
return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
}
static vector bool short __ATTRS_o_ai vec_ldl(int __a,
const vector bool short *__b) {
return (vector bool short)__builtin_altivec_lvxl(__a, __b);
}
static vector pixel __ATTRS_o_ai vec_ldl(int __a, const vector pixel *__b) {
return (vector pixel short)__builtin_altivec_lvxl(__a, __b);
}
static vector int __ATTRS_o_ai vec_ldl(int __a, const vector int *__b) {
return (vector int)__builtin_altivec_lvxl(__a, __b);
}
static vector int __ATTRS_o_ai vec_ldl(int __a, const int *__b) {
return (vector int)__builtin_altivec_lvxl(__a, __b);
}
static vector unsigned int __ATTRS_o_ai
vec_ldl(int __a, const vector unsigned int *__b) {
return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
}
static vector unsigned int __ATTRS_o_ai vec_ldl(int __a,
const unsigned int *__b) {
return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
}
static vector bool int __ATTRS_o_ai vec_ldl(int __a,
const vector bool int *__b) {
return (vector bool int)__builtin_altivec_lvxl(__a, __b);
}
static vector float __ATTRS_o_ai vec_ldl(int __a, const vector float *__b) {
return (vector float)__builtin_altivec_lvxl(__a, __b);
}
static vector float __ATTRS_o_ai vec_ldl(int __a, const float *__b) {
return (vector float)__builtin_altivec_lvxl(__a, __b);
}
/* vec_lvxl */
static vector signed char __ATTRS_o_ai vec_lvxl(int __a,
const vector signed char *__b) {
return (vector signed char)__builtin_altivec_lvxl(__a, __b);
}
static vector signed char __ATTRS_o_ai vec_lvxl(int __a,
const signed char *__b) {
return (vector signed char)__builtin_altivec_lvxl(__a, __b);
}
static vector unsigned char __ATTRS_o_ai
vec_lvxl(int __a, const vector unsigned char *__b) {
return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
}
static vector unsigned char __ATTRS_o_ai vec_lvxl(int __a,
const unsigned char *__b) {
return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
}
static vector bool char __ATTRS_o_ai vec_lvxl(int __a,
const vector bool char *__b) {
return (vector bool char)__builtin_altivec_lvxl(__a, __b);
}
static vector short __ATTRS_o_ai vec_lvxl(int __a, const vector short *__b) {
return (vector short)__builtin_altivec_lvxl(__a, __b);
}
static vector short __ATTRS_o_ai vec_lvxl(int __a, const short *__b) {
return (vector short)__builtin_altivec_lvxl(__a, __b);
}
static vector unsigned short __ATTRS_o_ai
vec_lvxl(int __a, const vector unsigned short *__b) {
return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
}
static vector unsigned short __ATTRS_o_ai vec_lvxl(int __a,
const unsigned short *__b) {
return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
}
static vector bool short __ATTRS_o_ai vec_lvxl(int __a,
const vector bool short *__b) {
return (vector bool short)__builtin_altivec_lvxl(__a, __b);
}
static vector pixel __ATTRS_o_ai vec_lvxl(int __a, const vector pixel *__b) {
return (vector pixel)__builtin_altivec_lvxl(__a, __b);
}
static vector int __ATTRS_o_ai vec_lvxl(int __a, const vector int *__b) {
return (vector int)__builtin_altivec_lvxl(__a, __b);
}
static vector int __ATTRS_o_ai vec_lvxl(int __a, const int *__b) {
return (vector int)__builtin_altivec_lvxl(__a, __b);
}
static vector unsigned int __ATTRS_o_ai
vec_lvxl(int __a, const vector unsigned int *__b) {
return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
}
static vector unsigned int __ATTRS_o_ai vec_lvxl(int __a,
const unsigned int *__b) {
return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
}
static vector bool int __ATTRS_o_ai vec_lvxl(int __a,
const vector bool int *__b) {
return (vector bool int)__builtin_altivec_lvxl(__a, __b);
}
static vector float __ATTRS_o_ai vec_lvxl(int __a, const vector float *__b) {
return (vector float)__builtin_altivec_lvxl(__a, __b);
}
static vector float __ATTRS_o_ai vec_lvxl(int __a, const float *__b) {
return (vector float)__builtin_altivec_lvxl(__a, __b);
}
/* vec_loge */
static vector float __attribute__((__always_inline__))
vec_loge(vector float __a) {
return __builtin_altivec_vlogefp(__a);
}
/* vec_vlogefp */
static vector float __attribute__((__always_inline__))
vec_vlogefp(vector float __a) {
return __builtin_altivec_vlogefp(__a);
}
/* vec_lvsl */
#ifdef __LITTLE_ENDIAN__
static vector unsigned char __ATTRS_o_ai
__attribute__((__deprecated__("use assignment for unaligned little endian \
loads/stores"))) vec_lvsl(int __a, const signed char *__b) {
vector unsigned char mask =
(vector unsigned char)__builtin_altivec_lvsl(__a, __b);
vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
7, 6, 5, 4, 3, 2, 1, 0};
return vec_perm(mask, mask, reverse);
}
#else
static vector unsigned char __ATTRS_o_ai vec_lvsl(int __a,
const signed char *__b) {
return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
}
#endif
#ifdef __LITTLE_ENDIAN__
static vector unsigned char __ATTRS_o_ai
__attribute__((__deprecated__("use assignment for unaligned little endian \
loads/stores"))) vec_lvsl(int __a, const unsigned char *__b) {
vector unsigned char mask =
(vector unsigned char)__builtin_altivec_lvsl(__a, __b);
vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
7, 6, 5, 4, 3, 2, 1, 0};
return vec_perm(mask, mask, reverse);
}
#else
static vector unsigned char __ATTRS_o_ai vec_lvsl(int __a,
const unsigned char *__b) {
return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
}
#endif
#ifdef __LITTLE_ENDIAN__
static vector unsigned char __ATTRS_o_ai
__attribute__((__deprecated__("use assignment for unaligned little endian \
loads/stores"))) vec_lvsl(int __a, const short *__b) {
vector unsigned char mask =
(vector unsigned char)__builtin_altivec_lvsl(__a, __b);
vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
7, 6, 5, 4, 3, 2, 1, 0};
return vec_perm(mask, mask, reverse);
}
#else
static vector unsigned char __ATTRS_o_ai vec_lvsl(int __a, const short *__b) {
return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
}
#endif
#ifdef __LITTLE_ENDIAN__
static vector unsigned char __ATTRS_o_ai
__attribute__((__deprecated__("use assignment for unaligned little endian \
loads/stores"))) vec_lvsl(int __a, const unsigned short *__b) {
vector unsigned char mask =
(vector unsigned char)__builtin_altivec_lvsl(__a, __b);
vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
7, 6, 5, 4, 3, 2, 1, 0};
return vec_perm(mask, mask, reverse);
}
#else
static vector unsigned char __ATTRS_o_ai vec_lvsl(int __a,
const unsigned short *__b) {
return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
}
#endif
#ifdef __LITTLE_ENDIAN__
static vector unsigned char __ATTRS_o_ai
__attribute__((__deprecated__("use assignment for unaligned little endian \
loads/stores"))) vec_lvsl(int __a, const int *__b) {
vector unsigned char mask =
(vector unsigned char)__builtin_altivec_lvsl(__a, __b);
vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
7, 6, 5, 4, 3, 2, 1, 0};
return vec_perm(mask, mask, reverse);
}
#else
static vector unsigned char __ATTRS_o_ai vec_lvsl(int __a, const int *__b) {
return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
}
#endif
#ifdef __LITTLE_ENDIAN__
static vector unsigned char __ATTRS_o_ai
__attribute__((__deprecated__("use assignment for unaligned little endian \
loads/stores"))) vec_lvsl(int __a, const unsigned int *__b) {
vector unsigned char mask =
(vector unsigned char)__builtin_altivec_lvsl(__a, __b);
vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
7, 6, 5, 4, 3, 2, 1, 0};
return vec_perm(mask, mask, reverse);
}
#else
static vector unsigned char __ATTRS_o_ai vec_lvsl(int __a,
const unsigned int *__b) {
return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
}
#endif
#ifdef __LITTLE_ENDIAN__
static vector unsigned char __ATTRS_o_ai
__attribute__((__deprecated__("use assignment for unaligned little endian \
loads/stores"))) vec_lvsl(int __a, const float *__b) {
vector unsigned char mask =
(vector unsigned char)__builtin_altivec_lvsl(__a, __b);
vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
7, 6, 5, 4, 3, 2, 1, 0};
return vec_perm(mask, mask, reverse);
}
#else
static vector unsigned char __ATTRS_o_ai vec_lvsl(int __a, const float *__b) {
return (vector unsigned char)__builtin_altivec_lvsl(__a, __b);
}
#endif
/* vec_lvsr */
#ifdef __LITTLE_ENDIAN__
static vector unsigned char __ATTRS_o_ai
__attribute__((__deprecated__("use assignment for unaligned little endian \
loads/stores"))) vec_lvsr(int __a, const signed char *__b) {
vector unsigned char mask =
(vector unsigned char)__builtin_altivec_lvsr(__a, __b);
vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
7, 6, 5, 4, 3, 2, 1, 0};
return vec_perm(mask, mask, reverse);
}
#else
static vector unsigned char __ATTRS_o_ai vec_lvsr(int __a,
const signed char *__b) {
return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
}
#endif
#ifdef __LITTLE_ENDIAN__
static vector unsigned char __ATTRS_o_ai
__attribute__((__deprecated__("use assignment for unaligned little endian \
loads/stores"))) vec_lvsr(int __a, const unsigned char *__b) {
vector unsigned char mask =
(vector unsigned char)__builtin_altivec_lvsr(__a, __b);
vector unsigned char reverse = {15, 14, 13, 12, 11, 10, 9, 8,
7, 6, 5, 4, 3, 2, 1, 0};
return vec_perm(mask, mask, reverse);
}
#else
static vector unsigned char __ATTRS_o_ai vec_lvsr(int __a,
const unsigned char *__b) {
return (vector unsigned char)__builtin_altivec_lvsr(__a, __b);
}
#endif
#ifdef __LITTLE_ENDIAN__
static vector unsigned char __ATTRS_o_ai
__attribute__((__deprecated__("use assignment for unaligned little endian \
loads/stores&q